@tiny-fish/cli 0.45.2-next.354 → 0.45.2-next.357

package/dist/commands/onboard.js

@@ -3,7 +3,7 @@ import { getApiKey, saveConfig } from '../lib/auth.js';
 import { fetchContentGet, searchQuery } from '../lib/client.js';
 import { BASE_URL, TINYFISH_API_KEY_VAR } from '../lib/constants.js';
 import { errLine, handleApiError, outLine } from '../lib/output.js';
-import { connectHarness, launchAgent } from './connect.js';
+import { connectHarness, launchAgent } from '../lib/connect-harness.js';
 import { HARNESS_DISPLAY_NAMES } from '../lib/harness-detect.js';
 const EXAMPLE_QUERIES = [
     'What are recent changes in the AI dev stack? Give me the top 5 changes that matter, why they matter, and any action needed.',

package/dist/lib/auth.d.ts

@@ -10,6 +10,8 @@ export type RecordedAuthMode = 'api-key' | 'keyless' | 'oauth' | 'deferred';
 interface ConnectEntry {
     attempt_id: string;
     auth_mode?: RecordedAuthMode;
+    /** `connect cline --config-dir`: uninstall and doctor must find the same store. */
+    config_dir?: string;
 }
 interface PendingConnectAttempt {
     id: string;
@@ -34,6 +36,8 @@ export declare function writeConfig(apiKey: string): void;
 export declare function saveConfig(apiKey: string): void;
 /** `authMode` omitted rewrites the entry without one: a reconnect that degraded must not keep a stale key claim. */
 export declare function saveConnectContext(client: string, attemptId: string, authMode?: RecordedAuthMode): void;
+/** Merged after connect wrote the entry; a missing entry means the install never landed. */
+export declare function saveConnectConfigDir(client: string, configDir: string): void;
 /** Distinguishes a missing entry from an unreadable config file. */
 export declare function connectContextState(client: string): 'present' | 'absent' | 'unreadable';
 /** Kept marker after uninstall makes doctor offer to reinstall the harness. */

package/dist/lib/auth.js

@@ -53,10 +53,14 @@ function parseConnectMap(value) {
         if (typeof attemptId !== 'string')
             continue;
         const authMode = record?.auth_mode;
-        out[client] =
-            typeof authMode === 'string' && RECORDED_AUTH_MODES.includes(authMode)
-                ? { attempt_id: attemptId, auth_mode: authMode }
-                : { attempt_id: attemptId };
+        const configDir = record?.config_dir;
+        out[client] = {
+            attempt_id: attemptId,
+            ...(typeof authMode === 'string' && RECORDED_AUTH_MODES.includes(authMode)
+                ? { auth_mode: authMode }
+                : {}),
+            ...(typeof configDir === 'string' ? { config_dir: configDir } : {}),
+        };
     }
     return Object.keys(out).length > 0 ? out : undefined;
 }
@@ -144,6 +148,24 @@ export function saveConnectContext(client, attemptId, authMode) {
         errLine(`Warning: could not persist connect context: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
+/** Merged after connect wrote the entry; a missing entry means the install never landed. */
+export function saveConnectConfigDir(client, configDir) {
+    try {
+        updateConfig((config) => {
+            const entry = config.connect?.[client];
+            if (!entry)
+                return config;
+            return {
+                ...config,
+                connect: { ...config.connect, [client]: { ...entry, config_dir: configDir } },
+            };
+        });
+    }
+    catch (e) {
+        // Best-effort, like saveConnectContext: a working install must not fail on this.
+        errLine(`Warning: could not persist the config dir: ${e instanceof Error ? e.message : String(e)}`);
+    }
+}
 /** Distinguishes a missing entry from an unreadable config file. */
 export function connectContextState(client) {
     let raw;

package/dist/lib/config/cline-config.d.ts

@@ -0,0 +1,4 @@
+import { type McpJsonServerEntry } from './mcp-json-config.js';
+export declare function clineConfigDir(): string;
+/** Reports the header's shape, never its value. */
+export declare function readClineTinyfishEntry(): McpJsonServerEntry;

package/dist/lib/config/cline-config.js

@@ -0,0 +1,36 @@
+import * as os from 'os';
+import * as path from 'path';
+import { loadConfig } from '../auth.js';
+import { readTinyfishEntry, } from './mcp-json-config.js';
+/** A `--config-dir` install outlives the flag, so later runs read it back. */
+function recordedConfigDir() {
+    try {
+        return loadConfig().connect?.['cline']?.config_dir;
+    }
+    catch {
+        // An unreadable config must degrade to the default, never throw out of a probe.
+        return undefined;
+    }
+}
+// Cline reads both raw, so neither is tilde-expanded here either.
+export function clineConfigDir() {
+    const override = process.env['CLINE_DIR']?.trim() || recordedConfigDir();
+    return override ? path.resolve(override) : path.join(os.homedir(), '.cline'); // nosemgrep: path-join-resolve-traversal -- fixed dir names under os.homedir()
+}
+/** CLINE_DIR moves the whole tree; CLINE_DATA_DIR moves only the data subtree. */
+function clineDataDir() {
+    const override = process.env['CLINE_DATA_DIR']?.trim();
+    return override ? path.resolve(override) : path.join(clineConfigDir(), 'data');
+}
+// Read-only: Cline writes this file itself, through `cline mcp add --yes`.
+const CLINE_TARGET = {
+    serverKey: 'tinyfish',
+    dir: clineConfigDir,
+    file: () => path.join(clineDataDir(), 'settings', 'cline_mcp_settings.json'),
+    keyHeader: { name: 'X-API-Key' },
+    transportKey: 'transport',
+};
+/** Reports the header's shape, never its value. */
+export function readClineTinyfishEntry() {
+    return readTinyfishEntry(CLINE_TARGET);
+}

package/dist/lib/config/connect-config-file.d.ts

@@ -0,0 +1,76 @@
+import { type ConnectAuthMode } from '../connect-runtime.js';
+import { cursorMcpPath, writeCursorMcpConfig } from './cursor-config.js';
+import { ompMcpPath, writeOmpMcpConfig } from './omp-config.js';
+import { piMcpPath, writePiMcpConfig } from './pi-config.js';
+declare function piPostConnectNotes(): string | undefined;
+declare const CONFIG_FILE_HARNESSES: {
+    cursor: {
+        skillTarget: {
+            readonly skillAgent: "cursor";
+            readonly displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writeCursorMcpConfig;
+        configPath: typeof cursorMcpPath;
+        tryLaunch: typeof launchCursorDeeplink;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+    omp: {
+        skillTarget: {
+            displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writeOmpMcpConfig;
+        configPath: typeof ompMcpPath;
+        tryLaunch: () => false;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+    pi: {
+        skillTarget: {
+            skillAgent: "pi";
+            displayName: string;
+        };
+        registeredUrl: () => string | undefined;
+        write: typeof writePiMcpConfig;
+        configPath: typeof piMcpPath;
+        tryLaunch: () => false;
+        postConnectNote: typeof piPostConnectNotes;
+        copy: {
+            verified: string;
+            authFailed: (reason: string) => string;
+            launched: string;
+            reload: string;
+        };
+    };
+};
+/** Writes the harness's MCP config file itself; no `mcp add` exists. */
+export declare function connectConfigFileHarness(harness: keyof typeof CONFIG_FILE_HARNESSES, options: {
+    apiKey?: string;
+    mcpUrl: string;
+    attemptId?: string;
+    verbose?: boolean;
+    authTimeoutMs?: number;
+    onPostInstallFailed?: () => void;
+}): Promise<ConnectAuthMode | undefined>;
+/** Writes mcp.json directly — no `cursor mcp add` exists. */
+export declare function connectCursor(options: {
+    apiKey?: string;
+    mcpUrl: string;
+    attemptId?: string;
+    verbose?: boolean;
+    authTimeoutMs?: number;
+    onPostInstallFailed?: () => void;
+}): Promise<void>;
+/** Best-effort: false when no handler/open fails — caller falls back to reload copy. */
+declare function launchCursorDeeplink(mcpUrl: string): boolean;
+export {};

package/dist/lib/config/connect-config-file.js

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+import { CONNECT_SOURCE, saveConnectContext, validatedApiKey } from '../auth.js';
+import { CURSOR_SKILL_TARGET, openExternalUrl } from '../connect-clients.js';
+import { ensureCliAuthenticated } from '../connect-auth.js';
+import { installWebSkill } from '../skill-install.js';
+import { ConnectStepError, createConnectTelemetry, runGuarded, settle, } from '../connect-runtime.js';
+import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from './cursor-config.js';
+import { ompMcpPath, readOmpTinyfishEntry, writeOmpMcpConfig } from './omp-config.js';
+import { PI_ADAPTER_INSTALL_COMMAND, piMcpAdapterState, piSkillDirMismatch, piMcpPath, readPiTinyfishEntry, writePiMcpConfig, } from './pi-config.js';
+import { AuthMode, HARNESS_DISPLAY_NAMES } from '../harness-detect.js';
+import { detectHumanInitiated } from '../harness.js';
+import { errLine } from '../output.js';
+import { verifyMcpAuth } from '../verify.js';
+import { apiBaseFromMcpUrl } from '../mcp-endpoint.js';
+import { finishSetupHint, requireKeylessMcp, trackPostInstallFailure } from '../connect-steps.js';
+const PI_RELOAD_COPY = 'TinyFish is configured in pi. Restart pi, then run `/mcp-auth tinyfish` there if it asks you ' +
+    'to sign in.';
+// The skill is the working path either way, so the note must not read as a failure.
+const PI_ADAPTER_DORMANT_NOTE = 'Note: pi has no built-in MCP support, so the entry in its mcp.json stays dormant until you ' +
+    `run \`${PI_ADAPTER_INSTALL_COMMAND}\`. The TinyFish skill works without it.`;
+// Only the dormant case was spoken for, leaving a working MCP install silent.
+const PI_ADAPTER_LIVE_NOTE = 'pi-mcp-adapter is installed, so pi loads the TinyFish MCP tools as well as the skill once ' +
+    'you restart it.';
+function piAdapterNote() {
+    const state = piMcpAdapterState();
+    if (state === 'installed')
+        return PI_ADAPTER_LIVE_NOTE;
+    return state === 'absent' ? PI_ADAPTER_DORMANT_NOTE : undefined;
+}
+// The `skills` CLI writes to the default dir even when pi reads another one.
+function piPostConnectNotes() {
+    const notes = [piAdapterNote()];
+    const skills = piSkillDirMismatch();
+    if (skills) {
+        notes.push(`Note: PI_CODING_AGENT_DIR points pi at ${skills.readFrom}, but the TinyFish skill ` +
+            `installed to ${skills.installedTo}. Copy or symlink it across for pi to load it.`);
+    }
+    const printable = notes.filter(Boolean);
+    return printable.length > 0 ? printable.join('\n') : undefined;
+}
+// Only interactive omp wires the OAuth handler; headless cannot sign in.
+const OMP_KEYLESS_COPY = 'TinyFish is configured in omp. Open omp and sign in to TinyFish when prompted, or run ' +
+    '`/mcp reauth tinyfish` there.';
+const CONFIG_FILE_HARNESSES = {
+    cursor: {
+        skillTarget: CURSOR_SKILL_TARGET,
+        registeredUrl: () => readCursorTinyfishEntry().url,
+        write: writeCursorMcpConfig,
+        configPath: cursorMcpPath,
+        tryLaunch: launchCursorDeeplink,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Reload the Cursor window (or restart cursor-agent) and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect cursor',
+            launched: 'Cursor should pop a TinyFish install confirmation — approve it, then sign in when prompted.',
+            reload: 'TinyFish is connected. Reload the Cursor window, then approve/sign in under Settings → MCP.',
+        },
+    },
+    omp: {
+        // No skill exists for omp; installWebSkill returns without one.
+        skillTarget: { displayName: HARNESS_DISPLAY_NAMES.omp },
+        registeredUrl: () => readOmpTinyfishEntry()?.url,
+        write: writeOmpMcpConfig,
+        configPath: ompMcpPath,
+        // No install deeplink exists; the keyless copy carries the sign-in.
+        tryLaunch: () => false,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart omp and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect omp',
+            launched: OMP_KEYLESS_COPY,
+            reload: OMP_KEYLESS_COPY,
+        },
+    },
+    pi: {
+        skillTarget: { skillAgent: 'pi', displayName: HARNESS_DISPLAY_NAMES.pi },
+        registeredUrl: () => readPiTinyfishEntry().url,
+        write: writePiMcpConfig,
+        configPath: piMcpPath,
+        // No install deeplink exists; the copy carries the restart instead.
+        tryLaunch: () => false,
+        postConnectNote: piPostConnectNotes,
+        copy: {
+            verified: "TinyFish is connected and verified (health+auth). Restart pi and it's live.",
+            authFailed: (reason) => `TinyFish is configured, but the authenticated check failed (${reason}). ` +
+                'Fix: rotate/re-enter your key with `tinyfish auth login`, then re-run: tinyfish connect pi',
+            launched: PI_RELOAD_COPY,
+            reload: PI_RELOAD_COPY,
+        },
+    },
+};
+/** Cosmetic and post-settle: a skill failure must not fail the connection. */
+function installSkillPostSettle(spec, displayName, state, telemetry, options) {
+    if (!spec.skillTarget.skillAgent)
+        return false;
+    state.stage = 'skill_install';
+    try {
+        installWebSkill(spec.skillTarget, { verbose: options.verbose ?? false });
+        telemetry.track('checkpoint', { phase: 'skill_installed' });
+        return false;
+    }
+    catch (error) {
+        trackPostInstallFailure(displayName, state, telemetry, error);
+        return true;
+    }
+}
+/** Prints last: the outro must own the final line. */
+function reportPostInstallFailure(harness, failed, onPostInstallFailed) {
+    if (!failed)
+        return;
+    errLine(finishSetupHint(harness));
+    onPostInstallFailed?.();
+}
+/** Writes the harness's MCP config file itself; no `mcp add` exists. */
+export async function connectConfigFileHarness(harness, options) {
+    const spec = CONFIG_FILE_HARNESSES[harness];
+    const displayName = HARNESS_DISPLAY_NAMES[harness];
+    let fallbackAttemptId;
+    const registeredUrl = spec.registeredUrl();
+    if (registeredUrl) {
+        try {
+            const registered = new URL(registeredUrl);
+            const requested = new URL(options.mcpUrl);
+            const registeredId = registered.searchParams.get('connect_attempt_id');
+            const registeredSource = registered.searchParams.get('source');
+            const registeredClient = registered.searchParams.get('client');
+            for (const key of ['source', 'client', 'connect_attempt_id']) {
+                registered.searchParams.delete(key);
+                requested.searchParams.delete(key);
+            }
+            registered.searchParams.sort();
+            requested.searchParams.sort();
+            if (registered.toString() === requested.toString() &&
+                registeredSource === CONNECT_SOURCE &&
+                registeredClient === harness &&
+                z.uuid().safeParse(registeredId).success) {
+                fallbackAttemptId = registeredId ?? undefined;
+            }
+        }
+        catch {
+            // A hand-edited invalid URL is repaired below with a fresh attempt id.
+        }
+    }
+    const telemetry = createConnectTelemetry(options.mcpUrl, harness, {
+        ...options,
+        fallbackAttemptId,
+    });
+    // Never degraded: no sign-in command to be missing. False, not absent, so a `= false`
+    // filter still catches these harnesses.
+    const state = {
+        stage: 'prerequisite_check',
+        settled: false,
+        harnessDegraded: false,
+    };
+    await runGuarded(state, telemetry, async () => {
+        telemetry.track('started');
+        telemetry.track('checkpoint', { phase: 'prerequisite_ok' });
+        const resolveAuth = async () => {
+            let resolvedKey = validatedApiKey(options.apiKey);
+            const keyless = !resolvedKey && harness === 'omp';
+            if (keyless) {
+                await requireKeylessMcp(options.mcpUrl);
+            }
+            else {
+                state.stage = 'authentication';
+                ensureCliAuthenticated(harness, options.apiKey, {
+                    interactiveLogin: options.authTimeoutMs === undefined,
+                });
+                resolvedKey = validatedApiKey(options.apiKey);
+                telemetry.track('checkpoint', { phase: 'authenticated' });
+                if (!resolvedKey) {
+                    errLine('Ignoring the stored API key: invalid format. Run: tinyfish auth login');
+                }
+            }
+            return { resolvedKey, keyless };
+        };
+        const { resolvedKey, keyless } = await resolveAuth();
+        state.stage = 'registration';
+        errLine(`Adding TinyFish to ${displayName}...`);
+        const mcpUrl = new URL(options.mcpUrl);
+        mcpUrl.searchParams.set('source', CONNECT_SOURCE);
+        mcpUrl.searchParams.set('client', harness);
+        mcpUrl.searchParams.set('connect_attempt_id', telemetry.attemptId);
+        const result = spec.write(mcpUrl.toString(), resolvedKey);
+        if (result.status === 'corrupt_skip') {
+            // The message fallback would leak the config path; tag instead.
+            throw new ConnectStepError(`Could not update ${spec.configPath()}: existing file could not be read or is not valid JSON (${result.error}). ` +
+                `Fix the file, then re-run: tinyfish connect ${harness}`, 'invalid_config', { failureDetail: `${harness}_mcp_json_corrupt` });
+        }
+        if (result.backupPath) {
+            errLine(`Backed up existing ${displayName} MCP config to ${result.backupPath}`);
+        }
+        if (result.repaired) {
+            errLine('Repaired the existing TinyFish entry (updated auth/config to current).');
+        }
+        telemetry.track('checkpoint', { phase: 'registered' });
+        let authMode = keyless ? AuthMode.Keyless : 'deferred';
+        if (resolvedKey)
+            authMode = AuthMode.ApiKey;
+        state.authMode = authMode;
+        if (keyless)
+            saveConnectContext(harness, telemetry.attemptId, AuthMode.Keyless);
+        else
+            saveConnectContext(harness, telemetry.attemptId);
+        settle(state, telemetry, 'completed', { authMode });
+        const postInstallFailed = installSkillPostSettle(spec, displayName, state, telemetry, options);
+        if (keyless) {
+            errLine(`TinyFish keyless Search is connected in ${displayName}.`);
+        }
+        else if (resolvedKey) {
+            // Deeplink would embed the key in a URL (process args, LaunchServices logs) — reload instead.
+            const verify = await verifyMcpAuth(resolvedKey, apiBaseFromMcpUrl(options.mcpUrl));
+            if (verify.ok) {
+                errLine(spec.copy.verified);
+            }
+            else {
+                errLine(spec.copy.authFailed(verify.reason ?? 'unknown'));
+            }
+        }
+        else if (detectHumanInitiated() && spec.tryLaunch(mcpUrl.toString())) {
+            errLine(spec.copy.launched);
+        }
+        else {
+            errLine(spec.copy.reload);
+        }
+        const note = spec.postConnectNote?.();
+        if (note)
+            errLine(note);
+        reportPostInstallFailure(harness, postInstallFailed, options.onPostInstallFailed);
+    });
+    return state.authMode;
+}
+/** Writes mcp.json directly — no `cursor mcp add` exists. */
+export async function connectCursor(options) {
+    await connectConfigFileHarness('cursor', options);
+}
+/** Best-effort: false when no handler/open fails — caller falls back to reload copy. */
+function launchCursorDeeplink(mcpUrl) {
+    const result = openExternalUrl(cursorInstallDeeplink(mcpUrl));
+    return !result.error && result.status === 0;
+}

package/dist/lib/{hermes-config.js → config/hermes-config.js}

@@ -2,8 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { parse } from 'yaml';
 import { z } from 'zod';
-import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from './constants.js';
-import { HERMES_KEY_VAR } from './hermes-env.js';
+import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from '../constants.js';
+import { HERMES_KEY_VAR } from '../hermes-env.js';
 /** Every message about the entry names this path. */
 export function hermesConfigPath(home) {
     return path.join(home, 'config.yaml');

package/dist/lib/{mcp-json-config.d.ts → config/mcp-json-config.d.ts}

@@ -8,6 +8,8 @@ export interface McpJsonTarget {
         name: string;
         valuePrefix?: string;
     };
+    /** Cline nests url and headers under this key; every other harness is flat. */
+    transportKey?: string;
 }
 export interface McpJsonWriteResult {
     status: 'written' | 'unchanged' | 'corrupt_skip';

package/dist/lib/{mcp-json-config.js → config/mcp-json-config.js}

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
-import { matchesCliKey } from './auth.js';
-import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from './constants.js';
+import { matchesCliKey } from '../auth.js';
+import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_KEYLESS_ACCESS_MODE } from '../constants.js';
 function isPlainRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -65,6 +65,11 @@ export function planWrite(target, mcpUrl, apiKey, serverEntry) {
 }
 // omp expands `${VAR}` / `${VAR:-default}` header values at load.
 const ENV_TEMPLATE_VALUE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}$/;
+/** Cline nests url and headers under `transport`; `enabled` stays on the entry itself. */
+function entryFields(entry, transportKey) {
+    const nested = transportKey ? entry[transportKey] : undefined;
+    return isPlainRecord(nested) ? nested : entry;
+}
 /** Reports the header's shape, never its value. */
 export function readTinyfishEntry(target) {
     const existing = readExisting(target);
@@ -75,9 +80,10 @@ export function readTinyfishEntry(target) {
     const entry = isPlainRecord(servers) ? servers[target.serverKey] : undefined;
     if (!isPlainRecord(entry))
         return { present: false, hasApiKeyHeader: false };
-    const key = readKeyHeader(entry.headers, target.keyHeader);
+    const fields = entryFields(entry, target.transportKey);
+    const key = readKeyHeader(fields.headers, target.keyHeader);
     const templateVar = key ? ENV_TEMPLATE_VALUE.exec(key.value)?.[1] : undefined;
-    const accessMode = readKeyHeader(entry.headers, { name: TINYFISH_ACCESS_MODE_HEADER })?.value;
+    const accessMode = readKeyHeader(fields.headers, { name: TINYFISH_ACCESS_MODE_HEADER })?.value;
     const keyless = accessMode?.trim().toLowerCase() === TINYFISH_KEYLESS_ACCESS_MODE;
     return {
         present: true,
@@ -86,7 +92,7 @@ export function readTinyfishEntry(target) {
         ...(entry.enabled === false ? { enabled: false } : {}),
         ...(matchesCliKey(key?.value) ? { keyMatchesCliKey: true } : {}),
         ...(templateVar ? { keyTemplateVar: templateVar } : {}),
-        ...(typeof entry.url === 'string' ? { url: entry.url } : {}),
+        ...(typeof fields.url === 'string' ? { url: fields.url } : {}),
     };
 }
 /** Reports the key header's shape, never its value. */

package/dist/lib/{omp-config.js → config/omp-config.js}

@@ -1,7 +1,7 @@
 import * as path from 'path';
 import spawn from 'cross-spawn';
-import { ConnectStepError } from './connect-runtime.js';
-import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
+import { ConnectStepError } from '../connect-runtime.js';
+import { HARNESS_PROBE_TIMEOUT_MS } from '../constants.js';
 import { buildTinyfishKeylessServerEntry, planWrite, readTinyfishEntry, removeServer, writeMcpConfig, } from './mcp-json-config.js';
 const UNRESOLVED_REASON = '`omp config path` did not report a config directory';
 // Cached: every later read must agree with the write.

package/dist/lib/{pi-config.js → config/pi-config.js}

@@ -3,7 +3,7 @@ import * as os from 'os';
 import * as path from 'path';
 import spawn from 'cross-spawn';
 import { z } from 'zod';
-import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
+import { HARNESS_PROBE_TIMEOUT_MS } from '../constants.js';
 import { planWrite, readTinyfishEntry, removeServer, writeMcpConfig, } from './mcp-json-config.js';
 // pi expands `~` and `~/`; writing one literally would mkdir '~'.
 function expandTilde(dir) {

package/dist/lib/connect-all-uninstall.js

@@ -1,9 +1,9 @@
 import { clearConnectContext, connectContextState } from './auth.js';
 import { NATIVE_BY_HARNESS, openclawSkillUninstall } from './connect-clients.js';
 import { ConnectInterruptedError, spawnRemoval } from './connect-runtime.js';
-import { removeCursorMcpServer, planCursorWrite } from './cursor-config.js';
-import { planOmpWrite, removeOmpMcpServer } from './omp-config.js';
-import { piMcpPath, planPiWrite, removePiMcpServer } from './pi-config.js';
+import { removeCursorMcpServer, planCursorWrite } from './config/cursor-config.js';
+import { planOmpWrite, removeOmpMcpServer } from './config/omp-config.js';
+import { piMcpPath, planPiWrite, removePiMcpServer } from './config/pi-config.js';
 import { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
 import { clearHermesWebBackends } from './hermes-plugin.js';
 import { HARNESS_DISPLAY_NAMES as DISPLAY_NAMES } from './harness-detect.js';

package/dist/lib/connect-all.js

@@ -1,7 +1,7 @@
 import * as readline from 'node:readline/promises';
 import { harnessSpec } from './harness-spec.js';
 import spawn from 'cross-spawn';
-import { connectHarness } from '../commands/connect.js';
+import { connectHarness } from './connect-harness.js';
 import { loadConfig, validatedApiKey } from './auth.js';
 import { installTinyFishCli, } from './cli-install.js';
 import { authGate, mapConnectError, OAUTH_SIGN_IN_TIMEOUT_MS } from './connect-all-auth.js';

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

@@ -104,7 +104,7 @@ export declare function hermesRegistrationEnabled(home: string, mode?: 'api-key'
 };
 export declare const NATIVE_MCP_CLIENTS: readonly NativeMcpClient[];
 /** Native descriptor by harness id; Cursor and OpenClaw have none. */
-export declare const NATIVE_BY_HARNESS: Map<"openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "command-code" | "opencode" | "pi" | "claude-code", NativeMcpClient>;
+export declare const NATIVE_BY_HARNESS: Map<"openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "command-code" | "opencode" | "pi" | "cline" | "claude-code", NativeMcpClient>;
 export declare const OPENCLAW: SupportedCommand;
 /** "printed" = handed to the user to paste; the walkthrough was never started for them. */
 export type WalkthroughOutcome = 'launched' | 'printed';

package/dist/lib/connect-clients.js

@@ -7,7 +7,7 @@ import { ConnectInterruptedError, ConnectStepError, spawnStepError, } from './co
 import { TINYFISH_ACCESS_MODE_HEADER, TINYFISH_API_KEY_VAR, TINYFISH_KEYLESS_ACCESS_MODE, } from './constants.js';
 import { HARNESS_SPECS, NATIVE_HARNESSES, harnessSpec, } from './harness-spec.js';
 import { HERMES_KEY_VAR, captureHermesKeyRestore, hermesEnvPath, resolveHermesHome, writeHermesKey, } from './hermes-env.js';
-import { hermesConfigPath, readHermesEntry } from './hermes-config.js';
+import { hermesConfigPath, readHermesEntry } from './config/hermes-config.js';
 import { installHermesPlugin, removeHermesMcpEntry, setHermesWebBackends, writeHermesMcpEntry, } from './hermes-plugin.js';
 const HERMES_SEED_TIMEOUT_MS = 120_000;
 const OPENCLAW_SKILL = '@tinyfish/tinyfish';
@@ -215,6 +215,12 @@ function installHermesWebPlugin({ apiKey, verbose, seededHome, }) {
 function launchOpencode(prompt) {
     handOverTerminal('opencode', ['--prompt', prompt], 'OpenCode');
 }
+// A bare `cline "<prompt>"` is a one-shot act run that auto-approves every tool, so it would
+// bill TinyFish calls unattended and cannot answer the walkthrough's questions. `-i` is the
+// only interactive mode.
+function launchCline(prompt) {
+    handOverTerminal('cline', ['-i', '--auto-approve', 'false', prompt], 'Cline');
+}
 /** "positional": flags before `tinyfish <url>`. "flag": flags after `--url`. */
 function specAddArgs(spec, mcpUrl) {
     const flags = spec.addFlags ?? [];
@@ -272,6 +278,7 @@ function specKeylessAddArgs(spec) {
 }
 /** Descriptor behaviour the spec cannot hold; every other field is spec data. */
 const HARNESS_OVERRIDES = {
+    cline: { launchWalkthrough: launchCline },
     codex: { detachedLaunch: launchCodexWalkthrough },
     hermes: {
         launchWalkthrough: launchHermesWalkthrough,

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

@@ -0,0 +1,4 @@
+import type { AgentClient, ConnectAuthMode } from './connect-runtime.js';
+import { type NativeConnectOptions } from './connect-steps.js';
+export declare function launchAgent(client: AgentClient): Promise<void>;
+export declare function connectHarness(harness: AgentClient, options: NativeConnectOptions): Promise<ConnectAuthMode | undefined>;