@ouro.bot/cli 0.1.0-alpha.425 → 0.1.0-alpha.427

package/changelog.json

@@ -1,6 +1,24 @@
 {
   "_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.427",
+      "changes": [
+        "Root `ouro connect` now runs the same shared live provider verification path as `ouro up` and `ouro auth verify` before it renders the connect bay, so freshly authed providers and failed live checks show their real current state.",
+        "The root connect bay now groups capabilities into a clearer `Next best move`, `Provider core`, `Portable`, and `This machine` layout, with truthful lane-specific status for outward and inner providers.",
+        "Shared provider health checks now refresh readiness for every selected provider/model pair instead of stopping after the first failure, and `ouro connect` keeps working when provider selection is missing so repair guidance can still render.",
+        "Auth/provider/testing docs now describe the live-verifying connect bay behavior, and `@ouro.bot/cli` plus the `ouro.bot` wrapper are version-synced for the truthful connect release."
+      ]
+    },
+    {
+      "version": "0.1.0-alpha.426",
+      "changes": [
+        "`ouro up` no longer marks `starting daemon` complete when a replacement daemon still is not answering; it now narrates replacement progress in plain language and reports replacement timeout as an incomplete replacement instead of a fake success.",
+        "Root `ouro connect --agent <agent>` now prints a short `checking current connections` preflight while it reads portable and machine-local runtime settings before showing the connect bay menu.",
+        "Auth/provider/setup docs now codify the human CLI rule that waits longer than about three seconds should show current work, and they describe the new daemon replacement wording and connect-bay preflight.",
+        "`@ouro.bot/cli` and the `ouro.bot` wrapper are version-synced for the daemon replacement and connect-bay progress release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.425",
       "changes": [

package/dist/heart/daemon/agent-config-check.js

@@ -378,7 +378,9 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             });
         }
     }
+    let firstFailure = null;
     for (const group of pingGroups.values()) {
+        deps.onProgress?.(`checking ${group.provider} / ${group.model}...`);
         const result = await ping(group.provider, providerCredentialConfig(group.record), { model: group.model });
         if (!result.ok) {
             for (const lane of group.lanes) {
@@ -392,7 +394,8 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
                     attempts: pingAttemptCount(result),
                 });
             }
-            return failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            firstFailure ??= failedPingResult(agentName, group.lanes[0], group.provider, group.model, result);
+            continue;
         }
         for (const lane of group.lanes) {
             writeLaneReadiness({
@@ -405,6 +408,8 @@ async function checkAgentConfigWithProviderHealth(agentName, bundlesRoot, deps =
             });
         }
     }
+    if (firstFailure)
+        return firstFailure;
     (0, runtime_1.emitNervesEvent)({
         component: "daemon",
         event: "daemon.agent_config_valid",

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

@@ -329,12 +329,10 @@ async function runCommandProgressPhase(progress, label, run, detail) {
     }
 }
 function daemonProgressSummary(result) {
-    if (result.verifyStartupStatus === false)
-        return "not answering yet";
     if (result.alreadyRunning)
         return "already running";
-    if (result.message.includes("restarted"))
-        return "restarted and ready";
+    if (result.message.includes("replaced"))
+        return "replacement ready";
     return "ready";
 }
 async function reportPostRepairProviderHealth(deps, repairedAgents, onProgress) {
@@ -464,6 +462,7 @@ async function ensureDaemonRunning(deps, options = {}) {
             cleanupStaleSocket: deps.cleanupStaleSocket,
             startDaemonProcess: deps.startDaemonProcess,
             checkSocketAlive: deps.checkSocketAlive,
+            onProgress: deps.reportDaemonStartupPhase,
         });
         if (!runtimeResult.verifyStartupStatus) {
             return runtimeResult;
@@ -1626,27 +1625,218 @@ function enableAgentSense(agent, sense, deps) {
     };
     fs.writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
-async function buildConnectMenu(agent, deps) {
+const CONNECT_MENU_PROMPT = "Choose [1-6] or type a name: ";
+const CONNECT_TITLE_WIDTH = 34;
+const CONNECT_STATUS_PRIORITY = {
+    "needs attention": 0,
+    locked: 1,
+    "needs credentials": 2,
+    "needs setup": 3,
+    missing: 4,
+    "not attached": 5,
+    ready: 6,
+    attached: 6,
+};
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+const DIM = "\x1b[2m";
+const TEAL = "\x1b[38;2;78;201;176m";
+const GREEN = "\x1b[38;2;46;204;64m";
+const YELLOW = "\x1b[38;2;230;190;50m";
+/* v8 ignore start -- cosmetic ANSI wrappers @preserve */
+function connectBold(text) { return `${BOLD}${text}${RESET}`; }
+function connectDim(text) { return `${DIM}${text}${RESET}`; }
+function connectTeal(text) { return `${TEAL}${text}${RESET}`; }
+function connectGreen(text) { return `${GREEN}${text}${RESET}`; }
+function connectYellow(text) { return `${YELLOW}${text}${RESET}`; }
+/* v8 ignore stop */
+function connectMenuIsTTY(deps) {
+    return deps.isTTY ?? process.stdout.isTTY === true;
+}
+function connectStatusText(status, isTTY) {
+    if (!isTTY)
+        return status;
+    if (status === "ready" || status === "attached")
+        return connectGreen(status);
+    if (status === "not attached")
+        return connectDim(status);
+    return connectYellow(status);
+}
+function connectSectionHeader(label, isTTY) {
+    const rule = "─".repeat(Math.max(6, CONNECT_TITLE_WIDTH - label.length));
+    if (!isTTY)
+        return `${label}\n${rule}`;
+    return `  ${connectTeal("──")} ${connectBold(label)} ${connectTeal(rule)}`;
+}
+function summarizeProviderLane(agent, lane, providerHealth) {
+    if (lane.status === "unconfigured") {
+        return {
+            lane: lane.lane,
+            status: "needs setup",
+            title: "choose provider and model",
+            detail: "needs setup",
+            action: lane.repairCommand,
+        };
+    }
+    const fallbackAction = lane.credential.repairCommand ?? providerHealth?.fix;
+    if (lane.credential.status === "missing") {
+        return {
+            lane: lane.lane,
+            status: "needs credentials",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: "credentials missing",
+            action: fallbackAction,
+        };
+    }
+    if (lane.credential.status === "invalid-pool") {
+        return {
+            lane: lane.lane,
+            status: "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: "vault unavailable",
+            action: fallbackAction,
+        };
+    }
+    if (lane.readiness.status === "failed") {
+        return {
+            lane: lane.lane,
+            status: "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: `failed live check: ${lane.readiness.error ?? "unknown error"}`,
+            action: providerHealth?.fix ?? `ouro auth --agent ${agent} --provider ${lane.provider}`,
+        };
+    }
+    if (lane.readiness.status === "stale") {
+        return {
+            lane: lane.lane,
+            status: "needs attention",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: ["live check is stale", lane.readiness.reason].filter(Boolean).join(": "),
+            action: providerHealth?.fix,
+        };
+    }
+    if (lane.readiness.status === "ready") {
+        return {
+            lane: lane.lane,
+            status: "ready",
+            title: `${lane.provider} / ${lane.model}`,
+            detail: "ready",
+        };
+    }
+    return {
+        lane: lane.lane,
+        status: "needs attention",
+        title: `${lane.provider} / ${lane.model}`,
+        detail: "live check did not complete yet",
+        action: providerHealth?.fix,
+    };
+}
+function summarizeProvidersForConnect(agent, visibility, providerHealth) {
+    const laneSummaries = visibility.lanes.map((lane) => summarizeProviderLane(agent, lane, providerHealth));
+    const worstLaneStatus = laneSummaries.reduce((worst, lane) => CONNECT_STATUS_PRIORITY[lane.status] < CONNECT_STATUS_PRIORITY[worst] ? lane.status : worst, "ready");
+    const providerHealthStatus = !providerHealth || providerHealth.ok
+        ? undefined
+        : (() => {
+            const error = String(providerHealth.error).toLowerCase();
+            const fix = String(providerHealth.fix).toLowerCase();
+            if (error.includes("failed live check"))
+                return "needs attention";
+            if (error.includes("has no credentials"))
+                return "needs credentials";
+            if (error.includes("missing") && error.includes("provider"))
+                return "needs setup";
+            if (error.includes("vault is locked") || error.includes("vault locked"))
+                return "locked";
+            if (fix.includes("ouro auth"))
+                return "needs credentials";
+            if (fix.includes("ouro use"))
+                return "needs setup";
+            if (fix.includes("vault unlock"))
+                return "locked";
+            return "needs attention";
+        })();
+    const nextLane = laneSummaries.find((lane) => lane.status !== "ready");
+    return {
+        status: providerHealthStatus ?? worstLaneStatus,
+        detailLines: laneSummaries.flatMap((lane) => [
+            `${lane.lane.padEnd(8)} ${lane.title}`,
+            `         ${lane.detail}`,
+        ]),
+        nextAction: nextLane?.action ?? providerHealth?.fix,
+        nextNote: nextLane ? `${nextLane.lane} ${nextLane.detail}` : undefined,
+    };
+}
+function connectEntryNeedsAttention(entry) {
+    return entry.status !== "ready" && entry.status !== "attached";
+}
+function connectNextEntry(entries) {
+    return entries.find((entry) => connectEntryNeedsAttention(entry));
+}
+function appendConnectOptionalLine(lines, prefix, value) {
+    if (typeof value === "string" && value.length > 0) {
+        lines.push(`  ${prefix}${value}`);
+    }
+}
+function connectNextMoveLines(entries, isTTY) {
+    const next = connectNextEntry(entries);
+    if (!next) {
+        return [
+            connectSectionHeader("Next best move", isTTY),
+            "  Everything here is ready. Pick what you want to review or refresh.",
+        ];
+    }
+    const lines = [
+        connectSectionHeader("Next best move", isTTY),
+        `  ${next.name} - ${next.status}`,
+    ];
+    appendConnectOptionalLine(lines, "", next.nextNote);
+    appendConnectOptionalLine(lines, "run: ", next.nextAction);
+    return lines;
+}
+function renderConnectEntry(entry, isTTY) {
+    const label = `${entry.option}. ${entry.name}`.padEnd(25);
+    const lines = [`  ${label} ${connectStatusText(entry.status, isTTY)}`];
+    for (const detail of entry.detailLines ?? []) {
+        lines.push(`     ${detail}`);
+    }
+    if (entry.description) {
+        lines.push(isTTY ? `     ${connectDim(entry.description)}` : `     ${entry.description}`);
+    }
+    return lines;
+}
+function readConnectBaySenseFlags(agent, deps) {
+    const configPath = path.join(providerCliAgentRoot({ agent }, deps), "agent.json");
+    const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    return {
+        teamsEnabled: parsed.senses?.teams?.enabled === true,
+        blueBubblesEnabled: parsed.senses?.bluebubbles?.enabled === true,
+    };
+}
+async function buildConnectMenu(agent, deps, onProgress) {
+    const bundlesRoot = path.dirname(providerCliAgentRoot({ agent }, deps));
+    let providerHealth;
+    try {
+        onProgress?.("checking selected providers");
+        providerHealth = await checkAgentProviderHealth(agent, bundlesRoot, deps, onProgress);
+    }
+    catch (error) {
+        providerHealth = {
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+            fix: `Run 'ouro auth verify --agent ${agent}' to inspect provider health.`,
+        };
+    }
     const providerVisibility = (0, provider_visibility_1.buildAgentProviderVisibility)({
         agentName: agent,
         agentRoot: providerCliAgentRoot({ agent }, deps),
         homeDir: providerCliHomeDir(deps),
     });
-    const providerStatus = providerVisibility.lanes.some((lane) => lane.status === "unconfigured")
-        ? "needs setup"
-        : providerVisibility.lanes.some((lane) => lane.status === "configured" && lane.credential.status !== "present")
-            ? "needs auth"
-            : providerVisibility.lanes.some((lane) => lane.status === "configured" && (lane.readiness.status === "failed" || lane.readiness.status === "stale"))
-                ? "needs attention"
-                : "ready";
-    const providerDetail = providerVisibility.lanes.map((lane) => lane.status === "configured"
-        ? `${lane.lane}: ${lane.provider} / ${lane.model}`
-        : `${lane.lane}: choose provider/model`).join(" | ");
+    const providerSummary = summarizeProvidersForConnect(agent, providerVisibility, providerHealth);
+    onProgress?.("loading portable settings");
     const runtimeConfig = await (0, runtime_credentials_1.refreshRuntimeCredentialConfig)(agent, { preserveCachedOnFailure: true });
+    onProgress?.("loading this machine's settings");
     const machineRuntime = await (0, runtime_credentials_1.refreshMachineRuntimeCredentialConfig)(agent, currentMachineId(deps), { preserveCachedOnFailure: true });
-    const agentConfig = (0, auth_flow_1.readAgentConfigForAgent)(agent, deps.bundlesRoot).config;
-    const teamsEnabled = agentConfig.senses?.teams?.enabled === true;
-    const blueBubblesEnabled = agentConfig.senses?.bluebubbles?.enabled === true;
+    const { teamsEnabled, blueBubblesEnabled } = readConnectBaySenseFlags(agent, deps);
     const perplexityStatus = runtimeConfig.ok
         ? hasRuntimeConfigValue(runtimeConfig.config, "integrations.perplexityApiKey") ? "ready" : "missing"
         : runtimeConfigReadStatus(runtimeConfig);
@@ -1668,29 +1858,90 @@ async function buildConnectMenu(agent, deps) {
             ? "attached"
             : "not attached"
         : machineRuntimeReadStatus(machineRuntime);
-    return [
-        `${agent} // connect bay`,
-        "Bring one capability online at a time.",
-        "",
-        `  1. [${providerStatus}] Providers`,
-        `     ${providerDetail}`,
-        "",
-        `  2. [${perplexityStatus}] Perplexity search`,
-        "     Portable. Web search via Perplexity.",
-        "",
-        `  3. [${embeddingsStatus}] Memory embeddings`,
-        "     Portable. Memory retrieval and note search.",
-        "",
-        `  4. [${teamsStatus}] Teams`,
-        "     Portable. Microsoft Teams sense credentials.",
-        "",
-        `  5. [${blueBubblesStatus}] BlueBubbles iMessage`,
-        "     This machine only. Local Mac Messages bridge.",
+    const entries = [
+        {
+            option: "1",
+            name: "Providers",
+            section: "Provider core",
+            status: providerSummary.status,
+            detailLines: providerSummary.detailLines,
+            nextAction: providerSummary.nextAction,
+            nextNote: providerSummary.nextNote,
+        },
+        {
+            option: "2",
+            name: "Perplexity search",
+            section: "Portable",
+            status: perplexityStatus,
+            description: "Web search via Perplexity.",
+            nextAction: connectEntryNeedsAttention({
+                option: "2",
+                name: "Perplexity search",
+                section: "Portable",
+                status: perplexityStatus,
+            }) ? `ouro connect perplexity --agent ${agent}` : undefined,
+        },
+        {
+            option: "3",
+            name: "Memory embeddings",
+            section: "Portable",
+            status: embeddingsStatus,
+            description: "Memory retrieval and note search.",
+            nextAction: connectEntryNeedsAttention({
+                option: "3",
+                name: "Memory embeddings",
+                section: "Portable",
+                status: embeddingsStatus,
+            }) ? `ouro connect embeddings --agent ${agent}` : undefined,
+        },
+        {
+            option: "4",
+            name: "Teams",
+            section: "Portable",
+            status: teamsStatus,
+            description: "Microsoft Teams sense credentials.",
+            nextAction: connectEntryNeedsAttention({
+                option: "4",
+                name: "Teams",
+                section: "Portable",
+                status: teamsStatus,
+            }) ? `ouro connect teams --agent ${agent}` : undefined,
+        },
+        {
+            option: "5",
+            name: "BlueBubbles iMessage",
+            section: "This machine",
+            status: blueBubblesStatus,
+            description: "Local Mac Messages bridge.",
+            nextAction: connectEntryNeedsAttention({
+                option: "5",
+                name: "BlueBubbles iMessage",
+                section: "This machine",
+                status: blueBubblesStatus,
+            }) ? `ouro connect bluebubbles --agent ${agent}` : undefined,
+        },
+    ];
+    const isTTY = connectMenuIsTTY(deps);
+    const lines = [
+        isTTY ? connectBold(`${agent} connect bay`) : `${agent} connect bay`,
+        isTTY
+            ? connectDim("Bring one capability online. Provider status is checked live.")
+            : "Bring one capability online. Provider status is checked live.",
         "",
-        "  6. Cancel",
+        ...connectNextMoveLines(entries, isTTY),
         "",
-        "Choose [1-6] or type a name: ",
-    ].join("\n");
+    ];
+    for (const section of ["Provider core", "Portable", "This machine"]) {
+        lines.push(connectSectionHeader(section, isTTY));
+        for (const entry of entries.filter((candidate) => candidate.section === section)) {
+            lines.push(...renderConnectEntry(entry, isTTY));
+            lines.push("");
+        }
+    }
+    lines.push(isTTY ? `  ${connectDim("6. Not now")}` : "  6. Not now");
+    lines.push("");
+    lines.push(CONNECT_MENU_PROMPT);
+    return lines.join("\n");
 }
 async function executeConnectPerplexity(agent, deps) {
     if (agent === "SerpentGuide") {
@@ -1951,7 +2202,14 @@ async function executeConnect(command, deps) {
         return executeConnectTeams(command.agent, deps);
     if (command.target === "bluebubbles")
         return executeConnectBlueBubbles(command.agent, deps);
-    const menu = await buildConnectMenu(command.agent, deps);
+    const progress = createHumanCommandProgress(deps, "connect");
+    let menu;
+    try {
+        menu = await runCommandProgressPhase(progress, "checking current connections", () => buildConnectMenu(command.agent, deps, (message) => progress.updateDetail(message)), () => "ready");
+    }
+    finally {
+        progress.end();
+    }
     const promptInput = deps.promptInput;
     if (!promptInput) {
         const message = [
@@ -3348,12 +3606,14 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
                 progress.announceStep?.(label);
             },
         }, { initialAlive: daemonAliveBeforeStart });
-        progress.completePhase("starting daemon", daemonProgressSummary(daemonResult));
         if (daemonResult.verifyStartupStatus === false) {
+            ;
+            progress.announceStep?.("replacement daemon did not answer in time");
             progress.end();
             deps.writeStdout(daemonResult.message);
             return daemonResult.message;
         }
+        progress.completePhase("starting daemon", daemonProgressSummary(daemonResult));
         if (!providerChecksAlreadyRun || daemonResult.alreadyRunning) {
             progress.startPhase("provider checks");
             const providerDegraded = await checkAlreadyRunningAgentProviders(deps, (msg) => progress.updateDetail(msg));

package/dist/heart/daemon/daemon-runtime-sync.js

@@ -9,6 +9,7 @@ async function verifyDaemonStarted(deps) {
     const maxWaitMs = 10_000;
     const pollIntervalMs = 500;
     const deadline = Date.now() + maxWaitMs;
+    deps.onProgress?.("waiting for the replacement daemon to answer");
     while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, pollIntervalMs));
         if (await deps.checkSocketAlive(deps.socketPath))
@@ -102,7 +103,9 @@ async function ensureCurrentDaemonRuntime(deps) {
         if (driftReasons.length > 0) {
             const includesVersionDrift = driftReasons.some((entry) => entry.key === "version");
             const publicDriftSummary = formatRuntimeDriftPublicSummary(driftReasons);
+            deps.onProgress?.("preparing a replacement for the running background service");
             try {
+                deps.onProgress?.("stopping the running background service");
                 await deps.stopDaemon();
             }
             catch (error) {
@@ -110,8 +113,8 @@ async function ensureCurrentDaemonRuntime(deps) {
                 result = {
                     alreadyRunning: true,
                     message: includesVersionDrift
-                        ? `daemon already running (${deps.socketPath}; could not replace stale daemon ${runningVersion} -> ${deps.localVersion}: ${reason})`
-                        : `daemon already running (${deps.socketPath}; could not replace runtime drift ${publicDriftSummary}: ${reason})`,
+                        ? `daemon already running (${deps.socketPath}; could not replace the running background service ${runningVersion} -> ${deps.localVersion}: ${reason})`
+                        : `daemon already running (${deps.socketPath}; could not replace the running background service after runtime drift ${publicDriftSummary}: ${reason})`,
                 };
                 (0, runtime_1.emitNervesEvent)({
                     level: "warn",
@@ -138,16 +141,17 @@ async function ensureCurrentDaemonRuntime(deps) {
                 return result;
             }
             deps.cleanupStaleSocket(deps.socketPath);
+            deps.onProgress?.("starting the replacement background service");
             const started = await deps.startDaemonProcess(deps.socketPath);
             const pid = started.pid ?? "unknown";
             const verified = await verifyDaemonStarted(deps);
             /* v8 ignore next -- daemon liveness failure: requires real daemon crash timing @preserve */
-            const suffix = verified ? "" : "\ndaemon restart has not answered yet; check logs with `ouro logs` or run `ouro doctor`.";
+            const suffix = verified ? "" : "\nreplacement daemon did not answer in time; check logs with `ouro logs` or run `ouro doctor`.";
             result = {
                 alreadyRunning: false,
                 message: includesVersionDrift
-                    ? `restarted stale daemon ${runningVersion} -> ${deps.localVersion} (pid ${pid})${suffix}`
-                    : `restarted daemon after runtime drift: ${publicDriftSummary} (pid ${pid})${suffix}`,
+                    ? `replaced the running background service ${runningVersion} -> ${deps.localVersion} (pid ${pid})${suffix}`
+                    : `replaced the running background service after runtime drift: ${publicDriftSummary} (pid ${pid})${suffix}`,
                 verifyStartupStatus: verified,
                 startedPid: started.pid ?? null,
             };

package/package.json

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