@cydm/happy-elves 0.1.0-beta.85 → 0.1.0-beta.87

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") {
@@ -118,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/lib/args.js

@@ -97,6 +97,7 @@ const booleanFlags = new Set([
     "keep-source",
     "local",
     "no-open",
+    "no-start",
     "no-wait",
     "repair-head",
     "summary",

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

@@ -1,11 +1,11 @@
 import { CliError } from "../../errors.js";
 import { 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 };

package/apps/cli/dist/commands/lib/local-daemon.d.ts

@@ -4,6 +4,7 @@ export declare function localDaemonStatus(): Promise<{
     running: boolean;
 }>;
 export declare function daemonBinaryUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
+export declare function daemonConfigUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
 export declare function spawnDaemonStart(args: string[], cwd?: string): number;
 export declare function stopLocalDaemon(timeoutMs?: number): Promise<{
     pidPath: string;

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

@@ -102,6 +102,20 @@ export async function daemonBinaryUpdatedAfterStart(status) {
         return false;
     }
 }
+export async function daemonConfigUpdatedAfterStart(status) {
+    if (!status.running || !status.pid)
+        return false;
+    const startedAt = readProcessStartedAtMs(status.pid);
+    if (!startedAt)
+        return false;
+    try {
+        const config = await fs.stat(path.join(configDir, "daemon.json"));
+        return config.mtimeMs > startedAt + 1000;
+    }
+    catch {
+        return false;
+    }
+}
 export function spawnDaemonStart(args, cwd = process.cwd()) {
     const child = spawn(process.execPath, [daemonCliPath(), "start", ...args], {
         cwd,

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

@@ -157,7 +157,7 @@ missed and are never auto-caught-up.
   happy-elves loop delete <loopId> --json
 `,
     daemon: `Usage:
-  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] --json
+  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] [--no-start] --json
   happy-elves daemon start [--relay <url>] [--json]
   happy-elves daemon stop [--json]
   happy-elves daemon restart [--relay <url>] [--json]

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.85",
+  "version": "0.1.0-beta.87",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/session/prompt.d.ts

@@ -1,4 +1,30 @@
 import { type MachineCommand } from "../../../../packages/shared/dist/index.js";
 import type { DaemonConfig } from "../types.js";
+type PromptCommand = Extract<MachineCommand, {
+    type: "machine:prompt";
+}>;
+type PromptExecutionPhase = "decrypt-prompt" | "decrypt-memory-options" | "prepare-memory-context" | "emit-submitted" | "emit-memory-status" | "start-turn" | "attach-turn" | "audit-turn-start" | "stream-turn" | "await-turn-result" | "write-memory" | "refresh-runtime-metadata" | "emit-terminal" | "refresh-authoritative-transcript" | "send-turn-done" | "terminal-hooks";
 export declare function handlePrompt(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export declare function promptFailureResponse(command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    type: "machine:error";
+    requestId: string;
+    sessionId: string;
+    code: string;
+    message: string;
+};
+export declare function promptFailureAuditEvent(config: Pick<DaemonConfig, "machineId">, command: PromptCommand, phase: PromptExecutionPhase, error: unknown): {
+    sessionId: string;
+    machineId: string;
+    actor: "system";
+    action: string;
+    summary: string;
+    evidence: {
+        requestId: string;
+        turnId: string;
+        code: string;
+        phase: PromptExecutionPhase;
+        message: string;
+    };
+};
 export declare function handleCancel(ws: WebSocket, config: DaemonConfig, command: MachineCommand): Promise<void>;
+export {};

package/apps/daemon/dist/session/prompt.js

@@ -52,19 +52,24 @@ export async function handlePrompt(ws, config, command) {
         activePromptRequests.delete(command.requestId);
         releaseSessionTurn(command.sessionId, command.requestId);
     };
+    let phase = "decrypt-prompt";
     try {
         const prompt = await decryptJson(config.accountSecret, command.encryptedPrompt);
         const rawText = prompt.type === "user_prompt" ? prompt.text : JSON.stringify(prompt);
+        phase = "decrypt-memory-options";
         const memoryOptions = await decryptMemoryOptions(config, command);
+        phase = "prepare-memory-context";
         const memoryContext = memoryOptions
             ? await prepareMemoryContext(memoryOptions, rawText)
             : { text: rawText, used: [], options: undefined };
         const text = memoryContext.text;
+        phase = "emit-submitted";
         await emitEvent(ws, config, command.sessionId, command.turnId, {
             type: "status",
             text: "Prompt submitted to runtime",
         });
         if (memoryOptions) {
+            phase = "emit-memory-status";
             await emitEvent(ws, config, command.sessionId, command.turnId, {
                 type: "status",
                 tag: "memory",
@@ -90,6 +95,7 @@ export async function handlePrompt(ws, config, command) {
             }
         }
         const previousBackendSessionId = session.handle.backendSessionId;
+        phase = "start-turn";
         const turn = getRuntime(session.cwd).startTurn({
             handle: session.handle,
             text,
@@ -98,9 +104,11 @@ export async function handlePrompt(ws, config, command) {
             requestId: command.requestId,
             timeoutMs: command.timeoutMs,
         });
+        phase = "attach-turn";
         if (!attachClaimedTurn(command.sessionId, command.requestId, command.turnId, turn)) {
             throw new Error(`Session turn claim was lost before start: ${command.sessionId}`);
         }
+        phase = "audit-turn-start";
         await appendAudit({
             sessionId: command.sessionId,
             machineId: config.machineId,
@@ -118,6 +126,7 @@ export async function handlePrompt(ws, config, command) {
             },
         });
         let outputPreview = "";
+        phase = "stream-turn";
         for await (const event of turn.events) {
             const payload = runtimeEventToPayload(event);
             if (payload.type === "text_delta" && payload.stream !== "thought") {
@@ -125,7 +134,9 @@ export async function handlePrompt(ws, config, command) {
             }
             await emitEvent(ws, config, command.sessionId, command.turnId, payload);
         }
+        phase = "await-turn-result";
         const result = await turn.result;
+        phase = "write-memory";
         const dailyMemory = await writeTurnMemory(memoryOptions, {
             promptText: rawText,
             outputPreview,
@@ -144,6 +155,7 @@ export async function handlePrompt(ws, config, command) {
                 ].filter(Boolean).join(" · "),
             });
         }
+        phase = "refresh-runtime-metadata";
         const refreshedMetadata = session.handle.backendSessionId
             ? await encryptedSessionMetadata(config, command.sessionId, session, {
                 currentHead: result.currentHead,
@@ -165,6 +177,7 @@ export async function handlePrompt(ws, config, command) {
                 },
             });
         }
+        phase = "emit-terminal";
         await emitEvent(ws, config, command.sessionId, command.turnId, result.status === "failed"
             ? {
                 type: "done",
@@ -180,8 +193,10 @@ export async function handlePrompt(ws, config, command) {
                 currentHead: result.currentHead,
                 lastTurnId: result.lastTurnId,
             });
+        phase = "refresh-authoritative-transcript";
         await refreshAuthoritativeTranscriptAfterTurn(ws, config, session, command.requestId, result.currentHead, result.lastTurnId, result.status);
         releasePromptTurn();
+        phase = "send-turn-done";
         await sendReliable({
             type: "machine:turnDone",
             sessionId: command.sessionId,
@@ -192,6 +207,7 @@ export async function handlePrompt(ws, config, command) {
             error: result.status === "failed" ? result.error.message : undefined,
             encryptedMetadata: refreshedMetadata,
         }, ws);
+        phase = "terminal-hooks";
         await handleGatewayTurnTerminal(config, {
             sessionId: command.sessionId,
             requestId: command.requestId,
@@ -231,10 +247,82 @@ export async function handlePrompt(ws, config, command) {
             },
         });
     }
+    catch (error) {
+        const response = promptFailureResponse(command, phase, error);
+        await appendAudit(promptFailureAuditEvent(config, command, phase, error)).catch((auditError) => {
+            console.error(`Prompt failure audit failed for ${command.turnId}: ${auditError instanceof Error ? auditError.message : String(auditError)}`);
+        });
+        await sendCommandResponse(ws, response);
+    }
     finally {
         releasePromptTurn();
     }
 }
+export function promptFailureResponse(command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        type: "machine:error",
+        requestId: command.requestId,
+        sessionId: command.sessionId,
+        code,
+        message: promptFailureMessage(code, error),
+    };
+}
+export function promptFailureAuditEvent(config, command, phase, error) {
+    const code = promptFailureCode(phase, error);
+    return {
+        sessionId: command.sessionId,
+        machineId: config.machineId,
+        actor: "system",
+        action: "turn.prompt.failed",
+        summary: `Failed to run prompt turn ${command.turnId}`,
+        evidence: {
+            requestId: command.requestId,
+            turnId: command.turnId,
+            code,
+            phase,
+            message: safeErrorMessage(error),
+        },
+    };
+}
+function promptFailureCode(phase, error) {
+    if (phase === "decrypt-prompt" && isCryptoOperationFailure(error))
+        return "PROMPT_DECRYPT_FAILED";
+    if (phase === "decrypt-memory-options" && isCryptoOperationFailure(error))
+        return "MEMORY_OPTIONS_DECRYPT_FAILED";
+    if (phase === "start-turn" || phase === "attach-turn")
+        return "TURN_START_FAILED";
+    if (phase === "stream-turn" || phase === "await-turn-result")
+        return "TURN_RUNTIME_FAILED";
+    if (phase === "refresh-runtime-metadata")
+        return "SESSION_METADATA_REFRESH_FAILED";
+    if (phase === "emit-submitted" || phase === "emit-memory-status" || phase === "emit-terminal")
+        return "SESSION_EVENT_EMIT_FAILED";
+    return "PROMPT_EXECUTION_FAILED";
+}
+function promptFailureMessage(code, error) {
+    if (code === "PROMPT_DECRYPT_FAILED") {
+        return "Failed to decrypt the prompt for this daemon. Re-pair the daemon with the correct account secret.";
+    }
+    if (code === "MEMORY_OPTIONS_DECRYPT_FAILED") {
+        return "Failed to decrypt memory options for this turn.";
+    }
+    return safeErrorMessage(error);
+}
+function isCryptoOperationFailure(error) {
+    const record = error && typeof error === "object" ? error : {};
+    const name = typeof record.name === "string" ? record.name : "";
+    const code = typeof record.code === "string" ? record.code : "";
+    const message = safeErrorMessage(error);
+    return name === "OperationError" ||
+        code === "ERR_OSSL_BAD_DECRYPT" ||
+        /operation-specific reason|decrypt|authentication tag|Unsupported state or unable to authenticate data/i.test(message);
+}
+function safeErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}
 async function decryptMemoryOptions(config, command) {
     if (!command.encryptedMemoryOptions)
         return undefined;

package/apps/daemon/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-daemon",
-  "version": "0.1.0-beta.85",
+  "version": "0.1.0-beta.87",
   "private": true,
   "type": "module"
 }

package/apps/relay/dist/index.js

@@ -18,6 +18,7 @@ const dbPath = process.env.HAPPY_ELVES_DB ?? path.join(process.cwd(), ".happy-el
 const pairingTtlMs = 10 * 60 * 1000;
 const controllerInviteTtlMs = 10 * 60 * 1000;
 const eventReplayLimit = intEnv("HAPPY_ELVES_EVENT_REPLAY_LIMIT", process.env.HAPPY_ELVES_EVENT_REPLAY_LIMIT, 100);
+const lanPackDir = process.env.HAPPY_ELVES_LAN_PACK_DIR ? path.resolve(process.env.HAPPY_ELVES_LAN_PACK_DIR) : undefined;
 const retention = createRetentionConfig(process.env);
 const retentionPruneIntervalMs = retentionMs("HAPPY_ELVES_RETENTION_PRUNE_INTERVAL_MS", process.env.HAPPY_ELVES_RETENTION_PRUNE_INTERVAL_MS, 60_000);
 const originAllowed = createOriginPolicy(process.env);
@@ -77,6 +78,33 @@ app.setErrorHandler((error, _request, reply) => {
     }
     reply.code(500).send({ error: { code: "INTERNAL_ERROR", message } });
 });
+if (lanPackDir) {
+    app.get("/__lan/*", async (request, reply) => {
+        const params = request.params;
+        const requested = decodeURIComponent(params["*"] ?? "");
+        const filePath = path.resolve(lanPackDir, requested);
+        if (!filePath.startsWith(`${lanPackDir}${path.sep}`)) {
+            reply.code(403).send("forbidden");
+            return;
+        }
+        let stat;
+        try {
+            stat = fs.statSync(filePath);
+        }
+        catch {
+            reply.code(404).send("not found");
+            return;
+        }
+        if (!stat.isFile()) {
+            reply.code(404).send("not found");
+            return;
+        }
+        const extension = path.extname(filePath);
+        reply.header("content-length", String(stat.size));
+        reply.type(extension === ".ps1" ? "text/plain; charset=utf-8" : extension === ".tgz" ? "application/gzip" : "application/octet-stream");
+        return reply.send(fs.createReadStream(filePath));
+    });
+}
 registerHttpRoutes(app, context, controllerInviteTtlMs);
 registerWebsocketRoute(app, context, originAllowed);
 export async function startRelay(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves",
-  "version": "0.1.0-beta.85",
+  "version": "0.1.0-beta.87",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {