@hyperdrive.bot/paseo-cli 0.3.6 → 0.3.8

package/dist/commands/daemon/index.js

@@ -3,6 +3,7 @@ import { startCommand } from "./start.js";
 import { runStatusCommand } from "./status.js";
 import { runStopCommand } from "./stop.js";
 import { runRestartCommand } from "./restart.js";
+import { runUpdateCommand } from "./update.js";
 import { runSetPasswordCommand } from "./set-password.js";
 import { pairCommand } from "./pair.js";
 import { withOutput } from "../../output/index.js";
@@ -47,6 +48,17 @@ export function createDaemonCommand() {
             hostnames: resolveHostnamesOption(options.hostnames, options.allowedHosts),
         }, command);
     }));
+    addJsonOption(daemon
+        .command("update")
+        .description("Install a newer daemon version into its own slot, with rollback"))
+        .option("--home <path>", "Paseo home directory (default: ~/.paseo)")
+        .option("--to <version>", "Install this exact version instead of the channel's latest")
+        .option("--channel <channel>", "Release channel: stable, beta or dev (default: stable)")
+        .option("--check", "Report whether an update is available without installing it")
+        .option("--force", "Reinstall even if current, or retry a version pinned after a failure")
+        .option("--use-staged", "Activate a slot already present under <home>/versions instead of downloading it (still verified before activation)")
+        .option("--ready-timeout <seconds>", "How long the new version has to come up before rollback (default: 20)")
+        .action(withOutput(runUpdateCommand));
     addJsonOption(daemon
         .command("set-password")
         .description("Prompt for and save a hashed daemon password to config.json"))

package/dist/commands/daemon/update.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+import type { CommandOptions, SingleResult } from "../../output/index.js";
+interface UpdateResult {
+    action: "up-to-date" | "available" | "updated" | "rolled-back" | "pinned";
+    currentVersion: string;
+    targetVersion: string;
+    channel: string;
+    message: string;
+}
+export type UpdateCommandResult = SingleResult<UpdateResult>;
+export declare function runUpdateCommand(options: CommandOptions, _command: Command): Promise<UpdateCommandResult>;
+export {};
+//# sourceMappingURL=update.d.ts.map

package/dist/commands/daemon/update.js

@@ -0,0 +1,237 @@
+import { fetchChannelVersion, isNewer, isPinned, readSlotVersion, readUpdateState, resolvePaseoHome, slotPath, rollback, stageVersion, swapTo, verifySlot, writeUpdateState, } from "@hyperdrive.bot/paseo-server";
+import { resolveCliVersion } from "../../version.js";
+import { resolveLocalDaemonState, startLocalDaemonDetached, stopLocalDaemon, } from "./local-daemon.js";
+const updateResultSchema = {
+    idField: "action",
+    columns: [
+        {
+            header: "STATUS",
+            field: "action",
+            color: (row) => {
+                const action = row.action;
+                if (action === "updated" || action === "up-to-date")
+                    return "green";
+                if (action === "available")
+                    return "yellow";
+                return "red";
+            },
+        },
+        { header: "CURRENT", field: "currentVersion" },
+        { header: "TARGET", field: "targetVersion" },
+        { header: "CHANNEL", field: "channel" },
+        { header: "MESSAGE", field: "message" },
+    ],
+};
+function parseChannel(raw) {
+    const value = typeof raw === "string" && raw.length > 0 ? raw : "stable";
+    if (value === "stable" || value === "beta" || value === "dev") {
+        return value;
+    }
+    const error = {
+        code: "INVALID_CHANNEL",
+        message: `Invalid channel: ${value}`,
+        details: "Channel must be one of: stable, beta, dev",
+    };
+    throw error;
+}
+/**
+ * Version the daemon is actually running.
+ *
+ * Prefers the active slot, because that is what the supervisor will exec on the next
+ * spawn. Falls back to the CLI's own version for an npm-global or checkout install,
+ * where the two are the same package.
+ */
+function resolveRunningVersion(paseoHome) {
+    return readSlotVersion(paseoHome, "current") ?? resolveCliVersion();
+}
+async function waitForDaemonVersion(paseoHome, expected, budgetMs) {
+    const deadline = Date.now() + budgetMs;
+    let observed = null;
+    while (Date.now() < deadline) {
+        const state = resolveLocalDaemonState({ home: paseoHome });
+        // `state.running` only means the SUPERVISOR is alive, which is true even while
+        // it crash-loops a worker that dies on boot, and `current` is whatever we just
+        // pointed it at. Neither says the daemon is serving.
+        //
+        // The real signal is the pid lock's own `listen` field: the entrypoint writes it
+        // from `onWorkerReady`, which fires only when the worker emits `paseo:ready`.
+        // Read `pidInfo` rather than `state.listen`, because the latter falls back to
+        // the configured listen target and so is set before the worker is up.
+        if (state.running && state.pidInfo?.listen) {
+            observed = readSlotVersion(paseoHome, "current");
+            if (observed === expected) {
+                return { ok: true, observed };
+            }
+        }
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return { ok: false, observed };
+}
+function single(data) {
+    return { type: "single", data, schema: updateResultSchema };
+}
+/**
+ * Version this run is aiming at: either the explicit `--to`, or whatever the
+ * channel's dist-tag currently points at.
+ *
+ * Records the lookup in update state even when nothing is installed, so a later
+ * `--check` (or the notify path) can answer without hitting the network.
+ */
+async function resolveTargetVersion(paseoHome, channel, to) {
+    if (typeof to === "string" && to.trim().length > 0) {
+        return to.trim();
+    }
+    let lookup;
+    try {
+        lookup = await fetchChannelVersion(channel);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "REGISTRY_UNAVAILABLE",
+            message: `Could not reach the npm registry: ${message}`,
+        };
+        throw error;
+    }
+    if (!lookup.version) {
+        const error = {
+            code: "NO_CHANNEL_RELEASE",
+            message: `No release published on the "${channel}" channel`,
+        };
+        throw error;
+    }
+    writeUpdateState(paseoHome, { lastCheckedAt: Date.now(), lastSeenVersion: lookup.version });
+    return lookup.version;
+}
+/**
+ * Download into a slot of its own and prove the tree can run, without touching
+ * the slot currently serving.
+ *
+ * An npm install exiting 0 is not evidence: 0.2.6 through 0.3.2 installed
+ * cleanly and still could not boot, because a declared dependency was never
+ * published. A tree that fails here is pinned so the next run skips it.
+ */
+async function stageAndVerify(paseoHome, targetVersion, reuseExisting) {
+    try {
+        await stageVersion(paseoHome, targetVersion, { reuseExisting });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "STAGE_FAILED",
+            message: `Failed to install ${targetVersion}: ${message}`,
+        };
+        throw error;
+    }
+    const verification = await verifySlot(slotPath(paseoHome, targetVersion), {});
+    if (verification.ok)
+        return;
+    writeUpdateState(paseoHome, {
+        pinned: targetVersion,
+        pinnedReason: `staged tree failed verification: ${verification.problems.join("; ")}`,
+    });
+    const error = {
+        code: "VERIFY_FAILED",
+        message: `Staged ${targetVersion} did not verify, so it was not activated`,
+        details: verification.problems.join("\n"),
+    };
+    throw error;
+}
+async function restartDaemon(home) {
+    try {
+        await stopLocalDaemon({ home, timeoutMs: 15000, force: false });
+    }
+    catch {
+        // A slow graceful stop is normal here: the daemon logs "Forcing shutdown -
+        // HTTP server didn't close in time" and exits a moment later. Force it.
+        await stopLocalDaemon({ home, timeoutMs: 15000, force: true });
+    }
+    await startLocalDaemonDetached({ home });
+}
+/**
+ * Restart onto the freshly-swapped slot and hold it to a deadline. If it does
+ * not report ready in time, roll the symlink back, pin the bad version, and
+ * bring the previous one up again.
+ *
+ * Returns null when the new version came up, or the result to report when it
+ * did not.
+ */
+async function restartWithRollback(paseoHome, home, targetVersion, fallbackVersion, channel, readyBudgetMs) {
+    await restartDaemon(home);
+    const ready = await waitForDaemonVersion(paseoHome, targetVersion, readyBudgetMs);
+    if (ready.ok)
+        return null;
+    const { rolledBackTo } = rollback(paseoHome, targetVersion, `daemon did not report ${targetVersion} within ${readyBudgetMs}ms`);
+    try {
+        await stopLocalDaemon({ home, timeoutMs: 15000, force: true });
+    }
+    catch {
+        /* already down */
+    }
+    await startLocalDaemonDetached({ home });
+    return single({
+        action: "rolled-back",
+        currentVersion: rolledBackTo ?? fallbackVersion,
+        targetVersion,
+        channel,
+        message: `${targetVersion} did not come up within ${readyBudgetMs}ms. Rolled back to ` +
+            `${rolledBackTo ?? "the bundled version"} and pinned ${targetVersion}.`,
+    });
+}
+export async function runUpdateCommand(options, _command) {
+    const home = typeof options.home === "string" ? options.home : undefined;
+    const paseoHome = resolvePaseoHome(home ? { PASEO_HOME: home } : {});
+    const channel = parseChannel(options.channel);
+    const force = options.force === true;
+    const readyBudgetMs = typeof options.readyTimeout === "string" && options.readyTimeout.trim().length > 0
+        ? Math.ceil(Number(options.readyTimeout) * 1000)
+        : 20000;
+    const currentVersion = resolveRunningVersion(paseoHome);
+    const state = readUpdateState(paseoHome);
+    const targetVersion = await resolveTargetVersion(paseoHome, channel, options.to);
+    const base = { currentVersion, targetVersion, channel };
+    // A version that already failed to boot here is not retried unless forced.
+    // Checked before the up-to-date short circuit: a pin on the version we are
+    // already running is still worth reporting.
+    if (!force && isPinned(state, targetVersion)) {
+        return single({
+            ...base,
+            action: "pinned",
+            message: `${targetVersion} is pinned after a previous failure (${state.pinnedReason ?? "unknown"}). Use --force to retry.`,
+        });
+    }
+    if (!force && !isNewer(targetVersion, currentVersion)) {
+        return single({
+            ...base,
+            action: "up-to-date",
+            message: `Already running ${currentVersion} (channel ${channel} is at ${targetVersion})`,
+        });
+    }
+    if (options.check === true) {
+        return single({
+            ...base,
+            action: "available",
+            message: `Update available: ${currentVersion} -> ${targetVersion}. Run without --check to install.`,
+        });
+    }
+    await stageAndVerify(paseoHome, targetVersion, options.useStaged === true);
+    // Only now does the running version change. The swap is a symlink rename, so
+    // the previous slot stays on disk and rollback is another rename.
+    swapTo(paseoHome, targetVersion);
+    const wasRunning = resolveLocalDaemonState({ home: paseoHome }).running;
+    if (wasRunning) {
+        const rolledBack = await restartWithRollback(paseoHome, home, targetVersion, currentVersion, channel, readyBudgetMs);
+        if (rolledBack)
+            return rolledBack;
+    }
+    writeUpdateState(paseoHome, { lastInstalled: targetVersion, pinned: null, pinnedReason: null });
+    return single({
+        ...base,
+        action: "updated",
+        currentVersion: targetVersion,
+        message: wasRunning
+            ? `Daemon updated ${currentVersion} -> ${targetVersion} and is serving.`
+            : `Installed ${targetVersion}. Start the daemon to run it.`,
+    });
+}
+//# sourceMappingURL=update.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperdrive.bot/paseo-cli",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "description": "Paseo CLI - control your AI coding agents from the command line",
   "bin": {
     "paseo": "bin/paseo"
@@ -27,9 +27,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.0.0",
-    "@hyperdrive.bot/paseo-client": "0.2.7",
-    "@hyperdrive.bot/paseo-protocol": "0.2.7",
-    "@hyperdrive.bot/paseo-server": "0.3.6",
+    "@hyperdrive.bot/paseo-client": "0.3.8",
+    "@hyperdrive.bot/paseo-protocol": "0.3.8",
+    "@hyperdrive.bot/paseo-server": "0.3.8",
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "mime-types": "^2.1.35",