@tiny-fish/cli 0.39.1-next.309 → 0.39.1-next.311

package/dist/lib/client.js

@@ -108,6 +108,9 @@ function createSdkClient(apiKey, timeout, baseUrl) {
         ...(timeout !== undefined ? { timeout } : {}),
     });
 }
+function sdk(apiKey, call) {
+    return call(createSdkClient(apiKey)).catch(rethrowSdkError);
+}
 function rethrowSdkError(error) {
     if (error instanceof APIStatusError) {
         throw new ApiError(error.statusCode, error.message);
@@ -136,14 +139,8 @@ const batchGetResponseSchema = z.object({
     data: z.array(runSchema),
     not_found: z.array(z.string()).nullable(),
 });
-const batchCancelResultSchema = z.object({
-    run_id: z.string(),
-    status: z.string(),
-    cancelled_at: z.string().nullable(),
-    message: z.string().nullable(),
-});
 const batchCancelResponseSchema = z.object({
-    results: z.array(batchCancelResultSchema),
+    results: z.array(cancelRunResponseSchema),
     not_found: z.array(z.string()).nullable(),
 });
 const runStepSchema = z.object({
@@ -219,27 +216,21 @@ async function* parseSseStream(stream) {
         reader.releaseLock();
     }
 }
-export async function runSync(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run', {
+export function runSync(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run', {
             json: req,
         });
         return parseWithSchema(agentRunResponseSchema, response, 'Invalid agent run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function runAsync(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run-async', {
+export function runAsync(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run-async', {
             json: req,
         });
         return parseWithSchema(agentRunAsyncResponseSchema, response, 'Invalid async run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 export async function* runStream(req, apiKey, signal) {
     let stream = null;
@@ -268,110 +259,75 @@ export async function* runStream(req, apiKey, signal) {
         }
     }
 }
-export async function listRuns(opts, apiKey, timeout, baseUrl) {
-    try {
-        return await createSdkClient(apiKey, timeout, baseUrl).runs.list(opts);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function listRuns(opts, apiKey, timeout, baseUrl) {
+    return createSdkClient(apiKey, timeout, baseUrl).runs.list(opts).catch(rethrowSdkError);
 }
-export async function getRun(runId, apiKey) {
-    try {
-        return await createSdkClient(apiKey).runs.get(runId);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function getRun(runId, apiKey) {
+    return sdk(apiKey, (client) => client.runs.get(runId));
 }
-export async function getRunSteps(runId, apiKey) {
-    try {
+export function getRunSteps(runId, apiKey) {
+    return sdk(apiKey, async (client) => {
         // The public GET /v1/runs/:id route returns the base run payload plus `steps`;
         // the installed SDK runSchema only models the base run, so steps need this local schema.
-        const response = await createSdkClient(apiKey).get(`/v1/runs/${encodeURIComponent(runId)}`, { params: { screenshots: 'none' } });
+        const response = await client.get(`/v1/runs/${encodeURIComponent(runId)}`, {
+            params: { screenshots: 'none' },
+        });
         return parseWithSchema(runStepsResponseSchema, response, 'Invalid run steps response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function searchQuery(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).search.query(params);
+export function searchQuery(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.search.query(params);
         return searchQueryResponseSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function fetchContentGet(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).fetch.getContents(params);
+export function fetchContentGet(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.fetch.getContents(params);
         return fetchResponseSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function browserSessionCreate(params, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/browser', { json: params });
+export function browserSessionCreate(params, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/browser', { json: params });
         return browserSessionSchema.parse(response);
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function cancelRun(runId, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, { json: {} });
+export function cancelRun(runId, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
+            json: {},
+        });
         return parseWithSchema(cancelRunResponseSchema, response, 'Invalid cancel run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 // ── Wallet ──────────────────────────────────────────────────────────────────
-export async function getWallet(apiKey) {
-    try {
-        return await createSdkClient(apiKey).wallet.get();
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+export function getWallet(apiKey) {
+    return sdk(apiKey, (client) => client.wallet.get());
 }
-export async function submitBatch(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/automation/run-batch', {
+export function submitBatch(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/automation/run-batch', {
             json: req,
         });
         return parseWithSchema(batchRunResponseSchema, response, 'Invalid batch run response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function getBatchRuns(runIds, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/runs/batch', {
+export function getBatchRuns(runIds, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/runs/batch', {
             json: { run_ids: runIds },
         });
         return parseWithSchema(batchGetResponseSchema, response, 'Invalid batch get response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function cancelBatchRuns(runIds, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/runs/batch/cancel', {
+export function cancelBatchRuns(runIds, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/runs/batch/cancel', {
             json: { run_ids: runIds },
         });
         return parseWithSchema(batchCancelResponseSchema, response, 'Invalid batch cancel response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 const profileCreateResponseSchema = z.object({
     id: z.string(),
@@ -384,25 +340,19 @@ const profileUploadResponseSchema = z.object({
     domains_updated: z.array(z.string()),
     domains_failed: z.array(z.string()).optional(),
 });
-export async function profileCreate(name, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/profiles', {
+export function profileCreate(name, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/profiles', {
             json: { name },
         });
         return parseWithSchema(profileCreateResponseSchema, response, 'Invalid profile create response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function profileUpload(profileId, cookies, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post(`/v1/profiles/${encodeURIComponent(profileId)}/upload`, { json: { cookies } });
+export function profileUpload(profileId, cookies, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post(`/v1/profiles/${encodeURIComponent(profileId)}/upload`, { json: { cookies } });
         return parseWithSchema(profileUploadResponseSchema, response, 'Invalid profile upload response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
 // ── Vault ───────────────────────────────────────────────────────────────────
 // /v1/vault/* returns camelCase fields (unlike the snake_case rest of the API).
@@ -451,52 +401,37 @@ const vaultItemsSyncResponseSchema = z.object({
         removed: z.number(),
     }),
 });
-export async function vaultConnections(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).get('/v1/vault/connections');
+export function vaultConnections(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.get('/v1/vault/connections');
         return parseWithSchema(vaultConnectionsListResponseSchema, response, 'Invalid vault connections response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultConnect(req, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/vault/connections', {
+export function vaultConnect(req, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/vault/connections', {
             json: req,
         });
         return parseWithSchema(vaultConnectResponseSchema, response, 'Invalid vault connect response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultDisconnect(connectionId, apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).del(`/v1/vault/connections/${encodeURIComponent(connectionId)}`);
+export function vaultDisconnect(connectionId, apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.del(`/v1/vault/connections/${encodeURIComponent(connectionId)}`);
         return parseWithSchema(vaultDisconnectResponseSchema, response, 'Invalid vault disconnect response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultItems(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).get('/v1/vault/items');
+export function vaultItems(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.get('/v1/vault/items');
         return parseWithSchema(vaultItemsListResponseSchema, response, 'Invalid vault items response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }
-export async function vaultSync(apiKey) {
-    try {
-        const response = await createSdkClient(apiKey).post('/v1/vault/items/sync', {
+export function vaultSync(apiKey) {
+    return sdk(apiKey, async (client) => {
+        const response = await client.post('/v1/vault/items/sync', {
             json: {},
         });
         return parseWithSchema(vaultItemsSyncResponseSchema, response, 'Invalid vault sync response');
-    }
-    catch (error) {
-        rethrowSdkError(error);
-    }
+    });
 }

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

@@ -19,7 +19,7 @@ const NO_BROWSER_REASONS = new Set([
 // Derived: these block `connect` on a browser sign-in when keyless.
 const BROWSER_SIGN_IN = new Set(ALL_HARNESSES.filter((harness) => {
     const native = NATIVE_BY_HARNESS.get(harness);
-    return !!native?.loginArgs || !!native?.oauthInAdd;
+    return !!native?.loginArgs;
 }));
 // Derived: these refuse a keyless install, so no sign-in helps.
 const KEY_REQUIRED = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyRequired));

package/dist/lib/connect-all.js

@@ -7,7 +7,6 @@ import { installTinyFishCli, } from './cli-install.js';
 import { authGate, mapConnectError, OAUTH_SIGN_IN_TIMEOUT_MS } from './connect-all-auth.js';
 import { actionable, computeExitCode, reloadHint, renderSummary } from './connect-all-summary.js';
 import { planText, uninstallHarness, uninstallPlanText } from './connect-all-uninstall.js';
-import { NATIVE_BY_HARNESS } from './connect-clients.js';
 import { createStdinPrompt, runCliFallback } from './connect-fallback.js';
 import { gateApiKey } from './connect-preflight.js';
 import { ConnectInterruptedError } from './connect-runtime.js';
@@ -19,21 +18,6 @@ import { errLine, outLine, setErrIndent } from './output.js';
 import { sendSetupCompleted, sendSetupStarted, } from './setup-telemetry.js';
 import { verifyMcpAuth, verifyMcpHealth } from './verify.js';
 const STEP_INDENT = '  ';
-// Derived: a native add carries the key, or the CLI holds it itself.
-const KEY_AUTH_CAPABLE = new Set(ALL_HARNESSES.filter((harness) => !!NATIVE_BY_HARNESS.get(harness)?.keyAuth || harnessSpec(harness).keyHeldByCli));
-async function runHarnessConnect(harness, opts, extras) {
-    return connectHarness(harness, {
-        apiKey: opts.apiKey,
-        mcpUrl: opts.mcpUrl,
-        launch: false,
-        keyAuthOnly: extras.keyAuthOnly,
-        authTimeoutMs: extras.authTimeoutMs,
-        hoistedCliInstall: extras.hoistedCliInstall,
-        onPostInstallFailed: extras.onPostInstallFailed,
-        verbose: opts.verbose,
-        deferOutro: extras.deferOutro,
-    });
-}
 /** Undefined means Ctrl+C: the caller stops the whole run. */
 function runHoistedCliInstall(verbose) {
     const startedAt = Date.now();
@@ -90,8 +74,8 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
         return settled;
     const isTTY = detectHumanInitiated();
     const apiKey = validatedApiKey(opts.apiKey);
-    // A key only leaves the own-OAuth set where the harness can actually carry one.
-    const keyed = !!apiKey && KEY_AUTH_CAPABLE.has(harness);
+    // All harnesses carry a key; one that cannot fails harness_too_old.
+    const keyed = !!apiKey;
     const fixCommand = `tinyfish connect ${harness}`;
     const gate = await authGate(base, oauthBudget, fixCommand, { prompt, isTTY, keyed });
     if (gate.result)
@@ -103,7 +87,11 @@ async function processHarness(detection, opts, prompt, oauthBudget, hoistedCliIn
     let postInstallFailed = false;
     try {
         // A keyed install too old for key auth fails, no browser.
-        authMode = await runHarnessConnect(harness, opts, {
+        authMode = await connectHarness(harness, {
+            apiKey: opts.apiKey,
+            mcpUrl: opts.mcpUrl,
+            launch: false,
+            verbose: opts.verbose,
             keyAuthOnly: keyed && !isTTY,
             authTimeoutMs: headlessAuth ? OAUTH_SIGN_IN_TIMEOUT_MS : undefined,
             hoistedCliInstall,
@@ -337,10 +325,6 @@ export async function runConnectAll(opts) {
     const prompt = isTTY ? createStdinPrompt() : undefined;
     const detections = detectInstalledHarnesses();
     const gateKey = validatedApiKey(opts.apiKey);
-    // Keyed installs first: working tools land before sign-ins can block.
-    if (gateKey) {
-        detections.sort((a, b) => Number(KEY_AUTH_CAPABLE.has(b.harness)) - Number(KEY_AUTH_CAPABLE.has(a.harness)));
-    }
     const pick = await resolvePick(detections, opts, prompt);
     if (pick.cancelled) {
         // Before summary and telemetry: an explicit nothing is not a setup.
@@ -349,10 +333,7 @@ export async function runConnectAll(opts) {
     }
     const { deselected, mode } = pick;
     // Mirrors processHarness's gate: headless, only keyless CLI-login harnesses skip.
-    const willAttempt = (harness) => !deselected.has(harness) &&
-        (isTTY ||
-            !harnessSpec(harness).signInViaCliLogin ||
-            (!!gateKey && KEY_AUTH_CAPABLE.has(harness)));
+    const willAttempt = (harness) => !deselected.has(harness) && (isTTY || !harnessSpec(harness).signInViaCliLogin || !!gateKey);
     const hoisted = hoistCliIfNeeded(detections, opts, willAttempt);
     if (hoisted === 'interrupted') {
         errLine('Setup interrupted — run the command again to finish.');

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

@@ -18,7 +18,7 @@ export declare const CURSOR_SKILL_TARGET: {
     readonly displayName: string;
 };
 /** The harness reads the key from its own store. */
-export interface SeededInstall {
+interface SeededInstall {
     /** Pins the add child at the home the key landed in. */
     env: typeof process.env;
     /** Answers prompts `mcp add` still asks once the key is seeded. */
@@ -45,8 +45,6 @@ interface BaseMcpClient extends SupportedCommand, Pick<HarnessSpec, 'skillAgent'
         seedKey?: (apiKey: string) => SeededInstall;
     };
     loginArgs?: string[];
-    /** Keyless `mcp add` itself blocks on the browser OAuth. */
-    oauthInAdd?: boolean;
     removals: {
         args: string[];
         label: string;
@@ -69,17 +67,16 @@ interface BaseMcpClient extends SupportedCommand, Pick<HarnessSpec, 'skillAgent'
     };
 }
 /** Keyless installs use this argv; the harness signs itself in. */
-export interface OauthCapableMcpClient extends BaseMcpClient {
+interface OauthCapableMcpClient extends BaseMcpClient {
     keyRequired?: false;
     addArgs: (mcpUrl: string) => string[];
 }
 /** No sign-in exists here, so connect refuses a keyless install (Hermes). */
-export interface KeyRequiredMcpClient extends BaseMcpClient {
+interface KeyRequiredMcpClient extends BaseMcpClient {
     keyRequired: true;
     keyAuth: NonNullable<BaseMcpClient['keyAuth']>;
     /** Restoring any of these three would restore the OAuth fallback. */
     addArgs?: never;
-    oauthInAdd?: never;
     loginArgs?: never;
 }
 export type NativeMcpClient = OauthCapableMcpClient | KeyRequiredMcpClient;

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

@@ -4,7 +4,7 @@ export declare const SEARCH_RETRY = "tinyfish search query --pretty -- \"<your q
 export declare const DEFAULT_VERIFICATION_QUERY = "today's top Hacker News story";
 export declare const MALFORMED_ENV_KEY_MESSAGE = "TINYFISH_API_KEY is set but malformed; it will override any stored key. Fix or unset it, then re-run.";
 export declare const MALFORMED_STORED_KEY_MESSAGE = "The stored TinyFish API key is malformed. Run: tinyfish auth login";
-export interface CliFallbackHooks {
+interface CliFallbackHooks {
     onStepStart?: (stage: ConnectFailureStage) => void;
     onStepDone?: (phase: ConnectCheckpoint) => void;
 }
@@ -22,3 +22,4 @@ export interface CliFallbackOptions {
 export declare function createStdinPrompt(): Prompt;
 /** Steps print retry lines and return outcomes; only interrupts throw. */
 export declare function runCliFallback(opts: CliFallbackOptions): Promise<CliFallbackOutcome>;
+export {};

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

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

package/dist/lib/connect-runtime.js

@@ -49,8 +49,6 @@ export function stageDurationOf(error) {
     const value = error?.stageDurationMs;
     return typeof value === 'number' ? value : undefined;
 }
-class PrerequisiteError extends ConnectStepError {
-}
 /** A bounded sign-in wait elapsed — unfinished, not broken. */
 export class SignInTimeoutError extends ConnectStepError {
     constructor(message, cause) {
@@ -190,7 +188,7 @@ function throwProbeFailure(client, result) {
             `${probeTimeoutMs(client) / 1000}s. Retry.`, 'timeout', { cause: result.error });
     }
     // It ran and exited non-zero, so the version is still answerable.
-    throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', { cause: result.error, harnessVersion: probeHarnessVersion(client) });
+    throw new ConnectStepError(client.supportCheck.unavailableMessage, 'harness_command_unsupported', { cause: result.error, harnessVersion: probeHarnessVersion(client) });
 }
 function supportProbeOutput(client) {
     const result = spawn.sync(client.command, client.supportCheck.args, {
@@ -201,7 +199,7 @@ function supportProbeOutput(client) {
     });
     // 127 is the shell's not-found code; a wrapper shim with no real binary behind it exits that.
     if (commandNotFound(result.error) || result.status === 127) {
-        throw new PrerequisiteError(`${client.displayName} is not installed or not available on PATH.`, 'harness_not_installed', { cause: result.error });
+        throw new ConnectStepError(`${client.displayName} is not installed or not available on PATH.`, 'harness_not_installed', { cause: result.error });
     }
     if (result.error || result.status !== 0) {
         throwProbeFailure(client, result);
@@ -218,7 +216,7 @@ function requireEssential(client, output) {
     if (client.supportCheck.patterns.every((pattern) => pattern.test(output)))
         return;
     debugProbeOutput(client, output);
-    throw new PrerequisiteError(client.supportCheck.unavailableMessage, 'harness_too_old', {
+    throw new ConnectStepError(client.supportCheck.unavailableMessage, 'harness_too_old', {
         harnessVersion: probeHarnessVersion(client),
     });
 }
@@ -235,7 +233,7 @@ function resolveVariant(client, output) {
         return undefined;
     // Unacknowledged policy warnings can block the install; fail before it does.
     debugProbeOutput(client, output);
-    throw new PrerequisiteError(`${client.displayName} lists \`${unknown}\`, which this TinyFish CLI does not recognise. ` +
+    throw new ConnectStepError(`${client.displayName} lists \`${unknown}\`, which this TinyFish CLI does not recognise. ` +
         'Upgrade the TinyFish CLI with `tinyfish upgrade` and retry.', 'harness_too_old', { harnessVersion: probeHarnessVersion(client) });
 }
 /** Refresh paths need the advertised alternative without connect's version probe. */

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

@@ -67,17 +67,17 @@ export interface HarnessSpec {
     /** Printed after a successful connect, on both the launch and non-launch paths. */
     postConnectNote?: string;
     /** Sign-in is the CLI's own interactive `tinyfish auth login`. */
-    signInViaCliLogin: boolean;
+    signInViaCliLogin?: true;
     /** Stored-key auth verification works against this harness's config. */
-    canVerifyAuth: boolean;
+    canVerifyAuth?: true;
     /** The CLI holds or writes the key; no harness `mcp add` carries it. */
-    keyHeldByCli: boolean;
+    keyHeldByCli?: true;
     /** Connect writes the MCP config file; no harness binary is spawned. */
-    cliWritesConfig: boolean;
+    cliWritesConfig?: true;
     /** Binary resolves the config path; absent binary, nothing reads it. */
     configPathFromBinary?: true;
     /** `mcp add` succeeds unauthenticated; OAuth lands at first tool use. */
-    authDeferredAtInstall: boolean;
+    authDeferredAtInstall?: true;
 }
 /** One entry per harness; every per-harness list derives from it. */
 export declare const HARNESS_SPECS: {
@@ -110,11 +110,6 @@ export declare const HARNESS_SPECS: {
             args: string[];
             label: string;
         }[];
-        signInViaCliLogin: false;
-        canVerifyAuth: false;
-        keyHeldByCli: false;
-        cliWritesConfig: false;
-        authDeferredAtInstall: false;
     };
     codex: {
         command: string;
@@ -136,10 +131,6 @@ export declare const HARNESS_SPECS: {
             deferred: string;
         };
         loginArgs: string[];
-        signInViaCliLogin: false;
-        canVerifyAuth: false;
-        keyHeldByCli: false;
-        cliWritesConfig: false;
         authDeferredAtInstall: true;
     };
     cursor: {
@@ -148,11 +139,9 @@ export declare const HARNESS_SPECS: {
         configDir: string;
         reloadAction: string;
         skillAgent: "cursor";
-        signInViaCliLogin: false;
         canVerifyAuth: true;
         keyHeldByCli: true;
         cliWritesConfig: true;
-        authDeferredAtInstall: false;
     };
     grok: {
         command: string;
@@ -175,11 +164,6 @@ export declare const HARNESS_SPECS: {
             viaEnv: true;
         };
         signInHint: string;
-        signInViaCliLogin: false;
-        canVerifyAuth: false;
-        keyHeldByCli: false;
-        cliWritesConfig: false;
-        authDeferredAtInstall: false;
     };
     hermes: {
         command: string;
@@ -201,11 +185,7 @@ export declare const HARNESS_SPECS: {
             label: string;
         };
         postConnectNote: string;
-        signInViaCliLogin: false;
-        canVerifyAuth: false;
         keyHeldByCli: true;
-        cliWritesConfig: false;
-        authDeferredAtInstall: false;
     };
     omp: {
         command: string;
@@ -213,11 +193,9 @@ export declare const HARNESS_SPECS: {
         configDir: string;
         reloadAction: string;
         configPathFromBinary: true;
-        signInViaCliLogin: false;
         canVerifyAuth: true;
         keyHeldByCli: true;
         cliWritesConfig: true;
-        authDeferredAtInstall: false;
     };
     openclaw: {
         command: string;
@@ -235,8 +213,6 @@ export declare const HARNESS_SPECS: {
         signInViaCliLogin: true;
         canVerifyAuth: true;
         keyHeldByCli: true;
-        cliWritesConfig: false;
-        authDeferredAtInstall: false;
     };
     opencode: {
         command: string;
@@ -259,11 +235,6 @@ export declare const HARNESS_SPECS: {
         loginArgs: string[];
         removals: never[];
         postConnectNote: string;
-        signInViaCliLogin: false;
-        canVerifyAuth: false;
-        keyHeldByCli: false;
-        cliWritesConfig: false;
-        authDeferredAtInstall: false;
     };
 };
 /** Derived from spec keys; one entry extends every union. */