@ciphore/radiocli 0.2.2 → 0.2.3

package/dist/agent/launcher.js

@@ -0,0 +1,71 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { detectAlarmTerminal } from '../alarms/terminal-launcher.js';
+const linuxTerminals = new Set(['alacritty', 'foot', 'ghostty', 'gnome-terminal', 'kitty', 'konsole', 'mate-terminal', 'qterminal', 'terminator', 'tilix', 'wezterm', 'xfce4-terminal', 'x-terminal-emulator']);
+export async function launchRadioTui(nodePath, cliPath, encodedCommand) {
+    const terminal = detectAlarmTerminal();
+    const direct = environmentCommand(nodePath, cliPath, ['agent-ui', encodedCommand]);
+    const command = `${direct.map(shellQuote).join(' ')}`;
+    if (terminal === 'darwin:apple-terminal')
+        await launched(spawnDetached('/usr/bin/osascript', appleTerminalScript(command)));
+    else if (terminal === 'darwin:iterm')
+        await launched(spawnDetached('/usr/bin/osascript', iTermScript(command)));
+    else if (terminal === 'darwin:wezterm')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'WezTerm', '--args', 'start', '--always-new-process', '--', ...direct]));
+    else if (terminal === 'darwin:ghostty')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'Ghostty', '--args', '-e', ...direct]));
+    else if (terminal === 'darwin:kitty')
+        await launched(spawnDetached('/usr/bin/open', ['-na', 'kitty', '--args', '--detach', ...direct]));
+    else if (terminal === 'win32:windows-terminal')
+        await launched(spawnDetached('wt.exe', ['-w', 'new', 'new-tab', '--title', 'RadioCLI', ...direct]));
+    else if (terminal === 'win32:console')
+        await launched(spawnDetached('cmd.exe', ['/d', '/c', 'start', 'RadioCLI', 'cmd.exe', '/k', windowsCommand(direct)]));
+    else if (terminal.startsWith('linux:')) {
+        const executable = terminal.slice('linux:'.length);
+        if (!linuxTerminals.has(basename(executable)))
+            throw new Error('Saved Linux terminal is not supported.');
+        const name = basename(executable);
+        const prefix = name === 'gnome-terminal' || name === 'mate-terminal' || name === 'xfce4-terminal'
+            ? ['--']
+            : name === 'wezterm' ? ['start', '--always-new-process', '--'] : ['-e'];
+        await launched(spawnDetached(executable, [...prefix, ...direct]));
+    }
+    else {
+        throw new Error('No supported graphical terminal was found. Set agentControl.openUiOnPlay to false or open radiocli manually.');
+    }
+}
+export async function launchHeadlessHost(nodePath, cliPath) {
+    await launched(spawnDetached(nodePath, [cliPath, 'agent-host']));
+}
+function environmentCommand(nodePath, cliPath, args) {
+    const command = [nodePath, cliPath, ...args];
+    const radioCliHome = process.env.RADIOCLI_HOME;
+    if (!radioCliHome)
+        return command;
+    if (process.platform === 'win32') {
+        return ['cmd.exe', '/d', '/c', `set "RADIOCLI_HOME=${cmdEscape(radioCliHome)}" && ${windowsCommand(command)}`];
+    }
+    return ['/usr/bin/env', `RADIOCLI_HOME=${radioCliHome}`, ...command];
+}
+function shellQuote(value) { return `'${value.replaceAll("'", `'\\''`)}'`; }
+function windowsCommand(values) { return values.map(value => `"${value.replaceAll('"', '""')}"`).join(' '); }
+function cmdEscape(value) { return value.replaceAll('%', '%%').replaceAll('"', '""').replaceAll('^', '^^').replaceAll('&', '^&').replaceAll('|', '^|').replaceAll('<', '^<').replaceAll('>', '^>'); }
+function appleTerminalScript(command) { return ['-e', 'on run argv', '-e', 'tell application "Terminal"', '-e', 'activate', '-e', 'do script (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }
+function iTermScript(command) { return ['-e', 'on run argv', '-e', 'tell application "iTerm"', '-e', 'activate', '-e', 'set w to (create window with default profile)', '-e', 'tell current session of w to write text (item 1 of argv)', '-e', 'end tell', '-e', 'end run', command]; }
+function spawnDetached(command, args) { return spawn(command, [...args], { detached: true, stdio: 'ignore', windowsHide: false }); }
+function launched(child) { return new Promise((resolve, reject) => { child.once('error', reject); child.once('spawn', () => { child.unref(); resolve(); }); }); }
+export function resolveExecutable(input, env = process.env, platform = process.platform) {
+    if ((input.includes('/') || input.includes('\\')) && existsSync(input))
+        return input;
+    const suffixes = platform === 'win32' ? ['.exe', '.cmd', '.bat', ''] : [''];
+    const pathDelimiter = platform === 'win32' ? ';' : ':';
+    for (const directory of (env.PATH ?? '').split(pathDelimiter)) {
+        for (const suffix of suffixes) {
+            const path = join(directory, `${input}${suffix}`);
+            if (existsSync(path))
+                return path;
+        }
+    }
+    return undefined;
+}

package/dist/agent/mcp-install.js

@@ -0,0 +1,467 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { applyEdits, modify, parse } from 'jsonc-parser';
+import { JsonLibraryStore } from '../storage/store.js';
+import { defaultAgentControlSettings } from '../types.js';
+import { resolveExecutable } from './launcher.js';
+const formatting = { insertSpaces: true, tabSize: 2, eol: '\n' };
+export async function configureMcpIntegrations(enabled, runtime, output = process.stdout) {
+    const store = new JsonLibraryStore();
+    const current = store.snapshot().settings;
+    if (!enabled)
+        store.updateSettings({ agentControl: { ...(current.agentControl ?? defaultAgentControlSettings), enabled: false } });
+    const results = [];
+    const command = mcpServerCommand(runtime);
+    if (enabled) {
+        const probe = await probeMcpServer(command);
+        results.push({ client: 'RadioCLI MCP server', status: probe.ok ? 'configured' : 'failed', detail: probe.detail });
+        if (!probe.ok) {
+            output?.write('\nAgent integration could not be enabled\n');
+            output?.write(`  RadioCLI MCP server: failed · ${probe.detail}\n`);
+            return results;
+        }
+    }
+    const codex = resolveCodexExecutable();
+    if (codex) {
+        results.push(await configureCliClient('Codex', codex, enabled
+            ? ['mcp', 'add', 'radiocli', '--', ...command]
+            : ['mcp', 'remove', 'radiocli'], ['mcp', 'remove', 'radiocli']));
+    }
+    else
+        results.push(notFound('Codex'));
+    const claude = resolveExecutable('claude');
+    if (claude) {
+        results.push(await configureCliClient('Claude Code', claude, enabled
+            ? ['mcp', 'add', '--scope', 'user', 'radiocli', '--', ...command]
+            : ['mcp', 'remove', '--scope', 'user', 'radiocli'], ['mcp', 'remove', '--scope', 'user', 'radiocli']));
+    }
+    else
+        results.push(notFound('Claude Code'));
+    const openCodePath = openCodeConfigPath();
+    if (resolveExecutable('opencode') || existsSync(openCodePath)) {
+        try {
+            updateOpenCodeConfig(openCodePath, enabled, command);
+            results.push({ client: 'OpenCode', status: enabled ? 'configured' : 'removed', detail: openCodePath });
+        }
+        catch (error) {
+            results.push({ client: 'OpenCode', status: 'failed', detail: message(error) });
+        }
+    }
+    else
+        results.push(notFound('OpenCode'));
+    configureJsonClient(results, 'Cursor', cursorDetected(), join(homedir(), '.cursor', 'mcp.json'), ['mcpServers', 'radiocli'], enabled, {
+        command: command[0], args: command.slice(1)
+    });
+    configureJsonClient(results, 'Gemini CLI', Boolean(resolveExecutable('gemini')), join(homedir(), '.gemini', 'settings.json'), ['mcpServers', 'radiocli'], enabled, {
+        command: command[0], args: command.slice(1)
+    });
+    configureJsonClient(results, 'VS Code / Copilot Agent Host', vsCodeDetected(), join(homedir(), '.copilot', 'mcp-config.json'), ['servers', 'radiocli'], enabled, {
+        type: 'stdio', command: command[0], args: command.slice(1)
+    });
+    if (resolveExecutable('orca')) {
+        results.push({ client: 'Orca', status: 'inherited', detail: 'Orca exposes MCP integrations through its configured Codex/Claude agent runtimes.' });
+    }
+    else
+        results.push(notFound('Orca'));
+    const portablePath = writePortableConfig(command, enabled);
+    results.push({ client: 'Other MCP clients', status: enabled ? 'configured' : 'removed', detail: portablePath });
+    if (enabled) {
+        const latest = store.snapshot().settings;
+        store.updateSettings({ agentControl: { ...(latest.agentControl ?? defaultAgentControlSettings), enabled: true } });
+    }
+    output?.write(`\nAgent integration ${enabled ? 'enabled' : 'disabled'}\n`);
+    for (const result of results)
+        output?.write(`  ${result.client}: ${result.status} · ${result.detail}\n`);
+    if (enabled) {
+        output?.write('\nIMPORTANT: Fully quit and reopen every running agent client before testing RadioCLI. New tasks opened before that restart will not have the RadioCLI tools and may incorrectly fall back to a browser.\n');
+    }
+    return results;
+}
+export function portableMcpConfig(runtime) {
+    const command = mcpServerCommand(runtime);
+    return { mcpServers: { radiocli: { type: 'stdio', command: command[0], args: command.slice(1) } } };
+}
+export async function mcpIntegrationReport(runtime) {
+    const settings = new JsonLibraryStore().snapshot().settings.agentControl ?? defaultAgentControlSettings;
+    const command = mcpServerCommand(runtime);
+    const shimLauncher = command.length === 3;
+    const server = await probeMcpServer(command);
+    const clients = await mcpClientStates(command);
+    const needsRepair = Object.entries(clients)
+        .filter(([, client]) => client.detected && (client.state === 'missing' || client.state === 'stale'))
+        .map(([client]) => client);
+    const launcherExists = Boolean(command[0] && existsSync(command[0]) && (shimLauncher || (command[1] && existsSync(command[1]))));
+    return {
+        enabled: settings.enabled,
+        health: !settings.enabled ? 'disabled' : launcherExists && server.ok && needsRepair.length === 0 ? 'ready' : 'needs-repair',
+        nextStep: !settings.enabled
+            ? 'Enable Agent control & MCP in the TUI, or run radiocli mcp enable.'
+            : !server.ok
+                ? `The configured MCP server cannot start: ${server.detail} Run radiocli mcp repair after reinstalling or rebuilding RadioCLI.`
+                : needsRepair.length > 0
+                    ? `Run radiocli mcp repair, then restart open agent clients. Needs repair: ${needsRepair.join(', ')}.`
+                    : 'RadioCLI is ready for local agents and Codex Voice.',
+        command,
+        server,
+        launcher: {
+            mode: shimLauncher ? 'radiocli-shim' : 'node-fallback',
+            path: command[0],
+            target: shimLauncher ? command[0] : command[1],
+            exists: launcherExists,
+            upgradeSafe: shimLauncher
+        },
+        clients,
+        portableConfigPath: portableConfigPath()
+    };
+}
+/** Prefer the package-manager-owned shim because it survives package/Cellar version changes. */
+export function mcpServerCommand(runtime, radioCliPath, platform = process.platform) {
+    const candidate = radioCliPath === undefined ? matchingRadioCliShim(runtime, platform) : radioCliPath;
+    const launcher = candidate && usableDirectLauncher(candidate, platform) ? candidate : undefined;
+    return launcher
+        ? [launcher, 'mcp', 'serve']
+        : [runtime.nodePath, runtime.cliPath, 'mcp', 'serve'];
+}
+export function probeMcpServer(command, timeoutMs = 5_000) {
+    return new Promise(resolve => {
+        const [program, ...args] = command;
+        if (!program) {
+            resolve({ ok: false, detail: 'No MCP server command was resolved.' });
+            return;
+        }
+        const child = spawn(program, args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.kill();
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({ ok: false, detail: `Handshake timed out after ${timeoutMs} ms.${stderr ? ` ${stderr.trim()}` : ''}` }), timeoutMs);
+        timer.unref();
+        child.stderr.on('data', value => { stderr += String(value); });
+        child.stdout.on('data', value => {
+            stdout += String(value);
+            let newline = stdout.indexOf('\n');
+            while (newline >= 0) {
+                const line = stdout.slice(0, newline).trim();
+                stdout = stdout.slice(newline + 1);
+                if (line) {
+                    try {
+                        const response = JSON.parse(line);
+                        if (response.id === 1 && response.result?.serverInfo?.name === 'radiocli') {
+                            finish({ ok: true, detail: 'stdio handshake succeeded' });
+                            return;
+                        }
+                        if (response.id === 1 && response.error) {
+                            finish({ ok: false, detail: `Handshake rejected: ${String(response.error.message ?? 'unknown MCP error')}` });
+                            return;
+                        }
+                    }
+                    catch {
+                        // Keep reading: a client may emit a non-protocol diagnostic line before startup.
+                    }
+                }
+                newline = stdout.indexOf('\n');
+            }
+        });
+        child.once('error', error => finish({ ok: false, detail: error.message }));
+        child.once('close', code => finish({ ok: false, detail: `${stderr.trim() || stdout.trim() || `server exited with code ${code ?? 1}`}` }));
+        child.stdin.end(`${JSON.stringify({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: { protocolVersion: '2025-11-25', capabilities: {}, clientInfo: { name: 'radiocli-setup', version: '1.0.0' } }
+        })}\n`);
+    });
+}
+function matchingRadioCliShim(runtime, platform) {
+    const candidate = resolveExecutable('radiocli', process.env, platform);
+    if (!candidate)
+        return undefined;
+    if (!usableDirectLauncher(candidate, platform))
+        return undefined;
+    try {
+        return realpathSync(candidate) === realpathSync(runtime.cliPath) ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function usableDirectLauncher(path, platform) {
+    return platform !== 'win32' || !/\.(?:cmd|bat)$/i.test(path);
+}
+async function mcpClientStates(command) {
+    const openCodePath = openCodeConfigPath();
+    const cursorPath = join(homedir(), '.cursor', 'mcp.json');
+    const geminiPath = join(homedir(), '.gemini', 'settings.json');
+    const vscodePath = join(homedir(), '.copilot', 'mcp-config.json');
+    return {
+        codex: await codexClientState(resolveCodexExecutable(), command),
+        claude: await claudeClientState(resolveExecutable('claude'), command),
+        opencode: jsonClientState(Boolean(resolveExecutable('opencode') || existsSync(openCodePath)), openCodePath, [
+            ['mcp', 'servers', 'radiocli'], ['mcp', 'radiocli']
+        ], command),
+        cursor: jsonClientState(cursorDetected(), cursorPath, [['mcpServers', 'radiocli']], command),
+        gemini: jsonClientState(Boolean(resolveExecutable('gemini')), geminiPath, [['mcpServers', 'radiocli']], command),
+        vscode: jsonClientState(vsCodeDetected(), vscodePath, [['servers', 'radiocli']], command),
+        orca: {
+            detected: Boolean(resolveExecutable('orca')),
+            state: resolveExecutable('orca') ? 'managed-by-client' : 'not-found',
+            detail: 'inherits MCP configuration from its Codex or Claude runtime'
+        },
+        portable: jsonClientState(true, portableConfigPath(), [['mcpServers', 'radiocli']], command)
+    };
+}
+function managedClientState(detected) {
+    return { detected, state: detected ? 'managed-by-client' : 'not-found', detail: detected ? 'inspect with the client MCP command' : 'client is not installed' };
+}
+export function resolveCodexExecutable(env = process.env, platform = process.platform, home = homedir()) {
+    const configured = env.CODEX_CLI_PATH;
+    if (configured && existsSync(configured))
+        return configured;
+    const pathExecutable = resolveExecutable('codex', env, platform);
+    if (pathExecutable)
+        return pathExecutable;
+    const candidates = platform === 'darwin'
+        ? [
+            '/Applications/ChatGPT.app/Contents/Resources/codex',
+            join(home, 'Applications', 'ChatGPT.app', 'Contents', 'Resources', 'codex')
+        ]
+        : platform === 'win32'
+            ? [
+                join(env.LOCALAPPDATA ?? join(home, 'AppData', 'Local'), 'Programs', 'ChatGPT', 'resources', 'codex.exe'),
+                join(env.ProgramFiles ?? 'C:\\Program Files', 'ChatGPT', 'resources', 'codex.exe')
+            ]
+            : [];
+    return candidates.find(candidate => existsSync(candidate));
+}
+function cursorDetected() {
+    return Boolean(resolveExecutable('cursor') ||
+        resolveExecutable('cursor-agent') ||
+        existsSync(join(homedir(), '.cursor')) ||
+        (process.platform === 'darwin' && existsSync('/Applications/Cursor.app')) ||
+        (process.platform === 'win32' && existsSync(join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'Programs', 'cursor', 'Cursor.exe'))));
+}
+function vsCodeDetected() {
+    return Boolean(resolveExecutable('code') ||
+        (process.platform === 'darwin' && existsSync('/Applications/Visual Studio Code.app')) ||
+        (process.platform === 'win32' && existsSync(join(process.env.LOCALAPPDATA ?? join(homedir(), 'AppData', 'Local'), 'Programs', 'Microsoft VS Code', 'Code.exe'))));
+}
+async function codexClientState(executable, expected) {
+    if (!executable)
+        return managedClientState(false);
+    const result = await run(executable, ['mcp', 'get', 'radiocli', '--json']);
+    if (result.code !== 0) {
+        const detail = `${result.stderr}\n${result.stdout}`.trim();
+        return missingRegistration(detail)
+            ? { detected: true, state: 'missing', detail: 'RadioCLI is not registered' }
+            : { detected: true, state: 'stale', detail: detail || `Codex MCP inspection exited with code ${result.code}` };
+    }
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const actual = parsed.transport?.type === 'stdio' && typeof parsed.transport.command === 'string' && Array.isArray(parsed.transport.args)
+            ? [parsed.transport.command, ...parsed.transport.args.filter((value) => typeof value === 'string')]
+            : [];
+        if (parsed.enabled === false)
+            return { detected: true, state: 'stale', detail: 'RadioCLI is registered but disabled in Codex' };
+        return arraysEqual(actual, expected)
+            ? { detected: true, state: 'configured', detail: 'shared ChatGPT desktop, Codex CLI, and IDE configuration' }
+            : { detected: true, state: 'stale', detail: `registered command: ${actual.join(' ') || 'unrecognized transport'}` };
+    }
+    catch {
+        return { detected: true, state: 'stale', detail: 'Codex returned an invalid MCP status response' };
+    }
+}
+async function claudeClientState(executable, expected) {
+    if (!executable)
+        return managedClientState(false);
+    const result = await run(executable, ['mcp', 'get', 'radiocli']);
+    const detail = `${result.stdout}\n${result.stderr}`.trim();
+    if (result.code !== 0) {
+        return missingRegistration(detail)
+            ? { detected: true, state: 'missing', detail: 'RadioCLI is not registered' }
+            : { detected: true, state: 'stale', detail: detail || `Claude MCP inspection exited with code ${result.code}` };
+    }
+    const commandMatches = expected.every(value => detail.includes(value));
+    return commandMatches
+        ? { detected: true, state: 'configured', detail: 'user-level MCP configuration' }
+        : { detected: true, state: 'stale', detail: 'RadioCLI is registered with a different command' };
+}
+function jsonClientState(detected, path, candidates, expected) {
+    if (!detected && !existsSync(path))
+        return { detected: false, state: 'not-found', detail: path };
+    if (!existsSync(path))
+        return { detected, state: 'missing', detail: path };
+    try {
+        const parsed = parse(readFileSync(path, 'utf8'));
+        const value = candidates.map(segments => valueAt(parsed, segments)).find(candidate => candidate !== undefined);
+        if (value === undefined)
+            return { detected, state: 'missing', detail: path };
+        const actual = commandFromConfig(value);
+        return { detected, state: arraysEqual(actual, expected) ? 'configured' : 'stale', detail: path };
+    }
+    catch {
+        return { detected, state: 'stale', detail: `${path} (invalid configuration)` };
+    }
+}
+function valueAt(value, segments) {
+    let current = value;
+    for (const segment of segments) {
+        if (!current || typeof current !== 'object' || !(segment in current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+function commandFromConfig(value) {
+    if (!value || typeof value !== 'object')
+        return [];
+    const object = value;
+    if (Array.isArray(object.command) && object.command.every(item => typeof item === 'string'))
+        return object.command;
+    if (typeof object.command === 'string' && Array.isArray(object.args) && object.args.every(item => typeof item === 'string')) {
+        return [object.command, ...object.args];
+    }
+    return [];
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function missingRegistration(detail) {
+    return /not found|does not exist|not configured|no mcp server(?:s)?.*found|no mcp servers are configured/i.test(detail);
+}
+async function configureCliClient(client, program, args, removeArgs) {
+    try {
+        let result = await run(program, args);
+        if (result.code !== 0 && args.includes('add') && /already exists|already configured|duplicate/i.test(`${result.stderr}\n${result.stdout}`)) {
+            const removed = await run(program, removeArgs);
+            if (removed.code !== 0)
+                throw new Error((removed.stderr || removed.stdout || `exit ${removed.code}`).trim());
+            result = await run(program, args);
+        }
+        if (result.code !== 0)
+            throw new Error((result.stderr || result.stdout || `exit ${result.code}`).trim());
+        return { client, status: args.includes('add') ? 'configured' : 'removed', detail: 'user-level MCP configuration' };
+    }
+    catch (error) {
+        if (!args.includes('add') && /not found|does not exist|No MCP server/i.test(message(error)))
+            return { client, status: 'removed', detail: 'already absent' };
+        return { client, status: 'failed', detail: message(error) };
+    }
+}
+export function updateOpenCodeConfig(path, enabled, command) {
+    const source = existsSync(path) ? readFileSync(path, 'utf8') : '';
+    const parsed = source ? parse(source) : {};
+    const legacy = Boolean(parsed.mcp && !('servers' in parsed.mcp) && Object.values(parsed.mcp).some(isLegacyOpenCodeServer));
+    const value = enabled
+        ? legacy ? { type: 'local', command, enabled: true } : { type: 'local', command, disabled: false }
+        : undefined;
+    updateJsoncValue(path, legacy ? ['mcp', 'radiocli'] : ['mcp', 'servers', 'radiocli'], value, '{\n  "$schema": "https://opencode.ai/config.json"\n}\n', 'OpenCode');
+}
+function isLegacyOpenCodeServer(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const candidate = value;
+    return (candidate.type === 'local' && Array.isArray(candidate.command)) || (candidate.type === 'remote' && typeof candidate.url === 'string');
+}
+function configureJsonClient(results, client, detected, path, segments, enabled, value) {
+    if (!detected && !existsSync(path)) {
+        results.push(notFound(client));
+        return;
+    }
+    try {
+        updateJsoncValue(path, segments, enabled ? value : undefined, '{}\n', client);
+        results.push({ client, status: enabled ? 'configured' : 'removed', detail: path });
+    }
+    catch (error) {
+        results.push({ client, status: 'failed', detail: message(error) });
+    }
+}
+function updateJsoncValue(path, segments, value, initial, client) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const source = existsSync(path) ? readFileSync(path, 'utf8') : initial;
+    const errors = [];
+    parse(source, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length)
+        throw new Error(`Cannot safely update invalid ${client} config: ${path}`);
+    const updated = applyEdits(source, modify(source, segments, value, { formattingOptions: formatting }));
+    writeFileSync(path, updated.endsWith('\n') ? updated : `${updated}\n`, { mode: 0o600 });
+}
+function writePortableConfig(command, enabled) {
+    const path = portableConfigPath();
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const config = enabled ? { mcpServers: { radiocli: { type: 'stdio', command: command[0], args: command.slice(1) } } } : { mcpServers: {} };
+    writeFileSync(path, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+    return path;
+}
+function portableConfigPath() {
+    if (process.env.RADIOCLI_HOME)
+        return join(process.env.RADIOCLI_HOME, 'mcp.json');
+    const base = process.platform === 'win32'
+        ? process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming')
+        : process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+    return join(base, 'radiocli', 'mcp.json');
+}
+function openCodeConfigPath() {
+    const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+    const directory = join(base, 'opencode');
+    const jsonc = join(directory, 'opencode.jsonc');
+    const json = join(directory, 'opencode.json');
+    return existsSync(jsonc) ? jsonc : json;
+}
+function run(program, args, timeoutMs = 15_000) {
+    return new Promise((resolve, reject) => {
+        const invocation = cliInvocation(program, args);
+        const child = spawn(invocation.program, invocation.args, { stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(result);
+        };
+        const timer = setTimeout(() => {
+            child.kill();
+            finish({ code: 1, stdout, stderr: `${stderr}${stderr ? '\n' : ''}Timed out after ${timeoutMs} ms.` });
+        }, timeoutMs);
+        timer.unref();
+        child.stdout.on('data', value => { stdout += String(value); });
+        child.stderr.on('data', value => { stderr += String(value); });
+        child.once('error', error => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once('close', code => finish({ code: code ?? 1, stdout, stderr }));
+    });
+}
+export function cliInvocation(program, args, platform = process.platform, env = process.env) {
+    if (platform !== 'win32' || !/\.(?:cmd|bat)$/i.test(program))
+        return { program, args };
+    const command = [program, ...args].map(value => `"${escapeCmdArgument(value)}"`).join(' ');
+    return { program: env.ComSpec || env.COMSPEC || 'cmd.exe', args: ['/d', '/s', '/v:off', '/c', command] };
+}
+function escapeCmdArgument(value) {
+    return value
+        .replaceAll('%', '%%')
+        .replaceAll('"', '""')
+        .replaceAll('^', '^^')
+        .replaceAll('&', '^&')
+        .replaceAll('|', '^|')
+        .replaceAll('<', '^<')
+        .replaceAll('>', '^>');
+}
+function notFound(client) { return { client, status: 'not-found', detail: 'client is not installed on this computer' }; }
+function message(error) { return error instanceof Error ? error.message : String(error); }