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

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.420",
+      "changes": [
+        "`ouro auth verify`, `ouro use`, and `ouro provider check` now share the human CLI progress checklist, so vault reads and live provider pings show visible phases instead of leaving a blinking cursor.",
+        "`ouro repair` provider-auth actions now reuse the same `ouro auth` runner/progress path, keeping browser/token repair flows consistent with direct auth commands.",
+        "Provider credential reads now accept the shared progress callback, letting command surfaces show vault-read detail without duplicating vault logic or exposing secrets.",
+        "`@ouro.bot/cli` and the `ouro.bot` wrapper are version-synced for the provider verification progress release."
+      ]
+    },
     {
       "version": "0.1.0-alpha.419",
       "changes": [

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

@@ -1513,8 +1513,8 @@ function pingAttemptCount(result) {
         return result.attempts.length;
     return undefined;
 }
-async function readProviderCredentialRecord(agent, provider, _deps) {
-    const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agent);
+async function readProviderCredentialRecord(agent, provider, _deps, options = {}) {
+    const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(agent, options);
     if (poolResult.ok) {
         const existing = poolResult.pool.providers[provider];
         if (existing)
@@ -1565,18 +1565,55 @@ function writeProviderReadiness(input) {
     (0, provider_state_1.writeProviderState)(input.agentRoot, input.state);
 }
 async function executeProviderUse(command, deps, options = {}) {
+    const progress = options.writeStdout === false ? null : createHumanCommandProgress(deps, "provider use");
     const writeMessage = (message) => {
+        progress?.end();
         if (options.writeStdout !== false)
             deps.writeStdout(message);
         return message;
     };
-    const { agentRoot, state } = readOrBootstrapProviderState(command.agent, deps);
-    const credential = await readProviderCredentialRecord(command.agent, command.provider, deps);
-    if (!credential.ok) {
-        if (!command.force) {
+    try {
+        const { agentRoot, state } = readOrBootstrapProviderState(command.agent, deps);
+        progress?.startPhase(`reading ${command.provider} credentials`);
+        const credential = await readProviderCredentialRecord(command.agent, command.provider, deps, {
+            onProgress: (message) => progress?.updateDetail(message),
+        });
+        if (!credential.ok) {
+            progress?.completePhase(`reading ${command.provider} credentials`, credential.reason);
+            if (!command.force) {
+                const message = [
+                    `no credentials stored for ${command.provider}.`,
+                    `Run \`ouro auth --agent ${command.agent} --provider ${command.provider}\` first.`,
+                ].join("\n");
+                return writeMessage(message);
+            }
+            writeProviderBinding({
+                agentRoot,
+                state,
+                lane: command.lane,
+                provider: command.provider,
+                model: command.model,
+                deps,
+                status: "failed",
+                error: credential.error,
+            });
+            const message = `forced ${command.agent} ${command.lane} to ${command.provider} / ${command.model}: failed (${credential.error})`;
+            return writeMessage(message);
+        }
+        progress?.completePhase(`reading ${command.provider} credentials`, "found");
+        progress?.startPhase(`checking ${command.provider} / ${command.model}`);
+        const pingResult = await (0, provider_ping_1.pingProvider)(command.provider, credentialPingConfig(credential.record), {
+            model: command.model,
+            attemptPolicy: { baseDelayMs: 0 },
+            sleep: deps.sleep,
+        });
+        const attempts = pingAttemptCount(pingResult);
+        const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
+        progress?.completePhase(`checking ${command.provider} / ${command.model}`, status);
+        if (!pingResult.ok && !command.force) {
             const message = [
-                `no credentials stored for ${command.provider}.`,
-                `Run \`ouro auth --agent ${command.agent} --provider ${command.provider}\` first.`,
+                `${command.agent} ${command.lane} ${command.provider} / ${command.model}: failed (${pingResult.message})`,
+                `Fix credentials with \`ouro auth --agent ${command.agent} --provider ${command.provider}\` or force the local binding with \`ouro use --agent ${command.agent} --lane ${command.lane} --provider ${command.provider} --model ${command.model} --force\`.`,
             ].join("\n");
             return writeMessage(message);
         }
@@ -1587,87 +1624,82 @@ async function executeProviderUse(command, deps, options = {}) {
             provider: command.provider,
             model: command.model,
             deps,
-            status: "failed",
-            error: credential.error,
+            status: pingResult.ok ? "ready" : "failed",
+            credentialRevision: credential.record.revision,
+            ...(!pingResult.ok ? { error: pingResult.message } : {}),
+            ...(attempts !== undefined ? { attempts } : {}),
+        });
+        const message = `${command.force ? "forced " : ""}${command.agent} ${command.lane} ${command.provider} / ${command.model}: ${status}`;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.provider_use_completed",
+            message: "provider use command completed",
+            meta: { agent: command.agent, lane: command.lane, provider: command.provider, model: command.model, status: pingResult.ok ? "ready" : "failed" },
         });
-        const message = `forced ${command.agent} ${command.lane} to ${command.provider} / ${command.model}: failed (${credential.error})`;
         return writeMessage(message);
     }
-    const pingResult = await (0, provider_ping_1.pingProvider)(command.provider, credentialPingConfig(credential.record), {
-        model: command.model,
-        attemptPolicy: { baseDelayMs: 0 },
-        sleep: deps.sleep,
-    });
-    const attempts = pingAttemptCount(pingResult);
-    if (!pingResult.ok && !command.force) {
-        const message = [
-            `${command.agent} ${command.lane} ${command.provider} / ${command.model}: failed (${pingResult.message})`,
-            `Fix credentials with \`ouro auth --agent ${command.agent} --provider ${command.provider}\` or force the local binding with \`ouro use --agent ${command.agent} --lane ${command.lane} --provider ${command.provider} --model ${command.model} --force\`.`,
-        ].join("\n");
-        return writeMessage(message);
+    catch (error) {
+        progress?.end();
+        throw error;
     }
-    writeProviderBinding({
-        agentRoot,
-        state,
-        lane: command.lane,
-        provider: command.provider,
-        model: command.model,
-        deps,
-        status: pingResult.ok ? "ready" : "failed",
-        credentialRevision: credential.record.revision,
-        ...(!pingResult.ok ? { error: pingResult.message } : {}),
-        ...(attempts !== undefined ? { attempts } : {}),
-    });
-    const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
-    const message = `${command.force ? "forced " : ""}${command.agent} ${command.lane} ${command.provider} / ${command.model}: ${status}`;
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.provider_use_completed",
-        message: "provider use command completed",
-        meta: { agent: command.agent, lane: command.lane, provider: command.provider, model: command.model, status: pingResult.ok ? "ready" : "failed" },
-    });
-    return writeMessage(message);
 }
 async function executeProviderCheck(command, deps) {
-    const { agentRoot, state } = readOrBootstrapProviderState(command.agent, deps);
-    const binding = state.lanes[command.lane];
-    const credential = await readProviderCredentialRecord(command.agent, binding.provider, deps);
-    if (!credential.ok) {
-        const message = [
-            `${command.agent} ${command.lane} ${binding.provider} / ${binding.model}: unknown (${credential.error})`,
-            `Run \`ouro auth --agent ${command.agent} --provider ${binding.provider}\` first.`,
-        ].join("\n");
+    const progress = createHumanCommandProgress(deps, "provider check");
+    const writeMessage = (message) => {
+        progress.end();
         deps.writeStdout(message);
         return message;
+    };
+    try {
+        const { agentRoot, state } = readOrBootstrapProviderState(command.agent, deps);
+        const binding = state.lanes[command.lane];
+        progress.startPhase(`reading ${binding.provider} credentials`);
+        const credential = await readProviderCredentialRecord(command.agent, binding.provider, deps, {
+            onProgress: (message) => progress.updateDetail(message),
+        });
+        if (!credential.ok) {
+            progress.completePhase(`reading ${binding.provider} credentials`, credential.reason);
+            const message = [
+                `${command.agent} ${command.lane} ${binding.provider} / ${binding.model}: unknown (${credential.error})`,
+                `Run \`ouro auth --agent ${command.agent} --provider ${binding.provider}\` first.`,
+            ].join("\n");
+            return writeMessage(message);
+        }
+        progress.completePhase(`reading ${binding.provider} credentials`, "found");
+        progress.startPhase(`checking ${binding.provider} / ${binding.model}`);
+        const pingResult = await (0, provider_ping_1.pingProvider)(binding.provider, credentialPingConfig(credential.record), {
+            model: binding.model,
+            attemptPolicy: { baseDelayMs: 0 },
+            sleep: deps.sleep,
+        });
+        const attempts = pingAttemptCount(pingResult);
+        const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
+        progress.completePhase(`checking ${binding.provider} / ${binding.model}`, status);
+        writeProviderReadiness({
+            agentRoot,
+            state,
+            lane: command.lane,
+            provider: binding.provider,
+            model: binding.model,
+            deps,
+            status: pingResult.ok ? "ready" : "failed",
+            credentialRevision: credential.record.revision,
+            ...(!pingResult.ok ? { error: pingResult.message } : {}),
+            ...(attempts !== undefined ? { attempts } : {}),
+        });
+        const message = `${command.agent} ${command.lane} ${binding.provider} / ${binding.model}: ${status}`;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.provider_check_completed",
+            message: "provider check command completed",
+            meta: { agent: command.agent, lane: command.lane, provider: binding.provider, model: binding.model, status: pingResult.ok ? "ready" : "failed" },
+        });
+        return writeMessage(message);
+    }
+    catch (error) {
+        progress.end();
+        throw error;
     }
-    const pingResult = await (0, provider_ping_1.pingProvider)(binding.provider, credentialPingConfig(credential.record), {
-        model: binding.model,
-        attemptPolicy: { baseDelayMs: 0 },
-        sleep: deps.sleep,
-    });
-    const attempts = pingAttemptCount(pingResult);
-    writeProviderReadiness({
-        agentRoot,
-        state,
-        lane: command.lane,
-        provider: binding.provider,
-        model: binding.model,
-        deps,
-        status: pingResult.ok ? "ready" : "failed",
-        credentialRevision: credential.record.revision,
-        ...(!pingResult.ok ? { error: pingResult.message } : {}),
-        ...(attempts !== undefined ? { attempts } : {}),
-    });
-    const status = pingResult.ok ? "ready" : `failed (${pingResult.message})`;
-    const message = `${command.agent} ${command.lane} ${binding.provider} / ${binding.model}: ${status}`;
-    deps.writeStdout(message);
-    (0, runtime_1.emitNervesEvent)({
-        component: "daemon",
-        event: "daemon.provider_check_completed",
-        message: "provider check command completed",
-        meta: { agent: command.agent, lane: command.lane, provider: binding.provider, model: binding.model, status: pingResult.ok ? "ready" : "failed" },
-    });
-    return message;
 }
 function renderProviderCredentialLine(credential) {
     if (credential.status === "present") {
@@ -1753,6 +1785,51 @@ async function executeProviderRefresh(command, deps) {
     deps.writeStdout(message);
     return message;
 }
+async function executeAuthRun(command, deps) {
+    const provider = command.provider ?? (0, auth_flow_1.readAgentConfigForAgent)(command.agent, deps.bundlesRoot).config.humanFacing.provider;
+    /* v8 ignore next -- tests always inject runAuthFlow; default is for production @preserve */
+    const authRunner = deps.runAuthFlow ?? (await Promise.resolve().then(() => __importStar(require("../auth/auth-flow")))).runRuntimeAuthFlow;
+    const progress = createHumanCommandProgress(deps, "auth");
+    progress.startPhase(`authenticating ${provider}`);
+    let result;
+    try {
+        result = await authRunner({
+            agentName: command.agent,
+            provider,
+            promptInput: deps.promptInput,
+            onProgress: (message) => progress.updateDetail(message),
+        });
+    }
+    catch (error) {
+        progress.end();
+        throw error;
+    }
+    progress.completePhase(`authenticating ${provider}`, "credentials stored");
+    // Behavior: ouro auth stores credentials only — does NOT switch provider.
+    // Use `ouro auth switch` to change the active provider.
+    // Verify the credentials actually work by pinging the provider.
+    /* v8 ignore start -- integration: real API ping after auth @preserve */
+    try {
+        progress.startPhase(`verifying ${provider}`);
+        const credential = await readProviderCredentialRecord(command.agent, provider, deps, {
+            onProgress: (message) => progress.updateDetail(message),
+        });
+        const status = credential.ok
+            ? await verifyProviderCredentials(provider, {
+                [provider]: { ...credential.record.config, ...credential.record.credentials },
+            })
+            : `stored but could not be re-read from vault (${credential.error})`;
+        progress.completePhase(`verifying ${provider}`, status);
+    }
+    catch (error) {
+        // Verification failure is non-blocking — credentials were saved regardless.
+        progress.completePhase(`verifying ${provider}`, `skipped (${error instanceof Error ? error.message : String(error)})`);
+    }
+    /* v8 ignore stop */
+    progress.end();
+    deps.writeStdout(result.message);
+    return result.message;
+}
 async function readinessReportForAgent(agent, deps) {
     const bundlesRoot = deps.bundlesRoot ?? (0, identity_1.getAgentBundlesRoot)();
     try {
@@ -1794,15 +1871,7 @@ async function executeReadinessRepairAction(agent, action, deps) {
         return;
     }
     if (action.kind === "provider-auth") {
-        const provider = action.provider;
-        const authRunner = deps.runAuthFlow ?? auth_flow_1.runRuntimeAuthFlow;
-        const result = await authRunner({
-            agentName: agent,
-            provider,
-            promptInput: deps.promptInput,
-            onProgress: deps.writeStdout,
-        });
-        deps.writeStdout(result.message);
+        await executeAuthRun({ kind: "auth.run", agent, provider: action.provider }, deps);
         await executeProviderRefresh({ kind: "provider.refresh", agent }, deps);
         return;
     }
@@ -3414,83 +3483,68 @@ async function runOuroCli(args, deps = (0, cli_defaults_1.createDefaultOuroCliDe
     }
     // ── auth (local, no daemon socket needed) ──
     if (command.kind === "auth.run") {
-        const provider = command.provider ?? (0, auth_flow_1.readAgentConfigForAgent)(command.agent, deps.bundlesRoot).config.humanFacing.provider;
-        /* v8 ignore next -- tests always inject runAuthFlow; default is for production @preserve */
-        const authRunner = deps.runAuthFlow ?? (await Promise.resolve().then(() => __importStar(require("../auth/auth-flow")))).runRuntimeAuthFlow;
-        const progress = createHumanCommandProgress(deps, "auth");
-        progress.startPhase(`authenticating ${provider}`);
-        let result;
-        try {
-            result = await authRunner({
-                agentName: command.agent,
-                provider,
-                promptInput: deps.promptInput,
-                onProgress: (message) => progress.updateDetail(message),
-            });
-        }
-        catch (error) {
-            progress.end();
-            throw error;
-        }
-        progress.completePhase(`authenticating ${provider}`, "credentials stored");
-        // Behavior: ouro auth stores credentials only — does NOT switch provider.
-        // Use `ouro auth switch` to change the active provider.
-        // Verify the credentials actually work by pinging the provider
-        /* v8 ignore start -- integration: real API ping after auth @preserve */
-        try {
-            progress.startPhase(`verifying ${provider}`);
-            const credential = await readProviderCredentialRecord(command.agent, provider, deps);
-            const status = credential.ok
-                ? await verifyProviderCredentials(provider, {
-                    [provider]: { ...credential.record.config, ...credential.record.credentials },
-                })
-                : `stored but could not be re-read from vault (${credential.error})`;
-            progress.completePhase(`verifying ${provider}`, status);
-        }
-        catch (error) {
-            // Verification failure is non-blocking — credentials were saved regardless.
-            progress.completePhase(`verifying ${provider}`, `skipped (${error instanceof Error ? error.message : String(error)})`);
-        }
-        /* v8 ignore stop */
-        progress.end();
-        deps.writeStdout(result.message);
-        return result.message;
+        return executeAuthRun(command, deps);
     }
     // ── auth verify (local, no daemon socket needed) ──
     /* v8 ignore start -- auth verify/switch: tested in daemon-cli.test.ts but v8 traces differ in CI @preserve */
     if (command.kind === "auth.verify") {
-        const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(command.agent);
-        if (!poolResult.ok) {
-            const message = `vault unavailable: ${poolResult.error}\n${(0, vault_unlock_1.vaultUnlockReplaceRecoverFix)(command.agent, "Then retry 'ouro auth verify'.")}`;
+        const progress = createHumanCommandProgress(deps, "auth verify");
+        const writeMessage = (message) => {
+            progress.end();
             deps.writeStdout(message);
             return message;
-        }
-        if (command.provider) {
-            const record = poolResult.pool.providers[command.provider];
-            if (!record) {
-                const message = `${command.provider}: missing. Run \`ouro auth --agent ${command.agent} --provider ${command.provider}\`.`;
-                deps.writeStdout(message);
-                return message;
-            }
-            const status = await verifyProviderCredentials(command.provider, {
-                [command.provider]: { ...record.config, ...record.credentials },
+        };
+        try {
+            progress.startPhase("reading provider credentials");
+            const poolResult = await (0, provider_credentials_1.refreshProviderCredentialPool)(command.agent, {
+                onProgress: (message) => progress.updateDetail(message),
             });
-            const message = `${command.provider}: ${status}`;
-            deps.writeStdout(message);
-            return message;
+            if (!poolResult.ok) {
+                progress.completePhase("reading provider credentials", poolResult.reason);
+                const message = `vault unavailable: ${poolResult.error}\n${(0, vault_unlock_1.vaultUnlockReplaceRecoverFix)(command.agent, "Then retry 'ouro auth verify'.")}`;
+                return writeMessage(message);
+            }
+            const providerCount = Object.keys(poolResult.pool.providers).length;
+            progress.completePhase("reading provider credentials", `${providerCount} provider${providerCount === 1 ? "" : "s"}`);
+            if (command.provider) {
+                const record = poolResult.pool.providers[command.provider];
+                if (!record) {
+                    const message = `${command.provider}: missing. Run \`ouro auth --agent ${command.agent} --provider ${command.provider}\`.`;
+                    return writeMessage(message);
+                }
+                progress.startPhase(`verifying ${command.provider}`);
+                const status = await verifyProviderCredentials(command.provider, {
+                    [command.provider]: { ...record.config, ...record.credentials },
+                });
+                progress.completePhase(`verifying ${command.provider}`, status);
+                const message = `${command.provider}: ${status}`;
+                return writeMessage(message);
+            }
+            const lines = [];
+            const entries = Object.entries(poolResult.pool.providers);
+            if (entries.length > 0) {
+                progress.startPhase("verifying providers");
+            }
+            for (const [p, record] of entries) {
+                const status = await verifyProviderCredentials(p, {
+                    [p]: { ...record.config, ...record.credentials },
+                });
+                const line = `${p}: ${status}`;
+                lines.push(line);
+                progress.updateDetail(line);
+            }
+            if (entries.length > 0) {
+                progress.completePhase("verifying providers", `${entries.length} checked`);
+            }
+            if (lines.length === 0)
+                lines.push(`no provider credentials in ${command.agent}'s vault`);
+            const message = lines.join("\n");
+            return writeMessage(message);
         }
-        const lines = [];
-        for (const [p, record] of Object.entries(poolResult.pool.providers)) {
-            const status = await verifyProviderCredentials(p, {
-                [p]: { ...record.config, ...record.credentials },
-            });
-            lines.push(`${p}: ${status}`);
+        catch (error) {
+            progress.end();
+            throw error;
         }
-        if (lines.length === 0)
-            lines.push(`no provider credentials in ${command.agent}'s vault`);
-        const message = lines.join("\n");
-        deps.writeStdout(message);
-        return message;
     }
     // ── auth switch (local, no daemon socket needed) ──
     if (command.kind === "auth.switch") {

package/package.json

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