@tiny-fish/cli 0.37.1-next.301 → 0.37.1-next.302

package/README.md

@@ -19,7 +19,7 @@ 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
+omp, 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.
 

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 { CURSOR_SKILL_TARGET, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
+import { CURSOR_SKILL_TARGET, OPENCLAW, OPENCLAW_SKILL_INSTALL_ARGS, NATIVE_BY_HARNESS, launchNativeMcpClient, launchOmpWalkthrough, launchOpenClawWalkthrough, openExternalUrl, } from '../lib/connect-clients.js';
 import { captureStdio, capturedOutput, HoistedFailureReportedError, installTinyFishCli, replay, SKILL_INSTALL_TIMEOUT_MS, STEP_MAX_BUFFER, } from '../lib/cli-install.js';
 import { ensureCliAuthenticated } from '../lib/connect-auth.js';
 import { createStdinPrompt, runCliFallback } from '../lib/connect-fallback.js';
@@ -8,6 +8,7 @@ import { installWebSkill } from '../lib/skill-install.js';
 import { ConnectInterruptedError, ConnectStepError, createConnectTelemetry, finishSetupCommand, requireCommandSupport, runGuarded, settle, SignInTimeoutError, spawnStepError, stageDurationOf, withStageDuration, spawnRemoval, } from '../lib/connect-runtime.js';
 import { cursorInstallDeeplink, cursorMcpPath, readCursorTinyfishEntry, writeCursorMcpConfig, } from '../lib/cursor-config.js';
 import { runConnectAll } from '../lib/connect-all.js';
+import { ompMcpPath, readOmpTinyfishEntry, writeOmpMcpConfig } from '../lib/omp-config.js';
 import { ALL_HARNESSES, AuthMode, HARNESS_DISPLAY_NAMES, RELOAD_ACTION, } from '../lib/harness-detect.js';
 import { detectHumanInitiated } from '../lib/harness.js';
 import { TINYFISH_API_KEY_VAR } from '../lib/constants.js';
@@ -507,6 +508,9 @@ export async function connectOpenClaw(options) {
         }
     });
 }
+// 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,
@@ -522,6 +526,22 @@ const CONFIG_FILE_HARNESSES = {
             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,
+        },
+    },
 };
 /** Writes the harness's MCP config file itself; no `mcp add` exists. */
 async function connectConfigFileHarness(harness, options) {
@@ -629,6 +649,7 @@ function launchCursorDeeplink(mcpUrl) {
 }
 /** Total over the non-native harnesses: a new one fails to compile until wired here. */
 const LAUNCH_OVERRIDES = {
+    omp: launchOmpWalkthrough,
     openclaw: launchOpenClawWalkthrough,
     // Cursor has no chat CLI to launch.
     cursor: () => {
@@ -655,6 +676,20 @@ const CONNECTOR_OVERRIDES = {
         }
         return undefined;
     },
+    omp: async (options) => {
+        await connectConfigFileHarness('omp', options);
+        if (options.launch) {
+            try {
+                await launchOmpWalkthrough();
+            }
+            catch (error) {
+                // Post-settle, like the native walkthrough step: never fail the connect.
+                errLine(error instanceof Error ? error.message : String(error));
+                errLine(finishSetupHint('omp'));
+            }
+        }
+        return undefined;
+    },
 };
 function requireNative(harness) {
     const client = NATIVE_BY_HARNESS.get(harness);
@@ -764,7 +799,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); omit to pick from the agents detected on this machine')
+        .argument('[client]', 'Agent client to connect (claude-code, codex, cursor, grok, hermes, omp, 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')

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

@@ -2,6 +2,7 @@ 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 { HERMES_KEY_VAR, hermesEnvPath, removeHermesKey, resolveHermesHome } from './hermes-env.js';
 import { clearHermesWebBackends, HERMES_PLUGIN_SHA } from './hermes-plugin.js';
 import { HARNESS_DISPLAY_NAMES as DISPLAY_NAMES } from './harness-detect.js';
@@ -11,6 +12,8 @@ const OPENCODE_UNINSTALL_POINTER = 'remove the tinyfish entry from ~/.config/ope
 export function planText(harness, mcpUrl, apiKey) {
     if (harness === 'cursor')
         return planCursorWrite(mcpUrl, apiKey);
+    if (harness === 'omp')
+        return planOmpWrite(mcpUrl, apiKey);
     // Only the keyed path seeds the .env; a keyless Hermes install writes nothing.
     if (harness === 'hermes' && apiKey) {
         return (`would run \`tinyfish connect hermes\` (harness-owned MCP write; the CLI writes ` +
@@ -23,6 +26,9 @@ export function uninstallPlanText(harness) {
     if (harness === 'cursor') {
         return 'would remove the tinyfish entry from ~/.cursor/mcp.json';
     }
+    if (harness === 'omp') {
+        return "would remove the tinyfish entry from omp's mcp.json (located via `omp config path`)";
+    }
     if (!uninstallRuns(harness)) {
         return `would print \`${uninstallPointer(harness)}\` (no removal command exists)`;
     }
@@ -170,10 +176,21 @@ function uninstallViaCommands(detection, verbose, binaryOnPath) {
         fixCommand: `Retry by hand: ${uninstallPointer(harness)}`,
     };
 }
-function uninstallCursor(detection) {
+/** The CLI wrote these mcp.json entries, so it removes them. */
+const MCP_JSON_UNINSTALLS = {
+    cursor: {
+        remove: removeCursorMcpServer,
+        fix: 'Fix ~/.cursor/mcp.json by hand, then re-run: tinyfish connect --all --uninstall',
+    },
+    omp: {
+        remove: removeOmpMcpServer,
+        fix: "Fix omp's mcp.json (at `omp config path`) by hand, then re-run: tinyfish connect --all --uninstall",
+    },
+};
+function uninstallMcpJson(detection, spec) {
     let result;
     try {
-        result = removeCursorMcpServer();
+        result = spec.remove();
     }
     catch (e) {
         result = { status: 'corrupt_skip', error: e instanceof Error ? e.message : String(e) };
@@ -183,20 +200,21 @@ function uninstallCursor(detection) {
             ...detection,
             outcome: 'uninstalled',
             removalFailed: true,
-            errorMessage: `could not update Cursor's mcp.json (${result.error}) — nothing removed.`,
-            fixCommand: 'Fix ~/.cursor/mcp.json by hand, then re-run: tinyfish connect --all --uninstall',
+            errorMessage: `could not update ${DISPLAY_NAMES[detection.harness]}'s mcp.json (${result.error}) — nothing removed.`,
+            fixCommand: spec.fix,
         };
     }
     if (result.status === 'unchanged') {
         return { ...detection, outcome: 'uninstall_noop' };
     }
-    clearConnectContext('cursor');
+    clearConnectContext(detection.harness);
     return { ...detection, outcome: 'uninstalled' };
 }
 export function uninstallHarness(harness, configPath, verbose, binaryOnPath) {
     const detection = { harness, detected: true, configPath, installed: false };
-    const result = harness === 'cursor'
-        ? uninstallCursor(detection)
+    const mcpJson = MCP_JSON_UNINSTALLS[harness];
+    const result = mcpJson
+        ? uninstallMcpJson(detection, mcpJson)
         : uninstallViaCommands(detection, verbose, binaryOnPath);
     if (harness !== 'hermes')
         return result;

package/dist/lib/connect-all.js

@@ -143,7 +143,10 @@ function noWorkOutcome(d, uninstall) {
 }
 /** A config-writing connect needs no binary; every other harness spawns one. */
 function isStaleConfig(detection) {
-    return (detection.detected && !detection.binaryOnPath && !harnessSpec(detection.harness).cliWritesConfig);
+    const spec = harnessSpec(detection.harness);
+    // Cursor's IDE reads mcp.json binary-less; omp's path needs the binary.
+    const binaryless = spec.cliWritesConfig && !spec.configPathFromBinary;
+    return detection.detected && !detection.binaryOnPath && !binaryless;
 }
 async function resolvePick(detections, opts, prompt) {
     let deselected = new Set();
@@ -404,6 +407,7 @@ export const FIRST_TASK_PROMPT = 'My TinyFish setup just finished — verify it
 const LAUNCHERS = [
     { harness: 'cursor', args: [FIRST_TASK_PROMPT] },
     { harness: 'claude-code', args: [FIRST_TASK_PROMPT] },
+    { harness: 'omp', args: [FIRST_TASK_PROMPT] },
 ];
 async function launchFirstTask(results) {
     const candidates = LAUNCHERS.filter((l) => results.some((r) => r.harness === l.harness && r.installed) &&

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

@@ -95,11 +95,12 @@ export declare function hermesRegistrationEnabled(home: string): {
 };
 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" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code", NativeMcpClient>;
+export declare const NATIVE_BY_HARNESS: Map<"openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "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';
 /** Awaited before the handover; track+flush must land pre-block. */
 type OnWalkthroughDecided = (outcome: WalkthroughOutcome) => void | Promise<void>;
 export declare function launchNativeMcpClient(client: NativeMcpClient, onDecided?: OnWalkthroughDecided): Promise<WalkthroughOutcome>;
+export declare function launchOmpWalkthrough(onDecided?: OnWalkthroughDecided): Promise<WalkthroughOutcome>;
 export declare function launchOpenClawWalkthrough(onDecided?: OnWalkthroughDecided): Promise<WalkthroughOutcome>;

package/dist/lib/connect-clients.js

@@ -293,6 +293,10 @@ export async function launchNativeMcpClient(client, onDecided) {
         ? client.launchWalkthrough()
         : handOverTerminal(client.command, [DEFAULT_ONBOARDING_PROMPT], client.displayName), onDecided);
 }
+// Via deliverWalkthrough: handOverTerminal alone would wedge a headless --launch.
+export function launchOmpWalkthrough(onDecided) {
+    return deliverWalkthrough('omp', 'omp', DEFAULT_ONBOARDING_PROMPT, () => handOverTerminal('omp', [DEFAULT_ONBOARDING_PROMPT], 'omp'), onDecided);
+}
 export function launchOpenClawWalkthrough(onDecided) {
     return deliverWalkthrough('OpenClaw', 'openclaw', OPENCLAW_ONBOARDING_PROMPT, () => handOverTerminal('openclaw', ['chat', '--message', OPENCLAW_ONBOARDING_PROMPT], 'OpenClaw'), onDecided);
 }

package/dist/lib/doctor-repairs.js

@@ -1,10 +1,11 @@
 import spawn from 'cross-spawn';
 import { connectHarness } from '../commands/connect.js';
-import { Registered } from './harness-detect.js';
+import { ALL_HARNESSES, Registered } from './harness-detect.js';
+import { harnessSpec } from './harness-spec.js';
 import { detectHumanInitiated } from './harness.js';
 import { errLine } from './output.js';
-// Only Cursor's repair is a pure local file write; every other one needs a browser sign-in.
-const UNATTENDED_SAFE = new Set(['cursor']);
+// Config-file repairs are local writes; the rest need browser sign-in.
+const UNATTENDED_SAFE = new Set(ALL_HARNESSES.filter((harness) => harnessSpec(harness).cliWritesConfig));
 export function repairsFor(checks, statuses) {
     const repairs = [];
     // A revoked-but-well-formed key passes the credential check and fails the call; both need login.

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";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -41,6 +42,7 @@ declare const doctorCheckSchema: z.ZodObject<{
 declare const doctorHarnessSchema: z.ZodObject<{
     harness: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -66,6 +68,7 @@ declare const doctorRepairSchema: z.ZodObject<{
     }>;
     harness: z.ZodNullable<z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -93,6 +96,7 @@ export declare const doctorReportSchema: z.ZodObject<{
         detail: z.ZodString;
         harness: z.ZodNullable<z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";
@@ -109,6 +113,7 @@ export declare const doctorReportSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";
@@ -134,6 +139,7 @@ export declare const doctorReportSchema: z.ZodObject<{
         }>;
         harness: z.ZodNullable<z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";

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

@@ -68,6 +68,8 @@ export interface HarnessSpec {
     keyHeldByCli: boolean;
     /** Connect writes the MCP config file; no harness binary is spawned. */
     cliWritesConfig: boolean;
+    /** Binary resolves the config path; absent binary, nothing reads it. */
+    configPathFromBinary?: true;
     /** `mcp add` succeeds unauthenticated; OAuth lands at first tool use. */
     authDeferredAtInstall: boolean;
 }
@@ -199,6 +201,18 @@ export declare const HARNESS_SPECS: {
         cliWritesConfig: false;
         authDeferredAtInstall: false;
     };
+    omp: {
+        command: string;
+        displayName: string;
+        configDir: string;
+        reloadAction: string;
+        configPathFromBinary: true;
+        signInViaCliLogin: false;
+        canVerifyAuth: true;
+        keyHeldByCli: true;
+        cliWritesConfig: true;
+        authDeferredAtInstall: false;
+    };
     openclaw: {
         command: string;
         displayName: string;
@@ -252,4 +266,4 @@ export type NonNativeHarness = {
     [K in Harness]: 'urlStyle' extends keyof (typeof HARNESS_SPECS)[K] ? never : K;
 }[Harness];
 /** Native MCP harnesses carry add-generation fields; the rest override connect. */
-export declare const NATIVE_HARNESSES: ("openclaw" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code")[];
+export declare const NATIVE_HARNESSES: ("openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code")[];

package/dist/lib/harness-spec.js

@@ -183,6 +183,18 @@ export const HARNESS_SPECS = {
         cliWritesConfig: false,
         authDeferredAtInstall: false,
     },
+    omp: {
+        command: 'omp',
+        displayName: 'omp',
+        configDir: '.omp',
+        reloadAction: 'restart it',
+        configPathFromBinary: true,
+        signInViaCliLogin: false,
+        canVerifyAuth: true,
+        keyHeldByCli: true,
+        cliWritesConfig: true,
+        authDeferredAtInstall: false,
+    },
     openclaw: {
         command: 'openclaw',
         displayName: 'OpenClaw',

package/dist/lib/mcp-json-config.d.ts

@@ -20,6 +20,8 @@ export interface McpJsonServerEntry {
     /** Registered endpoint, so a caller can tell "registered" from "registered at the right place". */
     url?: string;
     keyMatchesCliKey?: boolean;
+    /** Whole-value `${VAR}` template: the variable name, never a key. */
+    keyTemplateVar?: string;
     error?: string;
 }
 /** Reports the header's shape, never its value. */

package/dist/lib/mcp-json-config.js

@@ -56,6 +56,8 @@ export function planWrite(target, mcpUrl, apiKey) {
         ? `${filePath}: would create with a "${target.serverKey}" MCP server entry${authNote}`
         : `${filePath}: would back up to a timestamped copy, then merge in the "${target.serverKey}" MCP server entry${authNote}`;
 }
+// omp expands `${VAR}` / `${VAR:-default}` header values at load.
+const ENV_TEMPLATE_VALUE = /^\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-[^}]*)?\}$/;
 /** Reports the header's shape, never its value. */
 export function readTinyfishEntry(target) {
     const existing = readExisting(target);
@@ -71,10 +73,12 @@ export function readTinyfishEntry(target) {
     const keyHeader = isPlainRecord(headers)
         ? Object.entries(headers).find((entry) => entry[0].toLowerCase() === 'x-api-key' && typeof entry[1] === 'string')
         : undefined;
+    const templateVar = keyHeader ? ENV_TEMPLATE_VALUE.exec(keyHeader[1])?.[1] : undefined;
     return {
         present: true,
         hasApiKeyHeader: keyHeader !== undefined,
         ...(matchesCliKey(keyHeader?.[1]) ? { keyMatchesCliKey: true } : {}),
+        ...(templateVar ? { keyTemplateVar: templateVar } : {}),
         ...(typeof entry.url === 'string' ? { url: entry.url } : {}),
     };
 }

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

@@ -0,0 +1,16 @@
+import { type McpJsonServerEntry, type McpJsonTarget, type McpJsonWriteResult } from './mcp-json-config.js';
+/** Tests share one process; the resolver result must not. */
+export declare function resetOmpAgentDirCache(): void;
+/** Profiles move the dir; a guessed path is written unread. */
+export declare function ompAgentDir(): string | undefined;
+/** Undefined means unresolved; connect fails closed via requireOmpTarget. */
+export declare function ompMcpTarget(): McpJsonTarget | undefined;
+export declare function ompMcpPath(): string;
+/** Reports the header's shape, never its value; undefined means unresolved. */
+export declare function readOmpTinyfishEntry(): McpJsonServerEntry | undefined;
+/** Merges only the `tinyfish` key; throws when the dir is unresolved. */
+export declare function writeOmpMcpConfig(mcpUrl: string, apiKey?: string): McpJsonWriteResult;
+/** Dry-run description of the pending write; touches nothing. */
+export declare function planOmpWrite(mcpUrl: string, apiKey?: string): string;
+/** Removes only the `tinyfish` key. */
+export declare function removeOmpMcpServer(): McpJsonWriteResult;

package/dist/lib/omp-config.js

@@ -0,0 +1,71 @@
+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 { 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.
+let cachedAgentDir;
+/** Tests share one process; the resolver result must not. */
+export function resetOmpAgentDirCache() {
+    cachedAgentDir = undefined;
+}
+/** Profiles move the dir; a guessed path is written unread. */
+export function ompAgentDir() {
+    cachedAgentDir ??= { dir: resolveAgentDir() };
+    return cachedAgentDir.dir;
+}
+function resolveAgentDir() {
+    const result = spawn.sync('omp', ['config', 'path'], {
+        encoding: 'utf8',
+        timeout: HARNESS_PROBE_TIMEOUT_MS,
+    });
+    if (result.error || result.status !== 0)
+        return undefined;
+    const dir = (result.stdout ?? '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .at(-1);
+    return dir && path.isAbsolute(dir) ? dir : undefined;
+}
+/** Undefined means unresolved; connect fails closed via requireOmpTarget. */
+export function ompMcpTarget() {
+    const dir = ompAgentDir();
+    if (!dir)
+        return undefined;
+    return { serverKey: 'tinyfish', dir: () => dir, file: () => path.join(dir, 'mcp.json') };
+}
+function requireOmpTarget() {
+    const target = ompMcpTarget();
+    if (target)
+        return target;
+    throw new ConnectStepError("Could not locate omp's config directory: `omp config path` did not print one. " +
+        'Check that omp is installed and `omp config path` works, then re-run: tinyfish connect omp', 'invalid_config', { failureDetail: 'omp_agent_dir_unresolved' });
+}
+export function ompMcpPath() {
+    return requireOmpTarget().file();
+}
+/** Reports the header's shape, never its value; undefined means unresolved. */
+export function readOmpTinyfishEntry() {
+    const target = ompMcpTarget();
+    return target ? readTinyfishEntry(target) : undefined;
+}
+/** Merges only the `tinyfish` key; throws when the dir is unresolved. */
+export function writeOmpMcpConfig(mcpUrl, apiKey) {
+    return writeMcpConfig(requireOmpTarget(), mcpUrl, apiKey);
+}
+/** Dry-run description of the pending write; touches nothing. */
+export function planOmpWrite(mcpUrl, apiKey) {
+    const target = ompMcpTarget();
+    if (!target)
+        return `${UNRESOLVED_REASON} — connect omp would fail the same way`;
+    return planWrite(target, mcpUrl, apiKey);
+}
+/** Removes only the `tinyfish` key. */
+export function removeOmpMcpServer() {
+    const target = ompMcpTarget();
+    if (!target)
+        return { status: 'corrupt_skip', error: UNRESOLVED_REASON };
+    return removeServer(target);
+}

package/dist/lib/registration-detect.js

@@ -7,6 +7,7 @@ import { NATIVE_BY_HARNESS } from './connect-clients.js';
 import { HARNESS_PROBE_TIMEOUT_MS } from './constants.js';
 import { errLine } from './output.js';
 import { readCursorTinyfishEntry } from './cursor-config.js';
+import { readOmpTinyfishEntry } from './omp-config.js';
 import { readHermesKey, resolveHermesHome } from './hermes-env.js';
 import { readHermesEntry } from './hermes-config.js';
 import { detectInstalledHarnesses, harnessConfigPath, harnessDisplayPath, AuthMode, Registered, } from './harness-detect.js';
@@ -293,6 +294,38 @@ function probeCursor() {
         ...(entry.keyMatchesCliKey ? { keyMatchesCliKey: true } : {}),
     };
 }
+// omp shares Cursor's mcp.json shape; only `omp config path` resolves it.
+function probeOmp() {
+    const entry = readOmpTinyfishEntry();
+    if (!entry) {
+        return {
+            registered: Registered.Unknown,
+            authMode: AuthMode.Unknown,
+            reason: '`omp config path` did not report a config directory',
+        };
+    }
+    if (entry.error) {
+        return {
+            registered: Registered.Unknown,
+            authMode: AuthMode.Unknown,
+            reason: 'mcp.json exists but could not be read or parsed',
+        };
+    }
+    if (!entry.present)
+        return { registered: Registered.No, authMode: AuthMode.Unknown };
+    // A hand-written `${VAR}` header resolves like Codex's env-var key.
+    const keyVerdict = entry.keyTemplateVar
+        ? envKeyVerdict(entry.keyTemplateVar)
+        : entry.keyMatchesCliKey
+            ? { keyMatchesCliKey: true }
+            : {};
+    return {
+        registered: Registered.Yes,
+        authMode: entry.hasApiKeyHeader ? AuthMode.ApiKey : AuthMode.Unknown,
+        ...(entry.url ? { registeredUrl: entry.url } : {}),
+        ...keyVerdict,
+    };
+}
 // Both list commands print this header in every state, including "no servers configured".
 // Exit 0 with output we cannot recognise is not evidence of absence: reporting `no` there would
 // earn a connect repair off a parse failure, which is the bug class this command exists to kill.
@@ -486,6 +519,7 @@ const PROBES = {
     cursor: probeCursor,
     grok: probeGrok,
     hermes: probeHermes,
+    omp: probeOmp,
     openclaw: probeOpenClaw,
     opencode: probeOpencode,
 };

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

@@ -26,6 +26,7 @@ export declare function postConnectEvent(options: {
 declare const harnessResultSchema: z.ZodObject<{
     harness: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -59,6 +60,7 @@ export declare const setupCompletedPayloadSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";
@@ -91,7 +93,7 @@ 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, mode?: SetupMode, attemptId?: string): Promise<void>;
-export declare const DOCTOR_HARNESS_SCOPES: readonly ["all", ...("openclaw" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code")[]];
+export declare const DOCTOR_HARNESS_SCOPES: readonly ["all", ...("openclaw" | "omp" | "grok" | "cursor" | "codex" | "hermes" | "opencode" | "claude-code")[]];
 export declare const DOCTOR_ERROR_CLASSES: readonly ["command_not_found", "timeout", "spawn_error", "nonzero_exit", "unexpected_error"];
 export type DoctorErrorClass = (typeof DOCTOR_ERROR_CLASSES)[number];
 /** Derived, not read: the catch is generic, so only the code is trustworthy. */
@@ -120,6 +122,7 @@ export declare const doctorCompletedPayloadSchema: z.ZodObject<{
     }>;
     harness_scope: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -132,6 +135,7 @@ export declare const doctorCompletedPayloadSchema: z.ZodObject<{
     failed_check_ids: z.ZodArray<z.ZodString>;
     failed_harnesses: z.ZodArray<z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -142,6 +146,7 @@ export declare const doctorCompletedPayloadSchema: z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";
@@ -174,6 +179,7 @@ export declare const doctorCouldNotRunPayloadSchema: z.ZodObject<{
     }>;
     harness_scope: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -209,6 +215,7 @@ declare const doctorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     harness_scope: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -221,6 +228,7 @@ declare const doctorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     failed_check_ids: z.ZodArray<z.ZodString>;
     failed_harnesses: z.ZodArray<z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";
@@ -231,6 +239,7 @@ declare const doctorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     harnesses: z.ZodArray<z.ZodObject<{
         harness: z.ZodEnum<{
             openclaw: "openclaw";
+            omp: "omp";
             grok: "grok";
             cursor: "cursor";
             codex: "codex";
@@ -262,6 +271,7 @@ declare const doctorPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }>;
     harness_scope: z.ZodEnum<{
         openclaw: "openclaw";
+        omp: "omp";
         grok: "grok";
         cursor: "cursor";
         codex: "codex";

package/package.json

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