add channel connectivity and command

src/commands/alerts.ts

@@ -19,6 +19,21 @@ import { registerBuiltinChannels } from "../alerts/builtins.js";
 
 registerBuiltinChannels();
 
+function buildTestEvent(contractId: string, thresholdLedgers: number) {
+    return buildAlertEvent({
+        type: "threshold_crossed",
+        contractId,
+        contractName: null,
+        network: "testnet",
+        entryKeyXdr: "TEST_ENTRY_KEY",
+        entryType: "instance",
+        entryLabel: "test-entry",
+        configuredLedgers: thresholdLedgers,
+        remainingTTL: Math.floor(thresholdLedgers * 0.5),
+        firedAtLedger: 0,
+    });
+}
+
 export function registerAlertsCommand(program: Command): void {
     const alerts = program
         .command("alerts")
@@ -184,6 +199,31 @@ export function registerAlertsCommand(program: Command): void {
             console.log();
         });
 
+    // ── alerts channels ────────────────────────────────────────────────
+    alerts
+        .command("channels")
+        .description("List all registered alert channel plugins")
+        .action(() => {
+            const channels = listAlertChannels();
+
+            if (channels.length === 0) {
+                console.log(chalk.yellow("No alert channels are registered."));
+                return;
+            }
+
+            console.log();
+            console.log(chalk.bold("  Registered Alert Channels"));
+            console.log();
+            for (const channel of channels) {
+                console.log(
+                    `  Name: ${chalk.cyan(channel.name.padEnd(12))} | ` +
+                    `Target: ${chalk.yellow(channel.targetOption.padEnd(10))} | ` +
+                    `Signing: ${chalk.green(channel.supportsSigning ? "yes" : "no")}`
+                );
+            }
+            console.log();
+        });
+
     // ── alerts remove ──────────────────────────────────────────────────
     alerts
         .command("remove")
@@ -220,18 +260,7 @@ export function registerAlertsCommand(program: Command): void {
                 process.exit(1);
             }
 
-            const testEvent = buildAlertEvent({
-                type: "threshold_crossed",
-                contractId: config.contract_id,
-                contractName: null,
-                network: "testnet",
-                entryKeyXdr: "TEST_ENTRY_KEY",
-                entryType: "instance",
-                entryLabel: "test-entry",
-                configuredLedgers: config.threshold_ledgers,
-                remainingTTL: Math.floor(config.threshold_ledgers * 0.5),
-                firedAtLedger: 0,
-            });
+            const testEvent = buildTestEvent(config.contract_id, config.threshold_ledgers);
 
             console.log(`Sending test alert to ${config.channel_type}:${config.channel_target}...`);
 
@@ -250,6 +279,66 @@ export function registerAlertsCommand(program: Command): void {
             }
         });
 
+    // ── alerts test-all ────────────────────────────────────────────────
+    alerts
+        .command("test-all")
+        .description("Send test alerts to every configured channel for a contract")
+        .requiredOption("--contract <id>", "The contract ID to test alerts for")
+        .action(async (options) => {
+            const contractId = options.contract;
+            const db = getDatabase();
+
+            const contract = getContract(db, contractId);
+            if (!contract) {
+                console.error(chalk.red(`Error: Contract ${formatContractID(contractId)} is not registered.`));
+                process.exit(1);
+            }
+
+            const configs = getAlertConfigsForContract(db, contractId);
+            if (configs.length === 0) {
+                console.log(chalk.yellow(`No alert configurations found for contract ${formatContractID(contractId)}.`));
+                return;
+            }
+
+            const results: Array<{ channelType: string; target: string; success: boolean; }> = [];
+
+            for (const config of configs) {
+                const testEvent = buildTestEvent(config.contract_id, config.threshold_ledgers);
+                console.log(`Sending test alert to ${config.channel_type}:${config.channel_target}...`);
+
+                const success = await deliverSingleAlert(
+                    config.channel_type,
+                    config.channel_target,
+                    testEvent,
+                    config.webhook_secret,
+                );
+
+                results.push({
+                    channelType: config.channel_type,
+                    target: config.channel_target,
+                    success,
+                });
+            }
+
+            console.log();
+            console.log(chalk.bold(`  Alert Connectivity Summary for ${contract.name ?? formatContractID(contractId)}`));
+            console.log();
+            for (const result of results) {
+                console.log(
+                    `  Type: ${chalk.cyan(result.channelType.padEnd(10))} | ` +
+                    `Target: ${chalk.yellow(result.target.padEnd(30))} | ` +
+                    `Status: ${result.success ? chalk.green("success") : chalk.red("failure")}`
+                );
+            }
+            console.log();
+
+            const failedCount = results.filter((result) => !result.success).length;
+            if (failedCount > 0) {
+                console.error(chalk.red(`${failedCount} channel(s) failed connectivity testing.`));
+                process.exit(1);
+            }
+        });
+
     // ── alerts history ─────────────────────────────────────────────────
     alerts
         .command("history")
@@ -294,4 +383,4 @@ export function registerAlertsCommand(program: Command): void {
             }
             console.log();
         });
-}
+}

tests/commands/alerts.test.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import type Database from "better-sqlite3";
 import { getDatabaseForTesting } from "../../src/db/database";
 import { registerAlertsCommand } from "../../src/commands/alerts";
+import { registerAlertChannel } from "../../src/alerts/registry";
 import {
     insertContract,
     getAlertConfigsForContract,
@@ -761,4 +762,95 @@ describe("alerts command", () => {
             );
         });
     });
+
+    describe("alerts test-all", () => {
+        beforeEach(() => {
+            mockDeliverSingleAlert.mockReset();
+            insertAlertConfig(mockDb, {
+                contract_id: contractID,
+                channel_type: "webhook",
+                channel_target: "https://example.com/webhook",
+                threshold_ledgers: 1000,
+            });
+            insertAlertConfig(mockDb, {
+                contract_id: contractID,
+                channel_type: "slack",
+                channel_target: "#ops-alerts",
+                threshold_ledgers: 2000,
+            });
+        });
+
+        it("sends a test event to every configured channel for the contract", async () => {
+            mockDeliverSingleAlert.mockResolvedValue(true);
+
+            const program = new Command();
+            registerAlertsCommand(program);
+
+            await program.parseAsync([
+                "node", "sorokeep", "alerts", "test-all",
+                "--contract", contractID,
+            ]);
+
+            expect(mockDeliverSingleAlert).toHaveBeenCalledTimes(2);
+            expect(mockDeliverSingleAlert.mock.calls[0]![0]).toBe("webhook");
+            expect(mockDeliverSingleAlert.mock.calls[0]![1]).toBe("https://example.com/webhook");
+            expect(mockDeliverSingleAlert.mock.calls[1]![0]).toBe("slack");
+            expect(mockDeliverSingleAlert.mock.calls[1]![1]).toBe("#ops-alerts");
+
+            for (const [, , event] of mockDeliverSingleAlert.mock.calls) {
+                expect(event.type).toBe("threshold_crossed");
+                expect(event.contractId).toBe(contractID);
+            }
+        });
+
+        it("exits with 1 when any delivery fails", async () => {
+            mockDeliverSingleAlert.mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+
+            const program = new Command();
+            registerAlertsCommand(program);
+
+            await expect(
+                program.parseAsync([
+                    "node", "sorokeep", "alerts", "test-all",
+                    "--contract", contractID,
+                ])
+            ).rejects.toThrow("process.exit called");
+
+            expect(mockDeliverSingleAlert).toHaveBeenCalledTimes(2);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(
+                expect.stringContaining("1 channel(s) failed")
+            );
+            expect(exitSpy).toHaveBeenCalledWith(1);
+        });
+    });
+
+    describe("alerts channels", () => {
+        it("prints all five built-in channel names", () => {
+            parse(["alerts", "channels"]);
+
+            const output = consoleLogSpy.mock.calls.flat().join("\n");
+            expect(output).toContain("webhook");
+            expect(output).toContain("slack");
+            expect(output).toContain("pagerduty");
+            expect(output).toContain("discord");
+            expect(output).toContain("telegram");
+        });
+
+        it("includes dynamically registered plugin channels in the output", () => {
+            registerAlertChannel({
+                name: "matrix-listing-test",
+                channel: { send: vi.fn().mockResolvedValue(undefined) },
+                targetOption: "url",
+                missingTargetError: "Error: --url is required when --type is matrix-listing-test.",
+                supportsSigning: false,
+            });
+
+            parse(["alerts", "channels"]);
+
+            const output = consoleLogSpy.mock.calls.flat().join("\n");
+            expect(output).toContain("matrix-listing-test");
+            expect(output).toContain("url");
+            expect(output).toContain("no");
+        });
+    });
 });