@cydm/happy-elves 0.1.0-beta.497 → 0.1.0-beta.498

package/README.md

@@ -2,14 +2,6 @@
 
 Public beta CLI for Happy Elves.
 
-## Hosted relay
+First-time hosted attach (Windows):
 
-```bash
-happy-elves account create --relay https://relay.happyelves.ai --device-name "CLI" --json
-```
-
-## Self-host relay
-
-```bash
-happy-elves relay serve --host 0.0.0.0 --port 8787 --json
-```
+    npm.cmd --yes --package @cydm/happy-elves@0.1.0-beta.498 happy-elves-updater install --autostart

package/apps/cli/package.json

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

package/apps/daemon/package.json

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

package/apps/relay/dist/types.d.ts

@@ -1,5 +1,6 @@
 import type { RelayDataPlaneScope } from "../../../packages/shared/dist/index.js";
 export type TokenKind = "controller" | "machine";
+export type RelayReplayMode = "full" | "management";
 export type ScopedTokenScope = RelayDataPlaneScope;
 export type TokenRecord = {
     token: string;

package/apps/relay/dist/websocket.js

@@ -159,9 +159,11 @@ export function registerWebsocketRoute(app, context, originAllowed) {
                         });
                         await sendSnapshot(context, openedConnection, message.snapshotMode ?? "full");
                         broadcastPresence(context, openedConnection.spaceId, await presenceWithManifest(context, openedConnection.spaceId, presence));
-                        void replayNodePackets(context, openedConnection, message.cursor).catch((error) => {
-                            reportDetachedOperationFailure(openedConnection, error);
-                        });
+                        if (openedConnection.replayMode === "full") {
+                            void replayNodePackets(context, openedConnection, message.cursor).catch((error) => {
+                                reportDetachedOperationFailure(openedConnection, error);
+                            });
+                        }
                     }).catch((error) => {
                         app.log.warn({ error }, "failed to persist relay presence");
                         reportDetachedOperationFailure(openedConnection, error, true);
@@ -267,10 +269,11 @@ async function openConnection(context, socket, connectionId, message) {
             id: connectionId,
             nodeId,
             nodeKind,
+            replayMode: message.replayMode ?? "full",
             spaceId: token.account_id,
             authToken: message.token,
             socket,
-            subscriptions: [{ toNodeId: nodeId }],
+            subscriptions: message.replayMode === "management" ? [] : [{ toNodeId: nodeId }],
             subscriptionReplays: new Map(),
             pendingSubscriptionReplayKeys: [],
             activeSubscriptionReplayCount: 0,
@@ -295,6 +298,15 @@ async function handlePacketMessage(context, connection, message) {
         return;
     }
     if (message.type === "subscribe") {
+        const wantsManagement = isManagementChannel(message.channelId);
+        if ((connection.replayMode === "management" && !wantsManagement) || (connection.replayMode === "full" && wantsManagement)) {
+            send(connection.socket, {
+                type: "server:error",
+                code: wantsManagement ? "MANAGEMENT_CONNECTION_REQUIRED" : "BUSINESS_CONNECTION_REQUIRED",
+                message: wantsManagement ? "Updater channels require a management connection" : "Business connections may not subscribe to updater channels",
+            });
+            return;
+        }
         const authorization = await authorizeMessage(context, connection, message);
         if (!authorization.ok) {
             sendAuthorizationError(connection, authorization);
@@ -331,7 +343,7 @@ async function handlePacketMessage(context, connection, message) {
     if (message.type === "ackPacket") {
         const packet = await context.getPacketById({ spaceId: connection.spaceId, packetId: message.packetId });
         const authorization = packet
-            ? await context.checkDataPlaneTokenAsync(connection.authToken, "packet:read", packetReadResourceForReader(packet, connection.nodeId))
+            ? await context.checkDataPlaneTokenAsync(connection.authToken, isManagementChannel(packet.channelId) ? "management:read" : "packet:read", packetReadResourceForReader(packet, connection.nodeId))
             : await context.checkDataPlaneTokenAsync(connection.authToken, "packet:read", { allowScopedOmittedResource: true });
         if (!authorization.ok) {
             sendAuthorizationError(connection, authorization);
@@ -346,7 +358,8 @@ async function handlePacketMessage(context, connection, message) {
                 now: context.now(),
             });
             releasePendingAckBudget(connection, message.packetId);
-            queueCursorUpdate(context, connection, packet.serverSeq);
+            if (connection.replayMode === "full" && !isManagementChannel(packet.channelId))
+                queueCursorUpdate(context, connection, packet.serverSeq);
         }
         send(connection.socket, {
             type: "server:ack",
@@ -434,7 +447,7 @@ async function authorizeMessage(context, connection, message) {
                 message: "Scoped token subscriptions must name an allowed node, channel, or stream",
             };
         }
-        const managementChannel = message.channelId?.startsWith("he:update-") || message.channelId?.startsWith("he:update-response:");
+        const managementChannel = isManagementChannel(message.channelId);
         return await context.checkDataPlaneTokenAsync(connection.authToken, managementChannel ? "management:read" : "packet:read", {
             ...(message.toNodeId ? { nodeId: message.toNodeId } : {}),
             ...(message.channelId ? { channelId: message.channelId } : {}),
@@ -454,7 +467,7 @@ async function authorizeMessage(context, connection, message) {
         if (message.packet.channelId?.startsWith("he:update:") && connection.nodeKind !== "controller") {
             return { ok: false, code: "MANAGEMENT_CONTROLLER_REQUIRED", message: "Only a controller may publish updater management commands" };
         }
-        const managementChannel = message.packet.channelId?.startsWith("he:update:") || message.packet.channelId?.startsWith("he:update-response:");
+        const managementChannel = isManagementChannel(message.packet.channelId);
         return await context.checkDataPlaneTokenAsync(connection.authToken, managementChannel ? "management:write" : "packet:write", {
             ...(message.packet.toNodeId ? { nodeId: message.packet.toNodeId } : {}),
             ...(message.packet.channelId ? { channelId: message.packet.channelId } : {}),
@@ -632,6 +645,8 @@ function deliverPacket(context, packet) {
     if (packet.toNodeId) {
         const connections = connectionsByNode.get(nodeKey(packet.spaceId, packet.toNodeId));
         for (const connection of connections ?? []) {
+            if (!connectionAcceptsPacket(connection, packet))
+                continue;
             void sendPacket(context, connection, packet, "live").catch((error) => {
                 reportDetachedOperationFailure(connection, error);
             });
@@ -642,6 +657,8 @@ function deliverPacket(context, packet) {
     for (const connection of spaceConnections ?? []) {
         if (delivered.has(connection))
             continue;
+        if (!connectionAcceptsPacket(connection, packet))
+            continue;
         if (!connection.subscriptions.some((subscription) => subscriptionMatches(connection, subscription, packet)))
             continue;
         void sendPacket(context, connection, packet, "live").catch((error) => {
@@ -650,6 +667,8 @@ function deliverPacket(context, packet) {
     }
 }
 async function sendPacket(context, connection, packet, source) {
+    if (!connectionAcceptsPacket(connection, packet))
+        return false;
     const authorization = await context.checkDataPlaneTokenAsync(connection.authToken, "packet:read", packetReadResourceForReader(packet, connection.nodeId));
     if (!authorization.ok) {
         if (authorization.close)
@@ -685,7 +704,8 @@ async function sendPacket(context, connection, packet, source) {
         closeSlowReceiver(connection);
         return false;
     }
-    queueCursorUpdate(context, connection, packet.serverSeq);
+    if (connection.replayMode === "full" && !isManagementChannel(packet.channelId))
+        queueCursorUpdate(context, connection, packet.serverSeq);
     return true;
 }
 function queueCursorUpdate(context, connection, serverSeq) {
@@ -818,6 +838,13 @@ function subscriptionMatches(connection, subscription, packet) {
         return false;
     return Boolean(packet.channelId || packet.toNodeId);
 }
+function isManagementChannel(channelId) {
+    return channelId?.startsWith("he:update:") === true || channelId?.startsWith("he:update-response:") === true;
+}
+function connectionAcceptsPacket(connection, packet) {
+    const management = isManagementChannel(packet.channelId);
+    return connection.replayMode === "management" ? management : !management;
+}
 function registerConnection(connection) {
     diagnostics.openedConnections += 1;
     diagnostics.activeConnections += 1;

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

@@ -16,6 +16,7 @@ export declare function updaterPaths(stateRoot: string): {
     daemonStdoutPath: string;
     daemonStderrPath: string;
     relayCursorPath: string;
+    managementCursorPath: string;
     relayOutboxPath: string;
     relayRequestIndexPath: string;
     launcherDir: string;

package/apps/updater/dist/paths.js

@@ -26,6 +26,7 @@ export function updaterPaths(stateRoot) {
         daemonStdoutPath: path.join(updaterRoot, "logs", "daemon.stdout.log"),
         daemonStderrPath: path.join(updaterRoot, "logs", "daemon.stderr.log"),
         relayCursorPath: path.join(updaterRoot, "relay-cursor.json"),
+        managementCursorPath: path.join(updaterRoot, "management-cursor.json"),
         relayOutboxPath: path.join(updaterRoot, "relay-outbox.json"),
         relayRequestIndexPath: path.join(updaterRoot, "relay-request-index.json"),
         launcherDir: path.join(updaterRoot, "bin"),

package/apps/updater/dist/relay.js

@@ -8,7 +8,7 @@ const updateManifestKey = (machineId) => `node:${machineId}:updater-manifest`;
 const responseRetentionMs = 24 * 60 * 60 * 1000;
 /** The updater remains online while the daemon is stopped, so its reconnect and result delivery are durable here. */
 export async function startUpdaterRelay(input) {
-    let persistedCursor = await readCursor(input.stateRoot);
+    let persistedManagementCursor = await readManagementCursor(input.stateRoot);
     let ws;
     let closed = false;
     let subscribed = false;
@@ -35,7 +35,7 @@ export async function startUpdaterRelay(input) {
             subscribed = false;
             next.addEventListener("open", () => {
                 reconnectDelayMs = 500;
-                send({ type: "hello", token: input.config.machineToken, nodeKind: "machine", nodeId: input.config.machineId, cursor: persistedCursor, snapshotMode: "routing" });
+                send({ type: "hello", token: input.config.machineToken, nodeKind: "machine", nodeId: input.config.machineId, snapshotMode: "routing", replayMode: "management" });
             });
             next.addEventListener("message", (event) => { void handleRelayMessage(String(event.data), next).catch(() => undefined); });
             next.addEventListener("close", () => { if (ws === next && !closed) {
@@ -55,11 +55,9 @@ export async function startUpdaterRelay(input) {
         const delay = reconnectDelayMs;
         reconnectDelayMs = Math.min(30_000, reconnectDelayMs * 2);
         reconnectTimer = setTimeout(() => { reconnectTimer = undefined; void connect().catch(() => scheduleReconnect()); }, delay);
-        reconnectTimer.unref?.();
     }
     await connect(true);
     const manifestTimer = setInterval(() => { void publishManifest(latestManifest).catch(() => undefined); }, 30_000);
-    manifestTimer.unref?.();
     await publishManifest(input.initialManifest);
     await flushOutbox();
     return {
@@ -91,7 +89,7 @@ export async function startUpdaterRelay(input) {
         if (wire.type === "server:snapshot") {
             if (!subscribed) {
                 subscribed = true;
-                send({ type: "subscribe", channelId: updateChannel(input.config.machineId), cursor: persistedCursor });
+                send({ type: "subscribe", channelId: updateChannel(input.config.machineId), cursor: persistedManagementCursor });
             }
             await publishManifest(latestManifest);
             await flushOutbox();
@@ -99,12 +97,9 @@ export async function startUpdaterRelay(input) {
         }
         if (wire.type !== "server:packet")
             return;
-        packetCompletion.set(wire.packet.serverSeq, false);
-        if (wire.packet.channelId !== updateChannel(input.config.machineId)) {
-            send({ type: "ackPacket", packetId: wire.packet.packetId, serverSeq: wire.packet.serverSeq });
-            await commitPacket(wire.packet.serverSeq);
+        if (wire.packet.channelId !== updateChannel(input.config.machineId))
             return;
-        }
+        packetCompletion.set(wire.packet.serverSeq, false);
         const decoded = await decryptJson(input.config.accountSecret, wire.packet.encryptedPayload);
         const packet = parseUpdatePacket(decoded);
         if (!packet.type.startsWith("controller:update.") && !packet.type.startsWith("controller:host.") && !packet.type.startsWith("controller:daemon.")) {
@@ -223,9 +218,9 @@ export async function startUpdaterRelay(input) {
             if (pending === undefined || !packetCompletion.get(pending))
                 return;
             packetCompletion.delete(pending);
-            if (pending > persistedCursor) {
-                persistedCursor = pending;
-                await writeCursor(input.stateRoot, persistedCursor);
+            if (pending > persistedManagementCursor) {
+                persistedManagementCursor = pending;
+                await writeManagementCursor(input.stateRoot, persistedManagementCursor);
             }
         }
     }
@@ -248,14 +243,14 @@ async function waitForOpen(ws) {
     await new Promise((resolve, reject) => { const timer = setTimeout(() => reject(new Error("Timed out connecting updater to Relay")), 10_000); ws.addEventListener("open", () => { clearTimeout(timer); resolve(); }, { once: true }); ws.addEventListener("error", () => { clearTimeout(timer); reject(new Error("Updater Relay websocket failed")); }, { once: true }); });
 }
 function wsUrl(relayUrl) { const parsed = new URL(relayUrl); parsed.protocol = parsed.protocol === "https:" ? "wss:" : "ws:"; parsed.pathname = "/ws"; parsed.search = ""; return parsed.toString(); }
-async function readCursor(stateRoot) { try {
-    const value = JSON.parse(await fs.readFile(updaterPaths(stateRoot).relayCursorPath, "utf8"));
+async function readManagementCursor(stateRoot) { try {
+    const value = JSON.parse(await fs.readFile(updaterPaths(stateRoot).managementCursorPath, "utf8"));
     return typeof value.cursor === "number" && Number.isSafeInteger(value.cursor) ? value.cursor : 0;
 }
 catch {
     return 0;
 } }
-async function writeCursor(stateRoot, cursor) { await fs.mkdir(updaterPaths(stateRoot).updaterRoot, { recursive: true, mode: 0o700 }); await atomicWriteJson(updaterPaths(stateRoot).relayCursorPath, { cursor }); }
+async function writeManagementCursor(stateRoot, cursor) { await fs.mkdir(updaterPaths(stateRoot).updaterRoot, { recursive: true, mode: 0o700 }); await atomicWriteJson(updaterPaths(stateRoot).managementCursorPath, { cursor }); }
 async function readOutbox(stateRoot) {
     try {
         const value = JSON.parse(await fs.readFile(updaterPaths(stateRoot).relayOutboxPath, "utf8"));

package/apps/updater/dist/supervisor.js

@@ -101,9 +101,12 @@ export async function installCurrentPackage(input) {
         throw Object.assign(new Error("Installed package is missing a version"), { code: "UPDATE_PACKAGE_INVALID" });
     const current = await readCurrentSlot(stateRoot);
     if (current?.version === version) {
-        const updaterPid = await startUpdater({ stateRoot, nodeExecutable: node.executable, updaterEntrypoint: updaterEntrypoint(current.slotPath) });
-        await updateOperationIfPresent(stateRoot, { phase: "succeeded", machineId: config.machineId });
-        return await readOperation(stateRoot) ?? { schema: 1, operationId: randomId("upd_attach"), machineId: config.machineId, targetVersion: version, phase: "succeeded", attempt: 1, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), daemonWasRunning: true, ownerPid: updaterPid };
+        const existing = await readOperation(stateRoot);
+        const completed = existing && !["succeeded", "failed", "recovered", "manual_recovery_required"].includes(existing.phase)
+            ? await updateOperation(stateRoot, { phase: "succeeded", machineId: config.machineId, targetVersion: version })
+            : existing;
+        await startUpdater({ stateRoot, nodeExecutable: node.executable, updaterEntrypoint: updaterEntrypoint(current.slotPath) });
+        return completed ?? { schema: 1, operationId: randomId("upd_attach"), machineId: config.machineId, targetVersion: version, phase: "succeeded", attempt: 1, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), daemonWasRunning: true };
     }
     const operationId = randomId("upd_attach");
     const unlock = await acquireOperationLock(stateRoot, operationId);
@@ -115,10 +118,12 @@ export async function installCurrentPackage(input) {
         await writeStableLaunchers(stateRoot, node.executable);
         if (input.installAutostart)
             await installAutostart({ stateRoot, nodeExecutable: node.executable, updaterEntrypoint: updaterEntrypoint(slotPath(stateRoot, version)) });
+        const daemonWasRunning = (await localDaemonStatus(stateRoot)).running;
+        const completed = await updateOperation(stateRoot, { phase: "succeeded", machineId: config.machineId, daemonWasRunning, targetVersion: version, ownerPid: undefined, ownerLeaseExpiresAt: undefined });
         await startUpdater({ stateRoot, nodeExecutable: node.executable, updaterEntrypoint: updaterEntrypoint(slotPath(stateRoot, version)) });
         if (!(await waitForFile(updaterPaths(stateRoot).updaterPidPath, 10_000)))
             throw Object.assign(new Error("Attached updater did not become ready"), { code: "UPDATER_START_FAILED" });
-        return await updateOperation(stateRoot, { phase: "succeeded", machineId: config.machineId, daemonWasRunning: (await localDaemonStatus(stateRoot)).running, targetVersion: version, ownerPid: process.pid }) ?? operation;
+        return completed;
     }
     catch (error) {
         await updateOperation(stateRoot, { phase: "failed", errorCode: errorCode(error) ?? "ATTACH_FAILED", error: error instanceof Error ? error.message : String(error) }).catch(() => undefined);
@@ -128,10 +133,6 @@ export async function installCurrentPackage(input) {
         await unlock();
     }
 }
-async function updateOperationIfPresent(stateRoot, patch) {
-    if (await readOperation(stateRoot))
-        await updateOperation(stateRoot, patch);
-}
 async function waitForFile(file, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -269,6 +270,8 @@ async function prepareOperation(stateRoot, input) {
         attempt: 1,
         createdAt: now,
         updatedAt: now,
+        ownerPid: process.pid,
+        ownerLeaseExpiresAt: Date.now() + 30_000,
         ...(input.targetDigest ? { targetDigest: input.targetDigest } : {}),
     };
     await writeOperation(stateRoot, operation);
@@ -277,8 +280,11 @@ async function prepareOperation(stateRoot, input) {
 async function waitForDaemonIdle(input) {
     const deadline = Date.now() + input.maxWaitMs;
     while (true) {
-        if (!(await localDaemonStatus(input.stateRoot)).running)
+        const daemon = await localDaemonStatus(input.stateRoot);
+        if (!daemon.running)
             return;
+        if (daemon.identityVerified !== true)
+            throw Object.assign(new Error("The existing daemon identity cannot be verified; update lifecycle is disabled until the daemon is reinstalled once"), { code: "DAEMON_IDENTITY_UNVERIFIED" });
         const hostJobs = await activeHostJobCount(input.stateRoot);
         if (hostJobs > 0) {
             if (input.busyPolicy === "reject")

package/package.json

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

package/packages/client/dist/update.js

@@ -14,6 +14,7 @@ async function sendManagementCommand(config, command, timeoutMs, expectedType) {
     return await new Promise((resolve, reject) => {
         const ws = new WebSocket(wsUrl(config.relayUrl));
         let controllerId;
+        let snapshotCursor = 0;
         let published = false;
         let commandPacketId;
         let settled = false;
@@ -30,7 +31,7 @@ async function sendManagementCommand(config, command, timeoutMs, expectedType) {
                 resolve(value);
         };
         ws.addEventListener("open", () => {
-            ws.send(JSON.stringify({ type: "hello", token: config.controllerToken, nodeKind: "controller", snapshotMode: "routing" }));
+            ws.send(JSON.stringify({ type: "hello", token: config.controllerToken, nodeKind: "controller", snapshotMode: "routing", replayMode: "management" }));
         });
         ws.addEventListener("error", () => finish(undefined, new ControllerClientError("Relay websocket failed", "RELAY_WEBSOCKET_ERROR")));
         ws.addEventListener("message", (event) => {
@@ -49,6 +50,7 @@ async function sendManagementCommand(config, command, timeoutMs, expectedType) {
             if (wire.type === "server:snapshot") {
                 if (!controllerId || published)
                     return;
+                snapshotCursor = wire.cursor;
                 published = true;
                 void publish().catch((error) => finish(undefined, error instanceof Error ? error : new ControllerClientError("Failed to publish update command", "UPDATE_PUBLISH_FAILED")));
                 return;
@@ -77,6 +79,7 @@ async function sendManagementCommand(config, command, timeoutMs, expectedType) {
             ws.send(JSON.stringify({
                 type: "subscribe",
                 channelId: updateResponseChannel(controllerId),
+                cursor: snapshotCursor,
             }));
             commandPacketId = randomId("pkt_update_command");
             ws.send(JSON.stringify({

package/packages/shared/dist/packet-relay.d.ts

@@ -34,6 +34,8 @@ export type RelayWireMessage = {
     cursor?: number;
     /** Request a compact session-routing snapshot for cold command RPCs. */
     snapshotMode?: "full" | "routing";
+    /** Restrict this connection to the encrypted updater management plane. */
+    replayMode?: "full" | "management";
 } | {
     type: "subscribe";
     toNodeId?: string;

package/packages/shared/dist/packet-relay.js

@@ -41,6 +41,7 @@ const relayWireMessageSchema = z.discriminatedUnion("type", [
         nodeKind: relayNodeKindSchema.optional(),
         cursor: z.number().int().nonnegative().optional(),
         snapshotMode: z.enum(["full", "routing"]).optional(),
+        replayMode: z.enum(["full", "management"]).optional(),
     }),
     z.object({
         type: z.literal("subscribe"),