@ouro.bot/cli 0.1.0-alpha.42 → 0.1.0-alpha.420

package/dist/heart/versioning/ouro-path-installer.js

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diagnoseOuroPath = diagnoseOuroPath;
+exports.installOuroCommand = installOuroCommand;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const WRAPPER_SCRIPT = `#!/bin/sh
+# Check for dev mode — if dev-config.json exists, dispatch to the dev repo
+# Skip dev dispatch for "up" command (explicitly returns to production)
+DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
+if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
+  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
+  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
+  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
+    exec node "$DEV_ENTRY" "$@"
+  fi
+fi
+# Fall back to installed version
+ENTRY="$HOME/.ouro-cli/CurrentVersion/node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js"
+if [ ! -e "$ENTRY" ]; then
+  echo "ouro not installed. Run: npx ouro.bot" >&2
+  exit 1
+fi
+exec node "$ENTRY" "$@"
+`;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+    mkdirSync(path.dirname(scriptPath), { recursive: true });
+    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    chmodSync(scriptPath, 0o755);
+}
+function detectShellProfile(homeDir, shell, platform) {
+    if (!shell)
+        return null;
+    const base = path.basename(shell);
+    if (base === "zsh")
+        return path.join(homeDir, ".zshrc");
+    if (base === "bash") {
+        // macOS uses .bash_profile; Linux/WSL uses .bashrc (the default
+        // interactive shell config on Debian/Ubuntu). Writing to .bash_profile
+        // on Linux often has no effect because non-login shells skip it.
+        /* v8 ignore next -- ?? fallback: callers always pass platform from deps @preserve */
+        const effectivePlatform = platform ?? process.platform;
+        return effectivePlatform === "darwin"
+            ? path.join(homeDir, ".bash_profile")
+            : path.join(homeDir, ".bashrc");
+    }
+    if (base === "fish")
+        return path.join(homeDir, ".config", "fish", "config.fish");
+    return null;
+}
+function isBinDirInPath(binDir, envPath) {
+    return envPath.split(path.delimiter).some((p) => p === binDir);
+}
+function samePath(a, b) {
+    return path.resolve(a) === path.resolve(b);
+}
+function buildPathExportLine(binDir, shell) {
+    const base = shell ? path.basename(shell) : /* v8 ignore next -- unreachable: only called when detectShellProfile returns non-null, which requires shell @preserve */ "";
+    if (base === "fish") {
+        return `\n# Added by ouro\nset -gx PATH ${binDir} $PATH\n`;
+    }
+    return `\n# Added by ouro\nexport PATH="${binDir}:$PATH"\n`;
+}
+function isWrapperCurrent(scriptPath, existsSync, readFileSync) {
+    if (!existsSync(scriptPath))
+        return false;
+    try {
+        return readFileSync(scriptPath, "utf-8") === WRAPPER_SCRIPT;
+    }
+    catch {
+        return false;
+    }
+}
+function firstOuroOnPath(envPath, existsSync) {
+    for (const dir of envPath.split(path.delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = path.join(dir, "ouro");
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return null;
+}
+function diagnoseOuroPath(deps) {
+    const binDir = path.join(deps.homeDir, ".ouro-cli", "bin");
+    const expectedPath = path.join(binDir, "ouro");
+    const resolvedPath = firstOuroOnPath(deps.envPath, deps.existsSync);
+    if (!resolvedPath) {
+        return {
+            status: "missing",
+            expectedPath,
+            resolvedPath: null,
+            detail: `PATH does not resolve ouro; expected ${expectedPath}`,
+            remediation: `add ${binDir} to PATH or open a new shell after ouro up updates your shell profile`,
+        };
+    }
+    if (samePath(resolvedPath, expectedPath)) {
+        return {
+            status: "ok",
+            expectedPath,
+            resolvedPath,
+            detail: `PATH resolves ouro to ${expectedPath}`,
+            remediation: null,
+        };
+    }
+    if (isWrapperCurrent(resolvedPath, deps.existsSync, deps.readFileSync)) {
+        return {
+            status: "ok",
+            expectedPath,
+            resolvedPath,
+            detail: `PATH resolves ouro through a compatible wrapper at ${resolvedPath}`,
+            remediation: null,
+        };
+    }
+    const shadowDir = path.dirname(resolvedPath);
+    return {
+        status: "shadowed",
+        expectedPath,
+        resolvedPath,
+        detail: `PATH resolves ouro to ${resolvedPath} before ${expectedPath}`,
+        remediation: `move ${binDir} before ${shadowDir} in PATH, or remove/replace ${resolvedPath} after confirming it is the stale ouro launcher`,
+    };
+}
+function installOuroCommand(deps = {}) {
+    /* v8 ignore start -- dep defaults: only used in real runtime, tests always inject @preserve */
+    const platform = deps.platform ?? process.platform;
+    const homeDir = deps.homeDir ?? os.homedir();
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const readFileSync = deps.readFileSync ?? ((p, enc) => fs.readFileSync(p, enc));
+    const appendFileSync = deps.appendFileSync ?? fs.appendFileSync;
+    const chmodSync = deps.chmodSync ?? fs.chmodSync;
+    const envPath = deps.envPath ?? process.env.PATH ?? "";
+    const shell = deps.shell ?? process.env.SHELL;
+    /* v8 ignore stop */
+    if (platform === "win32") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "skipped ouro PATH install on Windows",
+            meta: { platform },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows", repairedOldLauncher: false };
+    }
+    // Ensure ~/.ouro-cli/ directory layout exists
+    if (deps.ensureCliLayout) {
+        deps.ensureCliLayout();
+    }
+    const binDir = path.join(homeDir, ".ouro-cli", "bin");
+    const scriptPath = path.join(binDir, "ouro");
+    const oldScriptPath = path.join(homeDir, ".local", "bin", "ouro");
+    const resolvePath = () => diagnoseOuroPath({ homeDir, envPath, existsSync, readFileSync });
+    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync);
+    const oldExists = existsSync(oldScriptPath);
+    const oldCurrent = oldExists && isWrapperCurrent(oldScriptPath, existsSync, readFileSync);
+    // ── Repair old ~/.local/bin/ouro launcher ──
+    // If the old launcher exists with stale content it can shadow the modern
+    // path and cause the wrong CLI version to run.  Overwrite it with the
+    // current wrapper so both paths resolve to ~/.ouro-cli/CurrentVersion.
+    let repairedOldLauncher = false;
+    if (oldExists && !oldCurrent) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_repair_old",
+            message: "repairing stale old launcher at ~/.local/bin/ouro",
+            meta: { oldScriptPath },
+        });
+        try {
+            writeFileSync(oldScriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+            chmodSync(oldScriptPath, 0o755);
+            repairedOldLauncher = true;
+        }
+        catch {
+            // Best effort — old launcher repair failure must not block modern install
+        }
+    }
+    // ── Fast-path: modern wrapper already current ──
+    if (modernCurrent) {
+        const pathResolution = resolvePath();
+        if (pathResolution.status === "shadowed") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "daemon",
+                event: "daemon.ouro_path_shadowed",
+                message: "PATH resolves ouro to a stale external launcher",
+                meta: { resolvedPath: pathResolution.resolvedPath, expectedPath: pathResolution.expectedPath, remediation: pathResolution.remediation },
+            });
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_skip",
+            message: "ouro command already installed",
+            meta: { scriptPath, pathStatus: pathResolution.status, resolvedPath: pathResolution.resolvedPath },
+        });
+        return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed", repairedOldLauncher, pathResolution };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: existsSync(scriptPath) ? "repairing stale ouro wrapper script" : "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
+    try {
+        if (!modernCurrent) {
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+        }
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_path_install_error",
+            message: "failed to install ouro command",
+            meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+        });
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: error instanceof Error ? error.message : /* v8 ignore next -- defensive @preserve */ String(error), repairedOldLauncher };
+    }
+    // Check if ~/.ouro-cli/bin is already in PATH
+    const pathReady = isBinDirInPath(binDir, envPath);
+    let shellProfileUpdated = null;
+    if (!pathReady) {
+        const profilePath = detectShellProfile(homeDir, shell, platform);
+        if (profilePath) {
+            try {
+                let existing = "";
+                try {
+                    existing = readFileSync(profilePath, "utf-8");
+                }
+                catch {
+                    // Profile doesn't exist yet — that's fine, we'll create it
+                }
+                if (!existing.includes(binDir)) {
+                    appendFileSync(profilePath, buildPathExportLine(binDir, shell));
+                    shellProfileUpdated = profilePath;
+                }
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.ouro_path_profile_error",
+                    message: "failed to update shell profile for PATH",
+                    meta: { profilePath, error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+        }
+    }
+    const pathResolution = resolvePath();
+    if (pathResolution.status === "shadowed") {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.ouro_path_shadowed",
+            message: "PATH resolves ouro to a stale external launcher",
+            meta: { resolvedPath: pathResolution.resolvedPath, expectedPath: pathResolution.expectedPath, remediation: pathResolution.remediation },
+        });
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_end",
+        message: "ouro command installed",
+        meta: { scriptPath, pathReady, shellProfileUpdated, oldScriptPath: oldExists ? oldScriptPath : null, pathStatus: pathResolution.status, resolvedPath: pathResolution.resolvedPath },
+    });
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated, repairedOldLauncher, pathResolution };
+}

package/dist/heart/versioning/ouro-version-manager.js

@@ -0,0 +1,295 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_RETAIN_VERSIONS = void 0;
+exports.getOuroCliHome = getOuroCliHome;
+exports.getCurrentVersion = getCurrentVersion;
+exports.getPreviousVersion = getPreviousVersion;
+exports.buildChangelogCommand = buildChangelogCommand;
+exports.listInstalledVersions = listInstalledVersions;
+exports.installVersion = installVersion;
+exports.activateVersion = activateVersion;
+exports.compareCliVersions = compareCliVersions;
+exports.selectVersionsToPrune = selectVersionsToPrune;
+exports.pruneOldVersions = pruneOldVersions;
+exports.ensureLayout = ensureLayout;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+/** Maximum number of installed CLI versions to retain after pruning. */
+exports.DEFAULT_RETAIN_VERSIONS = 5;
+function getOuroCliHome(homeDir) {
+    /* v8 ignore next -- dep default: tests always inject @preserve */
+    const home = homeDir ?? os.homedir();
+    return path.join(home, ".ouro-cli");
+}
+function getCurrentVersion(deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore next -- dep default: tests always inject @preserve */
+    const readlinkSync = deps.readlinkSync ?? fs.readlinkSync;
+    try {
+        const target = readlinkSync(path.join(cliHome, "CurrentVersion"));
+        return path.basename(target);
+    }
+    catch {
+        return null;
+    }
+}
+function getPreviousVersion(deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore next -- dep default: tests always inject @preserve */
+    const readlinkSync = deps.readlinkSync ?? fs.readlinkSync;
+    try {
+        const target = readlinkSync(path.join(cliHome, "previous"));
+        return path.basename(target);
+    }
+    catch {
+        return null;
+    }
+}
+function buildChangelogCommand(previousVersion, currentVersion) {
+    if (!previousVersion || !currentVersion || previousVersion === currentVersion) {
+        return null;
+    }
+    return `ouro changelog --from ${previousVersion}`;
+}
+function listInstalledVersions(deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore next -- dep default: tests always inject @preserve */
+    const readdirSync = deps.readdirSync ?? ((p, opts) => fs.readdirSync(p, opts));
+    try {
+        const entries = readdirSync(path.join(cliHome, "versions"), { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+function installVersion(version, deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore start -- dep defaults: tests always inject @preserve */
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const execSync = deps.execSync ?? ((cmd, opts) => require("child_process").execSync(cmd, opts));
+    /* v8 ignore stop */
+    const versionDir = path.join(cliHome, "versions", version);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_version_install_start",
+        message: "installing CLI version",
+        meta: { version, versionDir },
+    });
+    mkdirSync(versionDir, { recursive: true });
+    execSync(`npm install --prefix ${versionDir} @ouro.bot/cli@${version}`, { stdio: "pipe" });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_version_install_end",
+        message: "CLI version installed",
+        meta: { version, versionDir },
+    });
+}
+function activateVersion(version, deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore start -- dep defaults: tests always inject @preserve */
+    const readlinkSync = deps.readlinkSync ?? fs.readlinkSync;
+    const unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const symlinkSync = deps.symlinkSync ?? fs.symlinkSync;
+    const existsSync = deps.existsSync ?? fs.existsSync;
+    /* v8 ignore stop */
+    const currentVersionPath = path.join(cliHome, "CurrentVersion");
+    const previousPath = path.join(cliHome, "previous");
+    const newTarget = path.join(cliHome, "versions", version);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_version_activate",
+        message: "activating CLI version",
+        meta: { version },
+    });
+    // Read old CurrentVersion target (may not exist)
+    let oldTarget = null;
+    try {
+        oldTarget = readlinkSync(currentVersionPath);
+    }
+    catch {
+        // No current version — first install
+    }
+    // Update previous symlink to point to old current
+    if (oldTarget) {
+        try {
+            unlinkSync(previousPath);
+        }
+        catch {
+            // previous symlink may not exist yet
+        }
+        symlinkSync(oldTarget, previousPath);
+    }
+    // Update CurrentVersion symlink
+    if (existsSync(currentVersionPath)) {
+        unlinkSync(currentVersionPath);
+    }
+    symlinkSync(newTarget, currentVersionPath);
+}
+/**
+ * Compare two version strings of the form `0.1.0-alpha.{n}`. Returns
+ * positive when `a` is newer, negative when `b` is newer, 0 when equal.
+ *
+ * The harness only ships `0.1.0-alpha.{n}` versions today; this comparator
+ * extracts the numeric tail and falls back to a lexicographic compare for
+ * any version that doesn't match the pattern (so unexpected version
+ * formats sort consistently rather than throwing).
+ */
+function compareCliVersions(a, b) {
+    const aMatch = /alpha\.(\d+)/.exec(a);
+    const bMatch = /alpha\.(\d+)/.exec(b);
+    if (aMatch && bMatch) {
+        const aN = parseInt(aMatch[1], 10);
+        const bN = parseInt(bMatch[1], 10);
+        return aN - bN;
+    }
+    // Fallback: lexicographic. Both-mismatched and one-mismatched cases land
+    // here. Predictable, even if not strictly semver-correct.
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}
+/**
+ * Identify which installed CLI versions can be safely deleted, given a
+ * retention policy. Pure: takes the full version list and the protected
+ * (current/previous) versions, returns the versions to delete.
+ *
+ * Retention rules:
+ *   - Always keep the N most recent versions (default 5).
+ *   - Always keep the currently-active version (CurrentVersion symlink target).
+ *   - Always keep the previous version (previous symlink target) so rollback
+ *     stays one command away.
+ *   - Delete everything else.
+ *
+ * Exported so tests can pin the policy without shelling out to a real fs.
+ */
+function selectVersionsToPrune(installedVersions, protectedVersions, retain = exports.DEFAULT_RETAIN_VERSIONS) {
+    if (installedVersions.length <= retain)
+        return [];
+    const sorted = [...installedVersions].sort(compareCliVersions).reverse();
+    const keepers = new Set(sorted.slice(0, retain));
+    if (protectedVersions.current)
+        keepers.add(protectedVersions.current);
+    if (protectedVersions.previous)
+        keepers.add(protectedVersions.previous);
+    return installedVersions.filter((v) => !keepers.has(v));
+}
+/**
+ * Prune installed CLI versions according to the retention policy. Removes
+ * `~/.ouro-cli/versions/{version}/` directories for versions outside the
+ * retention window. Best-effort: per-version delete failures are logged
+ * via nerves but don't propagate.
+ *
+ * Called from the activate path (cli-defaults.ts) so that every successful
+ * `ouro up` self-prunes. The user observed `~/.ouro-cli/versions/` going
+ * back to alpha.85 from March 20 — every CLI version they'd ever installed
+ * was still on disk because nothing ever GCed.
+ */
+function pruneOldVersions(retain = exports.DEFAULT_RETAIN_VERSIONS, deps = {}) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore start -- dep defaults: tests always inject @preserve */
+    const readdirSync = deps.readdirSync ?? ((p, opts) => fs.readdirSync(p, opts));
+    const readlinkSync = deps.readlinkSync ?? fs.readlinkSync;
+    const rmSync = deps.rmSync ?? fs.rmSync;
+    /* v8 ignore stop */
+    const versionsDir = path.join(cliHome, "versions");
+    let installed;
+    try {
+        installed = readdirSync(versionsDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+    }
+    catch {
+        return { kept: [], deleted: [], failed: [] };
+    }
+    const current = (() => {
+        try {
+            return path.basename(readlinkSync(path.join(cliHome, "CurrentVersion")));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const previous = (() => {
+        try {
+            return path.basename(readlinkSync(path.join(cliHome, "previous")));
+        }
+        catch {
+            return null;
+        }
+    })();
+    const toDelete = selectVersionsToPrune(installed, { current, previous }, retain);
+    const deleted = [];
+    const failed = [];
+    for (const version of toDelete) {
+        const versionDir = path.join(versionsDir, version);
+        try {
+            rmSync(versionDir, { recursive: true, force: true });
+            deleted.push(version);
+        }
+        catch (error) {
+            failed.push({
+                version,
+                error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error),
+            });
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_versions_pruned",
+        message: `pruned ${deleted.length} old CLI versions`,
+        meta: { retain, deleted, failed: failed.length, kept: installed.filter((v) => !deleted.includes(v)) },
+    });
+    return { kept: installed.filter((v) => !deleted.includes(v)), deleted, failed };
+}
+function ensureLayout(deps) {
+    const cliHome = getOuroCliHome(deps.homeDir);
+    /* v8 ignore next -- dep default: tests always inject @preserve */
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    mkdirSync(cliHome, { recursive: true });
+    mkdirSync(path.join(cliHome, "bin"), { recursive: true });
+    mkdirSync(path.join(cliHome, "versions"), { recursive: true });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.cli_layout_ensured",
+        message: "CLI directory layout ensured",
+        meta: { cliHome },
+    });
+}

package/dist/heart/{daemon → versioning}/staged-restart.js

@@ -45,14 +45,22 @@ async function performStagedRestart(version, deps) {
     });
     // Step 1: Install new version
     try {
-        deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+        if (deps.installNewVersion) {
+            deps.installNewVersion(version);
+        }
+        else {
+            // Backward-compat fallback for callers that haven't migrated to the
+            // version-managed installer. Tests use this path with a mocked
+            // execSync; production callers inject installNewVersion.
+            deps.execSync(`npm install -g @ouro.bot/cli@${version}`);
+        }
     }
     catch (err) {
         const errorMessage = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.staged_restart_install_failed",
-            message: "npm install failed",
+            message: "install failed",
             meta: { version, error: errorMessage },
         });
         return { ok: false, error: errorMessage };
@@ -90,25 +98,49 @@ async function performStagedRestart(version, deps) {
         });
         return { ok: false, error: `hook runner exited with code ${spawnResult.status}` };
     }
-    // Step 4: Graceful shutdown (launchd will restart with new code)
+    // Step 4: Graceful shutdown then self-spawn new daemon
+    // We can't rely on launchd KeepAlive — the plist may not be loaded.
+    // Instead: shut down (releases socket), spawn new daemon from updated code.
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.staged_restart_hooks_passed",
-        message: "hooks passed, shutting down for restart",
+        message: "hooks passed, shutting down and spawning new daemon",
         meta: { version },
     });
+    let shutdownError;
     try {
         await deps.gracefulShutdown();
     }
     catch (err) {
-        const shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        shutdownError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
         (0, runtime_1.emitNervesEvent)({
             component: "daemon",
             event: "daemon.staged_restart_shutdown_error",
-            message: "graceful shutdown encountered error",
+            message: "graceful shutdown encountered error (continuing with spawn)",
             meta: { version, error: shutdownError },
         });
-        return { ok: true, shutdownError };
     }
-    return { ok: true };
+    // Spawn new daemon from updated code path
+    const newEntry = path.join(newCodePath, "dist", "heart", "daemon", "daemon-entry.js");
+    const socketArg = deps.socketPath ?? "/tmp/ouroboros-daemon.sock";
+    try {
+        const { pid } = deps.spawnNewDaemon(newEntry, socketArg);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_spawned",
+            message: "new daemon spawned successfully",
+            meta: { version, pid, entry: newEntry },
+        });
+    }
+    catch (err) {
+        const spawnError = err instanceof Error ? err.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(err);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.staged_restart_respawn_failed",
+            message: "failed to spawn new daemon after shutdown",
+            meta: { version, error: spawnError, entry: newEntry },
+        });
+        return { ok: false, error: `shutdown succeeded but failed to spawn new daemon: ${spawnError}`, shutdownError };
+    }
+    return { ok: true, shutdownError };
 }