@cydm/happy-elves 0.1.0-beta.30 → 0.1.0-beta.301

package/apps/cli/dist/commands/app.js

@@ -4,13 +4,18 @@ import { handleAccount } from "./account.js";
 import { handleCollect } from "./collect.js";
 import { handleConfig } from "./config.js";
 import { handleDaemon } from "./daemon.js";
+import { handleGateway } from "./gateway.js";
 import { handleLoop } from "./loop.js";
 import { handleMachine } from "./machine.js";
+import { handleMemory } from "./memory.js";
 import { handleRelay } from "./relay.js";
+import { handleRelease } from "./release.js";
+import { handleSchedule } from "./schedule.js";
 import { handleRemote } from "./remote.js";
 import { handleSession } from "./session.js";
 import { handleToken } from "./token.js";
 import { handleTurn } from "./turn.js";
+import { handleWorkspace } from "./workspace.js";
 import { commandUsage, commandUsageText, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
 export { handleCliError };
 const domainHandlers = [
@@ -18,12 +23,17 @@ const domainHandlers = [
     handleConfig,
     handleRemote,
     handleToken,
+    handleGateway,
     handleLoop,
     handleDaemon,
     handleRelay,
+    handleRelease,
     handleMachine,
+    handleMemory,
+    handleSchedule,
     handleSession,
     handleTurn,
+    handleWorkspace,
     handleCollect,
 ];
 export async function main() {

package/apps/cli/dist/commands/daemon.js

@@ -1,6 +1,6 @@
 import os from "node:os";
 import path from "node:path";
-import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, wantsJson, writeDaemonConfig } from "./lib/index.js";
+import { CliError, compactText, ControllerClient, configDir, configPath, daemonPidPath, deriveOrchestration, ensureDaemonRunning, idleSessionStatuses, localDaemonStatus, ok, parsePairingClaimResponse, randomId, readConfig, readDaemonConfig, readLocalAuditLog, readRelayJson, redactedDaemonConfig, requirePositional, requireRelayUrl, requireString, restartDaemonForNewConfig, showMachine, spawnDaemonStart, stopLocalDaemon, throwRelayHttpError, waitForMachineProjection, wantsJson, writeDaemonConfig } from "./lib/index.js";
 export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "pair") {
         const relayUrl = requireRelayUrl(flags);
@@ -25,11 +25,87 @@ export async function handleDaemon({ domain, action, flags }) {
             machineToken: claimed.machineToken,
             accountSecret,
         };
+        const localBefore = await localDaemonStatus();
         const daemonConfigPath = await writeDaemonConfig(daemonConfig);
-        ok("daemon.pair", {
+        let daemonStart = { skipped: true, reason: "not requested" };
+        let projection = { checked: false, reason: "not checked" };
+        let startError;
+        if (flags["no-start"] === true) {
+            daemonStart = { skipped: true, reason: "--no-start" };
+            projection = { checked: false, reason: "--no-start" };
+        }
+        else {
+            try {
+                const startResult = localBefore.running
+                    ? await restartDaemonForNewConfig(relayUrl)
+                    : await ensureDaemonRunning(relayUrl);
+                daemonStart = {
+                    skipped: false,
+                    restarted: localBefore.running,
+                    local: startResult.local,
+                    started: startResult.started,
+                    ...(startResult.startedPid ? { startedPid: startResult.startedPid } : {}),
+                    ...("stopped" in startResult ? { stop: startResult.stopped } : {}),
+                };
+                try {
+                    const controllerConfig = await readConfig({ relay: relayUrl });
+                    const machine = await waitForMachineProjection(new ControllerClient(controllerConfig), claimed.machineId, 10_000);
+                    projection = {
+                        checked: true,
+                        online: machine?.online === true,
+                        machineId: claimed.machineId,
+                        ...(machine?.lastSeen ? { lastSeen: machine.lastSeen } : {}),
+                    };
+                }
+                catch (error) {
+                    projection = {
+                        checked: false,
+                        reason: error instanceof Error ? error.message : String(error),
+                    };
+                }
+            }
+            catch (error) {
+                const code = error instanceof CliError ? error.code : "DAEMON_START_FAILED";
+                startError = { code, message: error instanceof Error ? error.message : String(error) };
+                process.exitCode = 1;
+                daemonStart = { skipped: true, reason: "start failed" };
+                projection = { checked: false, reason: "daemon did not start" };
+            }
+        }
+        const data = {
             path: daemonConfigPath,
             config: redactedDaemonConfig(daemonConfig),
-        });
+            daemon: daemonStart,
+            projection,
+            ...(startError ? { error: startError } : {}),
+        };
+        const commandOk = !startError && !(projection.checked && !projection.online);
+        if (!commandOk)
+            process.exitCode = 1;
+        if (!wantsJson(flags)) {
+            console.log(`Paired ${machineName} with ${relayUrl}`);
+            console.log(`Config: ${daemonConfigPath}`);
+            if (startError) {
+                console.error(`Daemon start failed: ${startError.message}`);
+            }
+            else if (daemonStart.skipped) {
+                console.log(`Daemon start: skipped (${daemonStart.reason})`);
+            }
+            else {
+                console.log(`${daemonStart.restarted ? "Restarted" : "Started"} daemon${daemonStart.startedPid ? ` pid ${daemonStart.startedPid}` : ""}`);
+            }
+            if (projection.checked) {
+                console.log(`Relay projection: ${projection.online ? "online" : "offline"} (${projection.machineId})`);
+                if (!projection.online) {
+                    console.log("If this stays offline, run happy-elves daemon logs --tail 100 and happy-elves daemon status --local.");
+                }
+            }
+            else {
+                console.log(`Relay projection: not checked (${projection.reason})`);
+            }
+            return true;
+        }
+        ok("daemon.pair", data, { machineId: claimed.machineId }, commandOk);
         return true;
     }
     if (domain === "daemon" && action === "doctor") {
@@ -57,9 +133,13 @@ export async function handleDaemon({ domain, action, flags }) {
             for (const check of checks) {
                 console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
             }
+            if (!data.ok)
+                process.exitCode = 1;
             return true;
         }
-        ok("daemon.doctor", data);
+        if (!data.ok)
+            process.exitCode = 1;
+        ok("daemon.doctor", data, {}, data.ok);
         return true;
     }
     if (domain === "daemon" && action === "config") {
@@ -114,6 +194,14 @@ export async function handleDaemon({ domain, action, flags }) {
     if (domain === "daemon" && action === "start") {
         const status = await localDaemonStatus();
         if (status.running) {
+            const existingConfig = await readDaemonConfig();
+            if (typeof flags.relay === "string")
+                existingConfig.relayUrl = requireRelayUrl(flags);
+            const restarted = await ensureDaemonRunning(existingConfig.relayUrl);
+            if (restarted.started) {
+                ok("daemon.start", { ...restarted.local, started: true, startedPid: restarted.startedPid, restartedForChangedConfig: true });
+                return true;
+            }
             ok("daemon.start", { ...status, started: false });
             return true;
         }

package/apps/cli/dist/commands/gateway.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleGateway({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/gateway.js

@@ -0,0 +1,410 @@
+import { createHash } from "node:crypto";
+import { createServer } from "node:http";
+import { encryptJson } from "../../../../packages/shared/dist/index.js";
+import { CliError, ControllerClient, ok, readConfig, readGatewayStore, requireString, updateGatewayStore, wantsJson, } from "./lib/index.js";
+export async function handleGateway({ domain, action, positional, flags }) {
+    if (domain !== "gateway")
+        return false;
+    if (action === "enable") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const type = gatewayChannelType(typeof flags.channel === "string" ? flags.channel : "fake");
+        const id = gatewayChannelId(flags, positional[0], type);
+        const targetMachineId = requireString(flags, "machine");
+        const targetCwd = typeof flags.cwd === "string" ? flags.cwd : undefined;
+        const targetSessionId = typeof flags.session === "string" ? flags.session : undefined;
+        if (!targetCwd && !targetSessionId)
+            throw new CliError("Gateway enable requires --cwd or --session", "MISSING_ARGUMENT");
+        const defaultAgent = typeof flags.agent === "string" ? flags.agent : "codex";
+        const defaultModel = typeof flags.model === "string" ? flags.model : undefined;
+        const appId = typeof flags["app-id"] === "string" ? flags["app-id"] : undefined;
+        const appSecret = flags["app-secret-stdin"] === true ? await readSecretFromStdin() : undefined;
+        const domainValue = typeof flags.domain === "string" ? flags.domain : "feishu";
+        if (domainValue !== "feishu" && domainValue !== "lark")
+            throw new CliError("Gateway --domain must be feishu or lark", "INVALID_ARGUMENT");
+        const inboundMode = typeof flags.inbound === "string" ? flags.inbound : "mention";
+        if (inboundMode !== "mention" && inboundMode !== "all")
+            throw new CliError("Gateway --inbound must be mention or all", "INVALID_ARGUMENT");
+        const reactionEmoji = typeof flags["reaction-emoji"] === "string" ? flags["reaction-emoji"] : "Typing";
+        const allowedChatIds = csvFlag(flags["allow-chat"]);
+        const allowedSenderIds = csvFlag(flags["allow-sender"]);
+        const allowAnySender = flags["allow-any-sender"] === true;
+        if (type === "lark" && (!appId || !appSecret)) {
+            throw new CliError("Lark gateway requires --app-id and --app-secret-stdin; appSecret is stored only in the target daemon config.", "MISSING_ARGUMENT");
+        }
+        if (type === "lark" && !allowAnySender && allowedChatIds.length === 0 && allowedSenderIds.length === 0) {
+            throw new CliError("Lark gateway requires --allow-any-sender or at least one --allow-chat/--allow-sender policy.", "MISSING_ARGUMENT");
+        }
+        if (type === "lark" && (typeof flags.token === "string" || typeof flags.secret === "string")) {
+            throw new CliError("Lark gateway no longer accepts --token/--secret; use --app-id and --app-secret-stdin.", "INVALID_ARGUMENT");
+        }
+        const result = await client.gateway({
+            machineId: targetMachineId,
+            action: "upsert",
+            channel: {
+                id,
+                type,
+                enabled: true,
+                targetMachineId,
+                targetSessionId,
+                targetCwd,
+                defaultAgent,
+                ...(defaultModel ? { defaultModel } : {}),
+                ...(type === "lark" ? {
+                    domain: domainValue,
+                    appId,
+                    appSecret,
+                    inboundMode,
+                    allowAnySender,
+                    ...(allowedChatIds.length > 0 ? { allowedChatIds } : {}),
+                    ...(allowedSenderIds.length > 0 ? { allowedSenderIds } : {}),
+                    processingReaction: {
+                        enabled: flags["disable-reaction"] !== true,
+                        emojiType: reactionEmoji,
+                    },
+                } : {}),
+            },
+        });
+        ok("gateway.enable", { channel: result.channel });
+        return true;
+    }
+    if (action === "disable") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
+        const id = gatewayChannelId(flags, positional[0], "fake");
+        const result = await client.gateway({ machineId, action: "disable", channelId: id });
+        ok("gateway.disable", { channel: result.channel });
+        return true;
+    }
+    if (action === "status") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
+        const result = await client.gateway({ machineId, action: "list" });
+        const includeDebug = flags["include-debug"] === true;
+        const channels = (result.channels ?? []).filter((channel) => includeDebug || channel.type === "lark");
+        const data = { machineId, channels };
+        if (!wantsJson(flags)) {
+            if (data.channels.length === 0) {
+                console.log(includeDebug ? "No gateways configured." : "No product gateways configured.");
+                return true;
+            }
+            for (const channel of data.channels) {
+                const target = channel.targetSessionId ? `session:${channel.targetSessionId}` : channel.targetCwd ?? "";
+                console.log(`${channel.id}  ${channel.type}  ${channel.enabled ? "enabled" : "disabled"}  ${target}  ${channel.listening ? "listening" : "stopped"}`);
+            }
+            return true;
+        }
+        ok("gateway.status", data);
+        return true;
+    }
+    if (action === "test") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
+        const channelId = gatewayChannelId(flags, positional[0], "fake");
+        const externalConversationId = requireString(flags, "conversation");
+        const externalMessageId = requireString(flags, "message-id");
+        const text = requireString(flags, "text");
+        const result = await client.gateway({
+            machineId,
+            action: "test",
+            channelId,
+            externalConversationId,
+            externalMessageId,
+            text,
+        });
+        ok("gateway.test", result);
+        return true;
+    }
+    if (action === "serve") {
+        const config = await readConfig(flags);
+        const port = Number(typeof flags.port === "string" ? flags.port : "8789");
+        if (!Number.isInteger(port) || port < 1 || port > 65_535)
+            throw new CliError("Invalid --port", "INVALID_ARGUMENT");
+        const host = typeof flags.host === "string" ? flags.host : "127.0.0.1";
+        const server = createServer((request, response) => {
+            void handleGatewayHttpRequest({ request, response, config, host, port }).catch((error) => {
+                writeGatewayHttpJson(response, error instanceof CliError ? 400 : 500, {
+                    ok: false,
+                    error: {
+                        code: error instanceof CliError ? error.code : "GATEWAY_REQUEST_FAILED",
+                        message: error instanceof Error ? error.message : String(error),
+                    },
+                });
+            });
+        });
+        await new Promise((resolve) => server.listen(port, host, resolve));
+        if (wantsJson(flags)) {
+            console.log(JSON.stringify({ ok: true, type: "gateway.serve", data: { host, port } }, null, 2));
+        }
+        else {
+            console.log(`Gateway listening on http://${host}:${port}`);
+        }
+        await new Promise((resolve) => {
+            const stop = () => server.close(() => resolve());
+            process.once("SIGTERM", stop);
+            process.once("SIGINT", stop);
+        });
+        return true;
+    }
+    return false;
+}
+async function handleGatewayHttpRequest(input) {
+    const { request, response, config } = input;
+    if (request.method === "GET" && request.url === "/health") {
+        writeGatewayHttpJson(response, 200, { ok: true, service: "happy-elves-gateway" });
+        return;
+    }
+    const url = new URL(request.url ?? "/", `http://${input.host}:${input.port}`);
+    const match = /^\/gateway\/([^/]+)$/.exec(url.pathname);
+    if (request.method !== "POST" || !match) {
+        writeGatewayHttpJson(response, 404, { ok: false, error: { code: "NOT_FOUND", message: "Gateway route not found" } });
+        return;
+    }
+    const channelId = decodeURIComponent(match[1]);
+    const store = await readGatewayStore();
+    const channel = mustFindEnabledChannel(store, channelId);
+    const body = await readJsonRequestBody(request);
+    if (channel.type === "lark" && isLarkChallenge(body)) {
+        writeGatewayHttpJson(response, 200, { challenge: body.challenge });
+        return;
+    }
+    assertGatewayToken(channel, request, body);
+    const message = channel.type === "lark" ? larkMessageFromBody(body) : fakeGatewayMessageFromBody(body);
+    const result = await deliverGatewayMessage({
+        store,
+        channel,
+        client: new ControllerClient(config),
+        accountSecret: config.accountSecret,
+        externalConversationId: message.externalConversationId,
+        externalMessageId: message.externalMessageId,
+        text: message.text,
+    });
+    writeGatewayHttpJson(response, 200, { ok: true, type: "gateway.deliver", data: result });
+}
+async function deliverGatewayMessage(input) {
+    const { channel, client, accountSecret, externalConversationId, externalMessageId, text } = input;
+    let store = input.store;
+    let mapping = store.mappings.find((item) => item.channelId === channel.id && item.externalConversationId === externalConversationId);
+    const createRequestId = stableGatewayId("gw_create", channel.id, externalConversationId);
+    if (!mapping) {
+        const create = await client.sendCommand({
+            type: "controller:createSession",
+            requestId: createRequestId,
+            machineId: channel.targetMachineId,
+            agent: channel.defaultAgent,
+            cwd: channel.targetCwd,
+            name: `Gateway ${channel.type}: ${externalConversationId}`,
+            encryptedMetadata: await encryptJson(accountSecret, `gateway:create:${createRequestId}`, {
+                createdFrom: "gateway",
+                gateway: {
+                    channelId: channel.id,
+                    channelType: channel.type,
+                    externalConversationId,
+                },
+                agent: channel.defaultAgent,
+                cwd: channel.targetCwd,
+                name: `Gateway ${channel.type}: ${externalConversationId}`,
+            }),
+        }, false, 15_000);
+        if (!create.sessionId)
+            throw new CliError("Gateway session admission did not return a sessionId", "GATEWAY_CREATE_FAILED");
+        const now = new Date().toISOString();
+        mapping = {
+            channelId: channel.id,
+            externalConversationId,
+            sessionId: create.sessionId,
+            createRequestId,
+            createdAt: now,
+            updatedAt: now,
+        };
+        store = await updateGatewayStore((current) => ({
+            ...current,
+            mappings: [mapping, ...current.mappings.filter((item) => !(item.channelId === channel.id && item.externalConversationId === externalConversationId))],
+        }));
+    }
+    const requestId = stableGatewayId("gw_msg", channel.id, externalConversationId, externalMessageId);
+    const turnId = stableGatewayId("turn_gw", channel.id, externalConversationId, externalMessageId);
+    const sent = await client.sendCommand({
+        type: "controller:prompt",
+        requestId,
+        sessionId: mapping.sessionId,
+        turnId,
+        encryptedPrompt: await encryptJson(accountSecret, `gateway:prompt:${mapping.sessionId}:${turnId}`, {
+            type: "user_prompt",
+            text,
+        }),
+        permissionMode: "approve-reads",
+    }, false, 15_000);
+    const deliveredAt = new Date().toISOString();
+    const lastDeliveredMessage = {
+        externalConversationId,
+        externalMessageId,
+        requestId,
+        sessionId: mapping.sessionId,
+        turnId: sent.turnId ?? turnId,
+        deliveredAt,
+    };
+    await updateGatewayStore((current) => ({
+        ...current,
+        channels: current.channels.map((item) => item.id === channel.id ? {
+            ...item,
+            lastError: undefined,
+            lastDeliveredMessage,
+            updatedAt: deliveredAt,
+        } : item),
+        mappings: current.mappings.map((item) => item.channelId === channel.id && item.externalConversationId === externalConversationId
+            ? { ...item, sessionId: mapping.sessionId, createRequestId, updatedAt: deliveredAt }
+            : item),
+    }));
+    return {
+        channelId: channel.id,
+        externalConversationId,
+        externalMessageId,
+        sessionId: mapping.sessionId,
+        requestId,
+        turnId: sent.turnId ?? turnId,
+        admission: sent.admission,
+        dispatch: sent.dispatch,
+    };
+}
+function stableGatewayId(prefix, ...parts) {
+    const hash = createHash("sha256").update(parts.join("\0")).digest("base64url").slice(0, 32);
+    return `${prefix}_${hash}`;
+}
+async function readJsonRequestBody(request) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        size += buffer.length;
+        if (size > 1024 * 1024)
+            throw new CliError("Gateway request body is too large", "REQUEST_TOO_LARGE");
+        chunks.push(buffer);
+    }
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
+    }
+    catch {
+        throw new CliError("Gateway request body must be JSON", "INVALID_JSON");
+    }
+}
+function writeGatewayHttpJson(response, statusCode, body) {
+    response.writeHead(statusCode, { "content-type": "application/json; charset=utf-8" });
+    response.end(`${JSON.stringify(body)}\n`);
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isLarkChallenge(value) {
+    return isRecord(value) && typeof value.challenge === "string";
+}
+function assertGatewayToken(channel, request, body) {
+    if (!channel.localToken)
+        return;
+    const auth = request.headers.authorization;
+    const bearer = typeof auth === "string" && auth.startsWith("Bearer ") ? auth.slice("Bearer ".length) : undefined;
+    const record = isRecord(body) ? body : {};
+    const header = isRecord(record.header) ? record.header : {};
+    const token = bearer ?? stringField(record, "token") ?? stringField(header, "token") ?? headerValue(request, "x-happy-elves-token");
+    if (token !== channel.localToken)
+        throw new CliError("Gateway token is invalid", "GATEWAY_TOKEN_INVALID");
+}
+function headerValue(request, key) {
+    const value = request.headers[key.toLowerCase()];
+    return typeof value === "string" ? value : undefined;
+}
+function fakeGatewayMessageFromBody(body) {
+    const record = isRecord(body) ? body : {};
+    const externalConversationId = stringField(record, "externalConversationId") ?? stringField(record, "conversationId");
+    const externalMessageId = stringField(record, "externalMessageId") ?? stringField(record, "messageId");
+    const text = stringField(record, "text");
+    if (!externalConversationId || !externalMessageId || !text) {
+        throw new CliError("Fake gateway body requires conversationId, messageId, and text", "GATEWAY_MESSAGE_INVALID");
+    }
+    return { externalConversationId, externalMessageId, text };
+}
+function larkMessageFromBody(body) {
+    const record = isRecord(body) ? body : {};
+    const event = isRecord(record.event) ? record.event : record;
+    const message = isRecord(event.message) ? event.message : event;
+    const sender = isRecord(event.sender) ? event.sender : {};
+    const senderId = isRecord(sender.sender_id) ? sender.sender_id : {};
+    const externalMessageId = stringField(message, "message_id") ?? stringField(event, "message_id") ?? stringField(record, "uuid");
+    const externalConversationId = stringField(message, "chat_id") ??
+        stringField(event, "chat_id") ??
+        stringField(event, "open_chat_id") ??
+        stringField(senderId, "open_id");
+    const text = larkTextFromContent(message.content) ?? stringField(message, "text");
+    if (!externalConversationId || !externalMessageId || !text) {
+        throw new CliError("Lark gateway event is not a supported text message", "GATEWAY_MESSAGE_INVALID");
+    }
+    return { externalConversationId, externalMessageId, text };
+}
+function larkTextFromContent(content) {
+    if (typeof content === "string") {
+        try {
+            const parsed = JSON.parse(content);
+            if (isRecord(parsed))
+                return stringField(parsed, "text");
+        }
+        catch {
+            return content;
+        }
+    }
+    if (isRecord(content))
+        return stringField(content, "text");
+    return undefined;
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function gatewayChannelType(value) {
+    if (value === "fake" || value === "lark")
+        return value;
+    throw new CliError("Gateway channel must be fake or lark", "INVALID_ARGUMENT");
+}
+function gatewayChannelId(flags, positional, fallbackType) {
+    return positional || (typeof flags.name === "string" ? flags.name : undefined) || (typeof flags.channel === "string" ? flags.channel : fallbackType);
+}
+function csvFlag(value) {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function readSecretFromStdin() {
+    let value = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) {
+        value += chunk;
+    }
+    const secret = value.trim();
+    if (!secret)
+        throw new CliError("--app-secret-stdin was set but stdin was empty", "MISSING_ARGUMENT");
+    return secret;
+}
+async function resolveGatewayMachineId(client, flags) {
+    if (typeof flags.machine === "string" && flags.machine.length > 0)
+        return flags.machine;
+    const snapshot = await client.snapshot();
+    const machine = snapshot.machines.find((item) => item.online) ?? snapshot.machines[0];
+    if (!machine)
+        throw new CliError("No daemon machine is available; pass --machine <machineId>", "MACHINE_NOT_FOUND");
+    return machine.id;
+}
+function mustFindChannel(store, id) {
+    const channel = store.channels.find((item) => item.id === id);
+    if (!channel)
+        throw new CliError("Gateway channel not found", "GATEWAY_NOT_FOUND");
+    return channel;
+}
+function mustFindEnabledChannel(store, id) {
+    const channel = mustFindChannel(store, id);
+    if (!channel.enabled)
+        throw new CliError("Gateway channel is disabled", "GATEWAY_DISABLED");
+    return channel;
+}
+//# sourceMappingURL=gateway.js.map