@stigg/terminal 0.0.1-alpha

package/dist/launch/agent.d.ts

@@ -0,0 +1,55 @@
+import type { HostAgent } from '../headless/host-agent.js';
+import type { ClientId } from '../types.js';
+/**
+ * The subset of {@link ClientId}s we can launch as a foreground CLI agent that
+ * inherits this terminal. GUI clients (`claude-desktop`, `vscode`) are excluded —
+ * they can't take over the TTY.
+ */
+export type LaunchableAgentId = 'claude-code' | 'codex' | 'cursor';
+export interface LaunchableAgent {
+    id: LaunchableAgentId;
+    name: string;
+}
+export interface LaunchRequest {
+    agentId: LaunchableAgentId;
+    /** Seed message passed to the agent as its first user turn. */
+    prompt: string;
+    /** When true, pass the agent's permission-bypass flag. */
+    skipPermissions: boolean;
+}
+export declare function agentName(id: LaunchableAgentId): string;
+export declare function skipPermissionFlag(id: LaunchableAgentId): string;
+/**
+ * Resolve the launch binary for an agent, or `null` when it isn't available.
+ *
+ * - `claude-code` reuses {@link findClaudeBinary} (known install paths + PATH,
+ *   honoring `STIGG_CLAUDE_BINARY`).
+ * - `codex` / `cursor` honor a `STIGG_*_BINARY` override (unset → real lookup,
+ *   empty string → treat as not found, any other value → that path) and
+ *   otherwise probe PATH. Note this is independent of the MCP client's
+ *   `isClientSupported()` — e.g. Cursor the IDE can be installed without the
+ *   `cursor-agent` CLI being on PATH.
+ */
+export declare function resolveAgentBinary(id: LaunchableAgentId): string | null;
+/** All agents whose launch binary is currently resolvable, in preference order. */
+export declare function listLaunchableAgents(): LaunchableAgent[];
+/**
+ * Pick which agent to preselect in the launch picker: the host agent if it's
+ * launchable, else the first configured client that's launchable, else the
+ * first available agent. Returns `undefined` only when nothing is launchable.
+ */
+export declare function chooseDefaultAgent(hostAgent: HostAgent | null, selectedClients: ClientId[] | undefined, launchable: LaunchableAgent[]): LaunchableAgentId | undefined;
+/**
+ * Spawn the agent so it inherits this terminal, seeded with `prompt` as its
+ * first user message. Resolves with the child's exit code; rejects if the
+ * binary can't be found or fails to spawn.
+ *
+ * MUST be called only after the Ink TUI has fully unmounted and restored the
+ * terminal (see `start-tui.ts`) — never while Ink owns the TTY.
+ */
+export declare function launchAgent(req: LaunchRequest): Promise<number>;
+/**
+ * Best-effort copy to the system clipboard. Resolves `false` when no clipboard
+ * tool is available (the caller should then fall back to showing the text).
+ */
+export declare function copyPromptToClipboard(text: string): Promise<boolean>;

package/dist/launch/agent.js

@@ -0,0 +1,134 @@
+import { execFileSync, spawn } from 'node:child_process';
+import { findClaudeBinary } from '../mcp/clients/claude-code.js';
+const AGENT_NAMES = {
+    'claude-code': 'Claude Code',
+    codex: 'Codex',
+    cursor: 'Cursor',
+};
+const AGENT_BINARIES = {
+    'claude-code': 'claude',
+    codex: 'codex',
+    cursor: 'cursor-agent',
+};
+/** Flag that disables the agent's interactive permission prompts. */
+const AGENT_SKIP_PERMISSION_FLAGS = {
+    'claude-code': '--dangerously-skip-permissions',
+    codex: '--yolo',
+    cursor: '--force',
+};
+/** Stable display/preference order. */
+const LAUNCHABLE_ORDER = ['claude-code', 'codex', 'cursor'];
+/** Env override that lets tests stand in a fake binary, mirroring STIGG_CLAUDE_BINARY. */
+const BINARY_OVERRIDE_ENV = {
+    codex: 'STIGG_CODEX_BINARY',
+    cursor: 'STIGG_CURSOR_AGENT_BINARY',
+};
+export function agentName(id) {
+    return AGENT_NAMES[id];
+}
+export function skipPermissionFlag(id) {
+    return AGENT_SKIP_PERMISSION_FLAGS[id];
+}
+/**
+ * POSIX `command -v` existence check. Windows is out of scope for agent launch
+ * (the binaries here are POSIX CLIs and detection relies on `sh`).
+ */
+function commandExists(cmd) {
+    try {
+        execFileSync('sh', ['-c', `command -v ${cmd}`], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the launch binary for an agent, or `null` when it isn't available.
+ *
+ * - `claude-code` reuses {@link findClaudeBinary} (known install paths + PATH,
+ *   honoring `STIGG_CLAUDE_BINARY`).
+ * - `codex` / `cursor` honor a `STIGG_*_BINARY` override (unset → real lookup,
+ *   empty string → treat as not found, any other value → that path) and
+ *   otherwise probe PATH. Note this is independent of the MCP client's
+ *   `isClientSupported()` — e.g. Cursor the IDE can be installed without the
+ *   `cursor-agent` CLI being on PATH.
+ */
+export function resolveAgentBinary(id) {
+    if (id === 'claude-code')
+        return findClaudeBinary();
+    const envVar = BINARY_OVERRIDE_ENV[id];
+    if (envVar in process.env) {
+        const override = process.env[envVar];
+        return override ? override : null;
+    }
+    const binary = AGENT_BINARIES[id];
+    return commandExists(binary) ? binary : null;
+}
+/** All agents whose launch binary is currently resolvable, in preference order. */
+export function listLaunchableAgents() {
+    return LAUNCHABLE_ORDER.filter((id) => resolveAgentBinary(id) !== null).map((id) => ({
+        id,
+        name: AGENT_NAMES[id],
+    }));
+}
+/**
+ * Pick which agent to preselect in the launch picker: the host agent if it's
+ * launchable, else the first configured client that's launchable, else the
+ * first available agent. Returns `undefined` only when nothing is launchable.
+ */
+export function chooseDefaultAgent(hostAgent, selectedClients, launchable) {
+    if (launchable.length === 0)
+        return undefined;
+    const available = new Set(launchable.map((a) => a.id));
+    const isLaunchable = (id) => available.has(id) && LAUNCHABLE_ORDER.includes(id);
+    if (hostAgent && isLaunchable(hostAgent.id))
+        return hostAgent.id;
+    const fromSelected = selectedClients?.find(isLaunchable);
+    if (fromSelected)
+        return fromSelected;
+    return launchable[0].id;
+}
+/**
+ * Spawn the agent so it inherits this terminal, seeded with `prompt` as its
+ * first user message. Resolves with the child's exit code; rejects if the
+ * binary can't be found or fails to spawn.
+ *
+ * MUST be called only after the Ink TUI has fully unmounted and restored the
+ * terminal (see `start-tui.ts`) — never while Ink owns the TTY.
+ */
+export function launchAgent(req) {
+    const binary = resolveAgentBinary(req.agentId);
+    if (!binary) {
+        return Promise.reject(new Error(`${AGENT_NAMES[req.agentId]} CLI ("${AGENT_BINARIES[req.agentId]}") was not found on your PATH`));
+    }
+    const args = req.skipPermissions
+        ? [AGENT_SKIP_PERMISSION_FLAGS[req.agentId], req.prompt]
+        : [req.prompt];
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, { stdio: 'inherit', cwd: process.cwd() });
+        child.on('error', reject);
+        child.on('close', (code) => resolve(code ?? 0));
+    });
+}
+const CLIPBOARD_COMMANDS = [
+    { bin: 'pbcopy', args: [] },
+    { bin: 'wl-copy', args: [] },
+    { bin: 'xclip', args: ['-selection', 'clipboard'] },
+    { bin: 'xsel', args: ['--clipboard', '--input'] },
+];
+/**
+ * Best-effort copy to the system clipboard. Resolves `false` when no clipboard
+ * tool is available (the caller should then fall back to showing the text).
+ */
+export function copyPromptToClipboard(text) {
+    const cmd = CLIPBOARD_COMMANDS.find((c) => commandExists(c.bin));
+    if (!cmd)
+        return Promise.resolve(false);
+    return new Promise((resolve) => {
+        const child = spawn(cmd.bin, cmd.args);
+        child.on('error', () => resolve(false));
+        child.on('close', (code) => resolve(code === 0));
+        child.stdin?.on('error', () => resolve(false));
+        child.stdin?.end(text);
+    });
+}

package/dist/mcp/clients/base.d.ts

@@ -0,0 +1,49 @@
+import type { ClientId, Credential, WriteResult } from '../../types.js';
+import { type McpServerConfig } from '../writer.js';
+export declare const STIGG_MCP_URL = "https://mcp.stigg.io";
+export declare const STIGG_SERVER_NAME = "stigg";
+export type { McpServerConfig };
+export interface InstallResult {
+    ok: boolean;
+    /** File path for JSON/TOML installs, or a label like "claude mcp add" for CLI installs. */
+    target: string;
+    /** Set when an existing entry was backed up before overwrite. */
+    backedUpTo?: string;
+    /** Present iff ok=false. */
+    reason?: string;
+}
+export declare abstract class McpClient {
+    abstract readonly id: ClientId;
+    abstract readonly name: string;
+    /** Human-readable short label for the picker (typically the config path or the CLI command). */
+    abstract installTarget(): string;
+    /** Is this client installed/usable on this machine? */
+    abstract isClientSupported(): Promise<boolean>;
+    /** Does this client already have a Stigg MCP entry? */
+    abstract hasExistingEntry(): Promise<boolean>;
+    /** Install or overwrite the Stigg MCP entry for this client. */
+    abstract addServer(credential: Credential): Promise<InstallResult>;
+    /** Remove the Stigg MCP entry, if any. */
+    abstract removeServer(): Promise<InstallResult>;
+    /** Map an InstallResult to the WriteResult shape used by the wizard. */
+    toWriteResult(r: InstallResult): WriteResult;
+}
+/**
+ * Concrete template for clients whose config is "edit JSON at a known path
+ * and put an entry under <propertyName>.<serverName>". Subclasses override:
+ *   - getConfigPath()      — required
+ *   - getServerConfig()    — required (the entry shape)
+ *   - getServerPropertyName() — optional, defaults to "mcpServers"
+ */
+export declare abstract class DefaultJsonMcpClient extends McpClient {
+    protected readonly serverName = "stigg";
+    abstract getConfigPath(): string;
+    abstract getServerConfig(credential: Credential): McpServerConfig;
+    getServerPropertyName(): string;
+    installTarget(): string;
+    hasExistingEntry(): Promise<boolean>;
+    addServer(credential: Credential): Promise<InstallResult>;
+    removeServer(): Promise<InstallResult>;
+}
+export declare function prettifyPath(p: string): string;
+export declare function errorMessage(e: unknown): string;

package/dist/mcp/clients/base.js

@@ -0,0 +1,66 @@
+import { homedir } from 'node:os';
+import { hasMcpEntry, removeMcpEntry, writeMcpEntry } from '../writer.js';
+export const STIGG_MCP_URL = 'https://mcp.stigg.io';
+export const STIGG_SERVER_NAME = 'stigg';
+export class McpClient {
+    /** Map an InstallResult to the WriteResult shape used by the wizard. */
+    toWriteResult(r) {
+        return {
+            path: r.target,
+            client: this.id,
+            written: r.ok,
+            backedUpTo: r.backedUpTo,
+        };
+    }
+}
+/**
+ * Concrete template for clients whose config is "edit JSON at a known path
+ * and put an entry under <propertyName>.<serverName>". Subclasses override:
+ *   - getConfigPath()      — required
+ *   - getServerConfig()    — required (the entry shape)
+ *   - getServerPropertyName() — optional, defaults to "mcpServers"
+ */
+export class DefaultJsonMcpClient extends McpClient {
+    serverName = STIGG_SERVER_NAME;
+    getServerPropertyName() {
+        return 'mcpServers';
+    }
+    installTarget() {
+        return prettifyPath(this.getConfigPath());
+    }
+    async hasExistingEntry() {
+        return hasMcpEntry(this.getConfigPath(), this.getServerPropertyName(), this.serverName);
+    }
+    async addServer(credential) {
+        const path = this.getConfigPath();
+        try {
+            const entry = this.getServerConfig(credential);
+            const result = await writeMcpEntry(path, this.getServerPropertyName(), this.serverName, entry);
+            return {
+                ok: true,
+                target: prettifyPath(result.path),
+                backedUpTo: result.backedUpTo ? prettifyPath(result.backedUpTo) : undefined,
+            };
+        }
+        catch (e) {
+            return { ok: false, target: prettifyPath(path), reason: errorMessage(e) };
+        }
+    }
+    async removeServer() {
+        const path = this.getConfigPath();
+        try {
+            const result = await removeMcpEntry(path, this.getServerPropertyName(), this.serverName);
+            return { ok: result.written, target: prettifyPath(path) };
+        }
+        catch (e) {
+            return { ok: false, target: prettifyPath(path), reason: errorMessage(e) };
+        }
+    }
+}
+export function prettifyPath(p) {
+    const home = homedir();
+    return p.startsWith(home) ? `~${p.slice(home.length)}` : p;
+}
+export function errorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}

package/dist/mcp/clients/claude-code.d.ts

@@ -0,0 +1,22 @@
+import type { ClientId, Credential } from '../../types.js';
+import { type InstallResult, McpClient } from './base.js';
+/**
+ * Locate the `claude` CLI binary using PostHog wizard's lookup order:
+ * three known install paths, then the shell PATH. Cached for the
+ * lifetime of the process.
+ *
+ * Tests can short-circuit via STIGG_CLAUDE_BINARY:
+ *   - unset → real lookup (default)
+ *   - empty string → behave as if not found
+ *   - any other value → that string is returned as the binary
+ */
+export declare function findClaudeBinary(): string | null;
+export declare class ClaudeCodeMcpClient extends McpClient {
+    readonly id: ClientId;
+    readonly name = "Claude Code";
+    installTarget(): string;
+    isClientSupported(): Promise<boolean>;
+    hasExistingEntry(): Promise<boolean>;
+    addServer(credential: Credential): Promise<InstallResult>;
+    removeServer(): Promise<InstallResult>;
+}

package/dist/mcp/clients/claude-code.js

@@ -0,0 +1,120 @@
+import { execFileSync, execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { errorMessage, McpClient, STIGG_MCP_URL, STIGG_SERVER_NAME, } from './base.js';
+let cachedBinary;
+/**
+ * Locate the `claude` CLI binary using PostHog wizard's lookup order:
+ * three known install paths, then the shell PATH. Cached for the
+ * lifetime of the process.
+ *
+ * Tests can short-circuit via STIGG_CLAUDE_BINARY:
+ *   - unset → real lookup (default)
+ *   - empty string → behave as if not found
+ *   - any other value → that string is returned as the binary
+ */
+export function findClaudeBinary() {
+    // Direct process.env read (not optionalEnv): we need to distinguish unset
+    // from empty-string, since '' means "treat as not found" for tests.
+    if ('STIGG_CLAUDE_BINARY' in process.env) {
+        const override = process.env.STIGG_CLAUDE_BINARY;
+        return override ? override : null;
+    }
+    if (cachedBinary !== undefined)
+        return cachedBinary;
+    const candidates = [
+        join(homedir(), '.claude', 'local', 'claude'),
+        '/usr/local/bin/claude',
+        '/opt/homebrew/bin/claude',
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            cachedBinary = path;
+            return path;
+        }
+    }
+    try {
+        execSync('command -v claude', { stdio: 'pipe' });
+        cachedBinary = 'claude';
+        return 'claude';
+    }
+    catch {
+        cachedBinary = null;
+        return null;
+    }
+}
+export class ClaudeCodeMcpClient extends McpClient {
+    id = 'claude-code';
+    name = 'Claude Code';
+    installTarget() {
+        return 'claude mcp add';
+    }
+    isClientSupported() {
+        return Promise.resolve(findClaudeBinary() !== null);
+    }
+    hasExistingEntry() {
+        const bin = findClaudeBinary();
+        if (!bin)
+            return Promise.resolve(false);
+        try {
+            execFileSync(bin, ['mcp', 'get', STIGG_SERVER_NAME], { stdio: 'pipe' });
+            return Promise.resolve(true);
+        }
+        catch {
+            return Promise.resolve(false);
+        }
+    }
+    addServer(credential) {
+        const bin = findClaudeBinary();
+        if (!bin) {
+            return Promise.resolve({
+                ok: false,
+                target: 'claude mcp add',
+                reason: 'claude CLI not found on PATH',
+            });
+        }
+        // Idempotent overwrite: remove first (may not exist), then add.
+        try {
+            execFileSync(bin, ['mcp', 'remove', '--scope', 'user', STIGG_SERVER_NAME], { stdio: 'pipe' });
+        }
+        catch {
+            // already absent — fine
+        }
+        try {
+            execFileSync(bin, [
+                'mcp',
+                'add',
+                '--scope',
+                'user',
+                '--transport',
+                'http',
+                STIGG_SERVER_NAME,
+                STIGG_MCP_URL,
+                '--header',
+                `X-API-KEY: ${credential.value}`,
+            ], { stdio: 'pipe' });
+            return Promise.resolve({ ok: true, target: 'claude mcp add' });
+        }
+        catch (e) {
+            return Promise.resolve({ ok: false, target: 'claude mcp add', reason: errorMessage(e) });
+        }
+    }
+    removeServer() {
+        const bin = findClaudeBinary();
+        if (!bin) {
+            return Promise.resolve({
+                ok: false,
+                target: 'claude mcp remove',
+                reason: 'claude CLI not found on PATH',
+            });
+        }
+        try {
+            execFileSync(bin, ['mcp', 'remove', '--scope', 'user', STIGG_SERVER_NAME], { stdio: 'pipe' });
+            return Promise.resolve({ ok: true, target: 'claude mcp remove' });
+        }
+        catch (e) {
+            return Promise.resolve({ ok: false, target: 'claude mcp remove', reason: errorMessage(e) });
+        }
+    }
+}

package/dist/mcp/clients/claude-desktop.d.ts

@@ -0,0 +1,9 @@
+import type { ClientId, Credential } from '../../types.js';
+import { DefaultJsonMcpClient, type McpServerConfig } from './base.js';
+export declare class ClaudeDesktopMcpClient extends DefaultJsonMcpClient {
+    readonly id: ClientId;
+    readonly name = "Claude Desktop";
+    getConfigPath(): string;
+    isClientSupported(): Promise<boolean>;
+    getServerConfig(credential: Credential): McpServerConfig;
+}

package/dist/mcp/clients/claude-desktop.js

@@ -0,0 +1,35 @@
+import { access, constants } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { optionalEnv } from '../../auth/config.js';
+import { DefaultJsonMcpClient } from './base.js';
+import { buildMcpRemoteEntry } from './mcp-remote.js';
+export class ClaudeDesktopMcpClient extends DefaultJsonMcpClient {
+    id = 'claude-desktop';
+    name = 'Claude Desktop';
+    getConfigPath() {
+        const override = optionalEnv('STIGG_CLAUDE_DESKTOP_CONFIG');
+        if (override)
+            return override;
+        if (process.platform === 'darwin') {
+            return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+        }
+        if (process.platform === 'win32') {
+            return join(process.env.APPDATA ?? '', 'Claude', 'claude_desktop_config.json');
+        }
+        return '';
+    }
+    async isClientSupported() {
+        if (process.platform !== 'darwin' && process.platform !== 'win32')
+            return false;
+        const configDir = dirname(this.getConfigPath());
+        return pathExists(configDir);
+    }
+    getServerConfig(credential) {
+        // Claude Desktop only supports stdio transport — wrap our HTTP MCP with mcp-remote.
+        return buildMcpRemoteEntry(credential);
+    }
+}
+function pathExists(path) {
+    return access(path, constants.F_OK).then(() => true, () => false);
+}

package/dist/mcp/clients/codex.d.ts

@@ -0,0 +1,13 @@
+import type { ClientId, Credential } from '../../types.js';
+import { type InstallResult, McpClient } from './base.js';
+export declare class CodexMcpClient extends McpClient {
+    readonly id: ClientId;
+    readonly name = "Codex";
+    private readonly serverName;
+    installTarget(): string;
+    getConfigPath(): string;
+    isClientSupported(): Promise<boolean>;
+    hasExistingEntry(): Promise<boolean>;
+    addServer(credential: Credential): Promise<InstallResult>;
+    removeServer(): Promise<InstallResult>;
+}

package/dist/mcp/clients/codex.js

@@ -0,0 +1,113 @@
+import { execFileSync } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import TOML from '@iarna/toml';
+import { optionalEnv } from '../../auth/config.js';
+import { errorMessage, McpClient, prettifyPath, STIGG_SERVER_NAME, } from './base.js';
+import { buildMcpRemoteEntry } from './mcp-remote.js';
+export class CodexMcpClient extends McpClient {
+    id = 'codex';
+    name = 'Codex';
+    serverName = STIGG_SERVER_NAME;
+    installTarget() {
+        return prettifyPath(this.getConfigPath());
+    }
+    getConfigPath() {
+        return optionalEnv('STIGG_CODEX_CONFIG') ?? join(homedir(), '.codex', 'config.toml');
+    }
+    isClientSupported() {
+        return commandExists('codex');
+    }
+    async hasExistingEntry() {
+        const parsed = await readToml(this.getConfigPath());
+        if (!parsed)
+            return false;
+        const servers = parsed.mcp_servers;
+        return typeof servers === 'object' && servers !== null && this.serverName in servers;
+    }
+    async addServer(credential) {
+        const path = this.getConfigPath();
+        try {
+            const { text, parsed } = (await readTomlWithText(path)) ?? { text: '', parsed: {} };
+            const entry = buildMcpRemoteEntry(credential);
+            const servers = isObject(parsed.mcp_servers) ? { ...parsed.mcp_servers } : {};
+            const existed = this.serverName in servers;
+            servers[this.serverName] = entry;
+            const next = { ...parsed, mcp_servers: servers };
+            let backedUpTo;
+            if (existed && text) {
+                backedUpTo = `${path}.bak.${Date.now()}`;
+                await writeFile(backedUpTo, text, 'utf8');
+            }
+            await mkdir(dirname(path), { recursive: true });
+            const stringified = TOML.stringify(next);
+            await writeFile(path, ensureNewline(stringified), 'utf8');
+            return {
+                ok: true,
+                target: prettifyPath(path),
+                backedUpTo: backedUpTo ? prettifyPath(backedUpTo) : undefined,
+            };
+        }
+        catch (e) {
+            return { ok: false, target: prettifyPath(path), reason: errorMessage(e) };
+        }
+    }
+    async removeServer() {
+        const path = this.getConfigPath();
+        try {
+            const tomlData = await readTomlWithText(path);
+            if (!tomlData)
+                return { ok: false, target: prettifyPath(path) };
+            const { text, parsed } = tomlData;
+            if (!isObject(parsed.mcp_servers) || !(this.serverName in parsed.mcp_servers)) {
+                return { ok: false, target: prettifyPath(path) };
+            }
+            const rest = Object.fromEntries(Object.entries(parsed.mcp_servers).filter(([k]) => k !== this.serverName));
+            const next = { ...parsed, mcp_servers: rest };
+            const backedUpTo = `${path}.bak.${Date.now()}`;
+            await writeFile(backedUpTo, text, 'utf8');
+            const stringified = TOML.stringify(next);
+            await writeFile(path, ensureNewline(stringified), 'utf8');
+            return { ok: true, target: prettifyPath(path), backedUpTo: prettifyPath(backedUpTo) };
+        }
+        catch (e) {
+            return { ok: false, target: prettifyPath(path), reason: errorMessage(e) };
+        }
+    }
+}
+async function readToml(path) {
+    const r = await readTomlWithText(path);
+    return r?.parsed ?? null;
+}
+async function readTomlWithText(path) {
+    let text;
+    try {
+        text = await readFile(path, 'utf8');
+    }
+    catch (e) {
+        if (e.code === 'ENOENT')
+            return null;
+        throw e;
+    }
+    if (!text.trim())
+        return { text, parsed: {} };
+    return { text, parsed: TOML.parse(text) };
+}
+function isObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function ensureNewline(s) {
+    return s.endsWith('\n') ? s : `${s}\n`;
+}
+function commandExists(cmd) {
+    return new Promise((resolve) => {
+        try {
+            execFileSync('sh', ['-c', `command -v ${cmd}`], { stdio: 'pipe' });
+            resolve(true);
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}

package/dist/mcp/clients/cursor.d.ts

@@ -0,0 +1,9 @@
+import type { ClientId, Credential } from '../../types.js';
+import { DefaultJsonMcpClient, type McpServerConfig } from './base.js';
+export declare class CursorMcpClient extends DefaultJsonMcpClient {
+    readonly id: ClientId;
+    readonly name = "Cursor";
+    getConfigPath(): string;
+    isClientSupported(): Promise<boolean>;
+    getServerConfig(credential: Credential): McpServerConfig;
+}

package/dist/mcp/clients/cursor.js

@@ -0,0 +1,26 @@
+import { access, constants } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { optionalEnv } from '../../auth/config.js';
+import { DefaultJsonMcpClient, STIGG_MCP_URL } from './base.js';
+export class CursorMcpClient extends DefaultJsonMcpClient {
+    id = 'cursor';
+    name = 'Cursor';
+    getConfigPath() {
+        return optionalEnv('STIGG_CURSOR_CONFIG') ?? join(homedir(), '.cursor', 'mcp.json');
+    }
+    async isClientSupported() {
+        if (process.platform !== 'darwin' && process.platform !== 'win32')
+            return false;
+        return pathExists(join(homedir(), '.cursor'));
+    }
+    getServerConfig(credential) {
+        return {
+            url: STIGG_MCP_URL,
+            headers: { 'X-API-KEY': credential.value },
+        };
+    }
+}
+function pathExists(path) {
+    return access(path, constants.F_OK).then(() => true, () => false);
+}

package/dist/mcp/clients/index.d.ts

@@ -0,0 +1,7 @@
+import type { ClientId } from '../../types.js';
+import type { McpClient } from './base.js';
+export type { InstallResult, McpServerConfig } from './base.js';
+export { McpClient, DefaultJsonMcpClient } from './base.js';
+export declare function getAllClients(): readonly McpClient[];
+export declare function getClientById(id: ClientId): McpClient | undefined;
+export declare function getSupportedClients(): Promise<McpClient[]>;