@tiny-fish/cli 0.25.2-next.220 → 0.25.2-next.221

package/README.md

@@ -10,6 +10,25 @@ npm install -g @tiny-fish/cli
 
 Requires Node.js 24+.
 
+### Connect your agents
+
+The recommended way in: run `connect` with no arguments.
+
+```bash
+npx -y @tiny-fish/cli@latest connect
+```
+
+It detects the agent configs on your machine (Claude Code, Codex, Cursor, Grok, Hermes,
+OpenClaw, OpenCode) and opens a checklist with everything pre-selected. Press enter to connect
+them all, or use the arrow keys and space to narrow the set first; `q` cancels without touching
+anything. Terminals without raw-key support get a numbered prompt instead.
+
+Without a terminal (agents, CI), bare `connect` behaves exactly like `tinyfish connect --all`
+and says so on its first line: every detected harness that can authenticate headlessly (via
+`TINYFISH_API_KEY` or `--api-key`) is connected, the rest are skipped with a fix command.
+`tinyfish connect --all` itself is unchanged and skips the picker; `--dry-run`, `--uninstall`
+and `--skip-launch` still require it.
+
 ### Connect Claude Code
 
 Add TinyFish MCP and the global `use-tinyfish` web skill, authenticate the CLI, and start the

package/dist/commands/connect.js

@@ -417,7 +417,7 @@ export function registerConnect(program) {
     program
         .command("connect")
         .description("Connect TinyFish to an AI agent")
-        .argument("[client]", "Agent client to connect (claude-code, codex, cursor, grok, hermes, openclaw, or opencode)")
+        .argument("[client]", "Agent client to connect (claude-code, codex, cursor, grok, hermes, openclaw, or opencode); omit to pick from the agents detected on this machine")
         .option("--all", "Detect and connect every supported harness found on this machine")
         .option("--dry-run", "Print planned writes per harness without touching anything (--all only)")
         .option("--uninstall", "Remove TinyFish entries written by connect --all")
@@ -476,7 +476,24 @@ export function registerConnect(program) {
             throw new Error("--dry-run, --uninstall and --skip-launch are only supported with --all.");
         }
         if (!client) {
-            throw new Error("Pass a client (claude-code, codex, cursor, grok, hermes, openclaw, opencode) or --all.");
+            if (options.launch) {
+                throw new Error("--launch is not supported with --all. Connect a single client to launch it.");
+            }
+            const humanInitiated = detectHumanInitiated();
+            if (!humanInitiated) {
+                errLine("No terminal detected: connecting every detected harness (same as tinyfish connect --all).");
+            }
+            const exitCode = await runConnectAll({
+                apiKey: options.apiKey,
+                mcpUrl,
+                dryRun: false,
+                uninstall: false,
+                pick: humanInitiated,
+            });
+            // Preserve the 130 runGuarded set on Ctrl+C.
+            if (!process.exitCode)
+                process.exitCode = exitCode;
+            return;
         }
         const connectOptions = {
             apiKey: options.apiKey,

package/dist/lib/connect-all.d.ts

@@ -5,5 +5,7 @@ export interface ConnectAllOptions {
     uninstall: boolean;
     /** Skip the end-of-install agent launch (finale still prints the ask). */
     noLaunch?: boolean;
+    /** Bare connect: offer the checkbox picker over the detected harnesses. */
+    pick?: boolean;
 }
 export declare function runConnectAll(opts: ConnectAllOptions): Promise<number>;

package/dist/lib/connect-all.js

@@ -1,27 +1,19 @@
 import * as readline from "node:readline/promises";
 import spawn from "cross-spawn";
 import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
-import { validatedApiKey } from "./auth.js";
+import { loadConfig, validatedApiKey } from "./auth.js";
 import { installTinyFishCli, } from "./cli-install.js";
 import { NATIVE_MCP_CLIENTS } from "./connect-clients.js";
 import { ensureCliAuthenticated, TINYFISH_CLI_NOT_FOUND_MESSAGE } from "./connect-auth.js";
 import { commandNotFound, ConnectInterruptedError, ConnectStepError, finishSetupCommand, throwIfInterrupted, } from "./connect-runtime.js";
-import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, ALL_HARNESSES, } from "./harness-detect.js";
+import { pickHarnesses } from "./connect-picker.js";
+import { commandOnPath, detectInstalledHarnesses, HARNESS_COMMANDS, HARNESS_DISPLAY_NAMES as DISPLAY_NAMES, ALL_HARNESSES, } from "./harness-detect.js";
 import { detectHumanInitiated } from "./harness.js";
 import { emitNotice } from "./notice.js";
 import { removeCursorMcpServer, planCursorWrite } from "./cursor-config.js";
 import { errLine, outLine } from "./output.js";
 import { sendSetupCompleted } from "./setup-telemetry.js";
 import { verifyMcpAuth, verifyMcpHealth } from "./verify.js";
-const DISPLAY_NAMES = {
-    "claude-code": "Claude Code",
-    codex: "Codex",
-    cursor: "Cursor",
-    grok: "Grok",
-    hermes: "Hermes",
-    openclaw: "OpenClaw",
-    opencode: "OpenCode",
-};
 // `codex mcp add` succeeds unauthenticated; OAuth lands at first tool use.
 // TODO(PF-3580): connect now probes Codex sign-in, so this over-warns a signed-in install.
 const AUTH_DEFERRED_AT_INSTALL = new Set(["codex"]);
@@ -241,6 +233,9 @@ function summaryLine(result, uninstall) {
             : "no stored credentials and no terminal to sign in";
         return `… ${name} — skipped, ${why}. Fix: ${result.fixCommand}`;
     }
+    if (result.outcome === "deselected") {
+        return `… ${name} — skipped, not selected. Fix: ${result.fixCommand}`;
+    }
     if (result.outcome === "uninstall_pointer") {
         return `… ${name} — not removed automatically (config is owned by ${name}). Run: ${result.fixCommand}`;
     }
@@ -384,9 +379,26 @@ export async function runConnectAll(opts) {
         }
         : undefined;
     const detections = detectInstalledHarnesses();
+    let deselected = new Set();
+    let mode = "all";
+    // Before willAttempt/cliNeeded: a cursor-only pick must not hoist the CLI.
+    // A stale config dir has no binary to connect, so never offer it as a choice.
+    const offerable = detections.filter((d) => d.detected && !isStaleConfig(d));
+    if (opts.pick && offerable.length > 0) {
+        const connected = new Set(Object.keys(loadConfig().connect ?? {}));
+        const pick = await pickHarnesses(offerable, connected, { prompt });
+        mode = pick.mode;
+        if (pick.selection === "cancel") {
+            // Before summary and telemetry: an explicit nothing is not a setup.
+            outLine("Nothing installed. Run: tinyfish connect --all or tinyfish connect <client>");
+            return 0;
+        }
+        const chosen = new Set(pick.selection);
+        deselected = new Set(offerable.filter((d) => !chosen.has(d.harness)).map((d) => d.harness));
+    }
     const gateKey = validatedApiKey(opts.apiKey);
     // Mirrors processHarness's skip gate: a skipped harness installs nothing today.
-    const willAttempt = (harness) => isTTY || (!!gateKey && KEY_AUTH_CAPABLE.has(harness));
+    const willAttempt = (harness) => !deselected.has(harness) && (isTTY || (!!gateKey && KEY_AUTH_CAPABLE.has(harness)));
     // Machine-global, so once per invocation; cursor's connect never installs it.
     const cliNeeded = !opts.dryRun &&
         !opts.uninstall &&
@@ -408,9 +420,21 @@ export async function runConnectAll(opts) {
         };
     }
     const results = [];
-    for (const [index, detection] of detections.entries()) {
+    const stepTotal = detections.length - deselected.size;
+    let step = 0;
+    for (const detection of detections) {
         const { harness } = detection;
-        errLine(`step ${index + 1} of ${detections.length} — ${DISPLAY_NAMES[harness]}`);
+        if (deselected.has(harness)) {
+            results.push({
+                ...detection,
+                installed: false,
+                outcome: "deselected",
+                fixCommand: `tinyfish connect ${harness}`,
+            });
+            continue;
+        }
+        step += 1;
+        errLine(`step ${step} of ${stepTotal} — ${DISPLAY_NAMES[harness]}`);
         let result;
         try {
             result = await processHarness(detection, opts, prompt, takeHoistedCli);
@@ -432,7 +456,7 @@ export async function runConnectAll(opts) {
         if (result.outcome === "interrupted")
             break;
     }
-    // The interrupt break truncates `results`; pad so the 5-entry telemetry schema still parses.
+    // The interrupt break truncates `results`; pad so the one-row-per-harness schema still parses.
     for (const detection of detections) {
         if (results.some((r) => r.harness === detection.harness))
             continue;
@@ -483,7 +507,7 @@ export async function runConnectAll(opts) {
             verify_depth: r.verifyDepth ?? null,
             verify_ok: r.verifyOk ?? null,
         }));
-        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey));
+        await sendSetupCompleted(opts.mcpUrl, harnessTelemetry, validatedApiKey(opts.apiKey), mode);
         // After the summary and before the launch, which is where the user is reading.
         emitNotice();
     }

package/dist/lib/connect-picker.d.ts

@@ -0,0 +1,16 @@
+import type { Readable } from "node:stream";
+import { type Harness, type HarnessDetection } from "./harness-detect.js";
+export type PickSelection = Harness[] | "cancel";
+export interface PickResult {
+    selection: PickSelection;
+    mode: "pick" | "pick_numeric";
+}
+export type PickerStdin = Readable & {
+    setRawMode?: (raw: boolean) => unknown;
+};
+export interface PickerIo {
+    stdin?: PickerStdin;
+    write?: (text: string) => void;
+    prompt?: (question: string) => Promise<string>;
+}
+export declare function pickHarnesses(detections: HarnessDetection[], connectedBefore: ReadonlySet<string>, io?: PickerIo): Promise<PickResult>;

package/dist/lib/connect-picker.js

@@ -0,0 +1,136 @@
+import * as readline from "node:readline";
+import { HARNESS_DISPLAY_NAMES } from "./harness-detect.js";
+const KEY_HELP = "  ↑↓ move   space toggle one   a none/all   q cancel";
+function header(count) {
+    return `Found ${count} agent config${count === 1 ? "" : "s"} on this machine.\n\n`;
+}
+function connectedNote(item) {
+    return item.connectedBefore ? "  (previously connected)" : "";
+}
+function enterHint(checkedCount, total) {
+    if (checkedCount === 0)
+        return "press enter to cancel";
+    if (checkedCount === total)
+        return `press enter to connect all ${total}`;
+    return `press enter to connect ${checkedCount} of ${total}`;
+}
+function frame(items, checked, cursor) {
+    const rows = items.map((item, i) => `  ${i === cursor ? ">" : " "} [${checked[i] ? "x" : " "}] ${item.name}${connectedNote(item)}`);
+    const count = checked.filter(Boolean).length;
+    return [...rows, "", `  ${enterHint(count, items.length)}`, KEY_HELP, ""].join("\n");
+}
+async function pickWithKeys(items, stdin, write) {
+    const checked = items.map(() => true);
+    let cursor = 0;
+    let painted = 0;
+    const paint = () => {
+        const text = frame(items, checked, cursor);
+        write((painted > 0 ? `\u001b[${painted}A\u001b[0J` : "") + text);
+        painted = items.length + 3;
+    };
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    let onKeypress;
+    try {
+        write(header(items.length));
+        paint();
+        return await new Promise((resolve, reject) => {
+            onKeypress = (_chunk, key = {}) => {
+                try {
+                    const name = key.name ?? "";
+                    // Raw mode eats terminal SIGINT, so Ctrl+C arrives only here.
+                    if ((key.ctrl && (name === "c" || name === "d")) || name === "q" || name === "escape") {
+                        resolve("cancel");
+                        return;
+                    }
+                    if (name === "return" || name === "enter") {
+                        const picked = items.filter((_, i) => checked[i]).map((item) => item.harness);
+                        resolve(picked.length > 0 ? picked : "cancel");
+                        return;
+                    }
+                    if (name === "up" || name === "k")
+                        cursor = (cursor + items.length - 1) % items.length;
+                    else if (name === "down" || name === "j")
+                        cursor = (cursor + 1) % items.length;
+                    else if (name === "space")
+                        checked[cursor] = !checked[cursor];
+                    else if (name === "a")
+                        checked.fill(!checked.every(Boolean));
+                    paint();
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            };
+            stdin.on("keypress", onKeypress);
+        });
+    }
+    finally {
+        // Restore before any child spawn can inherit raw stdin (PF-3635).
+        if (onKeypress)
+            stdin.removeListener("keypress", onKeypress);
+        stdin.setRawMode(false);
+        stdin.pause();
+    }
+}
+function numberedRows(items) {
+    return (items.map((item, i) => `  [${i + 1}] ${item.name}${connectedNote(item)}`).join("\n") + "\n");
+}
+function parseSubset(answer, items) {
+    const tokens = answer.split(/[\s,]+/).filter(Boolean);
+    if (tokens.length === 0)
+        return undefined;
+    const picked = new Set();
+    for (const token of tokens) {
+        if (!/^\d+$/.test(token))
+            return undefined;
+        const index = Number.parseInt(token, 10);
+        if (index < 1 || index > items.length)
+            return undefined;
+        picked.add(index - 1);
+    }
+    return items.filter((_, i) => picked.has(i)).map((item) => item.harness);
+}
+async function pickWithNumbers(items, prompt, write) {
+    write(header(items.length) + numberedRows(items));
+    const question = `Press enter to connect all ${items.length}, numbers for a subset (e.g. 1,3), or n to cancel: `;
+    // One re-prompt on garbage, then cancel; never a loop.
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        let answer;
+        try {
+            answer = (await prompt(question)).trim();
+        }
+        catch {
+            // Closed stdin: every later question would throw too.
+            return "cancel";
+        }
+        if (answer === "")
+            return items.map((item) => item.harness);
+        if (/^[nq]$/i.test(answer))
+            return "cancel";
+        const subset = parseSubset(answer, items);
+        if (subset)
+            return subset;
+    }
+    return "cancel";
+}
+export async function pickHarnesses(detections, connectedBefore, io = {}) {
+    const items = detections
+        .filter((detection) => detection.detected)
+        .map((detection) => ({
+        harness: detection.harness,
+        name: HARNESS_DISPLAY_NAMES[detection.harness],
+        connectedBefore: connectedBefore.has(detection.harness),
+    }));
+    const stdin = io.stdin ?? process.stdin;
+    const write = io.write ?? ((text) => void process.stderr.write(text));
+    if (typeof stdin.setRawMode !== "function") {
+        // No prompt means nothing to ask; keep --all semantics.
+        const selection = io.prompt
+            ? await pickWithNumbers(items, io.prompt, write)
+            : items.map((item) => item.harness);
+        return { selection, mode: "pick_numeric" };
+    }
+    return { selection: await pickWithKeys(items, stdin, write), mode: "pick" };
+}

package/dist/lib/harness-detect.d.ts

@@ -1,5 +1,6 @@
 export declare const ALL_HARNESSES: readonly ["claude-code", "codex", "cursor", "grok", "hermes", "openclaw", "opencode"];
 export type Harness = (typeof ALL_HARNESSES)[number];
+export declare const HARNESS_DISPLAY_NAMES: Record<Harness, string>;
 export declare enum Registered {
     Yes = "yes",
     No = "no",

package/dist/lib/harness-detect.js

@@ -11,6 +11,15 @@ export const ALL_HARNESSES = [
     "openclaw",
     "opencode",
 ];
+export const HARNESS_DISPLAY_NAMES = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    cursor: "Cursor",
+    grok: "Grok",
+    hermes: "Hermes",
+    openclaw: "OpenClaw",
+    opencode: "OpenCode",
+};
 // Values are the wire contract; the report schema derives from these.
 export var Registered;
 (function (Registered) {

package/dist/lib/setup-telemetry.d.ts

@@ -60,13 +60,19 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
         verify_ok: z.ZodNullable<z.ZodBoolean>;
     }, z.core.$strip>>;
     cli_version: z.ZodString;
+    mode: z.ZodOptional<z.ZodEnum<{
+        all: "all";
+        pick: "pick";
+        pick_numeric: "pick_numeric";
+    }>>;
 }, z.core.$strip>;
 export type SetupCompletedPayload = z.infer<typeof setupCompletedPayloadSchema>;
 export type HarnessResult = z.infer<typeof harnessResultSchema>;
+export type SetupMode = NonNullable<SetupCompletedPayload["mode"]>;
 export type UpgradeOutcome = "updated" | "failed" | "interrupted";
 /** Step selection; "updated" means every selected step ran. */
 export type UpgradeScope = "both" | "cli" | "skill";
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export declare function sendUpgradeCompleted(fromVersion: string, toVersion: string | null, outcome: UpgradeOutcome, scope: UpgradeScope, apiKey?: string): Promise<void>;
-export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string): Promise<void>;
+export declare function sendSetupCompleted(mcpUrl: string, harnesses: HarnessResult[], apiKey?: string, mode?: SetupMode): Promise<void>;
 export {};

package/dist/lib/setup-telemetry.js

@@ -109,6 +109,8 @@ export const setupCompletedPayloadSchema = z.object({
         message: "expected one result per harness",
     }),
     cli_version: z.string(),
+    // Segments picker runs from --all runs; the server field shipped first.
+    mode: z.enum(["all", "pick", "pick_numeric"]).optional(),
 });
 /** `toVersion` is null when the run was interrupted or the installed version could not be read. */
 export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scope, apiKey) {
@@ -126,7 +128,7 @@ export async function sendUpgradeCompleted(fromVersion, toVersion, outcome, scop
         apiKey,
     });
 }
-export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
+export async function sendSetupCompleted(mcpUrl, harnesses, apiKey, mode) {
     // Ahead of the parse so an opt-out run prints no telemetry debug.
     if (telemetryDisabled())
         return;
@@ -134,7 +136,11 @@ export async function sendSetupCompleted(mcpUrl, harnesses, apiKey) {
     let body;
     try {
         // Parse inside try — schema violation must not crash finished setup.
-        const payload = setupCompletedPayloadSchema.parse({ harnesses, cli_version: CLI_VERSION });
+        const payload = setupCompletedPayloadSchema.parse({
+            harnesses,
+            cli_version: CLI_VERSION,
+            ...(mode ? { mode } : {}),
+        });
         endpoint = new URL("/api/cli/connect-event", mcpUrl).toString();
         body = JSON.stringify({ event: "setup_completed", ...payload });
     }

package/package.json

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