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

package/changelog.json

@@ -1,6 +1,15 @@
 {
   "_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": [

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

@@ -1625,29 +1625,218 @@ function enableAgentSense(agent, sense, deps) {
     };
     fs.writeFileSync(configPath, `${JSON.stringify(raw, null, 2)}\n`, "utf-8");
 }
+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);
@@ -1669,29 +1858,90 @@ async function buildConnectMenu(agent, deps, onProgress) {
             ? "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") {

package/package.json

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