agent-embassy 1.0.0

package/dist/src/gateway/cli.js

@@ -0,0 +1,969 @@
+#!/usr/bin/env node
+/**
+ * Local gateway foreground launcher and metadata-only control client.
+ *
+ * Provider identities and message bodies are accepted only from inherited
+ * process state and stdin respectively. They are never reflected in output or
+ * error text. Only `serve` owns the long-lived provider capabilities and
+ * private control server; every other command is a bounded client operation.
+ */
+import { realpathSync } from "node:fs";
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { BridgeError } from "../errors.js";
+import { getCliCopy, } from "./cli-copy.js";
+import { GATEWAY_CONTROL_DEFAULT_TIMEOUT_MS, GATEWAY_CONTROL_MAX_MESSAGE_BYTES, GATEWAY_CONTROL_MAX_RESPONSE_BYTES, GATEWAY_CONTROL_PROTOCOL_VERSION, GatewayControlTransportError, isClaudeSessionSelector, isGatewayAlias, isGatewayConversationId, isGatewayDeliveryToken, isGatewayHostId, isGatewayReplyAddress, sendGatewayControlRequest, } from "./control.js";
+import { loadGatewayConfig } from "./config.js";
+import { isDashboardLocale, } from "./locale.js";
+import { runLiveDashboardCommand, } from "./live-dashboard-command.js";
+import { runGatewayServer, } from "./server.js";
+import { PROGRESS_WATCH_DEFAULT_IDLE_MS } from "./progress-watch-machine.js";
+import { isCompatibilityCertificationReport, isCompatibilityCheckReport, } from "./compatibility.js";
+const THREAD_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const DEFAULT_HOST_ID = "this-mac";
+const CLI_MAX_OUTPUT_BYTES = GATEWAY_CONTROL_MAX_RESPONSE_BYTES;
+const DELIVERY_POLL_INTERVAL_MS = 250;
+const DELIVERY_POLL_MIN_REQUEST_TIMEOUT_MS = 50;
+export const EMBASSY_VERSION = "1.0.0";
+const DEFAULT_CLI_LOCALE = "en";
+export const gatewayCliCommands = [
+    "serve",
+    "health",
+    "status",
+    "compat-check",
+    "compat-certify",
+    "delivery-status",
+    "wait-delivery",
+    "untrack",
+    "refresh-dashboard",
+    "dashboard",
+    "register-codex",
+    "unregister-codex",
+    "select-claude",
+    "unselect-claude",
+    "pair",
+    "unpair",
+    "send-to-claude",
+    "send-to-codex",
+    "reply",
+];
+export const gatewayCliExitCodes = Object.freeze({
+    ok: 0,
+    invalidInput: 2,
+    rejected: 3,
+    unavailable: 4,
+    ambiguous: 5,
+    failure: 6,
+    claudeCertificationFailed: 7,
+    codexCertificationFailed: 8,
+    multipleCertificationsFailed: 9,
+});
+const COMPAT_CERTIFY_CONTROL_TIMEOUT_MS = 90_000;
+class CliFault extends Error {
+    code;
+    retryable;
+    hint;
+    kind;
+    constructor(code, retryable = false, hint, kind) {
+        super("The gateway client rejected the request.");
+        this.name = "CliFault";
+        this.code = code;
+        this.retryable = retryable;
+        this.hint = hint;
+        this.kind = kind;
+    }
+}
+function isCommand(value) {
+    return (value !== undefined &&
+        gatewayCliCommands.includes(value));
+}
+function parseOptions(args, valueNames, flagNames = []) {
+    const values = new Set(valueNames);
+    const flags = new Set(flagNames);
+    const parsed = Object.create(null);
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === undefined || !token.startsWith("--") || token.length <= 2) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        const name = token.slice(2);
+        if (Object.hasOwn(parsed, name)) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        if (flags.has(name)) {
+            parsed[name] = true;
+            continue;
+        }
+        if (!values.has(name)) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--") || value.length === 0) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        parsed[name] = value;
+        index += 1;
+    }
+    return parsed;
+}
+function environmentLocale(env) {
+    const value = env.EMBASSY_LOCALE;
+    if (value === undefined || value.length === 0)
+        return DEFAULT_CLI_LOCALE;
+    if (!isDashboardLocale(value))
+        throw new CliFault("INVALID_ARGUMENTS");
+    return value;
+}
+function resolveCommonCliOptions(args, env) {
+    const stripped = [];
+    let locale;
+    let sawLocale = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token !== "--lang") {
+            if (token !== undefined)
+                stripped.push(token);
+            continue;
+        }
+        if (sawLocale)
+            throw new CliFault("INVALID_ARGUMENTS");
+        sawLocale = true;
+        const value = args[index + 1];
+        if (value === undefined || value.startsWith("--") || value.length === 0) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        if (!isDashboardLocale(value)) {
+            throw new CliFault("INVALID_ARGUMENTS");
+        }
+        locale = value;
+        index += 1;
+    }
+    return {
+        args: stripped,
+        // Resolve the environment only when no valid explicit flag exists. This
+        // lets an exact flag intentionally override even a malformed environment.
+        locale: locale ?? environmentLocale(env),
+    };
+}
+function fallbackCliLocale(args, env) {
+    const localeFlagIndices = [];
+    for (let index = 0; index < args.length; index += 1) {
+        if (args[index] === "--lang")
+            localeFlagIndices.push(index);
+    }
+    if (localeFlagIndices.length === 1) {
+        const value = args[(localeFlagIndices[0] ?? -1) + 1];
+        if (isDashboardLocale(value))
+            return value;
+    }
+    return isDashboardLocale(env.EMBASSY_LOCALE)
+        ? env.EMBASSY_LOCALE
+        : DEFAULT_CLI_LOCALE;
+}
+function fixedStderr(locale, kind) {
+    return `[embassy] ${getCliCopy(locale)[`error.${kind}`]}\n`;
+}
+function requireString(options, name) {
+    const value = options[name];
+    if (typeof value !== "string")
+        throw new CliFault("INVALID_ARGUMENTS");
+    return value;
+}
+function assertExactOptionCount(options, minimum, maximum = minimum) {
+    const count = Object.keys(options).length;
+    if (count < minimum || count > maximum) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+}
+function requireAlias(options, name) {
+    const alias = requireString(options, name);
+    if (!isGatewayAlias(alias))
+        throw new CliFault("INVALID_ARGUMENTS");
+    return alias;
+}
+function requireCodexAlias(options, name) {
+    const alias = requireAlias(options, name);
+    if (!alias.startsWith("codex-"))
+        throw new CliFault("INVALID_ARGUMENTS");
+    return alias;
+}
+function gatewayAliasHost(alias) {
+    return alias.slice(alias.lastIndexOf("@") + 1);
+}
+function requireClaudeSelector(options, name) {
+    const selector = requireString(options, name);
+    if (!isClaudeSessionSelector(selector)) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+    return selector;
+}
+function trackIdleMinutes(options) {
+    const tracking = options.track === true;
+    const raw = options["idle-minutes"];
+    if (raw !== undefined && !tracking) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+    if (!tracking)
+        return undefined;
+    if (raw === undefined)
+        return PROGRESS_WATCH_DEFAULT_IDLE_MS / 60_000;
+    if (typeof raw !== "string" ||
+        !/^[1-9][0-9]{0,3}$/.test(raw)) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+    const minutes = Number(raw);
+    if (!Number.isSafeInteger(minutes) || minutes > 24 * 60) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+    return minutes;
+}
+function requireDeliveryToken(options, name) {
+    const token = requireString(options, name);
+    if (!isGatewayDeliveryToken(token)) {
+        throw new CliFault("INVALID_ARGUMENTS");
+    }
+    return token;
+}
+function requireCodexThreadId(env) {
+    const threadId = env.CODEX_THREAD_ID;
+    if (typeof threadId !== "string" || !THREAD_ID_PATTERN.test(threadId)) {
+        throw new CliFault("CODEX_IDENTITY_REQUIRED");
+    }
+    return threadId.toLowerCase();
+}
+function hasInheritedIdentity(value) {
+    return typeof value === "string" && value.length > 0;
+}
+function requireExclusiveCodexThreadId(env) {
+    if (hasInheritedIdentity(env.CLAUDE_CODE_MESSAGING_SOCKET)) {
+        throw new CliFault("CALLER_IDENTITY_CONFLICT");
+    }
+    return requireCodexThreadId(env);
+}
+function optionalCodexThreadId(env) {
+    const threadId = env.CODEX_THREAD_ID;
+    if (threadId === undefined || threadId.length === 0)
+        return undefined;
+    if (!THREAD_ID_PATTERN.test(threadId)) {
+        throw new CliFault("CODEX_IDENTITY_REQUIRED");
+    }
+    return threadId.toLowerCase();
+}
+function optionalClaudeReplyAddress(env) {
+    const socketPath = env.CLAUDE_CODE_MESSAGING_SOCKET;
+    if (socketPath === undefined || socketPath.length === 0)
+        return undefined;
+    // Claude Code 2.1.225 exports the raw socket path. The peer protocol's
+    // transient callback capability is the same path with an explicit UDS
+    // scheme; form it only in memory and leave generation validation to the
+    // broker's pinned Claude adapter.
+    if (socketPath.includes("\0") ||
+        !path.isAbsolute(socketPath) ||
+        path.resolve(socketPath) !== socketPath) {
+        throw new CliFault("CLAUDE_IDENTITY_INVALID");
+    }
+    const replyAddress = `uds:${socketPath}`;
+    if (!isGatewayReplyAddress(replyAddress)) {
+        throw new CliFault("CLAUDE_IDENTITY_INVALID");
+    }
+    return replyAddress;
+}
+function requireClaudeReplyAddress(env) {
+    const replyAddress = optionalClaudeReplyAddress(env);
+    if (replyAddress === undefined) {
+        throw new CliFault("CLAUDE_IDENTITY_REQUIRED");
+    }
+    return replyAddress;
+}
+function requireExclusiveClaudeReplyAddress(env) {
+    if (hasInheritedIdentity(env.CODEX_THREAD_ID)) {
+        throw new CliFault("CALLER_IDENTITY_CONFLICT");
+    }
+    return requireClaudeReplyAddress(env);
+}
+async function readMessageBody(stdin) {
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of stdin) {
+        if (typeof chunk !== "string" && !Buffer.isBuffer(chunk)) {
+            throw new CliFault("INVALID_MESSAGE_INPUT");
+        }
+        const buffer = Buffer.isBuffer(chunk)
+            ? Buffer.from(chunk)
+            : Buffer.from(chunk, "utf8");
+        length += buffer.length;
+        if (length > GATEWAY_CONTROL_MAX_MESSAGE_BYTES) {
+            throw new CliFault("MESSAGE_TOO_LARGE");
+        }
+        chunks.push(buffer);
+    }
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, length));
+    }
+    catch {
+        throw new CliFault("INVALID_MESSAGE_INPUT");
+    }
+    if (text.trim().length === 0 || text.includes("\0")) {
+        throw new CliFault("MESSAGE_REQUIRED");
+    }
+    return text;
+}
+function emptyParams(args) {
+    if (args.length !== 0)
+        throw new CliFault("INVALID_ARGUMENTS");
+    return {};
+}
+function parseServeInboundMode(args) {
+    const options = parseOptions(args, ["inbound"]);
+    if (Object.keys(options).length === 0)
+        return "paired";
+    assertExactOptionCount(options, 1);
+    if (options.inbound !== "open")
+        throw new CliFault("INVALID_ARGUMENTS");
+    return "open";
+}
+function validateLiveDashboardArgs(args) {
+    if (args.length === 0) {
+        throw new CliFault("INVALID_ARGUMENTS", false, "hint.dashboardLiveRequired");
+    }
+    const options = parseOptions(args, [], ["live"]);
+    assertExactOptionCount(options, 1);
+    if (options.live !== true)
+        throw new CliFault("INVALID_ARGUMENTS");
+}
+async function buildRequest(command, args, env, stdin) {
+    switch (command) {
+        case "serve":
+        case "dashboard":
+            throw new CliFault("INVALID_ARGUMENTS");
+        case "health":
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "health",
+                params: emptyParams(args),
+            };
+        case "status":
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "list_snapshot",
+                params: emptyParams(args),
+            };
+        case "compat-check":
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "compat_check",
+                params: emptyParams(args),
+            };
+        case "compat-certify": {
+            const options = parseOptions(args, ["codex"], ["with-turn"]);
+            assertExactOptionCount(options, 0, 2);
+            const codexAlias = options.codex === undefined
+                ? undefined
+                : requireCodexAlias(options, "codex");
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "compat_certify",
+                params: {
+                    withTurn: options["with-turn"] === true,
+                    ...(codexAlias === undefined ? {} : { codexAlias }),
+                },
+            };
+        }
+        case "delivery-status":
+        case "wait-delivery": {
+            const options = parseOptions(args, ["token"]);
+            assertExactOptionCount(options, 1);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "delivery_status",
+                params: { token: requireDeliveryToken(options, "token") },
+            };
+        }
+        case "untrack": {
+            const options = parseOptions(args, ["conversation"]);
+            assertExactOptionCount(options, 1);
+            const conversationId = requireString(options, "conversation");
+            if (!isGatewayConversationId(conversationId)) {
+                throw new CliFault("INVALID_ARGUMENTS");
+            }
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "untrack",
+                params: { conversationId },
+            };
+        }
+        case "refresh-dashboard":
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "refresh_dashboard",
+                params: emptyParams(args),
+            };
+        case "register-codex": {
+            const options = parseOptions(args, ["alias", "host", "succeeds"]);
+            const alias = requireCodexAlias(options, "alias");
+            const succeedsAlias = options.succeeds === undefined
+                ? undefined
+                : requireCodexAlias(options, "succeeds");
+            if (succeedsAlias === undefined) {
+                assertExactOptionCount(options, 1, 2);
+            }
+            else {
+                assertExactOptionCount(options, 2);
+                if (options.host !== undefined) {
+                    throw new CliFault("INVALID_ARGUMENTS");
+                }
+            }
+            const host = succeedsAlias === undefined
+                ? (options.host ?? DEFAULT_HOST_ID)
+                : gatewayAliasHost(alias);
+            if (typeof host !== "string" ||
+                !isGatewayHostId(host) ||
+                !alias.endsWith(`@${host}`) ||
+                (succeedsAlias !== undefined &&
+                    (succeedsAlias === alias ||
+                        gatewayAliasHost(succeedsAlias) !== host))) {
+                throw new CliFault("INVALID_ARGUMENTS");
+            }
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "register_codex",
+                params: {
+                    alias,
+                    threadId: requireExclusiveCodexThreadId(env),
+                    hostId: host,
+                    busyPolicy: "queue",
+                    ...(succeedsAlias === undefined ? {} : { succeedsAlias }),
+                },
+            };
+        }
+        case "unregister-codex": {
+            const options = parseOptions(args, ["alias"]);
+            assertExactOptionCount(options, 1);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "unregister_codex",
+                params: {
+                    alias: requireCodexAlias(options, "alias"),
+                    threadId: requireExclusiveCodexThreadId(env),
+                },
+            };
+        }
+        case "select-claude":
+        case "unselect-claude": {
+            const options = parseOptions(args, ["alias", "session"]);
+            assertExactOptionCount(options, 1);
+            const selector = options.alias === undefined
+                ? requireClaudeSelector(options, "session")
+                : requireClaudeSelector(options, "alias");
+            const codexThreadId = optionalCodexThreadId(env);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: command === "select-claude" ? "select_claude" : "unselect_claude",
+                params: {
+                    alias: selector,
+                    ...(codexThreadId === undefined ? {} : { codexThreadId }),
+                },
+            };
+        }
+        case "pair":
+        case "unpair": {
+            const options = parseOptions(args, ["claude", "codex"]);
+            assertExactOptionCount(options, 2);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: command,
+                params: {
+                    claudeAlias: requireClaudeSelector(options, "claude"),
+                    codexAlias: requireCodexAlias(options, "codex"),
+                    codexThreadId: requireExclusiveCodexThreadId(env),
+                },
+            };
+        }
+        case "send-to-claude": {
+            const options = parseOptions(args, ["from", "to", "idle-minutes"], ["expects-reply", "track"]);
+            assertExactOptionCount(options, 2, 5);
+            const threadId = requireExclusiveCodexThreadId(env);
+            const idleMinutes = trackIdleMinutes(options);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "send_to_claude",
+                params: {
+                    fromAlias: requireAlias(options, "from"),
+                    threadId,
+                    toAlias: requireClaudeSelector(options, "to"),
+                    text: await readMessageBody(stdin),
+                    expectsReply: options["expects-reply"] === true,
+                    ...(idleMinutes === undefined
+                        ? {}
+                        : { trackIdleMinutes: idleMinutes }),
+                },
+            };
+        }
+        case "send-to-codex": {
+            const options = parseOptions(args, ["from", "to", "idle-minutes"], ["expects-reply", "track"]);
+            assertExactOptionCount(options, 2, 5);
+            const replyAddress = requireExclusiveClaudeReplyAddress(env);
+            const idleMinutes = trackIdleMinutes(options);
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "send_to_codex",
+                params: {
+                    fromAlias: requireAlias(options, "from"),
+                    toAlias: requireAlias(options, "to"),
+                    text: await readMessageBody(stdin),
+                    replyAddress,
+                    expectsReply: options["expects-reply"] === true,
+                    ...(idleMinutes === undefined
+                        ? {}
+                        : { trackIdleMinutes: idleMinutes }),
+                },
+            };
+        }
+        case "reply": {
+            const options = parseOptions(args, ["conversation", "alias", "idle-minutes"], ["track"]);
+            assertExactOptionCount(options, 2, 4);
+            const conversationId = requireString(options, "conversation");
+            if (!isGatewayConversationId(conversationId)) {
+                throw new CliFault("INVALID_ARGUMENTS");
+            }
+            const alias = requireAlias(options, "alias");
+            const idleMinutes = trackIdleMinutes(options);
+            const threadId = env.CODEX_THREAD_ID;
+            const replyAddress = optionalClaudeReplyAddress(env);
+            const hasCodexIdentity = hasInheritedIdentity(threadId);
+            const hasClaudeIdentity = replyAddress !== undefined;
+            if (hasCodexIdentity && hasClaudeIdentity) {
+                throw new CliFault("CALLER_IDENTITY_CONFLICT");
+            }
+            if (!hasCodexIdentity && !hasClaudeIdentity) {
+                throw new CliFault("CALLER_IDENTITY_REQUIRED");
+            }
+            return {
+                protocolVersion: GATEWAY_CONTROL_PROTOCOL_VERSION,
+                method: "reply",
+                params: {
+                    conversationId,
+                    text: await readMessageBody(stdin),
+                    ...(idleMinutes === undefined
+                        ? {}
+                        : { trackIdleMinutes: idleMinutes }),
+                    caller: hasCodexIdentity
+                        ? {
+                            kind: "codex",
+                            alias,
+                            threadId: requireCodexThreadId(env),
+                        }
+                        : {
+                            kind: "claude",
+                            alias,
+                            replyAddress: requireClaudeReplyAddress(env),
+                        },
+                },
+            };
+        }
+    }
+}
+export async function validatePrivateGatewayControlSocket(stateDir, socketPath) {
+    if (process.platform === "win32") {
+        throw new CliFault("CONTROL_SOCKET_UNAVAILABLE", true);
+    }
+    let state;
+    let socket;
+    try {
+        [state, socket] = await Promise.all([lstat(stateDir), lstat(socketPath)]);
+    }
+    catch {
+        throw new CliFault("CONTROL_SOCKET_UNAVAILABLE", true);
+    }
+    const getuid = process.getuid;
+    const expectedUid = getuid?.call(process);
+    if (state.isSymbolicLink() ||
+        !state.isDirectory() ||
+        (state.mode & 0o700) !== 0o700 ||
+        (state.mode & 0o077) !== 0 ||
+        (expectedUid !== undefined && state.uid !== expectedUid)) {
+        throw new CliFault("CONTROL_STATE_UNSAFE", false, undefined, "unsafe");
+    }
+    if (socket.isSymbolicLink() ||
+        !socket.isSocket() ||
+        (socket.mode & 0o777) !== 0o600 ||
+        (expectedUid !== undefined && socket.uid !== expectedUid)) {
+        throw new CliFault("CONTROL_SOCKET_UNSAFE", false, undefined, "unsafe");
+    }
+    let stateReal;
+    let socketParentReal;
+    try {
+        [stateReal, socketParentReal] = await Promise.all([
+            realpath(stateDir),
+            realpath(path.dirname(socketPath)),
+        ]);
+    }
+    catch {
+        throw new CliFault("CONTROL_SOCKET_UNSAFE", false, undefined, "unsafe");
+    }
+    if (path.dirname(socketPath) !== stateDir ||
+        stateReal !== socketParentReal) {
+        throw new CliFault("CONTROL_SOCKET_UNSAFE", false, undefined, "unsafe");
+    }
+}
+function safeCommandLabel(command) {
+    return command ?? "unknown";
+}
+function serializedOutput(value) {
+    const line = `${JSON.stringify(value)}\n`;
+    if (Buffer.byteLength(line, "utf8") > CLI_MAX_OUTPUT_BYTES) {
+        throw new CliFault("OUTPUT_TOO_LARGE");
+    }
+    return line;
+}
+function writeFailure(stdout, stderr, locale, command, code, options) {
+    const ambiguous = options.ambiguous ?? false;
+    const retryable = options.retryable ?? false;
+    stdout.write(serializedOutput({
+        ok: false,
+        command: safeCommandLabel(command),
+        error: { code, ambiguous, retryable },
+    }));
+    stderr.write(fixedStderr(locale, options.kind));
+}
+function isRejectedResult(result) {
+    return (result !== null &&
+        typeof result === "object" &&
+        Object.hasOwn(result, "accepted") &&
+        result.accepted === false);
+}
+function responseExitCode(response) {
+    if (!response.ok)
+        return gatewayCliExitCodes.failure;
+    if (isRejectedResult(response.result))
+        return gatewayCliExitCodes.rejected;
+    return gatewayCliExitCodes.ok;
+}
+function waitDeliveryExitCode(response) {
+    if (!response.ok ||
+        !response.result.found ||
+        !response.result.terminal) {
+        return gatewayCliExitCodes.failure;
+    }
+    return response.result.state === "delivered"
+        ? gatewayCliExitCodes.ok
+        : gatewayCliExitCodes.failure;
+}
+async function defaultDelay(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function waitForDelivery(socketPath, request, sendRequest, now, delay) {
+    let clientDeadlineMs;
+    while (true) {
+        const beforeRequest = now();
+        let requestTimeoutMs = GATEWAY_CONTROL_DEFAULT_TIMEOUT_MS;
+        if (clientDeadlineMs !== undefined) {
+            const remainingMs = clientDeadlineMs - beforeRequest;
+            if (remainingMs <= 0)
+                return { kind: "timeout" };
+            if (remainingMs < DELIVERY_POLL_MIN_REQUEST_TIMEOUT_MS) {
+                await delay(remainingMs);
+                return { kind: "timeout" };
+            }
+            requestTimeoutMs = Math.min(GATEWAY_CONTROL_DEFAULT_TIMEOUT_MS, Math.floor(remainingMs));
+        }
+        let response;
+        try {
+            response = await sendRequest({
+                socketPath,
+                request,
+                timeoutMs: requestTimeoutMs,
+            });
+        }
+        catch (error) {
+            if (clientDeadlineMs !== undefined &&
+                now() >= clientDeadlineMs &&
+                error instanceof GatewayControlTransportError &&
+                error.recoverable) {
+                return { kind: "timeout" };
+            }
+            throw error;
+        }
+        if (!response.ok) {
+            if (response.error.code === "REQUEST_TIMEOUT" &&
+                clientDeadlineMs !== undefined &&
+                now() >= clientDeadlineMs) {
+                return { kind: "timeout" };
+            }
+            return { kind: "response", response };
+        }
+        if (!response.result.found)
+            return { kind: "unknown" };
+        // A retained terminal decision is authoritative even when the command is
+        // invoked after the original delivery deadline and client grace window.
+        if (response.result.terminal) {
+            return { kind: "response", response };
+        }
+        const parsedDeadlineMs = Date.parse(response.result.deadlineAt);
+        if (!Number.isFinite(parsedDeadlineMs)) {
+            throw new Error("invalid validated delivery deadline");
+        }
+        const observedClientDeadlineMs = parsedDeadlineMs + GATEWAY_CONTROL_DEFAULT_TIMEOUT_MS;
+        clientDeadlineMs =
+            clientDeadlineMs === undefined
+                ? observedClientDeadlineMs
+                : Math.min(clientDeadlineMs, observedClientDeadlineMs);
+        const afterRequest = now();
+        const remainingMs = clientDeadlineMs - afterRequest;
+        if (remainingMs <= 0)
+            return { kind: "timeout" };
+        await delay(Math.min(DELIVERY_POLL_INTERVAL_MS, remainingMs));
+    }
+}
+/** Run one command; foreground runners own and release their signal handlers. */
+export async function runGatewayCli(argv = process.argv.slice(2), dependencies = {}) {
+    const env = dependencies.env ?? process.env;
+    const stdin = dependencies.stdin ?? process.stdin;
+    const stdout = dependencies.stdout ?? process.stdout;
+    const stderr = dependencies.stderr ?? process.stderr;
+    const loadConfig = dependencies.loadConfig ?? loadGatewayConfig;
+    const sendRequest = dependencies.sendRequest ?? sendGatewayControlRequest;
+    const validateControlSocket = dependencies.validateControlSocket ?? validatePrivateGatewayControlSocket;
+    const runServer = dependencies.runServer ?? runGatewayServer;
+    const runLiveDashboard = dependencies.runLiveDashboard ?? runLiveDashboardCommand;
+    const now = dependencies.now ?? Date.now;
+    const delay = dependencies.delay ?? defaultDelay;
+    if (argv.length === 1 &&
+        (argv[0] === "--version" || argv[0] === "-v")) {
+        stdout.write(`embassy ${EMBASSY_VERSION}\n`);
+        return gatewayCliExitCodes.ok;
+    }
+    const command = isCommand(argv[0]) ? argv[0] : undefined;
+    let locale = fallbackCliLocale(argv.slice(1), env);
+    let serverReadyEmitted = false;
+    let liveDashboardReadyEmitted = false;
+    try {
+        const common = resolveCommonCliOptions(argv.slice(1), env);
+        locale = common.locale;
+        if (argv.length === 0 ||
+            argv[0] === "--help" ||
+            argv[0] === "-h") {
+            emptyParams(common.args);
+            stdout.write(getCliCopy(locale)["help.usage"]);
+            return gatewayCliExitCodes.ok;
+        }
+        if (command === undefined)
+            throw new CliFault("UNKNOWN_COMMAND");
+        if (command === "serve") {
+            const inboundMode = parseServeInboundMode(common.args);
+            await runServer({
+                env,
+                locale,
+                inboundMode,
+                ...(dependencies.serverSignal === undefined
+                    ? {}
+                    : { signal: dependencies.serverSignal }),
+                onReady: async (result) => {
+                    if (serverReadyEmitted) {
+                        throw new CliFault("SERVER_READY_ALREADY_EMITTED");
+                    }
+                    stdout.write(serializedOutput({
+                        ok: true,
+                        command,
+                        result,
+                    }));
+                    serverReadyEmitted = true;
+                },
+            });
+            if (!serverReadyEmitted) {
+                throw new CliFault("SERVER_NOT_READY");
+            }
+            return gatewayCliExitCodes.ok;
+        }
+        if (command === "dashboard") {
+            validateLiveDashboardArgs(common.args);
+            const outcome = await runLiveDashboard({
+                env,
+                locale,
+                ...(dependencies.liveDashboardSignal === undefined
+                    ? {}
+                    : { signal: dependencies.liveDashboardSignal }),
+                loadConfig,
+                validateControlSocket,
+                sendRequest,
+                onReady: async (result) => {
+                    if (liveDashboardReadyEmitted) {
+                        throw new CliFault("LIVE_DASHBOARD_READY_ALREADY_EMITTED");
+                    }
+                    stdout.write(serializedOutput({
+                        ok: true,
+                        command,
+                        result,
+                    }));
+                    liveDashboardReadyEmitted = true;
+                },
+            });
+            if (!liveDashboardReadyEmitted) {
+                if (outcome?.status === "cancelled") {
+                    return gatewayCliExitCodes.ok;
+                }
+                throw new Error("LIVE_DASHBOARD_NOT_READY");
+            }
+            return gatewayCliExitCodes.ok;
+        }
+        const request = await buildRequest(command, common.args, env, stdin);
+        const config = loadConfig(env);
+        await validateControlSocket(config.stateDir, config.controlSocketPath);
+        let response;
+        let waitedDeliveryResponse;
+        if (command === "wait-delivery") {
+            if (request.method !== "delivery_status") {
+                throw new CliFault("INVALID_ARGUMENTS");
+            }
+            const outcome = await waitForDelivery(config.controlSocketPath, request, sendRequest, now, delay);
+            if (outcome.kind === "unknown") {
+                writeFailure(stdout, stderr, locale, command, "DELIVERY_TOKEN_UNKNOWN", {
+                    kind: "tokenUnknown",
+                });
+                return gatewayCliExitCodes.rejected;
+            }
+            if (outcome.kind === "timeout") {
+                writeFailure(stdout, stderr, locale, command, "DELIVERY_WAIT_TIMEOUT", {
+                    retryable: true,
+                    kind: "deliveryTimeout",
+                });
+                return gatewayCliExitCodes.unavailable;
+            }
+            waitedDeliveryResponse = outcome.response;
+            response = waitedDeliveryResponse;
+        }
+        else {
+            response = await sendRequest({
+                socketPath: config.controlSocketPath,
+                request,
+                ...(command === "compat-certify"
+                    ? { timeoutMs: COMPAT_CERTIFY_CONTROL_TIMEOUT_MS }
+                    : {}),
+            });
+        }
+        if (!response.ok) {
+            writeFailure(stdout, stderr, locale, command, response.error.code, {
+                kind: "failure",
+            });
+            return gatewayCliExitCodes.failure;
+        }
+        stdout.write(serializedOutput({
+            ok: true,
+            command,
+            result: response.result,
+        }));
+        if (command === "compat-check" && isCompatibilityCheckReport(response.result)) {
+            for (const surface of response.result.surfaces) {
+                stderr.write(`[embassy] ${surface.surface}: ${surface.tier} (${surface.version})${surface.safeErrorCode === undefined
+                    ? ""
+                    : ` — ${surface.safeErrorCode}`}\n`);
+            }
+            return response.result.compatible
+                ? gatewayCliExitCodes.ok
+                : gatewayCliExitCodes.failure;
+        }
+        if (command === "compat-certify" &&
+            isCompatibilityCertificationReport(response.result)) {
+            for (const surface of response.result.surfaces) {
+                const certification = surface.certification;
+                if (certification === undefined)
+                    continue;
+                stderr.write(`[embassy] ${surface.surface}: ${certification.outcome} (${certification.depth})${certification.safeErrorCode === undefined
+                    ? ""
+                    : ` — ${certification.safeErrorCode}`}\n`);
+            }
+            if (response.result.certified)
+                return gatewayCliExitCodes.ok;
+            const failedSurfaces = response.result.surfaces.filter((surface) => surface.certification?.outcome === "fail");
+            if (failedSurfaces.length > 1) {
+                return gatewayCliExitCodes.multipleCertificationsFailed;
+            }
+            return failedSurfaces[0]?.surface === "claude"
+                ? gatewayCliExitCodes.claudeCertificationFailed
+                : gatewayCliExitCodes.codexCertificationFailed;
+        }
+        const exitCode = waitedDeliveryResponse === undefined
+            ? responseExitCode(response)
+            : waitDeliveryExitCode(waitedDeliveryResponse);
+        if (exitCode === gatewayCliExitCodes.rejected) {
+            stderr.write(fixedStderr(locale, "decision"));
+        }
+        else if (command === "wait-delivery" &&
+            exitCode === gatewayCliExitCodes.failure) {
+            stderr.write(fixedStderr(locale, "failure"));
+        }
+        return exitCode;
+    }
+    catch (error) {
+        if ((command === "serve" && serverReadyEmitted) ||
+            (command === "dashboard" && liveDashboardReadyEmitted)) {
+            stderr.write(fixedStderr(locale, "failure"));
+            return gatewayCliExitCodes.failure;
+        }
+        if (error instanceof GatewayControlTransportError) {
+            const ambiguous = error.ambiguous;
+            writeFailure(stdout, stderr, locale, command, error.code, {
+                ambiguous,
+                retryable: ambiguous ? false : error.recoverable,
+                kind: ambiguous ? "ambiguous" : "unavailable",
+            });
+            return ambiguous
+                ? gatewayCliExitCodes.ambiguous
+                : gatewayCliExitCodes.unavailable;
+        }
+        if (error instanceof CliFault) {
+            writeFailure(stdout, stderr, locale, command, error.code, {
+                retryable: error.retryable,
+                kind: error.kind ?? (error.retryable ? "unavailable" : "input"),
+            });
+            if (error.hint !== undefined) {
+                stderr.write(`[embassy] ${getCliCopy(locale)[error.hint]}\n`);
+            }
+            return error.retryable
+                ? gatewayCliExitCodes.unavailable
+                : gatewayCliExitCodes.invalidInput;
+        }
+        if (error instanceof BridgeError) {
+            writeFailure(stdout, stderr, locale, command, error.code, {
+                retryable: error.recoverable,
+                kind: error.code === "CLAUDE_VERSION_DRIFT"
+                    ? "versionDrift"
+                    : error.recoverable
+                        ? "unavailable"
+                        : "input",
+            });
+            return error.recoverable
+                ? gatewayCliExitCodes.unavailable
+                : gatewayCliExitCodes.invalidInput;
+        }
+        writeFailure(stdout, stderr, locale, command, "INTERNAL_ERROR", {
+            kind: "failure",
+        });
+        return gatewayCliExitCodes.failure;
+    }
+}
+function isDirectExecution() {
+    const entry = process.argv[1];
+    if (entry === undefined)
+        return false;
+    try {
+        // npm exposes package binaries through symlinks. Compare canonical paths
+        // so an installed `embassy` executable is recognized as the entry point,
+        // while importing this module in tests remains side-effect free.
+        return realpathSync(entry) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isDirectExecution()) {
+    void runGatewayCli().then((exitCode) => {
+        process.exitCode = exitCode;
+    }, () => {
+        process.stderr.write(fixedStderr(fallbackCliLocale(process.argv.slice(3), process.env), "failure"));
+        process.exitCode = gatewayCliExitCodes.failure;
+    });
+}
+//# sourceMappingURL=cli.js.map