@cydm/happy-elves 0.1.0-beta.632 → 0.1.0-beta.633

package/README.md

@@ -6,8 +6,8 @@ Public beta CLI for Happy Elves.
 
 Run once in the existing user account; it detects %USERPROFILE%\.happy-elves\hosted, keeps the current daemon and sessions running, installs the independent updater, and registers per-user startup.
 
-    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.632
-    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.632 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
+    npm.cmd install --prefix $HOME\.happy-elves\management-entry --ignore-scripts --no-audit --no-fund --package-lock=false @cydm/happy-elves@0.1.0-beta.633
+    npm.cmd exec --yes --package @cydm/happy-elves@0.1.0-beta.633 -- happy-elves-updater install --state-root $HOME\.happy-elves\hosted --autostart
 
 The same updater entrypoint works on macOS after selecting a permanent user prefix.
 

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

@@ -20,7 +20,7 @@ import { handleSidechat } from "./sidechat.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";
+import { commandUsage, commandUsageText, delegateHostedStart, handleCliError, parseCliFlags, skillText, startBootstrap, topLevelDoctor, topLevelStatus, usage, usageText } from "./lib/index.js";
 export { handleCliError };
 const domainHandlers = [
     handleAccount,
@@ -68,6 +68,8 @@ export async function main() {
     }
     if (domain === "start") {
         const { flags } = parseCliFlags(argv.slice(1));
+        if (await delegateHostedStart(argv, flags))
+            return;
         await startBootstrap(flags);
         return;
     }

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

@@ -1,4 +1,3 @@
-import fs from "node:fs/promises";
 import path from "node:path";
 import { ControllerClient } from "../../../../../packages/client/dist/index.js";
 import { randomId } from "../../../../../packages/foundation/dist/index.js";
@@ -7,21 +6,6 @@ import { CliError } from "../../errors.js";
 import { configDir, configPath, defaultHostedControllerUrl, defaultHostedRelayUrl } from "./paths.js";
 import { normalizeRelayUrl, requireRelayUrl, writeConfig, writeDaemonConfig } from "./config.js";
 import { cliErrorFromFetch, isAuthTokenInvalid, parsePairingClaimResponse, parsePairingStartResponse, readExistingControllerConfig, readExistingDaemonConfig, readRelayJson, throwRelayHttpError } from "./relay-http.js";
-function backupTimestamp() {
-    return new Date().toISOString().replace(/[:.]/g, "-");
-}
-async function backupConfigFile(filePath, reason) {
-    const backupPath = `${filePath}.bak.${backupTimestamp()}`;
-    try {
-        await fs.rename(filePath, backupPath);
-        return { path: filePath, backupPath, reason };
-    }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return undefined;
-        throw new CliError(`Could not back up ${filePath}: ${error instanceof Error ? error.message : String(error)}`, "CONFIG_INVALID");
-    }
-}
 async function createControllerConfig(params) {
     const accountSecret = generateAccountSecret();
     let response;
@@ -49,33 +33,28 @@ async function createControllerConfig(params) {
 }
 export async function ensureControllerConfig(params) {
     let existing;
-    let backup;
     try {
         existing = await readExistingControllerConfig();
     }
-    catch (error) {
-        if (!(error instanceof CliError) || error.code !== "CONFIG_INVALID")
-            throw error;
-        backup = await backupConfigFile(configPath, "invalid-controller-config");
+    catch {
+        throw new CliError(`Existing controller configuration at ${configPath} is invalid; refusing to replace its account.`, "CONFIG_INVALID");
     }
     if (existing) {
         if (params.explicitRelay && existing.relayUrl !== params.relayUrl) {
-            backup = await backupConfigFile(configPath, "controller-relay-changed");
+            throw new CliError("Existing controller uses a different relay; refusing to create a replacement account during start.", "CONTROLLER_RELAY_MISMATCH");
+        }
+        try {
+            await new ControllerClient(existing).snapshotSummary();
+            return { config: existing, created: false, reconfigured: false };
         }
-        else {
-            try {
-                await new ControllerClient(existing).snapshot();
-                return { config: existing, created: false, reconfigured: false };
-            }
-            catch (error) {
-                if (!isAuthTokenInvalid(error))
-                    throw error;
-                backup = await backupConfigFile(configPath, "controller-token-invalid");
-            }
+        catch (error) {
+            if (!isAuthTokenInvalid(error))
+                throw error;
+            throw new CliError("Existing controller token was rejected; refusing to create a replacement account during start.", "CONTROLLER_AUTH_REJECTED");
         }
     }
     const created = await createControllerConfig({ relayUrl: params.relayUrl, deviceName: params.deviceName });
-    return { config: created.config, created: true, accountId: created.accountId, backup, reconfigured: Boolean(backup) };
+    return { config: created.config, created: true, accountId: created.accountId, reconfigured: false };
 }
 async function claimMachinePairing(params) {
     let response;
@@ -115,24 +94,19 @@ async function createDaemonConfig(config, machineName) {
 export async function ensureDaemonPaired(config, machineName) {
     const daemonConfigPath = path.join(configDir, "daemon.json");
     let existing;
-    let backup;
     try {
         existing = await readExistingDaemonConfig();
     }
-    catch (error) {
-        if (!(error instanceof CliError) || error.code !== "CONFIG_INVALID")
-            throw error;
-        backup = await backupConfigFile(daemonConfigPath, "invalid-daemon-config");
+    catch {
+        throw new CliError(`Existing daemon configuration at ${daemonConfigPath} is invalid; refusing to replace its machine.`, "CONFIG_INVALID");
     }
     if (existing) {
         if (existing.relayUrl !== config.relayUrl || existing.accountSecret !== config.accountSecret) {
-            backup = await backupConfigFile(daemonConfigPath, "daemon-account-changed");
-        }
-        else {
-            return { config: existing, created: false, reconfigured: false };
+            throw new CliError("Existing daemon belongs to a different relay or account; refusing to replace its machine during start.", "DAEMON_ACCOUNT_MISMATCH");
         }
+        return { config: existing, created: false, reconfigured: false };
     }
-    return { config: await createDaemonConfig(config, machineName), created: true, backup, reconfigured: Boolean(backup) };
+    return { config: await createDaemonConfig(config, machineName), created: true, reconfigured: false };
 }
 export function controllerBaseUrl(flags) {
     const value = typeof flags.controller === "string" ? flags.controller : defaultHostedControllerUrl;

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

@@ -6,6 +6,8 @@ import { daemonBinaryUpdatedAfterStart, daemonConfigUpdatedAfterStart, localDaem
 export async function ensureDaemonRunning(relayUrl, cwd = process.cwd()) {
     const current = await localDaemonStatus();
     if (current.running) {
+        if (current.identityVerified !== true)
+            throw new CliError("Daemon identity cannot be verified; refusing to reuse or restart it.", "DAEMON_IDENTITY_UNVERIFIED");
         if ((await daemonBinaryUpdatedAfterStart(current)) || (await daemonConfigUpdatedAfterStart(current))) {
             return await restartDaemonForNewConfig(relayUrl, cwd);
         }
@@ -42,9 +44,9 @@ export async function waitForMachineProjection(client, machineId, timeoutMs = 50
     const deadline = Date.now() + timeoutMs;
     let lastSeen;
     while (Date.now() <= deadline) {
-        const snapshot = await client.snapshot();
+        const snapshot = await client.snapshotSummary();
         lastSeen = snapshot.machines.find((machine) => machine.id === machineId);
-        if (lastSeen?.online)
+        if (lastSeen?.daemonOnline === true)
             return lastSeen;
         await new Promise((resolve) => setTimeout(resolve, 300));
     }

package/apps/cli/dist/commands/lib/bootstrap-output.d.ts

@@ -11,6 +11,7 @@ export declare function writeHumanStartOutput(data: {
     daemon: {
         pid?: number;
     };
+    inviteCreated: boolean;
 }): void;
 export declare function openUrl(url: string): {
     opened: boolean;

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

@@ -12,7 +12,7 @@ export function writeHumanStartOutput(data) {
     }
     console.log("");
     console.log("Phone");
-    console.log("Open the same link on your phone.");
+    console.log(data.inviteCreated ? "Open the same link on your phone within 10 minutes." : "To add a new phone, run happy-elves remote invite-controller.");
     console.log("");
     console.log("Machine");
     console.log(`${data.machine.online ? "online" : "starting"}, ${data.machine.name}`);

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

@@ -1 +1,3 @@
 export declare function startBootstrap(flags: Record<string, string | boolean>): Promise<void>;
+/** The default hosted install is the one managed daemon entrypoint after an updater install. */
+export declare function delegateHostedStart(argv: string[], flags: Record<string, string | boolean>): Promise<boolean>;

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

@@ -1,5 +1,7 @@
 import os from "node:os";
 import path from "node:path";
+import fs from "node:fs/promises";
+import { spawn } from "node:child_process";
 import { ControllerClient } from "../../../../../packages/client/dist/index.js";
 import { CliError } from "../../errors.js";
 import { configDir, configPath } from "./paths.js";
@@ -31,20 +33,21 @@ export async function startBootstrap(flags) {
         : await ensureDaemonRunning(controllerState.config.relayUrl, cwd);
     const client = new ControllerClient(controllerState.config);
     const machine = await waitForMachineProjection(client, daemonState.config.machineId);
-    if (!machine?.online) {
+    if (machine?.daemonOnline !== true) {
         throw new CliError("Daemon started, but this machine did not appear online in the relay snapshot. Run happy-elves doctor and happy-elves daemon logs.", "DAEMON_ONLINE_TIMEOUT");
     }
-    const invite = await client.createControllerInvite({
+    const invite = controllerState.created ? await client.createControllerInvite({
         deviceName: "Web controller",
         ttlMs: 10 * 60_000,
         joinUrlBase: controllerBaseUrl(flags),
         relayUrl: controllerState.config.relayUrl,
     }).catch((error) => {
         throw cliErrorFromFetch(error, "INVITE_CREATE_FAILED", "Could not create controller invite");
-    });
+    }) : undefined;
+    const controllerUrl = invite?.joinUrl ?? controllerBaseUrl(flags);
     const data = {
         relayUrl: controllerState.config.relayUrl,
-        controllerUrl: invite.joinUrl,
+        controllerUrl,
         workspace: cwd,
         config: {
             controllerPath: configPath,
@@ -59,7 +62,7 @@ export async function startBootstrap(flags) {
         machine: {
             id: daemonState.config.machineId,
             name: machine.name ?? daemonState.config.machineName,
-            online: machine.online,
+            online: machine.daemonOnline,
             lastSeen: machine?.lastSeen,
         },
         daemon: {
@@ -70,19 +73,16 @@ export async function startBootstrap(flags) {
             alreadyRunning: daemonBefore.running,
             restarted: daemonBefore.running && daemonState.reconfigured,
         },
-        invite: {
-            id: invite.inviteCode,
-            expiresAt: invite.expiresAt,
-        },
+        ...(invite ? { invite: { id: invite.inviteCode, expiresAt: invite.expiresAt } } : {}),
     };
     if (flags.json === true) {
         ok("start", data);
         return;
     }
-    const openResult = flags["no-open"] === true ? { opened: false } : openUrl(invite.joinUrl);
+    const openResult = flags["no-open"] === true ? { opened: false } : openUrl(controllerUrl);
     writeHumanStartOutput({
         workspace: cwd,
-        controllerUrl: invite.joinUrl,
+        controllerUrl,
         relayUrl: controllerState.config.relayUrl,
         opened: openResult.opened,
         openError: openResult.error,
@@ -91,6 +91,48 @@ export async function startBootstrap(flags) {
             online: data.machine.online,
         },
         daemon: data.daemon,
+        inviteCreated: Boolean(invite),
+    });
+}
+/** The default hosted install is the one managed daemon entrypoint after an updater install. */
+export async function delegateHostedStart(argv, flags) {
+    if (process.env.HAPPY_ELVES_HOME || process.env.HAPPY_ELVES_START_DELEGATED === "1" || flags.relay || flags.controller)
+        return false;
+    const stateRoot = path.join(os.homedir(), ".happy-elves", "hosted");
+    const currentPath = path.join(stateRoot, "updater", "current.json");
+    const currentStat = await fs.stat(currentPath).catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+    if (!currentStat)
+        return false;
+    if (!currentStat.isFile() || currentStat.size > 64 * 1024)
+        throw new CliError("Hosted updater current slot is invalid.", "HOSTED_INSTALL_INVALID");
+    const current = JSON.parse(await fs.readFile(currentPath, "utf8"));
+    if (typeof current.version !== "string" || !/^[A-Za-z0-9._-]+$/u.test(current.version) ||
+        typeof current.slotPath !== "string" ||
+        path.resolve(current.slotPath) !== path.join(stateRoot, "updater", "versions", current.version)) {
+        throw new CliError("Hosted updater current slot does not match its state root.", "HOSTED_INSTALL_INVALID");
+    }
+    const launcher = path.join(stateRoot, "updater", "bin", process.platform === "win32" ? "happy-elves.cmd" : "happy-elves");
+    const installedCli = path.join(current.slotPath, "node_modules", "@cydm", "happy-elves", "apps", "cli", "dist", "index.js");
+    await Promise.all([fs.access(launcher), fs.access(installedCli)]).catch(() => {
+        throw new CliError("Hosted launcher or active package is missing.", "HOSTED_INSTALL_INVALID");
+    });
+    const result = await new Promise((resolve, reject) => {
+        const child = spawn(launcher, argv, {
+            stdio: "inherit",
+            env: { ...process.env, HAPPY_ELVES_START_DELEGATED: "1" },
+            windowsHide: true,
+            ...(process.platform === "win32" ? { shell: true } : {}),
+        });
+        child.once("error", reject);
+        child.once("exit", (code, signal) => resolve({ code, signal }));
     });
+    if (result.signal)
+        process.kill(process.pid, result.signal);
+    process.exitCode = result.code ?? 1;
+    return true;
 }
 //# sourceMappingURL=bootstrap.js.map

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

@@ -93,6 +93,11 @@ export function handleCliError(error) {
         console.error("  happy-elves machine exec <machineId> --shell <command> --wait-timeout-ms <ms>");
         process.exit(1);
     }
+    if (enriched.operationId && enriched.machineId && ["UPDATER_UNAVAILABLE", "RELAY_WEBSOCKET_ERROR", "UPDATE_PUBLISH_FAILED"].includes(enriched.code ?? "") && !wantsJsonOutput()) {
+        console.error(`Update outcome is unknown: ${enriched.operationId}`);
+        printRunCommands([`happy-elves machine update status ${enriched.machineId} --operation ${enriched.operationId}`]);
+        process.exit(1);
+    }
     if (enriched.code === "TURN_WAIT_TIMEOUT" && enriched.turnId && !wantsJsonOutput()) {
         console.error(message);
         if (enriched.sessionId) {
@@ -121,6 +126,8 @@ export function handleCliError(error) {
     }
     writeError(enriched.code ?? "COMMAND_FAILED", message, {
         requestId: enriched.requestId,
+        operationId: enriched.operationId,
+        machineId: enriched.machineId,
         sessionId: enriched.sessionId,
         turnId: enriched.turnId,
         activeTurnId: enriched.activeTurnId,

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

@@ -2,6 +2,7 @@ export declare function localDaemonStatus(): Promise<{
     pidPath: string;
     pid?: number;
     running: boolean;
+    identityVerified?: boolean;
 }>;
 export declare function daemonBinaryUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;
 export declare function daemonConfigUpdatedAfterStart(status: Awaited<ReturnType<typeof localDaemonStatus>>): Promise<boolean>;

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

@@ -1,14 +1,14 @@
-import { execFileSync, spawn } from "node:child_process";
+import { spawn } from "node:child_process";
+import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import { appendFileSync, closeSync, mkdirSync, openSync } from "node:fs";
+import net from "node:net";
+import os from "node:os";
 import path from "node:path";
 import { configDir, daemonPidPath } from "./paths.js";
 function daemonCliPath() {
     return path.resolve(import.meta.dirname, "../../../../daemon/dist/cli.js");
 }
-function daemonSourceCliPath() {
-    return path.resolve(import.meta.dirname, "../../../../daemon/src/cli.ts");
-}
 function isPidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
         return false;
@@ -20,58 +20,59 @@ function isPidAlive(pid) {
         return false;
     }
 }
-function readProcessCommand(pid) {
-    if (process.platform === "win32")
-        return readWindowsProcessCommand(pid);
+async function readDaemonIdentity() {
     try {
-        return execFileSync("ps", ["-p", String(pid), "-o", "command="], { encoding: "utf8" }).trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function readWindowsProcessCommand(pid) {
-    try {
-        const script = `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($p) { [Console]::Out.Write($p.CommandLine) }`;
-        return execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
-            encoding: "utf8",
-            windowsHide: true,
-        }).trim() || undefined;
+        const value = JSON.parse(await fs.readFile(path.join(configDir, "daemon.identity.json"), "utf8"));
+        if (!Number.isSafeInteger(value.pid) || !value.pid || value.pid <= 0 || typeof value.stateRoot !== "string" || typeof value.machineId !== "string" || typeof value.nonce !== "string" || typeof value.startedAt !== "string")
+            return undefined;
+        return value;
     }
     catch {
         return undefined;
     }
 }
-function readProcessStartedAtMs(pid) {
-    try {
-        if (process.platform === "win32") {
-            const script = `$p = Get-CimInstance Win32_Process -Filter "ProcessId = ${pid}"; if ($p) { [Console]::Out.Write($p.CreationDate.ToUniversalTime().ToString("o")) }`;
-            const text = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], {
-                encoding: "utf8",
-                windowsHide: true,
-            }).trim();
-            const startedAt = Date.parse(text);
-            return Number.isFinite(startedAt) ? startedAt : undefined;
-        }
-        const text = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], { encoding: "utf8" }).trim();
-        const startedAt = Date.parse(text);
-        return Number.isFinite(startedAt) ? startedAt : undefined;
-    }
-    catch {
-        return undefined;
-    }
+function controlPath(machineId) {
+    if (process.platform === "win32")
+        return `\\\\.\\pipe\\happy-elves-daemon-${machineId}`;
+    const preferred = path.join(configDir, "daemon-control.sock");
+    if (preferred.length < 96)
+        return preferred;
+    const digest = crypto.createHash("sha256").update(path.resolve(configDir)).digest("hex").slice(0, 24);
+    return path.join(os.tmpdir(), `happy-elves-daemon-${digest}.sock`);
 }
-function isManagedDaemonPid(pid) {
-    const command = readProcessCommand(pid);
-    const scriptPaths = [daemonCliPath(), daemonSourceCliPath()];
-    const repoSuffixes = [
-        path.join("apps", "daemon", "dist", "cli.js"),
-        path.join("apps", "daemon", "src", "cli.ts"),
-    ];
-    return (command !== undefined &&
-        (scriptPaths.some((scriptPath) => command.includes(scriptPath) || command.includes(path.relative(process.cwd(), scriptPath))) ||
-            repoSuffixes.some((repoSuffix) => command.includes(repoSuffix))) &&
-        /\bstart\b/.test(command));
+async function controlRequest(machineId, request) {
+    return await new Promise((resolve, reject) => {
+        const socket = net.createConnection(controlPath(machineId));
+        let buffer = "";
+        let settled = false;
+        const finish = (error, value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else
+                resolve(value ?? {});
+        };
+        const timer = setTimeout(() => finish(new Error("Timed out waiting for daemon control")), 2_000);
+        socket.setEncoding("utf8");
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            const index = buffer.indexOf("\n");
+            if (index < 0)
+                return;
+            try {
+                finish(undefined, JSON.parse(buffer.slice(0, index)));
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        socket.once("error", (error) => finish(error));
+        socket.once("connect", () => socket.write(`${JSON.stringify(request)}\n`));
+    });
 }
 async function readDaemonPid() {
     try {
@@ -87,12 +88,20 @@ async function readDaemonPid() {
 }
 export async function localDaemonStatus() {
     const pid = await readDaemonPid();
-    return { pidPath: daemonPidPath, pid, running: pid !== undefined && isPidAlive(pid) && isManagedDaemonPid(pid) };
+    if (!pid || !isPidAlive(pid))
+        return { pidPath: daemonPidPath, pid, running: false };
+    const identity = await readDaemonIdentity();
+    const handshake = identity?.pid === pid && path.resolve(identity.stateRoot) === path.resolve(configDir)
+        ? await controlRequest(identity.machineId, { type: "identity" }).catch(() => undefined)
+        : undefined;
+    const verified = handshake?.ok === true && handshake.pid === pid && handshake.nonce === identity?.nonce && handshake.machineId === identity?.machineId && handshake.stateRoot === path.resolve(configDir);
+    return { pidPath: daemonPidPath, pid, running: true, identityVerified: verified };
 }
 export async function daemonBinaryUpdatedAfterStart(status) {
     if (!status.running || !status.pid)
         return false;
-    const startedAt = readProcessStartedAtMs(status.pid);
+    const identity = await readDaemonIdentity();
+    const startedAt = status.identityVerified && identity?.pid === status.pid ? Date.parse(identity.startedAt) : undefined;
     if (!startedAt)
         return false;
     try {
@@ -106,7 +115,8 @@ export async function daemonBinaryUpdatedAfterStart(status) {
 export async function daemonConfigUpdatedAfterStart(status) {
     if (!status.running || !status.pid)
         return false;
-    const startedAt = readProcessStartedAtMs(status.pid);
+    const identity = await readDaemonIdentity();
+    const startedAt = status.identityVerified && identity?.pid === status.pid ? Date.parse(identity.startedAt) : undefined;
     if (!startedAt)
         return false;
     try {
@@ -143,13 +153,20 @@ export function spawnDaemonStart(args, cwd = process.cwd()) {
         closeSync(logFd);
     }
 }
-export async function stopLocalDaemon(timeoutMs = 5000) {
+export async function stopLocalDaemon(timeoutMs = 15_000) {
     const status = await localDaemonStatus();
     if (!status.pid || !status.running) {
         await fs.rm(daemonPidPath, { force: true });
         return { ...status, stopped: false, running: false };
     }
-    process.kill(status.pid, "SIGTERM");
+    if (status.identityVerified !== true)
+        throw Object.assign(new Error("Daemon identity cannot be verified; refusing to stop it"), { code: "DAEMON_IDENTITY_UNVERIFIED" });
+    const identity = await readDaemonIdentity();
+    if (!identity || identity.pid !== status.pid)
+        throw Object.assign(new Error("Daemon identity changed before shutdown"), { code: "DAEMON_IDENTITY_UNVERIFIED" });
+    const shutdown = await controlRequest(identity.machineId, { type: "shutdown", operationId: crypto.randomUUID(), expectedPid: identity.pid, expectedNonce: identity.nonce });
+    if (shutdown.ok !== true)
+        throw Object.assign(new Error("Daemon refused shutdown"), { code: String(shutdown.code ?? "DAEMON_SHUTDOWN_FAILED") });
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
         if (!isPidAlive(status.pid)) {
@@ -158,6 +175,6 @@ export async function stopLocalDaemon(timeoutMs = 5000) {
         }
         await new Promise((resolve) => setTimeout(resolve, 100));
     }
-    return { ...status, stopped: false, running: isPidAlive(status.pid) };
+    throw Object.assign(new Error(`Daemon did not stop within ${timeoutMs}ms`), { code: "DAEMON_STOP_TIMEOUT" });
 }
 //# sourceMappingURL=local-daemon.js.map

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

@@ -179,6 +179,8 @@ export async function handleMachine({ domain, action, positional, flags }) {
         if (updateAction === "status") {
             const operationId = typeof flags.operation === "string" ? flags.operation : undefined;
             const result = await client.machineUpdateStatus(machineId, operationId);
+            if (result.errorCode)
+                process.exitCode = 1;
             if (!wantsJson(flags)) {
                 console.log(`${machineId}: ${result.phase}${result.operationId ? ` ${result.operationId}` : ""}`);
                 if (result.currentVersion || result.daemonVersion)
@@ -187,7 +189,7 @@ export async function handleMachine({ domain, action, positional, flags }) {
                     console.log(`  ${result.errorCode ?? "error"}: ${result.error}`);
                 return true;
             }
-            ok("machine.update.status", { machineId, result }, { machineId, ...(result.operationId ? { operationId: result.operationId } : {}) });
+            ok("machine.update.status", { machineId, result }, { machineId, ...(result.operationId ? { operationId: result.operationId } : {}) }, !result.errorCode);
             return true;
         }
         if (updateAction === "apply") {

package/apps/cli/package.json

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

package/apps/daemon/dist/direct/server.js

@@ -632,7 +632,7 @@ class DirectState {
         }
         const sessionRoutes = [...sessions.keys()].map((sessionId) => ({ sessionId, nodeId: this.config.machineId }));
         const retainedPackets = [manifestPacket];
-        if (snapshotMode === "full")
+        if (snapshotMode !== "routing")
             for (const session of sessions.values()) {
                 retainedPackets.push(await this.retainedPacket(`node:${this.config.machineId}:session:${session.sessionId}`, {
                     type: "machine:sessionReady",
@@ -647,7 +647,7 @@ class DirectState {
             cursor: this.packetSeq,
             presence: [this.presence()],
             retainedPackets,
-            ...(sessionRoutes.length > 0 ? { sessionRoutes } : {}),
+            sessionRoutes,
         };
     }
     presence() {
@@ -655,6 +655,7 @@ class DirectState {
             nodeId: this.config.machineId,
             nodeKind: "machine",
             online: true,
+            daemonOnline: true,
             lastSeen: Date.now(),
         };
     }

package/apps/daemon/dist/local-control.d.ts

@@ -1,4 +1,4 @@
 export type LocalControlServer = {
     close: () => Promise<void>;
 };
-export declare function startLocalControl(machineId: string): Promise<LocalControlServer>;
+export declare function startLocalControl(machineId: string, requestShutdown: () => void): Promise<LocalControlServer>;

package/apps/daemon/dist/local-control.js

@@ -1,28 +1,14 @@
-import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import net from "node:net";
-import os from "node:os";
 import path from "node:path";
-import { configDir } from "./paths.js";
+import { configDir, daemonControlPath } from "./paths.js";
 import { readDaemonIdentity } from "./process.js";
 import { beginUpdateBarrier, clearUpdateBarrier, markUpdateBarrierPending } from "./update-barrier.js";
 import { pendingOptionsForSession } from "./state.js";
 import { sessionTurns } from "./state.js";
 import { sessions } from "./state.js";
-function localControlPath(machineId) {
-    return process.platform === "win32"
-        ? `\\\\.\\pipe\\happy-elves-daemon-${machineId}`
-        : unixControlPath(configDir);
-}
-function unixControlPath(root) {
-    const preferred = path.join(root, "daemon-control.sock");
-    if (preferred.length < 96)
-        return preferred;
-    const digest = crypto.createHash("sha256").update(path.resolve(root)).digest("hex").slice(0, 24);
-    return path.join(os.tmpdir(), `happy-elves-daemon-${digest}.sock`);
-}
-export async function startLocalControl(machineId) {
-    const socketPath = localControlPath(machineId);
+export async function startLocalControl(machineId, requestShutdown) {
+    const socketPath = daemonControlPath(machineId);
     if (process.platform !== "win32")
         await fs.rm(socketPath, { force: true }).catch(() => undefined);
     const server = net.createServer((socket) => {
@@ -35,7 +21,7 @@ export async function startLocalControl(machineId) {
                 const line = buffer.slice(0, index);
                 buffer = buffer.slice(index + 1);
                 index = buffer.indexOf("\n");
-                void handleControlRequest(line, socket);
+                void handleControlRequest(line, socket, requestShutdown);
             }
         });
     });
@@ -53,7 +39,7 @@ export async function startLocalControl(machineId) {
         },
     };
 }
-async function handleControlRequest(raw, socket) {
+async function handleControlRequest(raw, socket, requestShutdown) {
     try {
         const request = JSON.parse(raw);
         if (request.type === "identity") {
@@ -94,8 +80,16 @@ async function handleControlRequest(raw, socket) {
             return;
         }
         if (request.type === "shutdown") {
+            if (request.expectedPid !== undefined || request.expectedNonce !== undefined) {
+                const identity = await readDaemonIdentity();
+                if (!identity || identity.pid !== request.expectedPid || identity.nonce !== request.expectedNonce || identity.stateRoot !== path.resolve(configDir)) {
+                    write(socket, { ok: false, code: "DAEMON_IDENTITY_UNVERIFIED" });
+                    return;
+                }
+            }
             write(socket, { ok: true });
-            setTimeout(() => process.kill(process.pid, "SIGTERM"), 25).unref?.();
+            socket.once("finish", requestShutdown);
+            socket.end();
             return;
         }
         write(socket, { ok: false, code: "INVALID_CONTROL_COMMAND" });