@cydm/happy-elves 0.1.0-beta.49 → 0.1.0-beta.490

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

@@ -0,0 +1,429 @@
+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 === "notify") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
+        const channelId = gatewayChannelId(flags, positional[0], "lark");
+        const externalConversationId = requireString(flags, "conversation");
+        const externalMessageId = typeof flags["message-id"] === "string" ? flags["message-id"] : `notify_${Date.now()}`;
+        const text = requireString(flags, "text");
+        const result = await client.gateway({
+            machineId,
+            action: "notify",
+            channelId,
+            externalConversationId,
+            externalMessageId,
+            text,
+        });
+        ok("gateway.notify", 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

package/apps/cli/dist/commands/lib/args.js

@@ -2,87 +2,160 @@ import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/d
 import { CliError } from "../../errors.js";
 const valueFlags = new Set([
     "agent",
+    "account",
+    "app-id",
+    "artifact-id",
+    "at",
+    "channel",
     "code",
+    "conversation",
+    "consumer-session",
+    "cron",
     "controller",
+    "crew-session",
     "cwd",
+    "date",
     "device-id",
     "device-name",
+    "brief-file",
+    "every-ms",
+    "execution",
+    "file",
     "from",
     "host",
+    "if-busy",
+    "domain",
     "invite-secret",
+    "inbound",
     "join-url-base",
+    "label",
+    "layer",
     "limit",
     "machine",
     "machine-id",
+    "native-identity",
+    "memory",
+    "memory-mode",
+    "message-id",
+    "memory-project",
+    "memory-top-n",
     "name",
+    "observed-at",
+    "model",
+    "thinking-level",
     "mode",
     "output",
     "path",
     "port",
     "permission",
     "permission-mode",
+    "profile",
+    "prefix",
+    "project",
+    "publish",
+    "query",
     "prompt",
     "prompt-file",
-    "query",
-    "request-id",
     "every",
     "reason",
+    "request-id",
+    "release-tag",
+    "reaction-emoji",
     "relay",
+    "route-decision",
     "root",
-    "runtime-limit",
-    "runtime-session",
     "shell",
     "actions",
+    "ack-timeout",
+    "allow-chat",
+    "allow-sender",
     "expires-in",
     "format",
+    "history-version",
     "loops",
     "machines",
-    "messages",
     "sessions",
+    "session",
     "secret",
     "since",
+    "slot",
+    "slot-secret",
+    "source",
+    "status",
+    "stream",
     "stop-on",
+    "strategy",
     "tail",
     "tag",
     "tags",
+    "task-id",
     "text",
     "text-file",
     "timeout",
     "timeout-ms",
+    "timezone",
+    "through",
     "wait-timeout-ms",
+    "inactivity-timeout",
     "runtime-timeout",
     "to",
     "token",
     "ttl",
+    "title",
     "url",
     "turn",
+    "turn-id",
     "until",
+    "import-token",
+    "reviewer-tag",
+    "dogfood-tag",
 ]);
 const booleanFlags = new Set([
     "all",
+    "allow-any-sender",
+    "app-secret-stdin",
+    "confirm-risk",
+    "confirm-native-handoff",
+    "copy-tags",
     "detach",
-    "force",
+    "disable-reaction",
     "help",
+    "hidden",
     "h",
-    "include-output",
     "include-archived",
+    "include-debug",
     "json",
     "keep-source",
     "local",
     "no-open",
+    "no-start",
     "no-wait",
+    "preserve-secret",
     "repair-head",
+    "skip-local-daemon",
+    "strict",
     "summary",
+    "subscribe",
     "verbose",
     "wait",
+    "decode",
+    "manual",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);
 const dashPrefixedValueFlags = new Set(["secret"]);
+const repeatableValueFlags = new Set([
+    "tag",
+    "tags",
+    "release-tag",
+    "reviewer-tag",
+    "dogfood-tag",
+]);
 export function parseCliFlags(argv) {
-    const parsed = parseSharedFlags(argv, { valueFlags, dashPrefixedValueFlags });
+    const parsed = parseSharedFlags(argv, { valueFlags, dashPrefixedValueFlags, repeatableValueFlags });
     const unknown = Object.keys(parsed.flags).filter((flag) => !knownFlags.has(flag));
     if (unknown.length > 0) {
         throw new CliError(`Unknown flag: --${unknown[0]}`, "UNKNOWN_FLAG");
     }
     return parsed;
 }
+//# sourceMappingURL=args.js.map

package/apps/cli/dist/commands/lib/audit.js

@@ -23,3 +23,4 @@ export async function readLocalAuditLog(tail = 100) {
         throw error;
     }
 }
+//# sourceMappingURL=audit.js.map

package/apps/cli/dist/commands/lib/bootstrap-config.js

@@ -147,3 +147,4 @@ export function startRelayUrl(flags, existing) {
     const relayUrl = normalizeRelayUrl(defaultHostedRelayUrl);
     return { relayUrl, explicit: false };
 }
+//# sourceMappingURL=bootstrap-config.js.map

package/apps/cli/dist/commands/lib/bootstrap-daemon.js

@@ -1,11 +1,12 @@
+import path from "node:path";
 import { CliError } from "../../errors.js";
-import { startDaemonTimeoutMs } from "./paths.js";
+import { configDir, startDaemonTimeoutMs } from "./paths.js";
 import { readDaemonConfig } from "./config.js";
-import { daemonBinaryUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
+import { daemonBinaryUpdatedAfterStart, daemonConfigUpdatedAfterStart, localDaemonStatus, spawnDaemonStart, stopLocalDaemon } from "./local-daemon.js";
 export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
     const current = await localDaemonStatus();
     if (current.running) {
-        if (await daemonBinaryUpdatedAfterStart(current)) {
+        if ((await daemonBinaryUpdatedAfterStart(current)) || (await daemonConfigUpdatedAfterStart(current))) {
             return await restartDaemonForNewConfig(relayUrl, cwd);
         }
         return { local: current, started: false };
@@ -19,9 +20,15 @@ export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
         const local = await localDaemonStatus();
         if (local.running)
             return { local, started: true, startedPid };
+        try {
+            process.kill(startedPid, 0);
+        }
+        catch {
+            throw new CliError(`Daemon exited before becoming locally ready. Startup output: ${path.join(configDir, "daemon.startup.log")}`, "DAEMON_START_FAILED");
+        }
         await new Promise((resolve) => setTimeout(resolve, 250));
     }
-    throw new CliError("Daemon did not become ready in time. Run happy-elves daemon doctor and happy-elves daemon logs.", "DAEMON_START_FAILED");
+    throw new CliError(`Daemon did not become locally ready in time. Startup output: ${path.join(configDir, "daemon.startup.log")}`, "DAEMON_START_FAILED");
 }
 export async function restartDaemonForNewConfig(relayUrl, cwd = process.cwd()) {
     const stopped = await stopLocalDaemon();
@@ -43,3 +50,4 @@ export async function waitForMachineProjection(client, machineId, timeoutMs = 50
     }
     return lastSeen;
 }
+//# sourceMappingURL=bootstrap-daemon.js.map

package/apps/cli/dist/commands/lib/bootstrap-output.js

@@ -37,3 +37,4 @@ export function openUrl(url) {
         return { opened: false, error: error instanceof Error ? error.message : String(error) };
     }
 }
+//# sourceMappingURL=bootstrap-output.js.map

package/apps/cli/dist/commands/lib/bootstrap.js

@@ -93,3 +93,4 @@ export async function startBootstrap(flags) {
         daemon: data.daemon,
     });
 }
+//# sourceMappingURL=bootstrap.js.map

package/apps/cli/dist/commands/lib/config.d.ts

@@ -2,7 +2,6 @@ import type { CliConfig, DaemonConfig } from "./types.js";
 export declare function requireString(flags: Record<string, string | boolean>, key: string): string;
 export declare function requirePositional(value: string | undefined, name: string): string;
 export declare function normalizeRelayUrl(value: string): string;
-export declare function redactedRelayUrl(value: string): string;
 export declare function requireRelayUrl(flags: Record<string, string | boolean>, key?: string): string;
 export declare function readConfig(flags: Record<string, string | boolean>): Promise<CliConfig>;
 export declare function readDaemonConfig(): Promise<DaemonConfig>;