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

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.86",
   "private": true,
   "type": "module"
 }

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.86",
   "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.86",
   "description": "Remote controller for local coding agents with hosted or self-hosted relay support.",
   "type": "module",
   "bin": {