@tiny-fish/cli 0.15.1-next.160 → 0.15.1-next.161

package/dist/commands/doctor.d.ts

@@ -1,9 +1,17 @@
 import type { Command } from "commander";
-import { type DoctorReport } from "../lib/doctor-report.js";
+import { type DoctorRepair, type DoctorReport } from "../lib/doctor-report.js";
 import { type FiveHarness } from "../lib/harness-detect.js";
 export interface DoctorOptions {
     mcpUrl: string;
     harness?: FiveHarness;
+    fix?: boolean;
+    yes?: boolean;
 }
 export declare function runDoctor(options: DoctorOptions): Promise<DoctorReport>;
+export interface RepairOutcome {
+    repair: DoctorRepair;
+    status: "repaired" | "skipped" | "failed";
+    reason?: string;
+}
+export declare function applyRepairs(repairs: DoctorRepair[], options: DoctorOptions): Promise<RepairOutcome[]>;
 export declare function registerDoctor(program: Command): void;

package/dist/commands/doctor.js

@@ -1,11 +1,13 @@
+import spawn from "cross-spawn";
 import { apiKeyStatus } from "../lib/auth.js";
 import { CLI_VERSION } from "../lib/constants.js";
 import { DOCTOR_COULD_NOT_RUN, DOCTOR_SCHEMA_VERSION, doctorReportSchema, exitCodeFor, renderPretty, } from "../lib/doctor-report.js";
 import { FIVE_HARNESSES } from "../lib/harness-detect.js";
+import { detectHumanInitiated } from "../lib/harness.js";
 import { err, errLine, out, outLine } from "../lib/output.js";
 import { detectRegistrations } from "../lib/registration-detect.js";
 import { verifyMcpAuth, verifyMcpHealth } from "../lib/verify.js";
-import { DEFAULT_MCP_URL } from "./connect.js";
+import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, DEFAULT_MCP_URL, } from "./connect.js";
 // A green auth mode with a red auth call proves nothing, so the call's verdict gates the claim.
 function provesHarnessReach(status, authCallPassed, healthOk, mcpUrl) {
     // An endpoint doctor could not reach proves nothing about a harness pointed at it.
@@ -117,6 +119,7 @@ async function checkAuthCall(key) {
 const UNATTENDED_SAFE = new Set(["cursor"]);
 function repairsFor(checks, statuses) {
     const repairs = [];
+    const credentialResolves = checks.some((c) => c.id === "cli-credential" && c.status === "pass");
     for (const status of statuses) {
         // `unknown` earns nothing: running connect off a failed probe contradicts the check's detail.
         // A registered-but-misaimed entry does earn one, since connect rewrites the URL.
@@ -132,7 +135,8 @@ function repairsFor(checks, statuses) {
             action: "connect",
             harness: status.harness,
             command: `tinyfish connect ${status.harness}`,
-            unattended_safe: UNATTENDED_SAFE.has(status.harness),
+            // Without a credential even Cursor's repair shells an interactive `auth login`.
+            unattended_safe: UNATTENDED_SAFE.has(status.harness) && credentialResolves,
         });
     }
     // A revoked-but-well-formed key passes the credential check and fails the call; both need login.
@@ -178,6 +182,75 @@ export async function runDoctor(options) {
     // Nothing to scrub: every string above is authored here or enumerated at its source.
     return doctorReportSchema.parse(body);
 }
+// Shell out rather than import the login flow: `auth login` owns its own browser and prompts.
+// Re-invoke this same entry script, never a global `tinyfish` — under `npx` there is no such
+// binary on PATH, and npx is the install-nothing path doctor exists to serve.
+function runAuthLogin() {
+    const entry = process.argv[1];
+    if (!entry)
+        throw new Error("Could not locate the TinyFish CLI entry point to re-invoke");
+    const result = spawn.sync(process.execPath, [entry, "auth", "login", "--source", "doctor"], {
+        stdio: "inherit",
+    });
+    if (result.error)
+        throw new Error("Could not run `tinyfish auth login`", { cause: result.error });
+    if (result.status !== 0) {
+        throw new Error(`\`tinyfish auth login\` exited ${result.status ?? "unknown"}`);
+    }
+}
+const CONNECTORS = {
+    "claude-code": (opts) => connectClaudeCode({ ...opts, launch: false }),
+    codex: (opts) => connectCodex({ ...opts, launch: false }),
+    cursor: (opts) => connectCursor(opts),
+    hermes: (opts) => connectHermes({ ...opts, launch: false }),
+    openclaw: (opts) => connectOpenClaw({ ...opts, launch: false }),
+};
+/** Dispatches on `action`, never on a null harness: that conflation made the credential fix a no-op. */
+async function runRepair(repair, mcpUrl) {
+    if (repair.action === "auth-login")
+        return runAuthLogin();
+    if (repair.harness)
+        await CONNECTORS[repair.harness]({ mcpUrl });
+}
+export async function applyRepairs(repairs, options) {
+    const interactive = detectHumanInitiated();
+    const outcomes = [];
+    for (const repair of repairs) {
+        if (!interactive && !options.yes) {
+            outcomes.push({
+                repair,
+                status: "skipped",
+                reason: "no terminal; re-run with --yes to repair unattended",
+            });
+            continue;
+        }
+        if (!interactive && !repair.unattended_safe) {
+            outcomes.push({
+                repair,
+                status: "skipped",
+                reason: "needs a browser sign-in, which has no unattended path",
+            });
+            continue;
+        }
+        try {
+            await runRepair(repair, options.mcpUrl);
+            outcomes.push({ repair, status: "repaired" });
+        }
+        catch (e) {
+            // Connect quotes absolute config paths in its errors, so the raw text stays behind
+            // --debug and the user is told where to find it rather than handed a generic dead end.
+            if (process.env["TINYFISH_DEBUG"]) {
+                errLine(e instanceof Error ? (e.stack ?? e.message) : String(e));
+            }
+            outcomes.push({
+                repair,
+                status: "failed",
+                reason: `\`${repair.command}\` failed; re-run it directly, or --debug for the raw error`,
+            });
+        }
+    }
+    return outcomes;
+}
 export function registerDoctor(program) {
     program
         .command("doctor")
@@ -185,18 +258,31 @@ export function registerDoctor(program) {
         .option("--pretty", "Human-readable check list instead of JSON")
         .option("--harness <name>", `Restrict to one harness (${FIVE_HARNESSES.join(", ")})`)
         .option("--url <mcpUrl>", "MCP endpoint override")
+        .option("--fix", "Repair what can be repaired by re-running tinyfish connect")
+        .option("--yes", "Allow --fix to run without a terminal (unattended-safe repairs only)")
         .action(async (options) => {
         if (options.harness && !FIVE_HARNESSES.includes(options.harness)) {
             err({ error: `Unknown --harness value: ${options.harness}` });
             process.exitCode = DOCTOR_COULD_NOT_RUN;
             return;
         }
+        const doctorOptions = {
+            mcpUrl: options.url ?? DEFAULT_MCP_URL,
+            fix: Boolean(options.fix),
+            yes: Boolean(options.yes),
+            ...(options.harness ? { harness: options.harness } : {}),
+        };
         let report;
         try {
-            report = await runDoctor({
-                mcpUrl: options.url ?? DEFAULT_MCP_URL,
-                ...(options.harness ? { harness: options.harness } : {}),
-            });
+            report = await runDoctor(doctorOptions);
+            if (doctorOptions.fix && report.repairs.length > 0) {
+                for (const outcome of await applyRepairs(report.repairs, doctorOptions)) {
+                    const reason = outcome.reason ? ` (${outcome.reason})` : "";
+                    errLine(`${outcome.status}: ${outcome.repair.command}${reason}`);
+                }
+                // Re-diagnose so the emitted report describes the machine after repair, not before.
+                report = await runDoctor(doctorOptions);
+            }
         }
         catch (e) {
             // Exit 2 means doctor itself broke, a different claim from "your setup is broken".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.15.1-next.160",
+  "version": "0.15.1-next.161",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {