@cydm/happy-elves 0.1.0-beta.267 → 0.1.0-beta.271

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

@@ -32,6 +32,7 @@ const valueFlags = new Set([
     "memory-project",
     "memory-top-n",
     "name",
+    "package-url",
     "model",
     "mode",
     "output",
@@ -61,6 +62,7 @@ const valueFlags = new Set([
     "sessions",
     "session",
     "secret",
+    "sha256",
     "since",
     "source",
     "stop-on",
@@ -81,6 +83,8 @@ const valueFlags = new Set([
     "url",
     "turn",
     "until",
+    "version",
+    "wait-timeout",
 ]);
 const booleanFlags = new Set([
     "all",

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

@@ -30,6 +30,10 @@ Check local controller config, relay reachability, and daemon state.
   happy-elves remote add-controller [--device-id <id>] [--device-name <name>] --json
   happy-elves remote rename <deviceId> --name <name> --json
   happy-elves remote revoke <deviceId> --json
+  happy-elves remote daemon-status <machineId> [--json]
+  happy-elves remote daemon-restart <machineId> [--wait] [--timeout 2m] [--json]
+  happy-elves remote daemon-update <machineId> [--version latest|0.1.0-beta.N] [--package-url <url> --sha256 <hex>] [--wait] [--timeout 10m] [--json]
+  happy-elves remote daemon-logs <machineId> [--tail 100] [--json]
 `,
     machine: `Usage:
   happy-elves machine list [--verbose] [--json]

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

@@ -9,6 +9,7 @@ export async function handleMemory({ domain, action, positional, flags }) {
         const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
         const result = await client.memory({ machineId, action: "overview", projectKey, mode: parseMemoryMode(flags.mode) ?? "readonly" });
         if (!wantsJson(flags)) {
+            printMemoryProject(projectKey);
             const files = result.overview?.files ?? [];
             if (files.length === 0)
                 console.log("No memory files.");
@@ -17,7 +18,7 @@ export async function handleMemory({ domain, action, positional, flags }) {
                     console.log(`${file.layer}  ${file.path}  ${file.lineCount} lines  ${file.updatedAt}`);
             return true;
         }
-        ok(`memory.${action}`, result);
+        ok(`memory.${action}`, withMemoryProject(result, projectKey));
         return true;
     }
     if (action === "save" || action === "write") {
@@ -43,7 +44,8 @@ export async function handleMemory({ domain, action, positional, flags }) {
                 ...(typeof flags.date === "string" ? { date: flags.date } : {}),
             },
         });
-        ok("memory.save", result);
+        printMemoryProjectIfHuman(flags, projectKey);
+        ok("memory.save", withMemoryProject(result, projectKey));
         return true;
     }
     if (action === "read") {
@@ -52,10 +54,11 @@ export async function handleMemory({ domain, action, positional, flags }) {
         const path = typeof flags.path === "string" ? flags.path : requirePositional(positional[0], "path");
         const result = await client.memory({ machineId, action: "read", projectKey, path });
         if (!wantsJson(flags)) {
+            printMemoryProject(projectKey);
             console.log(result.content ?? "");
             return true;
         }
-        ok("memory.read", result);
+        ok("memory.read", withMemoryProject(result, projectKey));
         return true;
     }
     if (action === "search") {
@@ -67,6 +70,7 @@ export async function handleMemory({ domain, action, positional, flags }) {
             throw new CliError("Invalid --limit", "INVALID_ARGUMENT");
         const result = await client.memory({ machineId, action: "search", projectKey, query, limit });
         if (!wantsJson(flags)) {
+            printMemoryProject(projectKey);
             const results = result.results ?? [];
             if (results.length === 0)
                 console.log("No matching memory.");
@@ -80,7 +84,7 @@ export async function handleMemory({ domain, action, positional, flags }) {
                 }
             return true;
         }
-        ok("memory.search", result);
+        ok("memory.search", withMemoryProject(result, projectKey));
         return true;
     }
     if (action === "promote") {
@@ -101,17 +105,33 @@ export async function handleMemory({ domain, action, positional, flags }) {
                 ...(typeof flags.title === "string" ? { title: flags.title } : {}),
             },
         });
-        ok("memory.promote", result);
+        printMemoryProjectIfHuman(flags, projectKey);
+        ok("memory.promote", withMemoryProject(result, projectKey));
         return true;
     }
     if (action === "reindex" || action === "sync") {
         const machineId = await resolveMemoryMachineId(client, flags);
         const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
-        ok(`memory.${action}`, await client.memory({ machineId, action, projectKey, mode: parseMemoryMode(flags.mode) ?? "readonly" }));
+        const result = await client.memory({ machineId, action, projectKey, mode: parseMemoryMode(flags.mode) ?? "readonly" });
+        printMemoryProjectIfHuman(flags, projectKey);
+        ok(`memory.${action}`, withMemoryProject(result, projectKey));
         return true;
     }
     return false;
 }
+function withMemoryProject(result, projectKey) {
+    if (result && typeof result === "object" && !Array.isArray(result)) {
+        return { ...result, projectKey };
+    }
+    return { result, projectKey };
+}
+function printMemoryProjectIfHuman(flags, projectKey) {
+    if (!wantsJson(flags))
+        printMemoryProject(projectKey);
+}
+function printMemoryProject(projectKey) {
+    console.error(`Memory project: ${projectKey}`);
+}
 async function resolveMemoryMachineId(client, flags) {
     if (typeof flags.machine === "string" && flags.machine.length > 0)
         return flags.machine;

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

@@ -1,5 +1,5 @@
 import os from "node:os";
-import { ControllerClient, configPath, ok, parseControllerJoinUrl, parseDurationMs, randomId, readConfig, relayHealth, requirePositional, requireRelayUrl, requireString, showMachine, wantsJson, wantsVerbose, writeConfig } from "./lib/index.js";
+import { CliError, ControllerClient, configPath, ok, parseControllerJoinUrl, parseDurationMs, randomId, readConfig, relayHealth, requirePositional, requireRelayUrl, requireString, showMachine, wantsJson, wantsVerbose, writeConfig } from "./lib/index.js";
 export async function handleRemote({ domain, action, positional, flags }) {
     if (domain === "remote" && action === "devices") {
         const config = await readConfig(flags);
@@ -81,6 +81,56 @@ export async function handleRemote({ domain, action, positional, flags }) {
         ok("remote.status", data);
         return true;
     }
+    if (domain === "remote" && action === "daemon-status") {
+        const config = await readConfig(flags);
+        const machineId = requirePositional(positional[0], "machineId");
+        const result = await new ControllerClient(config).daemonLifecycle({
+            machineId,
+            action: "status",
+            waitTimeoutMs: parseDurationMs(flags["wait-timeout"], 45_000),
+        });
+        printDaemonLifecycle("remote.daemon-status", result, flags);
+        return true;
+    }
+    if (domain === "remote" && action === "daemon-logs") {
+        const config = await readConfig(flags);
+        const machineId = requirePositional(positional[0], "machineId");
+        const tail = typeof flags.tail === "string" ? Number(flags.tail) : 100;
+        if (!Number.isInteger(tail) || tail <= 0)
+            throw new CliError("--tail must be a positive integer", "INVALID_ARGUMENT");
+        const result = await new ControllerClient(config).daemonLifecycle({
+            machineId,
+            action: "logs",
+            tail,
+            waitTimeoutMs: parseDurationMs(flags["wait-timeout"], 45_000),
+        });
+        printDaemonLifecycle("remote.daemon-logs", result, flags);
+        return true;
+    }
+    if (domain === "remote" && (action === "daemon-restart" || action === "daemon-update")) {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = requirePositional(positional[0], "machineId");
+        const isUpdate = action === "daemon-update";
+        const result = await client.daemonLifecycle({
+            machineId,
+            action: isUpdate ? "update" : "restart",
+            targetVersion: isUpdate ? (typeof flags.version === "string" ? flags.version : "latest") : undefined,
+            packageUrl: isUpdate && typeof flags["package-url"] === "string" ? flags["package-url"] : undefined,
+            sha256: isUpdate && typeof flags.sha256 === "string" ? flags.sha256 : undefined,
+            waitTimeoutMs: parseDurationMs(flags["wait-timeout"], 45_000),
+        });
+        let finalResult = result;
+        if (result.accepted === true && flags.wait) {
+            finalResult = await waitForDaemonLifecycle(client, machineId, result.requestId, isUpdate ? "update" : "restart", {
+                timeoutMs: parseDurationMs(flags.timeout, isUpdate ? 10 * 60_000 : 2 * 60_000),
+            });
+        }
+        printDaemonLifecycle(isUpdate ? "remote.daemon-update" : "remote.daemon-restart", finalResult, flags);
+        if (finalResult.accepted === false || finalResult.updateState?.status === "failed")
+            process.exitCode = 1;
+        return true;
+    }
     if (domain === "remote" &&
         ((action === "pairing" && positional[0] === "new") || (action === "machine-pairing" && positional[0] === "new"))) {
         const config = await readConfig(flags);
@@ -148,4 +198,83 @@ export async function handleRemote({ domain, action, positional, flags }) {
     }
     return false;
 }
+function printDaemonLifecycle(type, result, flags) {
+    const success = result.accepted !== false && result.updateState?.status !== "failed";
+    if (wantsJson(flags)) {
+        ok(type, result, { requestId: result.requestId, machineId: result.machineId }, success);
+        return;
+    }
+    const state = result.updateState;
+    const summary = [
+        `Machine: ${result.machineId}`,
+        `Action: ${result.action}`,
+        `Version: ${result.version ?? "-"}`,
+        `Running: ${result.running === undefined ? "-" : result.running ? "yes" : "no"}`,
+        `Install: ${result.installMode ?? "-"}`,
+    ];
+    if (result.updateSupported === false)
+        summary.push(`Update: unsupported (${result.updateUnsupportedReason ?? "unknown"})`);
+    if (result.accepted !== undefined)
+        summary.push(`Accepted: ${result.accepted ? "yes" : "no"}`);
+    if (state) {
+        summary.push(`Update state: ${state.status}`);
+        if (state.targetVersion)
+            summary.push(`Target: ${state.targetVersion}`);
+        if (state.toVersion)
+            summary.push(`Installed: ${state.toVersion}`);
+        if (state.logPath)
+            summary.push(`Log: ${state.logPath}`);
+        if (state.error)
+            summary.push(`Error: ${state.error}`);
+    }
+    for (const line of summary)
+        console.log(line);
+    if (result.logs?.length) {
+        console.log("Logs:");
+        for (const line of result.logs)
+            console.log(line);
+    }
+}
+async function waitForDaemonLifecycle(client, machineId, requestId, action, options) {
+    const deadline = Date.now() + Math.max(1, options.timeoutMs);
+    let lastResult;
+    let lastError;
+    while (Date.now() < deadline) {
+        try {
+            const result = await client.daemonLifecycle({ machineId, action: "status", waitTimeoutMs: 15_000 });
+            lastResult = result;
+            const state = result.updateState;
+            if (state?.requestId === requestId) {
+                if (state.status === "succeeded" || state.status === "failed")
+                    return result;
+            }
+            else if (action === "restart" && result.running === true) {
+                return result;
+            }
+        }
+        catch (error) {
+            lastError = error;
+            const code = errorCode(error);
+            if (code !== "MACHINE_OFFLINE" && code !== "COMMAND_TIMEOUT" && code !== "RELAY_CONNECT_TIMEOUT")
+                throw error;
+        }
+        await sleep(1000);
+    }
+    if (lastResult)
+        return {
+            ...lastResult,
+            accepted: false,
+            updateUnsupportedReason: `WAIT_TIMEOUT_${requestId}`,
+        };
+    throw new CliError(`Timed out waiting for daemon ${action}: ${errorMessage(lastError)}`, "COMMAND_TIMEOUT");
+}
+function errorCode(error) {
+    return typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error ?? "unknown");
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 //# sourceMappingURL=remote.js.map

package/apps/cli/package.json

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

package/apps/daemon/dist/paths.d.ts

@@ -8,6 +8,8 @@ export declare const loopStoreLockPath: string;
 export declare const gatewayStorePath: string;
 export declare const scheduleStorePath: string;
 export declare const memoryRootDir: string;
+export declare const updatesDir: string;
+export declare const updateStatePath: string;
 export declare const pidPath: string;
 export declare const daemonScriptPath: string;
 export declare const daemonScriptRelativePath: string;

package/apps/daemon/dist/paths.js

@@ -13,6 +13,8 @@ export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
 export const gatewayStorePath = path.join(configDir, "gateway.json");
 export const scheduleStorePath = path.join(configDir, "schedules.json");
 export const memoryRootDir = path.join(configDir, "memory");
+export const updatesDir = path.join(configDir, "updates");
+export const updateStatePath = path.join(configDir, "update-state.json");
 export const pidPath = path.join(configDir, "daemon.pid");
 export const daemonScriptPath = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "./cli.ts" : "./cli.js", import.meta.url));
 export const daemonScriptRelativePath = path.relative(process.cwd(), daemonScriptPath);

package/apps/daemon/dist/relay/connection.js

@@ -12,6 +12,7 @@ import { handleFork, handleRename, handleRewind } from "../session/primitives.js
 import { handleReconcileTurn } from "../session/reconcile.js";
 import { parseRelayMessage, relayWsUrl } from "../relay-http.js";
 import { handleDevExec, handleDiagnose } from "./devtools.js";
+import { handleDaemonLifecycleCommand } from "./lifecycle.js";
 import { registerMachine } from "./register.js";
 import { clearActiveRelaySocket, configureRelaySender, flushRelayOutbox, handleMachineMessageAck, send, sendCommandResponse, setActiveRelaySocket, } from "./send.js";
 async function handleServerMessage(ws, config, message) {
@@ -63,6 +64,10 @@ async function handleServerMessage(ws, config, message) {
         await handleDevExec(ws, config, message);
         return;
     }
+    if (message.type === "machine:daemonLifecycle") {
+        await handleDaemonLifecycleCommand(ws, config, message);
+        return;
+    }
     if (message.type === "machine:gateway") {
         await handleGatewayCommand(ws, config, message);
         return;

package/apps/daemon/dist/relay/lifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { MachineCommand } from "../../../../packages/shared/dist/index.js";
+import type { DaemonConfig } from "../types.js";
+type DaemonLifecycleCommand = Extract<MachineCommand, {
+    type: "machine:daemonLifecycle";
+}>;
+export declare function handleDaemonLifecycleCommand(ws: WebSocket, config: DaemonConfig, command: DaemonLifecycleCommand): Promise<void>;
+export {};