@ouro.bot/cli 0.1.0-alpha.1 → 0.1.0-alpha.100

package/dist/heart/daemon/os-cron.js

@@ -0,0 +1,260 @@
+"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.CrontabCronManager = exports.LaunchdCronManager = void 0;
+exports.createOsCronManager = createOsCronManager;
+exports.cadenceToSeconds = cadenceToSeconds;
+exports.scheduleToCalendarInterval = scheduleToCalendarInterval;
+exports.generatePlistXml = generatePlistXml;
+exports.plistLabel = plistLabel;
+exports.crontabLine = crontabLine;
+const os = __importStar(require("os"));
+const runtime_1 = require("../../nerves/runtime");
+const PLIST_PREFIX = "bot.ouro.";
+function plistLabel(job) {
+    return `${PLIST_PREFIX}${job.agent}.${job.taskId}`;
+}
+function cadenceToSeconds(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const [minute, hour, day, month, weekday] = parts;
+    // Simple interval patterns only
+    if (month !== "*" || weekday !== "*" || day !== "*")
+        return null;
+    const everyNMinutes = /^\*\/(\d+)$/.exec(minute);
+    if (everyNMinutes && hour === "*") {
+        return parseInt(everyNMinutes[1], 10) * 60;
+    }
+    const everyNHours = /^\*\/(\d+)$/.exec(hour);
+    if (everyNHours && minute === "0") {
+        return parseInt(everyNHours[1], 10) * 3600;
+    }
+    return null;
+}
+function scheduleToCalendarInterval(schedule) {
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const [minute, hour, day, month] = parts;
+    const result = {};
+    if (minute !== "*" && !/^\*\//.test(minute))
+        result.Minute = parseInt(minute, 10);
+    if (hour !== "*" && !/^\*\//.test(hour))
+        result.Hour = parseInt(hour, 10);
+    if (day !== "*")
+        result.Day = parseInt(day, 10);
+    if (month !== "*")
+        result.Month = parseInt(month, 10);
+    return Object.keys(result).length > 0 ? result : null;
+}
+function generatePlistXml(job) {
+    const label = plistLabel(job);
+    const seconds = cadenceToSeconds(job.schedule);
+    const calendar = seconds === null ? scheduleToCalendarInterval(job.schedule) : null;
+    let triggerXml;
+    if (seconds !== null) {
+        triggerXml = `  <key>StartInterval</key>\n  <integer>${seconds}</integer>`;
+    }
+    else if (calendar !== null) {
+        const entries = Object.entries(calendar)
+            .map(([k, v]) => `      <key>${k}</key>\n      <integer>${v}</integer>`)
+            .join("\n");
+        triggerXml = `  <key>StartCalendarInterval</key>\n  <dict>\n${entries}\n  </dict>`;
+    }
+    else {
+        triggerXml = `  <key>StartInterval</key>\n  <integer>1800</integer>`;
+    }
+    return [
+        `<?xml version="1.0" encoding="UTF-8"?>`,
+        `<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">`,
+        `<plist version="1.0">`,
+        `<dict>`,
+        `  <key>Label</key>`,
+        `  <string>${label}</string>`,
+        `  <key>ProgramArguments</key>`,
+        `  <array>`,
+        `    <string>${job.command.split(" ")[0]}</string>`,
+        ...job.command.split(" ").slice(1).map((arg) => `    <string>${arg}</string>`),
+        `  </array>`,
+        triggerXml,
+        `  <key>StandardOutPath</key>`,
+        `  <string>/tmp/${label}.stdout.log</string>`,
+        `  <key>StandardErrorPath</key>`,
+        `  <string>/tmp/${label}.stderr.log</string>`,
+        `</dict>`,
+        `</plist>`,
+        ``,
+    ].join("\n");
+}
+class LaunchdCronManager {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    get launchAgentsDir() {
+        return `${this.deps.homeDir}/Library/LaunchAgents`;
+    }
+    sync(jobs) {
+        this.deps.mkdirp(this.launchAgentsDir);
+        const desiredLabels = new Set(jobs.map(plistLabel));
+        // Remove stale plists
+        const existing = this.listPlistFiles();
+        for (const filename of existing) {
+            const label = filename.replace(".plist", "");
+            if (!desiredLabels.has(label)) {
+                const fullPath = `${this.launchAgentsDir}/${filename}`;
+                try {
+                    this.deps.exec(`launchctl unload "${fullPath}"`);
+                }
+                catch { /* best effort */ }
+                this.deps.removeFile(fullPath);
+            }
+        }
+        // Write current plists
+        for (const job of jobs) {
+            const label = plistLabel(job);
+            const filename = `${label}.plist`;
+            const fullPath = `${this.launchAgentsDir}/${filename}`;
+            const xml = generatePlistXml(job);
+            try {
+                this.deps.exec(`launchctl unload "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+            this.deps.writeFile(fullPath, xml);
+            try {
+                this.deps.exec(`launchctl load "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+        }
+        (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.os_cron_synced", message: "synced OS cron entries", meta: { platform: "darwin", jobCount: jobs.length } });
+    }
+    removeAll() {
+        const existing = this.listPlistFiles();
+        for (const filename of existing) {
+            const fullPath = `${this.launchAgentsDir}/${filename}`;
+            try {
+                this.deps.exec(`launchctl unload "${fullPath}"`);
+            }
+            catch { /* best effort */ }
+            this.deps.removeFile(fullPath);
+        }
+    }
+    list() {
+        return this.listPlistFiles().map((f) => f.replace(".plist", ""));
+    }
+    listPlistFiles() {
+        if (!this.deps.existsFile(this.launchAgentsDir))
+            return [];
+        return this.deps.listDir(this.launchAgentsDir).filter((f) => f.startsWith(PLIST_PREFIX) && f.endsWith(".plist"));
+    }
+}
+exports.LaunchdCronManager = LaunchdCronManager;
+const CRONTAB_MARKER_PREFIX = "# ouro:";
+function crontabLine(job) {
+    return `${CRONTAB_MARKER_PREFIX}${job.id}\n${job.schedule} ${job.command}`;
+}
+class CrontabCronManager {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    sync(jobs) {
+        const currentLines = this.readCrontab();
+        const cleaned = this.removeOuroLines(currentLines);
+        const newLines = jobs.map(crontabLine);
+        const combined = [...cleaned, ...newLines].join("\n").trim();
+        this.deps.execWrite("crontab -", combined ? `${combined}\n` : "");
+    }
+    removeAll() {
+        const currentLines = this.readCrontab();
+        const cleaned = this.removeOuroLines(currentLines);
+        const combined = cleaned.join("\n").trim();
+        this.deps.execWrite("crontab -", combined ? `${combined}\n` : "");
+    }
+    list() {
+        const lines = this.readCrontab();
+        return lines
+            .filter((l) => l.startsWith(CRONTAB_MARKER_PREFIX))
+            .map((l) => l.slice(CRONTAB_MARKER_PREFIX.length));
+    }
+    readCrontab() {
+        try {
+            return this.deps.execOutput("crontab -l").split("\n");
+        }
+        catch {
+            return [];
+        }
+    }
+    removeOuroLines(lines) {
+        const result = [];
+        let skipNext = false;
+        for (const line of lines) {
+            if (line.startsWith(CRONTAB_MARKER_PREFIX)) {
+                skipNext = true;
+                continue;
+            }
+            if (skipNext) {
+                skipNext = false;
+                continue;
+            }
+            result.push(line);
+        }
+        return result;
+    }
+}
+exports.CrontabCronManager = CrontabCronManager;
+function createOsCronManager(options = {}) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "darwin") {
+        /* v8 ignore start -- integration: default stubs for real OS operations @preserve */
+        const deps = options.launchdDeps ?? {
+            exec: () => { },
+            writeFile: () => { },
+            removeFile: () => { },
+            existsFile: () => false,
+            listDir: () => [],
+            mkdirp: () => { },
+            homeDir: os.homedir(),
+        };
+        /* v8 ignore stop */
+        return new LaunchdCronManager(deps);
+    }
+    const deps = options.crontabDeps ?? {
+        execOutput: () => "",
+        execWrite: () => { },
+    };
+    return new CrontabCronManager(deps);
+}

package/dist/heart/daemon/ouro-bot-global-installer.js

@@ -0,0 +1,128 @@
+"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.syncGlobalOuroBotWrapper = syncGlobalOuroBotWrapper;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const runtime_metadata_1 = require("./runtime-metadata");
+function normalizeOutput(output) {
+    return (typeof output === "string" ? output : output.toString("utf-8")).trim();
+}
+function resolveGlobalPrefix(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["prefix", "-g"], { encoding: "utf-8" }));
+}
+function resolveGlobalRoot(execFileSyncImpl) {
+    return normalizeOutput(execFileSyncImpl("npm", ["root", "-g"], { encoding: "utf-8" }));
+}
+function readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl) {
+    const packageJsonPath = path.join(globalRoot, "ouro.bot", "package.json");
+    if (!existsSyncImpl(packageJsonPath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSyncImpl(packageJsonPath, "utf-8"));
+        return typeof parsed.version === "string" && parsed.version.trim().length > 0 ? parsed.version.trim() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl) {
+    const binName = platform === "win32" ? "ouro.bot.cmd" : "ouro.bot";
+    const binPath = platform === "win32"
+        ? path.join(globalPrefix, binName)
+        : path.join(globalPrefix, "bin", binName);
+    if (!existsSyncImpl(binPath))
+        return null;
+    try {
+        const resolved = realpathSyncImpl(binPath);
+        if (resolved.includes(`${path.sep}node_modules${path.sep}ouro.bot${path.sep}`))
+            return "wrapper";
+        if (resolved.includes(`${path.sep}node_modules${path.sep}@ouro.bot${path.sep}cli${path.sep}`))
+            return "cli";
+        return "other";
+    }
+    catch {
+        return "unknown";
+    }
+}
+function syncGlobalOuroBotWrapper(deps = {}) {
+    /* v8 ignore start -- dependency-injection defaults are only exercised in the live runtime */
+    const execFileSyncImpl = deps.execFileSync ?? child_process_1.execFileSync;
+    const existsSyncImpl = deps.existsSync ?? fs.existsSync;
+    const readFileSyncImpl = deps.readFileSync ?? fs.readFileSync;
+    const realpathSyncImpl = deps.realpathSync ?? fs.realpathSync;
+    const runtimeVersion = deps.runtimeVersion ?? (0, runtime_metadata_1.getRuntimeMetadata)().version;
+    const platform = deps.platform ?? process.platform;
+    /* v8 ignore stop */
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_start",
+        message: "checking global ouro.bot wrapper",
+        meta: { version: runtimeVersion },
+    });
+    const globalPrefix = resolveGlobalPrefix(execFileSyncImpl);
+    const globalRoot = resolveGlobalRoot(execFileSyncImpl);
+    const installedVersion = readInstalledWrapperVersion(globalRoot, existsSyncImpl, readFileSyncImpl);
+    const executableOwner = resolveExecutableOwner(globalPrefix, platform, existsSyncImpl, realpathSyncImpl);
+    if (executableOwner === "wrapper") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_bot_global_sync_end",
+            message: "global ouro.bot wrapper already current",
+            meta: { version: runtimeVersion, installedVersion, executableOwner, installed: false },
+        });
+        return {
+            installed: false,
+            version: runtimeVersion,
+            installedVersion,
+            executableOwner,
+        };
+    }
+    execFileSyncImpl("npm", ["install", "-g", "--force", "ouro.bot@latest"], { stdio: "pipe", encoding: "utf-8" });
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_bot_global_sync_end",
+        message: "global ouro.bot wrapper synced",
+        meta: { version: runtimeVersion, installedVersion, executableOwner, installed: true },
+    });
+    return {
+        installed: true,
+        version: runtimeVersion,
+        installedVersion,
+        executableOwner,
+    };
+}

package/dist/heart/daemon/ouro-bot-wrapper.js

@@ -37,8 +37,9 @@ exports.runOuroBotWrapper = runOuroBotWrapper;
 const runtime_1 = require("../../nerves/runtime");
 const daemon_cli_1 = require("./daemon-cli");
 async function defaultLoadCanonicalRunner() {
-    const packageName = "@ouro.bot/cli";
-    const specifier = packageName;
+    // Use the subpath export so we get the daemon-cli module directly,
+    // NOT the root entry point which has side-effects (immediately runs the CLI).
+    const specifier = "@ouro.bot/cli/runOuroCli";
     const loaded = await Promise.resolve(`${specifier}`).then(s => __importStar(require(s)));
     const candidate = Object.prototype.hasOwnProperty.call(loaded, "runOuroCli")
         ? loaded["runOuroCli"]
@@ -46,7 +47,7 @@ async function defaultLoadCanonicalRunner() {
     if (typeof candidate === "function") {
         return candidate;
     }
-    throw new Error("@ouro.bot/cli does not export runOuroCli");
+    throw new Error("@ouro.bot/cli/runOuroCli does not export runOuroCli");
 }
 function defaultWriteStdout(_text) {
     // Wrapper is intentionally silent by default to avoid duplicate terminal output.

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

@@ -0,0 +1,260 @@
+"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.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
+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 detectShellProfile(homeDir, shell) {
+    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 uses .bashrc
+        const profilePath = path.join(homeDir, ".bash_profile");
+        return profilePath;
+    }
+    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 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`;
+}
+/**
+ * Remove lines matching the old ouro PATH block from shell profile content.
+ * Returns the cleaned content.
+ */
+function removeOldPathBlock(content, oldBinDir) {
+    const lines = content.split("\n");
+    const result = [];
+    let i = 0;
+    while (i < lines.length) {
+        // Detect "# Added by ouro" followed by a PATH export containing the old binDir
+        if (lines[i].trim() === "# Added by ouro" && i + 1 < lines.length && lines[i + 1].includes(oldBinDir)) {
+            // Skip both lines (comment + export)
+            i += 2;
+            // Also skip trailing blank line if present
+            /* v8 ignore next -- edge: trailing blank line presence varies @preserve */
+            if (i < lines.length && lines[i].trim() === "")
+                i++;
+            continue;
+        }
+        result.push(lines[i]);
+        i++;
+    }
+    return result.join("\n");
+}
+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 unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const rmdirSync = deps.rmdirSync ?? fs.rmdirSync;
+    const readdirSync = deps.readdirSync ?? ((p) => fs.readdirSync(p).map(String));
+    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", migratedFromOldPath: 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");
+    // ── Migration from old ~/.local/bin/ouro ──
+    const oldBinDir = path.join(homeDir, ".local", "bin");
+    const oldScriptPath = path.join(oldBinDir, "ouro");
+    let migratedFromOldPath = false;
+    if (existsSync(oldScriptPath)) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_migrate_start",
+            message: "migrating ouro from old PATH location",
+            meta: { oldScriptPath },
+        });
+        try {
+            unlinkSync(oldScriptPath);
+            migratedFromOldPath = true;
+            // Remove empty ~/.local/bin/ directory
+            if (existsSync(oldBinDir)) {
+                try {
+                    const remaining = readdirSync(oldBinDir);
+                    if (remaining.length === 0) {
+                        rmdirSync(oldBinDir);
+                    }
+                }
+                catch {
+                    // Best effort cleanup
+                }
+            }
+        }
+        catch {
+            // Best effort migration — continue with new install
+        }
+        // Remove old PATH entry from shell profile
+        const profilePath = detectShellProfile(homeDir, shell);
+        /* v8 ignore start -- profile cleanup: only fires during migration from old layout @preserve */
+        if (profilePath) {
+            try {
+                const profileContent = readFileSync(profilePath, "utf-8");
+                if (profileContent.includes(oldBinDir)) {
+                    const cleaned = removeOldPathBlock(profileContent, oldBinDir);
+                    writeFileSync(profilePath, cleaned);
+                }
+            }
+            catch {
+                // Best effort profile cleanup
+            }
+        }
+        /* v8 ignore stop */
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_start",
+        message: "installing ouro command to PATH",
+        meta: { scriptPath, binDir },
+    });
+    // If ouro already exists, check content and repair if stale
+    if (existsSync(scriptPath)) {
+        let existingContent = "";
+        try {
+            existingContent = readFileSync(scriptPath, "utf-8");
+        }
+        catch {
+            // Can't read — treat as stale, will overwrite below
+        }
+        if (existingContent === WRAPPER_SCRIPT) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "daemon",
+                event: "daemon.ouro_path_install_skip",
+                message: "ouro command already installed",
+                meta: { scriptPath },
+            });
+            return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed", migratedFromOldPath };
+        }
+        // Content is stale — repair by overwriting
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.ouro_path_install_repair",
+            message: "repairing stale ouro wrapper script",
+            meta: { scriptPath },
+        });
+    }
+    try {
+        mkdirSync(binDir, { recursive: true });
+        writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+        chmodSync(scriptPath, 0o755);
+    }
+    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), migratedFromOldPath };
+    }
+    // Check if ~/.ouro-cli/bin is already in PATH
+    let shellProfileUpdated = null;
+    const pathReady = isBinDirInPath(binDir, envPath);
+    if (!pathReady) {
+        const profilePath = detectShellProfile(homeDir, shell);
+        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) },
+                });
+            }
+        }
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_path_install_end",
+        message: "ouro command installed",
+        meta: { scriptPath, pathReady, shellProfileUpdated },
+    });
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated, migratedFromOldPath };
+}