@ouro.bot/cli 0.1.0-alpha.77 → 0.1.0-alpha.79

package/changelog.json

@@ -1,6 +1,20 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.79",
+      "changes": [
+        "New: Versioned CLI directory layout (~/.ouro-cli/) replaces npx-based ouro wrapper. Explicit version management, rollback support, and deterministic updates.",
+        "New: `ouro up` now checks the registry for newer CLI versions, installs them into ~/.ouro-cli/versions/, activates via symlink flip, and re-execs — no more silent npx downloads.",
+        "New: `ouro rollback [<version>]` swaps CurrentVersion/previous symlinks, stops the daemon. With a version arg, installs if needed then activates.",
+        "New: `ouro versions` lists cached CLI versions with * current and (previous) markers.",
+        "Migration: On first run, old ~/.local/bin/ouro wrapper is removed, old PATH entry cleaned from shell profile, new ~/.ouro-cli/bin added to PATH.",
+        "Trust manifest: rollback requires family trust, versions requires acquaintance.",
+        "Fix: BlueBubbles group chats no longer start typing just because the model turn began. Group chats stay visually quiet until the agent has committed to replying.",
+        "Tool/progress updates now count as reply commitment in BlueBubbles group chats, so read/typing can begin before final user-facing text without regressing back to model-start typing.",
+        "Silent group-chat turns remain fully quiet: when the agent chooses no_response, the inbound message still reaches the model but the chat is not marked read, never types, and never sends a message."
+      ]
+    },
     {
       "version": "0.1.0-alpha.77",
       "changes": [

package/dist/heart/daemon/daemon-cli.js

@@ -298,6 +298,8 @@ function usage() {
         "  ouro session list [--agent <name>]",
         "  ouro mcp list",
         "  ouro mcp call <server> <tool> [--args '{...}']",
+        "  ouro rollback [<version>]",
+        "  ouro versions",
     ].join("\n");
 }
 function formatVersionOutput() {
@@ -908,6 +910,10 @@ function parseOuroCommand(args) {
     }
     if (head === "up")
         return { kind: "daemon.up" };
+    if (head === "rollback")
+        return { kind: "rollback", ...(second ? { version: second } : {}) };
+    if (head === "versions")
+        return { kind: "versions" };
     if (head === "stop" || head === "down")
         return { kind: "daemon.stop" };
     if (head === "status")
@@ -1439,7 +1445,11 @@ async function performSystemSetup(deps) {
     // Install ouro command to PATH (non-blocking)
     if (deps.installOuroCommand) {
         try {
-            deps.installOuroCommand();
+            const installResult = deps.installOuroCommand();
+            /* v8 ignore next -- migration hint: only fires once during old→new layout migration @preserve */
+            if (installResult.migratedFromOldPath) {
+                deps.writeStdout("migrated ouro to ~/.ouro-cli/ — open a new terminal or run: source ~/.zshrc");
+            }
         }
         catch (error) {
             (0, runtime_1.emitNervesEvent)({
@@ -1752,6 +1762,35 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         meta: { kind: command.kind },
     });
     if (command.kind === "daemon.up") {
+        // ── versioned CLI update check ──
+        if (deps.checkForCliUpdate) {
+            let pendingReExec = false;
+            try {
+                const updateResult = await deps.checkForCliUpdate();
+                if (updateResult.available && updateResult.latestVersion) {
+                    /* v8 ignore next -- fallback: getCurrentCliVersion always injected in tests @preserve */
+                    const currentVersion = deps.getCurrentCliVersion?.() ?? "unknown";
+                    await deps.installCliVersion(updateResult.latestVersion);
+                    deps.activateCliVersion(updateResult.latestVersion);
+                    deps.writeStdout(`ouro updated to ${updateResult.latestVersion} (was ${currentVersion})`);
+                    pendingReExec = true;
+                }
+                /* v8 ignore start -- update check error: tested via daemon-cli-update-flow.test.ts @preserve */
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "daemon",
+                    event: "daemon.cli_update_check_error",
+                    message: "CLI update check failed",
+                    meta: { error: error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error) },
+                });
+            }
+            /* v8 ignore stop */
+            if (pendingReExec) {
+                deps.reExecFromNewVersion(args);
+            }
+        }
         await performSystemSetup(deps);
         if (deps.ensureDaemonBootPersistence) {
             try {
@@ -1793,6 +1832,70 @@ async function runOuroCli(args, deps = createDefaultOuroCliDeps()) {
         deps.writeStdout(daemonResult.message);
         return daemonResult.message;
     }
+    // ── rollback command (local, no daemon socket needed for symlinks) ──
+    /* v8 ignore start -- rollback/versions: tested via daemon-cli-rollback/versions tests @preserve */
+    if (command.kind === "rollback") {
+        const currentVersion = deps.getCurrentCliVersion?.() ?? "unknown";
+        if (command.version) {
+            // Rollback to a specific version
+            const installed = deps.listCliVersions?.() ?? [];
+            if (!installed.includes(command.version)) {
+                try {
+                    await deps.installCliVersion(command.version);
+                }
+                catch (error) {
+                    const message = `failed to install version ${command.version}: ${error instanceof Error ? error.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(error)}`;
+                    deps.writeStdout(message);
+                    return message;
+                }
+            }
+            deps.activateCliVersion(command.version);
+        }
+        else {
+            // Rollback to previous version
+            const previousVersion = deps.getPreviousCliVersion?.();
+            if (!previousVersion) {
+                const message = "no previous version to roll back to";
+                deps.writeStdout(message);
+                return message;
+            }
+            deps.activateCliVersion(previousVersion);
+            command = { ...command, version: previousVersion };
+        }
+        // Stop daemon (non-fatal if not running)
+        try {
+            await deps.sendCommand(deps.socketPath, { kind: "daemon.stop" });
+        }
+        catch {
+            // Daemon may not be running — that's fine
+        }
+        const message = `rolled back to ${command.version} (was ${currentVersion})`;
+        deps.writeStdout(message);
+        return message;
+    }
+    // ── versions command (local, no daemon socket needed) ──
+    if (command.kind === "versions") {
+        const versions = deps.listCliVersions?.() ?? [];
+        if (versions.length === 0) {
+            const message = "no versions installed";
+            deps.writeStdout(message);
+            return message;
+        }
+        const current = deps.getCurrentCliVersion?.();
+        const previous = deps.getPreviousCliVersion?.();
+        const lines = versions.map((v) => {
+            let line = v;
+            if (v === current)
+                line += " * current";
+            if (v === previous)
+                line += " (previous)";
+            return line;
+        });
+        const message = lines.join("\n");
+        deps.writeStdout(message);
+        return message;
+    }
+    /* v8 ignore stop */
     if (command.kind === "daemon.logs" && deps.tailLogs) {
         deps.tailLogs();
         return "";

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

@@ -38,9 +38,13 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-const CLI_PACKAGE_SPECIFIER = "@ouro.bot/cli@alpha";
 const WRAPPER_SCRIPT = `#!/bin/sh
-exec npx --prefer-online --yes ${CLI_PACKAGE_SPECIFIER} "$@"
+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)
@@ -67,6 +71,30 @@ function buildPathExportLine(binDir, shell) {
     }
     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;
@@ -77,6 +105,9 @@ function installOuroCommand(deps = {}) {
     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 */
@@ -87,10 +118,61 @@ function installOuroCommand(deps = {}) {
             message: "skipped ouro PATH install on Windows",
             meta: { platform },
         });
-        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows" };
+        return { installed: false, scriptPath: null, pathReady: false, shellProfileUpdated: null, skippedReason: "windows", migratedFromOldPath: false };
     }
-    const binDir = path.join(homeDir, ".local", "bin");
+    // 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",
@@ -113,7 +195,7 @@ function installOuroCommand(deps = {}) {
                 message: "ouro command already installed",
                 meta: { scriptPath },
             });
-            return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed" };
+            return { installed: false, scriptPath, pathReady: isBinDirInPath(binDir, envPath), shellProfileUpdated: null, skippedReason: "already-installed", migratedFromOldPath };
         }
         // Content is stale — repair by overwriting
         (0, runtime_1.emitNervesEvent)({
@@ -136,9 +218,9 @@ function installOuroCommand(deps = {}) {
             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) };
+        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 ~/.local/bin is already in PATH
+    // Check if ~/.ouro-cli/bin is already in PATH
     let shellProfileUpdated = null;
     const pathReady = isBinDirInPath(binDir, envPath);
     if (!pathReady) {
@@ -174,5 +256,5 @@ function installOuroCommand(deps = {}) {
         message: "ouro command installed",
         meta: { scriptPath, pathReady, shellProfileUpdated },
     });
-    return { installed: true, scriptPath, pathReady, shellProfileUpdated };
+    return { installed: true, scriptPath, pathReady, shellProfileUpdated, migratedFromOldPath };
 }

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

@@ -0,0 +1,164 @@
+"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.getOuroCliHome = getOuroCliHome;
+exports.getCurrentVersion = getCurrentVersion;
+exports.getPreviousVersion = getPreviousVersion;
+exports.listInstalledVersions = listInstalledVersions;
+exports.installVersion = installVersion;
+exports.activateVersion = activateVersion;
+exports.ensureLayout = ensureLayout;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+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 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);
+}
+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/mind/prompt.js

@@ -192,6 +192,8 @@ my bones give me the \`ouro\` cli. always pass \`--agent ${agentName}\`:
   ouro auth switch --agent ${agentName} --provider <provider>
   ouro mcp list --agent ${agentName}
   ouro mcp call --agent ${agentName} <server> <tool> --args '{...}'
+  ouro versions --agent ${agentName}
+  ouro rollback --agent ${agentName} [<version>]
   ouro --help
 
 provider/model changes via \`ouro config model\` or \`ouro auth switch\` take effect on the next turn automatically — no restart needed.`;

package/dist/repertoire/guardrails.js

@@ -174,6 +174,8 @@ exports.OURO_CLI_TRUST_MANIFEST = {
     auth: "family",
     "auth verify": "family",
     "auth switch": "family",
+    rollback: "family",
+    versions: "acquaintance",
 };
 // --- trust level comparison ---
 const LEVEL_ORDER = {

package/dist/senses/bluebubbles.js

@@ -343,13 +343,14 @@ function emitBlueBubblesMarkReadWarning(chat, error) {
         },
     });
 }
-function createBlueBubblesCallbacks(client, chat, replyTarget) {
+function createBlueBubblesCallbacks(client, chat, replyTarget, isGroupChat) {
     let textBuffer = "";
     const phrases = (0, phrases_1.getPhrases)();
     const activity = (0, debug_activity_1.createDebugActivityController)({
         thinkingPhrases: phrases.thinking,
         followupPhrases: phrases.followup,
-        startTypingOnModelStart: true,
+        startTypingOnModelStart: !isGroupChat,
+        startTypingOnFirstTextChunk: isGroupChat,
         suppressInitialModelStatus: true,
         suppressFollowupPhraseStatus: true,
         transport: {
@@ -607,7 +608,7 @@ async function handleBlueBubblesNormalizedEvent(event, resolvedDeps, source) {
             role: "user",
             content: buildInboundContent(event, existing?.messages ?? sessionMessages),
         };
-        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget);
+        const callbacks = createBlueBubblesCallbacks(client, event.chat, replyTarget, event.chat.isGroup);
         const controller = new AbortController();
         // BB-specific tool context wrappers
         const summarize = (0, core_1.createSummarize)();

package/dist/senses/debug-activity.js

@@ -109,7 +109,13 @@ function createDebugActivityController(options) {
             })));
         },
         onTextChunk(text) {
-            if (!text || !hadToolRun || followupShown) {
+            if (!text) {
+                return;
+            }
+            if (!hadToolRun && options.startTypingOnFirstTextChunk) {
+                startTypingNow();
+            }
+            if (!hadToolRun || followupShown) {
                 return;
             }
             followupShown = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.77",
+  "version": "0.1.0-alpha.79",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",