@tiny-fish/cli 0.23.1-next.203 → 0.23.1-next.205

package/dist/commands/connect.js

@@ -1,6 +1,6 @@
 import spawn from "cross-spawn";
 import { CONNECT_SOURCE, persistApiKeyToEnvironment, saveConnectContext, validateKeyFormat, validatedApiKey, } from "../lib/auth.js";
-import { CLAUDE_CODE, CODEX, GROK, HERMES, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, OPENCODE, launchNativeMcpClient, launchOpenClawWalkthrough, openExternalUrl, } from "../lib/connect-clients.js";
+import { CLAUDE_CODE, CODEX, CURSOR_SKILL_TARGET, GROK, HERMES, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, OPENCODE, launchNativeMcpClient, launchOpenClawWalkthrough, openExternalUrl, } from "../lib/connect-clients.js";
 import { ensureCliAuthenticated, installTinyFishCli, installWebSkill, SKILL_INSTALL_TIMEOUT_MS, UPGRADE_HINT, } from "../lib/connect-install.js";
 import { ConnectInterruptedError, ConnectStepError, createConnectTelemetry, requireCommandSupport, runGuarded, settle, spawnStepError, throwIfInterrupted, NON_INTERACTIVE_TIMEOUT_MS, } from "../lib/connect-runtime.js";
 import { cursorInstallDeeplink, cursorMcpPath, writeCursorMcpConfig, } from "../lib/cursor-config.js";
@@ -266,6 +266,9 @@ export async function connectCursor(options) {
     await runGuarded(state, telemetry, async () => {
         telemetry.track("started");
         telemetry.track("checkpoint", { phase: "prerequisite_ok" });
+        state.stage = "skill_install";
+        installWebSkill(CURSOR_SKILL_TARGET);
+        telemetry.track("checkpoint", { phase: "skill_installed" });
         // Auth first: a key lets the config carry an X-API-Key header, removing the sign-in hand-back.
         state.stage = "authentication";
         ensureCliAuthenticated("cursor", options.apiKey);

package/dist/commands/doctor.js

@@ -7,7 +7,7 @@ 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 { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, connectOpencode, DEFAULT_MCP_URL, } from "./connect.js";
+import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, 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, keyAuth, healthOk, mcpUrl) {
     // An endpoint doctor could not reach proves nothing about a harness pointed at it.
@@ -300,6 +300,7 @@ const CONNECTORS = {
     "claude-code": (opts) => connectClaudeCode({ ...opts, launch: false }),
     codex: (opts) => connectCodex({ ...opts, launch: false }),
     cursor: (opts) => connectCursor(opts),
+    grok: (opts) => connectGrok({ ...opts, launch: false }),
     hermes: (opts) => connectHermes({ ...opts, launch: false }),
     openclaw: (opts) => connectOpenClaw({ ...opts, launch: false }),
     opencode: (opts) => connectOpencode({ ...opts, launch: false }),

package/dist/lib/connect-all.js

@@ -1,6 +1,6 @@
 import * as readline from "node:readline/promises";
 import spawn from "cross-spawn";
-import { connectClaudeCode, connectCodex, connectCursor, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
+import { connectClaudeCode, connectCodex, connectCursor, connectGrok, connectHermes, connectOpenClaw, connectOpencode, } from "../commands/connect.js";
 import { validatedApiKey } from "./auth.js";
 import { NATIVE_MCP_CLIENTS } from "./connect-clients.js";
 import { ensureCliAuthenticated, installTinyFishCli, TINYFISH_CLI_NOT_FOUND_MESSAGE, } from "./connect-install.js";
@@ -16,6 +16,7 @@ const DISPLAY_NAMES = {
     "claude-code": "Claude Code",
     codex: "Codex",
     cursor: "Cursor",
+    grok: "Grok",
     hermes: "Hermes",
     openclaw: "OpenClaw",
     opencode: "OpenCode",
@@ -26,7 +27,6 @@ const AUTH_DEFERRED_AT_INSTALL = new Set(["codex"]);
 const AUTH_CHECK_CAPABLE = new Set(["cursor", "openclaw"]);
 // Descriptor-derived so a harness that cannot carry a key is skipped, not failed, when headless.
 // Cursor and OpenClaw hold the key themselves rather than handing it to a harness `mcp add`.
-// `--all` only reaches harnesses it can detect; Grok has a keyAuth but no detection yet.
 const KEY_AUTH_CAPABLE = new Set([
     ...NATIVE_MCP_CLIENTS.filter((client) => !!client.keyAuth)
         .map((client) => client.connectClient)
@@ -40,6 +40,7 @@ const KEY_AUTH_CAPABLE = new Set([
 const UNINSTALL_POINTERS = {
     "claude-code": "claude mcp remove tinyfish --scope user",
     codex: "codex mcp remove tinyfish",
+    grok: "grok mcp remove tinyfish",
     hermes: "hermes mcp remove tinyfish",
     openclaw: "openclaw skills uninstall @tinyfish/tinyfish --global",
     // OpenCode ships no `mcp remove`, so the only removal is editing the config it wrote.
@@ -60,8 +61,14 @@ async function runHarnessConnect(harness, opts, keyAuthOnly) {
     }
     if (harness === "opencode")
         return connectOpencode(base);
-    await connectCursor({ apiKey: opts.apiKey, mcpUrl: opts.mcpUrl });
-    return undefined;
+    if (harness === "grok")
+        return connectGrok(base);
+    if (harness === "cursor") {
+        await connectCursor({ apiKey: opts.apiKey, mcpUrl: opts.mcpUrl });
+        return undefined;
+    }
+    // Explicit: a new harness reaching an untested branch must fail, not write Cursor's config.
+    throw new Error(`No installer is wired for ${harness}`);
 }
 async function verifyHarness(harness, mcpUrl, keyed, apiKey) {
     const health = await verifyMcpHealth(mcpUrl);

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

@@ -3,10 +3,17 @@ import { type AgentClient, type SupportedCommand } from "./connect-runtime.js";
 export declare const OPENCLAW_SKILL_INSTALL_ARGS: readonly string[];
 export declare const DEFAULT_ONBOARDING_PROMPT: string;
 export declare const OPENCLAW_ONBOARDING_PROMPT: string;
+/** The `skills` CLI's own agent names — not ours, and not every harness has one. */
+export type SkillAgent = "claude-code" | "codex" | "cursor" | "hermes-agent" | "opencode";
+/** Cursor writes its own MCP config, so it has no descriptor to carry this. */
+export declare const CURSOR_SKILL_TARGET: {
+    readonly skillAgent: "cursor";
+    readonly displayName: "Cursor";
+};
 export interface NativeMcpClient extends SupportedCommand {
     connectClient: Exclude<AgentClient, "openclaw">;
     /** Omitted where the `skills` CLI has no agent for this harness (Grok ships its own plugin). */
-    skillAgent?: "claude-code" | "codex" | "hermes-agent" | "opencode";
+    skillAgent?: SkillAgent;
     /** Replaces `addArgs` when a stored key is available: key auth removes the OAuth hop. */
     keyAuth?: {
         /** Key reaches the client through TINYFISH_API_KEY, not argv. */

package/dist/lib/connect-clients.js

@@ -62,6 +62,8 @@ export const OPENCLAW_ONBOARDING_PROMPT = "I just installed the TinyFish skill.
     "want to search and wait for my reply before using TinyFish Search. Show me the results, ask " +
     "which result I want to read, and wait before using TinyFish Fetch. Then ask what browser task " +
     "I want to complete and wait before using TinyFish Agent. Never skip ahead or choose for me.";
+/** Cursor writes its own MCP config, so it has no descriptor to carry this. */
+export const CURSOR_SKILL_TARGET = { skillAgent: "cursor", displayName: "Cursor" };
 const HEADER_FLAG = /(?:^|\s)--header(?:[\s<=]|$)/m;
 const claudeAddArgs = (mcpUrl) => [
     "mcp",

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

@@ -1,4 +1,4 @@
-import { type NativeMcpClient } from "./connect-clients.js";
+import { type SkillAgent } from "./connect-clients.js";
 import { type AgentClient } from "./connect-runtime.js";
 export declare const SKILL_INSTALL_TIMEOUT_MS = 120000;
 export declare const TINYFISH_CLI_NOT_FOUND_MESSAGE = "TinyFish CLI installed but is not available on PATH. Open a new terminal and retry.";
@@ -8,7 +8,10 @@ export type InstallOptions = {
     verbose: boolean;
 };
 export declare function installTinyFishCli({ verbose }: InstallOptions): void;
-export declare function installWebSkill(client: NativeMcpClient): void;
+export declare function installWebSkill(client: {
+    skillAgent?: SkillAgent;
+    displayName: string;
+}): void;
 /**
  * Refresh the skill we installed, for the harnesses we installed it in.
  *

package/dist/lib/connect-install.js

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import spawn from "cross-spawn";
 import { loadConfig, persistApiKeyToEnvironment, validateKeyFormat, writeConfig } from "./auth.js";
-import { NATIVE_MCP_CLIENTS, OPENCLAW_SKILL_INSTALL_ARGS, } from "./connect-clients.js";
+import { CURSOR_SKILL_TARGET, NATIVE_MCP_CLIENTS, OPENCLAW_SKILL_INSTALL_ARGS, } from "./connect-clients.js";
 import { commandNotFound, ConnectStepError, spawnStepError, throwIfInterrupted, NON_INTERACTIVE_TIMEOUT_MS, } from "./connect-runtime.js";
 import { TINYFISH_CLI_PACKAGE } from "./constants.js";
 import { installRoot } from "./install-root.js";
@@ -112,13 +112,14 @@ export function installWebSkill(client) {
 export function updateWebSkill({ verbose }) {
     // One entry per `tinyfish connect <client>`, persisted by PF-3169.
     const connected = loadConfig().connect ?? {};
-    const skillAgents = NATIVE_MCP_CLIENTS
-        .filter((client) => connected[client.connectClient])
-        .map((client) => client.skillAgent)
-        .filter((agent) => agent !== undefined);
+    const skillAgents = [
+        ...NATIVE_MCP_CLIENTS.filter((client) => connected[client.connectClient]).map((client) => client.skillAgent),
+        // Cursor is not a NativeMcpClient — it writes its own MCP config.
+        ...(connected["cursor"] ? [CURSOR_SKILL_TARGET.skillAgent] : []),
+    ].filter((agent) => agent !== undefined);
     const hasOpenClaw = Boolean(connected["openclaw"]);
     // Installs predating PF-3169 recorded nothing; ask `skills` to refresh what it tracks. A
-    // skill-less recorded install (Grok, Cursor) may still have one from before, so refresh anyway
+    // skill-less recorded install (Grok) may still have one from before, so refresh anyway
     // — but there having been none is then expected, not an upgrade failure.
     if (skillAgents.length === 0 && !hasOpenClaw) {
         return refreshWebSkillByHash(verbose, Object.keys(connected).length > 0);

package/dist/lib/doctor-report.d.ts

@@ -25,6 +25,7 @@ declare const doctorCheckSchema: z.ZodObject<{
     detail: z.ZodString;
     harness: z.ZodNullable<z.ZodEnum<{
         openclaw: "openclaw";
+        grok: "grok";
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
@@ -40,6 +41,7 @@ declare const doctorCheckSchema: z.ZodObject<{
 declare const doctorHarnessSchema: z.ZodObject<{
     harness: z.ZodEnum<{
         openclaw: "openclaw";
+        grok: "grok";
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
@@ -59,6 +61,7 @@ declare const doctorRepairSchema: z.ZodObject<{
     }>;
     harness: z.ZodNullable<z.ZodEnum<{
         openclaw: "openclaw";
+        grok: "grok";
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
@@ -85,6 +88,7 @@ export declare const doctorReportSchema: z.ZodObject<{
         detail: z.ZodString;
         harness: z.ZodNullable<z.ZodEnum<{
             openclaw: "openclaw";
+            grok: "grok";
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
@@ -100,6 +104,7 @@ export declare const doctorReportSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            grok: "grok";
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";
@@ -119,6 +124,7 @@ export declare const doctorReportSchema: z.ZodObject<{
         }>;
         harness: z.ZodNullable<z.ZodEnum<{
             openclaw: "openclaw";
+            grok: "grok";
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";

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

@@ -1,4 +1,4 @@
-export declare const ALL_HARNESSES: readonly ["claude-code", "codex", "cursor", "hermes", "openclaw", "opencode"];
+export declare const ALL_HARNESSES: readonly ["claude-code", "codex", "cursor", "grok", "hermes", "openclaw", "opencode"];
 export type Harness = (typeof ALL_HARNESSES)[number];
 export declare enum Registered {
     Yes = "yes",

package/dist/lib/harness-detect.js

@@ -5,6 +5,7 @@ export const ALL_HARNESSES = [
     "claude-code",
     "codex",
     "cursor",
+    "grok",
     "hermes",
     "openclaw",
     "opencode",
@@ -27,6 +28,7 @@ const CONFIG_DIRS = {
     "claude-code": ".claude",
     codex: ".codex",
     cursor: ".cursor",
+    grok: ".grok",
     hermes: ".hermes",
     openclaw: ".openclaw",
     opencode: ".config/opencode",

package/dist/lib/registration-detect.js

@@ -342,10 +342,69 @@ function probeOpencode() {
     }
     return fromMcpList("opencode", probe.output, AuthMode.Unknown, OPENCODE_ROW_URL);
 }
+// Verified against grok 0.0.60: a list, with the header value in the clear.
+const grokEntrySchema = z.looseObject({
+    name: z.string().optional(),
+    url: z.string().optional(),
+    headers: z.record(z.string(), z.string()).optional(),
+});
+const grokListSchema = z.array(grokEntrySchema);
+// Grok drops X-API-Key when the server advertises OAuth metadata, so keys ride Authorization.
+const BEARER_VALUE = /^Bearer\s+(\S+)$/i;
+// Grok has no `mcp get`; `mcp list --json` is the only machine-readable view.
+function probeGrok() {
+    const probe = runProbe("grok", ["mcp", "list", "--json"]);
+    if (probe.outcome === "unavailable") {
+        return { registered: Registered.Unknown, authMode: AuthMode.Unknown, reason: probe.reason };
+    }
+    if (probe.exitCode !== 0) {
+        if (UNSUPPORTED_SUBCOMMAND.test(probe.output)) {
+            return {
+                registered: Registered.Unknown,
+                authMode: AuthMode.Unknown,
+                reason: "this Grok build has no `mcp list --json`",
+            };
+        }
+        return {
+            registered: Registered.Unknown,
+            authMode: AuthMode.Unknown,
+            reason: `\`grok mcp list --json\` exited ${probe.exitCode}`,
+        };
+    }
+    let entries;
+    try {
+        entries = grokListSchema.parse(JSON.parse(probe.stdout));
+    }
+    catch {
+        return {
+            registered: Registered.Unknown,
+            authMode: AuthMode.Unknown,
+            reason: "`grok mcp list --json` did not return the expected shape",
+        };
+    }
+    const entry = entries.find((server) => server.name === "tinyfish");
+    if (!entry)
+        return { registered: Registered.No, authMode: AuthMode.Unknown };
+    const authorization = Object.entries(entry.headers ?? {}).find(([name]) => name.toLowerCase() === "authorization")?.[1];
+    // `${VAR}` expands to "" when the env var is unset: a present-but-empty header is a broken key.
+    const hasAuthorization = authorization !== undefined;
+    const key = extractableKey(BEARER_VALUE.exec(authorization ?? "")?.[1]);
+    return {
+        registered: Registered.Yes,
+        authMode: hasAuthorization ? AuthMode.ApiKey : AuthMode.OAuth,
+        ...(entry.url ? { registeredUrl: entry.url } : {}),
+        ...(key ? { apiKey: key } : {}),
+        // A keyed Grok entry suppresses OAuth discovery, so an unreadable key cannot fall back.
+        ...(hasAuthorization && !key
+            ? { keyReason: "its Authorization header is not a readable TinyFish key" }
+            : {}),
+    };
+}
 const PROBES = {
     "claude-code": () => fromMcpGet("claude", API_KEY_HEADER),
     codex: probeCodex,
     cursor: probeCursor,
+    grok: probeGrok,
     hermes: probeHermes,
     openclaw: probeOpenClaw,
     opencode: probeOpencode,

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

@@ -25,6 +25,7 @@ export declare function postConnectEvent(options: {
 declare const harnessResultSchema: z.ZodObject<{
     harness: z.ZodEnum<{
         openclaw: "openclaw";
+        grok: "grok";
         cursor: "cursor";
         codex: "codex";
         hermes: "hermes";
@@ -43,6 +44,7 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            grok: "grok";
             cursor: "cursor";
             codex: "codex";
             hermes: "hermes";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiny-fish/cli",
-  "version": "0.23.1-next.203",
+  "version": "0.23.1-next.205",
   "description": "TinyFish CLI — run web automations from your terminal",
   "type": "module",
   "bin": {
@@ -32,7 +32,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@tiny-fish/sdk": "^0.4.0",
+    "@tiny-fish/sdk": "^0.5.0",
     "chrome-cookies-secure": "^3.0.2",
     "commander": "^12.0.0",
     "cross-spawn": "^7.0.6",