@openclaw/crabline 0.1.9 → 0.1.11

package/dist/src/cli/program.js

@@ -1,12 +1,17 @@
-import { Command } from "commander";
+import { Command, CommanderError } from "commander";
+import { randomUUID } from "node:crypto";
+import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import nodePath from "node:path";
+import { lock } from "proper-lockfile";
 import { loadManifest } from "../config/load.js";
 import { createRegistry } from "../providers/registry.js";
-import { formatJson, formatRunResultText } from "../core/reporters.js";
-import { computeExitCode, runFixtureCommand, runSuite } from "../core/run.js";
+import { formatJson, formatRunResultText, sanitizeTerminalText } from "../core/reporters.js";
+import { assertScriptStdinPayloadSize, computeExitCode, runFixtureCommand, runSuite, } from "../core/run.js";
 import { CrablineError, ensureErrorMessage } from "../core/errors.js";
 import { isCrablineServerChannel, startCrablineServer, } from "../servers/index.js";
+const READY_FILE_LEASE_STALE_MS = 60_000;
+const READY_FILE_LEASE_UPDATE_MS = 1_000;
 const SERVE_PARAM_FACTORIES = {
     mattermost: (shared, commandOptions) => ({
         ...shared,
@@ -56,17 +61,85 @@ const SERVE_PARAM_FACTORIES = {
         channel: "zalo",
     }),
 };
-function print(value) {
-    process.stdout.write(`${value}\n`);
+function isClosedPipeError(error) {
+    const code = error.code;
+    return code === "EPIPE" || code === "ERR_STREAM_DESTROYED";
+}
+async function writeOutput(stream, value) {
+    try {
+        await new Promise((resolve, reject) => {
+            let drained = false;
+            let written = false;
+            const cleanup = () => {
+                stream.off("drain", onDrain);
+                stream.off("error", onError);
+            };
+            const finish = () => {
+                if (drained && written) {
+                    cleanup();
+                    resolve();
+                }
+            };
+            const onDrain = () => {
+                drained = true;
+                finish();
+            };
+            const onError = (error) => {
+                cleanup();
+                reject(error);
+            };
+            stream.once("error", onError);
+            let hasCapacity;
+            try {
+                hasCapacity = stream.write(value, (error) => {
+                    if (error) {
+                        stream.once("error", () => undefined);
+                        onError(error);
+                        return;
+                    }
+                    written = true;
+                    finish();
+                });
+            }
+            catch (error) {
+                cleanup();
+                reject(error);
+                return;
+            }
+            if (hasCapacity) {
+                drained = true;
+                finish();
+            }
+            else {
+                stream.once("drain", onDrain);
+            }
+        });
+        return true;
+    }
+    catch (error) {
+        if (isClosedPipeError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function print(value) {
+    return await writeOutput(process.stdout, `${value}\n`);
 }
 async function withManifest(options, action) {
     return action(await loadManifest(options.config));
 }
 export function createProgram(setExitCode = (code) => {
     process.exitCode = code;
-}) {
+}, dependencies = {}) {
     const program = new Command();
+    const acquireReadyLease = dependencies.acquireReadyFileLease ?? acquireReadyFileLease;
+    const registryFactory = dependencies.createRegistry ?? createRegistry;
+    const publish = dependencies.publishReadyFile ?? publishReadyFileUnlocked;
+    const removeReady = dependencies.removeReadyFile ?? removeReadyFileIfOwned;
+    const startServer = dependencies.startServer ?? startCrablineServer;
     program
+        .exitOverride()
         .name("crabline")
         .description("Deterministic CLI harness for messaging provider E2E tests")
         .option("-c, --config <path>", "Config file path")
@@ -78,7 +151,7 @@ export function createProgram(setExitCode = (code) => {
         .action(async () => {
         const options = program.opts();
         const { manifest, path } = await loadManifest(options.config);
-        const registry = createRegistry(manifest, path);
+        const registry = registryFactory(manifest, path);
         const payload = {
             configured: Object.entries(manifest.providers).map(([id, config]) => ({
                 adapter: config.adapter,
@@ -89,7 +162,7 @@ export function createProgram(setExitCode = (code) => {
             })),
             support: registry.catalog,
         };
-        print(options.json ? formatJson(payload) : renderProvidersText(payload));
+        await print(options.json ? formatJson(payload) : renderProvidersText(payload));
     });
     program
         .command("fixtures")
@@ -97,24 +170,23 @@ export function createProgram(setExitCode = (code) => {
         .action(async () => {
         const options = program.opts();
         const { manifest } = await loadManifest(options.config);
-        print(options.json
+        await print(options.json
             ? formatJson(manifest.fixtures)
             : manifest.fixtures
-                .map((fixture) => `${fixture.id} ${fixture.mode} provider=${fixture.provider} target=${fixture.target.id}`)
+                .map((fixture) => `${sanitizeTerminalText(fixture.id, true)} ${sanitizeTerminalText(fixture.mode, true)} provider=${sanitizeTerminalText(fixture.provider, true)} target=${sanitizeTerminalText(fixture.target.id, true)}`)
                 .join("\n"));
     });
     program
-        .command("probe <fixtureOrProvider>")
-        .description("Probe provider readiness using a fixture or provider id")
-        .action(async (fixtureOrProvider) => {
+        .command("probe <fixtureId>")
+        .description("Probe provider readiness using a fixture")
+        .action(async (fixtureId) => {
         const options = program.opts();
         const { manifest, path } = await loadManifest(options.config);
-        const fixture = manifest.fixtures.find((entry) => entry.id === fixtureOrProvider) ??
-            manifest.fixtures.find((entry) => entry.provider === fixtureOrProvider);
+        const fixture = manifest.fixtures.find((entry) => entry.id === fixtureId);
         if (!fixture) {
-            throw new CrablineError(`No fixture found for "${fixtureOrProvider}"`, { kind: "config" });
+            throw new CrablineError(`Unknown fixture: ${fixtureId}`, { kind: "config" });
         }
-        const registry = createRegistry(manifest, path);
+        const registry = registryFactory(manifest, path);
         const result = await runFixtureCommand({
             fixtureId: fixture.id,
             manifest,
@@ -122,7 +194,7 @@ export function createProgram(setExitCode = (code) => {
             modeOverride: "probe",
             registry,
         });
-        print(options.json ? formatJson(result) : formatRunResultText(result));
+        await print(options.json ? formatJson(result) : formatRunResultText(result));
         setExitCode(computeExitCode(result));
     });
     for (const mode of ["send", "roundtrip", "agent"]) {
@@ -132,7 +204,7 @@ export function createProgram(setExitCode = (code) => {
             .action(async (fixtureId) => {
             const options = program.opts();
             const { manifest, path } = await loadManifest(options.config);
-            const registry = createRegistry(manifest, path);
+            const registry = registryFactory(manifest, path);
             const result = await runFixtureCommand({
                 fixtureId,
                 manifest,
@@ -140,7 +212,7 @@ export function createProgram(setExitCode = (code) => {
                 modeOverride: mode,
                 registry,
             });
-            print(options.json ? formatJson(result) : formatRunResultText(result));
+            await print(options.json ? formatJson(result) : formatRunResultText(result));
             setExitCode(computeExitCode(result));
         });
     }
@@ -150,14 +222,14 @@ export function createProgram(setExitCode = (code) => {
         .action(async (fixtureIds) => {
         const options = program.opts();
         const { manifest, path } = await loadManifest(options.config);
-        const registry = createRegistry(manifest, path);
+        const registry = registryFactory(manifest, path);
         const result = await runSuite({
             fixtureIds,
             manifest,
             manifestPath: path,
             registry,
         });
-        print(options.json ? formatJson(result) : formatRunResultText(result));
+        await print(options.json ? formatJson(result) : formatRunResultText(result));
         setExitCode(computeExitCode(result));
     });
     program
@@ -171,28 +243,83 @@ export function createProgram(setExitCode = (code) => {
             if (!fixture) {
                 throw new CrablineError(`Unknown fixture: ${fixtureId}`, { kind: "config" });
             }
-            const provider = createRegistry(manifest, path).resolve(fixture.provider, fixture.id);
+            const provider = registryFactory(manifest, path).resolve(fixture.provider, fixture.id);
             if (!provider.watch) {
                 throw new CrablineError(`Provider "${fixture.provider}" does not implement watch.`, {
                     kind: "config",
                 });
             }
+            const controller = new AbortController();
+            let iterator;
+            const stopWatch = onceAsync(async () => {
+                controller.abort();
+                await iterator?.return?.();
+            });
+            const shutdown = installShutdownHandler(stopWatch);
+            const lifecycleErrors = [];
             try {
-                for await (const message of provider.watch({
+                const watchContext = {
                     config: manifest.providers[fixture.provider],
                     fixture,
                     manifestPath: path,
                     providerId: fixture.provider,
+                    signal: controller.signal,
                     userName: manifest.userName,
-                })) {
-                    print(options.json
+                };
+                if (watchContext.config.adapter === "script") {
+                    assertScriptStdinPayloadSize({
+                        fixture,
+                        provider: {
+                            config: watchContext.config,
+                            id: fixture.provider,
+                            manifestPath: path,
+                        },
+                        watch: {
+                            target: fixture.target,
+                        },
+                    });
+                }
+                const watch = provider.watch(watchContext);
+                iterator = watch[Symbol.asyncIterator]();
+                while (true) {
+                    const result = await iterator.next();
+                    if (result.done) {
+                        break;
+                    }
+                    const message = result.value;
+                    const written = await print(options.json
                         ? formatJson(message)
-                        : `${message.sentAt} ${message.author} ${message.text}`);
+                        : `${sanitizeTerminalText(message.sentAt, true)} ${sanitizeTerminalText(message.author, true)} ${sanitizeTerminalText(message.text, true)}`);
+                    if (!written) {
+                        break;
+                    }
                 }
             }
-            finally {
+            catch (error) {
+                lifecycleErrors.push(error);
+            }
+            try {
+                await stopWatch();
+            }
+            catch (error) {
+                if (!lifecycleErrors.includes(error)) {
+                    lifecycleErrors.push(error);
+                }
+            }
+            try {
                 await provider.cleanup?.();
             }
+            catch (error) {
+                if (!lifecycleErrors.includes(error)) {
+                    lifecycleErrors.push(error);
+                }
+            }
+            finally {
+                shutdown.dispose();
+            }
+            if (lifecycleErrors.length > 0) {
+                throw combineLifecycleErrors(lifecycleErrors, "Crabline watch lifecycle failed.");
+            }
         });
     });
     program
@@ -200,15 +327,16 @@ export function createProgram(setExitCode = (code) => {
         .description("Start a local provider server that OpenClaw live adapters can target")
         .option("--host <host>", "Bind host", "127.0.0.1")
         .option("--port <port>", "Bind port", "0")
-        .option("--admin-token <token>", "Admin token for inbound test messages")
+        .option("--admin-token <token>", "Admin token for inbound test messages (or CRABLINE_ADMIN_TOKEN)")
         .option("--account <number>", "Signal account number")
-        .option("--access-token <token>", "Matrix or WhatsApp access token")
-        .option("--bot-token <token>", "Mattermost, Slack, Telegram, or Zalo bot token")
+        .option("--access-token <token>", "Matrix or WhatsApp access token (or CRABLINE_ACCESS_TOKEN)")
+        .option("--bot-token <token>", "Mattermost, Slack, Telegram, or Zalo bot token (or CRABLINE_BOT_TOKEN)")
         .option("--bot-username <username>", "Mattermost, Telegram, or Zalo bot username", "crabline_bot")
         .option("--recorder <path>", "JSONL recorder path")
         .option("--ready-file <path>", "Write the server runtime manifest to this path")
         .option("--self-jid <jid>", "WhatsApp self JID")
-        .option("--signing-secret <secret>", "Slack signing secret")
+        .option("--show-secrets", "Print provider credentials in text output", false)
+        .option("--signing-secret <secret>", "Slack signing secret (or CRABLINE_SIGNING_SECRET)")
         .option("--once", "Start, print the runtime manifest, and stop immediately", false)
         .action(async (provider, commandOptions) => {
         const options = program.opts();
@@ -217,6 +345,15 @@ export function createProgram(setExitCode = (code) => {
                 kind: "config",
             });
         }
+        commandOptions.accessToken ??= process.env.CRABLINE_ACCESS_TOKEN;
+        commandOptions.adminToken ??= process.env.CRABLINE_ADMIN_TOKEN;
+        commandOptions.botToken ??= process.env.CRABLINE_BOT_TOKEN;
+        commandOptions.signingSecret ??= process.env.CRABLINE_SIGNING_SECRET;
+        if (!/^[0-9]+$/u.test(commandOptions.port)) {
+            throw new CrablineError(`Invalid local server port: ${commandOptions.port}`, {
+                kind: "config",
+            });
+        }
         const port = Number(commandOptions.port);
         if (!Number.isInteger(port) || port < 0 || port > 65_535) {
             throw new CrablineError(`Invalid local server port: ${commandOptions.port}`, {
@@ -229,22 +366,116 @@ export function createProgram(setExitCode = (code) => {
                 kind: "config",
             });
         }
-        const server = await startCrablineServer(factory({
-            host: commandOptions.host,
-            port,
-            recorderPath: commandOptions.recorder,
-        }, commandOptions));
-        const payload = formatJson(server.manifest);
-        if (commandOptions.readyFile) {
-            await fs.mkdir(nodePath.dirname(commandOptions.readyFile), { recursive: true });
-            await fs.writeFile(commandOptions.readyFile, `${payload}\n`, "utf8");
-        }
-        print(options.json ? payload : renderServeText(server.manifest));
-        if (commandOptions.once) {
-            await server.close();
-            return;
+        let server;
+        let startupSettled = false;
+        let settleStartup;
+        const startup = new Promise((resolve) => {
+            settleStartup = resolve;
+        });
+        const finishStartup = () => {
+            if (!startupSettled) {
+                startupSettled = true;
+                settleStartup?.();
+            }
+        };
+        let publicationSettled = false;
+        let settlePublication;
+        const publication = new Promise((resolve) => {
+            settlePublication = resolve;
+        });
+        const finishPublication = () => {
+            if (!publicationSettled) {
+                publicationSettled = true;
+                settlePublication?.();
+            }
+        };
+        const close = onceAsync(async () => {
+            await startup;
+            await publication;
+            await server?.close();
+        });
+        const shutdown = installShutdownHandler(close);
+        let releaseReadyLease;
+        let publishedReady;
+        let actionFailed = false;
+        let actionError;
+        try {
+            if (commandOptions.readyFile) {
+                releaseReadyLease = await acquireReadyLease(commandOptions.readyFile);
+            }
+            if (shutdown.requested()) {
+                finishStartup();
+                finishPublication();
+                await shutdown.wait();
+            }
+            else {
+                try {
+                    server = await startServer(factory({
+                        host: commandOptions.host,
+                        port,
+                        recorderPath: commandOptions.recorder,
+                    }, commandOptions));
+                }
+                finally {
+                    finishStartup();
+                }
+                if (shutdown.requested()) {
+                    finishPublication();
+                    await shutdown.wait();
+                }
+                else {
+                    try {
+                        const payload = formatJson(server.manifest);
+                        if (commandOptions.readyFile) {
+                            const readyContents = `${payload}\n`;
+                            publishedReady = {
+                                contents: readyContents,
+                                identity: await publish(commandOptions.readyFile, readyContents),
+                            };
+                        }
+                        await print(options.json
+                            ? payload
+                            : renderServeText(server.manifest, commandOptions.showSecrets === true));
+                    }
+                    finally {
+                        finishPublication();
+                    }
+                    if (shutdown.requested() || !commandOptions.once) {
+                        await shutdown.wait();
+                    }
+                }
+            }
+        }
+        catch (error) {
+            actionFailed = true;
+            actionError = error;
+        }
+        finishStartup();
+        finishPublication();
+        const cleanupErrors = [];
+        const readyToRemove = publishedReady;
+        for (const cleanup of [
+            close,
+            ...(commandOptions.readyFile && readyToRemove
+                ? [
+                    () => removeReady(commandOptions.readyFile, readyToRemove.contents, readyToRemove.identity),
+                ]
+                : []),
+            ...(releaseReadyLease ? [releaseReadyLease] : []),
+        ]) {
+            try {
+                await cleanup();
+            }
+            catch (error) {
+                if (!actionFailed || error !== actionError) {
+                    cleanupErrors.push(error);
+                }
+            }
+        }
+        shutdown.dispose();
+        if (actionFailed || cleanupErrors.length > 0) {
+            throw combineLifecycleErrors(actionFailed ? [actionError, ...cleanupErrors] : cleanupErrors, "Crabline server lifecycle failed.");
         }
-        await waitForShutdown(server.close);
     });
     program
         .command("doctor")
@@ -255,28 +486,242 @@ export function createProgram(setExitCode = (code) => {
         const findings = diagnose(manifest);
         const ok = findings.length === 0;
         const payload = { findings, ok };
-        print(options.json ? formatJson(payload) : ok ? "doctor ok" : findings.join("\n"));
+        await print(options.json ? formatJson(payload) : ok ? "doctor ok" : findings.join("\n"));
         setExitCode(ok ? 0 : 10);
     });
     return program;
 }
-function waitForShutdown(close) {
-    return new Promise((resolve, reject) => {
-        const shutdown = () => {
-            close().then(resolve, reject);
-        };
-        process.once("SIGINT", shutdown);
-        process.once("SIGTERM", shutdown);
+function onceAsync(action) {
+    let result;
+    return () => (result ??= Promise.resolve().then(action));
+}
+async function readReadyFileIdentity(filePath) {
+    const stats = await fs.stat(filePath, { bigint: true });
+    return {
+        birthtimeNs: stats.birthtimeNs,
+        ctimeNs: stats.ctimeNs,
+        dev: stats.dev,
+        ino: stats.ino,
+        size: stats.size,
+    };
+}
+function sameReadyFileIdentity(left, right) {
+    return (left.birthtimeNs === right.birthtimeNs &&
+        left.ctimeNs === right.ctimeNs &&
+        left.dev === right.dev &&
+        left.ino === right.ino &&
+        left.size === right.size);
+}
+function sameReadyFileObject(left, right) {
+    return (left.birthtimeNs === right.birthtimeNs &&
+        left.dev === right.dev &&
+        left.ino === right.ino &&
+        left.size === right.size);
+}
+async function withReadyFileLock(filePath, action) {
+    const release = await acquireReadyFileLease(filePath);
+    let actionFailed = false;
+    let actionError;
+    let result;
+    try {
+        result = await action();
+    }
+    catch (error) {
+        actionFailed = true;
+        actionError = error;
+    }
+    try {
+        await release();
+    }
+    catch (releaseError) {
+        if (actionFailed) {
+            throw combineLifecycleErrors([actionError, releaseError], `Ready-file action and lock release both failed for "${filePath}".`);
+        }
+        throw releaseError;
+    }
+    if (actionFailed) {
+        throw actionError;
+    }
+    return result;
+}
+async function acquireReadyFileLease(filePath) {
+    await fs.mkdir(nodePath.dirname(filePath), { recursive: true });
+    return await lock(filePath, {
+        realpath: false,
+        retries: {
+            factor: 1,
+            maxTimeout: 10,
+            minTimeout: 10,
+            retries: 100,
+        },
+        stale: READY_FILE_LEASE_STALE_MS,
+        update: READY_FILE_LEASE_UPDATE_MS,
     });
 }
-function renderServeText(manifest) {
+export async function publishReadyFile(filePath, contents) {
+    let publishedIdentity;
+    try {
+        return await withReadyFileLock(filePath, async () => {
+            publishedIdentity = await publishReadyFileUnlocked(filePath, contents);
+            return publishedIdentity;
+        });
+    }
+    catch (error) {
+        if (publishedIdentity) {
+            try {
+                await removeReadyFileIfOwned(filePath, contents, publishedIdentity);
+            }
+            catch (cleanupError) {
+                const aggregateError = new AggregateError([error, cleanupError], `Ready-file publication and compensation both failed for "${filePath}".`);
+                aggregateError.cause = error;
+                throw aggregateError;
+            }
+        }
+        throw error;
+    }
+}
+async function publishReadyFileUnlocked(filePath, contents) {
+    const suffix = `${process.pid}.${randomUUID()}.tmp`;
+    const temporaryPath = nodePath.join(nodePath.dirname(filePath), `.${nodePath.basename(filePath)}.${suffix}`);
+    const backupPath = `${temporaryPath}.backup`;
+    let manifestPublished = false;
+    let destinationBackedUp = false;
+    try {
+        await fs.writeFile(temporaryPath, contents, {
+            encoding: "utf8",
+            flag: "wx",
+            mode: 0o600,
+        });
+        destinationBackedUp = await backupReadyFile(filePath, backupPath);
+        await fs.rename(temporaryPath, filePath);
+        manifestPublished = true;
+        const identity = await readReadyFileIdentity(filePath);
+        if (destinationBackedUp) {
+            await fs.rm(backupPath);
+            destinationBackedUp = false;
+        }
+        return identity;
+    }
+    catch (error) {
+        const recoveryErrors = [];
+        if (manifestPublished && !destinationBackedUp) {
+            await fs.rm(filePath, { force: true }).catch((cleanupError) => {
+                recoveryErrors.push(cleanupError);
+            });
+        }
+        if (destinationBackedUp) {
+            await fs.rename(backupPath, filePath).catch((restoreError) => {
+                recoveryErrors.push(restoreError);
+            });
+        }
+        if (recoveryErrors.length > 0) {
+            const aggregateError = new AggregateError([error, ...recoveryErrors], `Ready-file replacement and recovery both failed for "${filePath}".`);
+            aggregateError.cause = error;
+            throw aggregateError;
+        }
+        throw error;
+    }
+    finally {
+        await fs.rm(temporaryPath, { force: true }).catch(() => undefined);
+    }
+}
+async function backupReadyFile(filePath, backupPath) {
+    try {
+        await fs.copyFile(filePath, backupPath, fsConstants.COPYFILE_EXCL);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+async function removeReadyFileIfOwned(filePath, expectedContents, expectedIdentity) {
+    const tombstonePath = nodePath.join(nodePath.dirname(filePath), `.${nodePath.basename(filePath)}.${process.pid}.${randomUUID()}.remove`);
+    try {
+        if ((await fs.readFile(filePath, "utf8")) !== expectedContents ||
+            !sameReadyFileIdentity(await readReadyFileIdentity(filePath), expectedIdentity)) {
+            return;
+        }
+        await fs.rename(filePath, tombstonePath);
+        if ((await fs.readFile(tombstonePath, "utf8")) === expectedContents &&
+            sameReadyFileObject(await readReadyFileIdentity(tombstonePath), expectedIdentity)) {
+            await fs.rm(tombstonePath);
+            return;
+        }
+        try {
+            await fs.link(tombstonePath, filePath);
+            await fs.rm(tombstonePath);
+        }
+        catch (restoreError) {
+            throw new Error(`Ready-file path changed while removing "${filePath}"; the moved file remains at "${tombstonePath}".`, { cause: restoreError });
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    }
+}
+export async function removeReadyFile(filePath, expectedContents, expectedIdentity) {
+    await withReadyFileLock(filePath, async () => {
+        await removeReadyFileIfOwned(filePath, expectedContents, expectedIdentity);
+    });
+}
+export function waitForShutdown(close, signalTarget = process) {
+    return installShutdownHandler(close, signalTarget).wait();
+}
+function installShutdownHandler(close, signalTarget = process) {
+    let shutdownPromise;
+    let resolveWait;
+    let rejectWait;
+    const wait = new Promise((resolve, reject) => {
+        resolveWait = resolve;
+        rejectWait = reject;
+    });
+    void wait.catch(() => undefined);
+    const removeListeners = () => {
+        signalTarget.removeListener("SIGINT", shutdown);
+        signalTarget.removeListener("SIGTERM", shutdown);
+    };
+    const shutdown = () => {
+        if (shutdownPromise) {
+            return;
+        }
+        shutdownPromise = Promise.resolve().then(close);
+        void shutdownPromise.then(() => {
+            removeListeners();
+            resolveWait?.();
+        }, (error) => {
+            removeListeners();
+            rejectWait?.(error);
+        });
+    };
+    signalTarget.on("SIGINT", shutdown);
+    signalTarget.on("SIGTERM", shutdown);
+    return {
+        dispose: removeListeners,
+        requested: () => shutdownPromise !== undefined,
+        wait: () => wait,
+    };
+}
+function combineLifecycleErrors(errors, message) {
+    if (errors.length === 1) {
+        return errors[0];
+    }
+    const aggregateError = new AggregateError(errors, message);
+    aggregateError.cause = errors[0];
+    return aggregateError;
+}
+function renderServeText(manifest, showSecrets) {
     const lines = [
         `${manifest.provider} local server ready`,
         `  apiRoot: ${manifest.provider === "matrix" ? manifest.endpoints.clientApiRoot : manifest.endpoints.apiRoot}`,
         `  inbound: ${manifest.endpoints.adminInboundUrl}`,
         `  recorder: ${manifest.recorderPath}`,
     ];
-    const providerFields = renderServeProviderFields(manifest);
+    const providerFields = renderServeProviderFields(manifest, showSecrets);
     if (!providerFields) {
         throw new CrablineError(`Unsupported server manifest provider: ${String(manifest.provider)}`, {
             kind: "config",
@@ -285,49 +730,57 @@ function renderServeText(manifest) {
     lines.splice(2, 0, ...providerFields);
     return lines.join("\n");
 }
-function renderServeProviderFields(manifest) {
+function renderServeProviderFields(manifest, showSecrets) {
+    const secret = (value) => (showSecrets ? value : "<redacted>");
     if (manifest.provider === "mattermost") {
         return [
-            `  adminToken: ${manifest.adminToken}`,
-            `  botToken: ${manifest.botToken}`,
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  botToken: ${secret(manifest.botToken)}`,
             `  websocket: ${manifest.endpoints.websocketUrl}`,
         ];
     }
     if (manifest.provider === "matrix") {
         return [
-            `  adminToken: ${manifest.adminToken}`,
-            `  accessToken: ${manifest.accessToken}`,
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  accessToken: ${secret(manifest.accessToken)}`,
             `  botUserId: ${manifest.botUserId}`,
             `  sync: ${manifest.endpoints.syncUrl}`,
         ];
     }
     if (manifest.provider === "signal") {
-        return [`  adminToken: ${manifest.adminToken}`, `  account: ${manifest.account}`];
+        return [`  adminToken: ${secret(manifest.adminToken)}`, `  account: ${manifest.account}`];
     }
     if (manifest.provider === "slack") {
         return [
-            `  adminToken: ${manifest.adminToken}`,
-            `  botToken: ${manifest.botToken}`,
-            `  signingSecret: ${manifest.signingSecret}`,
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  botToken: ${secret(manifest.botToken)}`,
+            `  signingSecret: ${secret(manifest.signingSecret)}`,
         ];
     }
     if (manifest.provider === "telegram") {
-        return [`  adminToken: ${manifest.adminToken}`, `  botToken: ${manifest.botToken}`];
+        return [
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  botToken: ${secret(manifest.botToken)}`,
+        ];
     }
     if (manifest.provider === "whatsapp") {
+        const baileysWebSocketUrl = showSecrets
+            ? manifest.endpoints.baileysWebSocketUrl
+            : `${manifest.endpoints.baileysWebSocketUrl.split("?")[0]}?access_token=<redacted>`;
         return [
-            `  adminToken: ${manifest.adminToken}`,
-            `  accessToken: ${manifest.accessToken}`,
-            `  baileysWebSocket: ${manifest.endpoints.baileysWebSocketUrl}`,
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  accessToken: ${secret(manifest.accessToken)}`,
+            `  baileysWebSocket: ${baileysWebSocketUrl}`,
             `  messages: ${manifest.endpoints.messagesUrl}`,
-            `  presence: ${manifest.endpoints.presenceUrl}`,
+            `  phoneNumber: ${manifest.endpoints.phoneNumberUrl}`,
+            `  status: ${manifest.endpoints.statusUrl}`,
             `  selfJid: ${manifest.selfJid}`,
         ];
     }
     if (manifest.provider === "zalo") {
         return [
-            `  adminToken: ${manifest.adminToken}`,
-            `  botToken: ${manifest.botToken}`,
+            `  adminToken: ${secret(manifest.adminToken)}`,
+            `  botToken: ${secret(manifest.botToken)}`,
             `  botId: ${manifest.botId}`,
         ];
     }
@@ -372,15 +825,20 @@ function diagnose(manifest) {
                 findings.push(`provider ${providerId} missing env ${envName}`);
             }
         }
-        if (provider.adapter === "script") {
-            if (!provider.script?.commands.send) {
+        if (provider.adapter === "script" && provider.status === "active") {
+            const commands = provider.script?.commands;
+            if (provider.capabilities.includes("probe") && !commands?.probe) {
+                findings.push(`provider ${providerId} missing script.commands.probe`);
+            }
+            if (provider.capabilities.some((capability) => ["agent", "roundtrip", "send"].includes(capability)) &&
+                !commands?.send) {
                 findings.push(`provider ${providerId} missing script.commands.send`);
             }
-            if (!provider.script?.commands.waitForInbound) {
+            if (provider.capabilities.some((capability) => ["agent", "roundtrip"].includes(capability)) &&
+                !commands?.waitForInbound) {
                 findings.push(`provider ${providerId} missing script.commands.waitForInbound`);
             }
         }
-        void providerId;
     }
     return findings;
 }
@@ -389,17 +847,56 @@ export async function runCli(argv) {
     const program = createProgram((code) => {
         exitCode = code;
     });
+    const parserErrors = [];
+    const parserOutput = [];
+    const bufferParserErrors = (command) => {
+        command.configureOutput({
+            writeErr: (message) => parserErrors.push(message),
+            writeOut: (message) => parserOutput.push(message),
+        });
+        for (const child of command.commands) {
+            bufferParserErrors(child);
+        }
+    };
+    bufferParserErrors(program);
     try {
         await program.parseAsync(argv);
+        await writeOutput(process.stdout, parserOutput.join(""));
         return exitCode;
     }
     catch (error) {
-        const message = ensureErrorMessage(error);
-        process.stderr.write(`${message}\n`);
-        if (error instanceof CrablineError) {
-            return error.exitCode;
+        const errorExitCode = error instanceof CommanderError
+            ? error.code === "commander.help" && error.exitCode !== 0
+                ? 1
+                : error.exitCode
+            : error instanceof CrablineError
+                ? error.exitCode
+                : 1;
+        if (error instanceof CommanderError && errorExitCode === 0) {
+            await writeOutput(process.stdout, parserOutput.join(""));
+            return 0;
+        }
+        const json = program.opts().json === true;
+        if (json) {
+            await writeOutput(process.stderr, `${formatJson({
+                error: {
+                    ...(error instanceof CommanderError ? { code: error.code } : {}),
+                    exitCode: errorExitCode,
+                    ...(error instanceof CrablineError && error.kind ? { kind: error.kind } : {}),
+                    message: error instanceof CommanderError && error.code === "commander.help"
+                        ? "No command specified."
+                        : ensureErrorMessage(error),
+                },
+                ok: false,
+            })}\n`);
+        }
+        else if (error instanceof CommanderError) {
+            await writeOutput(process.stderr, parserErrors.join(""));
+        }
+        else {
+            await writeOutput(process.stderr, `${ensureErrorMessage(error)}\n`);
         }
-        return 1;
+        return errorExitCode;
     }
 }
 //# sourceMappingURL=program.js.map