@warmio/mcp 9.1.1 → 11.0.0

package/dist/install.js

@@ -1,533 +1,303 @@
-import { createInterface } from 'readline';
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { dirname, join, resolve } from 'path';
-import { homedir, platform } from 'os';
-import { WARM_MCP_CLIENTS, WARM_MCP_CREDENTIALS, WARM_MCP_PROJECT_CONFIGS, WARM_MCP_SERVER_CONFIGS, } from '@warmio/contracts/mcp';
-import { verifyWarmApiKey, WarmApiError } from './server.js';
-import { getWarmApiKeyPath, readConfigFile } from './config-paths.js';
-const HOME = homedir();
-const CWD = process.cwd();
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { createInterface } from 'node:readline';
+import { API_ORIGIN, WARM_API_KEY_PREFIX } from '@warmio/contracts/api';
+import { WARM_MCP_CLIENTS, WARM_MCP_PROJECT_CONFIGS, WARM_MCP_SERVER_CONFIG, } from '@warmio/contracts/mcp';
+import { getWarmApiKeyPath } from './config-paths.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function resolveClientConfigPath(configPath) {
-    const root = configPath.root === 'appData' ? process.env.APPDATA || join(HOME, 'AppData', 'Roaming') : HOME;
-    return join(root, ...configPath.segments);
-}
-function getClientConfigPath(clientId) {
-    const client = WARM_MCP_CLIENTS.find((candidate) => candidate.id === clientId);
-    if (!client) {
-        throw new Error(`Unsupported MCP client: ${clientId}`);
-    }
-    const currentPlatform = platform();
-    const configPath = currentPlatform === 'darwin'
-        ? client.configPaths.darwin
-        : currentPlatform === 'win32'
-            ? client.configPaths.win32
-            : client.configPaths.linux;
-    return resolveClientConfigPath(configPath);
-}
-const GLOBAL_CLIENTS = WARM_MCP_CLIENTS.map((client) => ({
-    name: client.name,
-    format: client.format,
-    configPath: getClientConfigPath(client.id),
-    alwaysInclude: 'alwaysInclude' in client && client.alwaysInclude,
-}));
-function getServerName(mode) {
-    return WARM_MCP_SERVER_CONFIGS[mode].serverName;
-}
-function getCredential(mode) {
-    return WARM_MCP_CREDENTIALS[mode];
-}
-function getOppositeCredential(mode) {
-    return WARM_MCP_CREDENTIALS[mode === 'automation' ? 'context' : 'automation'];
-}
-function getMcpConfig(mode) {
-    const serverConfig = WARM_MCP_SERVER_CONFIGS[mode];
-    return platform() === 'win32'
-        ? { command: 'cmd', args: ['/c', serverConfig.command, ...serverConfig.args] }
-        : { command: serverConfig.command, args: [...serverConfig.args] };
-}
-function formatTomlStringArray(values) {
-    return `[${values.map((value) => JSON.stringify(value)).join(', ')}]`;
-}
-function detectProjectClients() {
-    const found = [];
-    for (const name of WARM_MCP_PROJECT_CONFIGS) {
-        const configPath = resolve(CWD, name);
-        if (existsSync(configPath)) {
-            found.push({
-                name: `Project (${name})`,
-                configPath,
-                format: 'json',
-                isProjectLevel: true,
-            });
-        }
-    }
-    return found;
-}
-function isDetected(client) {
-    if (client.alwaysInclude) {
+const API_KEY_PATTERN = new RegExp(`^${WARM_API_KEY_PREFIX}[A-Za-z0-9_-]{43}$`);
+function configPath(config, homeDir) {
+    const root = config.root === 'appData'
+        ? process.env.APPDATA?.trim() || path.join(homeDir, 'AppData', 'Roaming')
+        : homeDir;
+    return path.join(root, ...config.segments);
+}
+function supportedClients(homeDir, workingDirectory) {
+    const platform = process.platform === 'win32' ? 'win32' : process.platform === 'darwin' ? 'darwin' : 'linux';
+    const globalClients = WARM_MCP_CLIENTS.map((client) => ({
+        alwaysInclude: 'alwaysInclude' in client && client.alwaysInclude,
+        configDialect: client.configDialect,
+        configPath: configPath(client.configPaths[platform], homeDir),
+        format: client.format,
+        name: client.name,
+    })).filter((client) => client.alwaysInclude || fs.existsSync(path.dirname(client.configPath)));
+    const projectClients = WARM_MCP_PROJECT_CONFIGS.map((relativePath) => path.resolve(workingDirectory, relativePath))
+        .filter((candidate) => fs.existsSync(candidate))
+        .map((candidate) => ({
+        configPath: candidate,
+        configDialect: 'mcpServers',
+        format: 'json',
+        name: `Project (${path.relative(workingDirectory, candidate)})`,
+    }));
+    const configPaths = new Set();
+    return [...globalClients, ...projectClients].filter((client) => {
+        if (configPaths.has(client.configPath))
+            return false;
+        configPaths.add(client.configPath);
         return true;
-    }
-    return existsSync(dirname(client.configPath));
-}
-function getStringArray(value) {
-    if (!Array.isArray(value)) {
-        return [];
-    }
-    return value.filter((entry) => typeof entry === 'string');
-}
-function isWarmPackageSpecifier(value) {
-    return /^@warmio\/mcp(?:@.+)?$/.test(value);
+    });
 }
-function isSupportedWarmInvocation(command, args, mode) {
-    if (command !== 'npx' && command !== 'cmd') {
+function isCurrentWarmConfig(client, server) {
+    if (!isRecord(server))
         return false;
+    if (client.configDialect === 'openCode') {
+        return (server.type === 'local' &&
+            Array.isArray(server.command) &&
+            server.command.length === WARM_MCP_SERVER_CONFIG.args.length + 1 &&
+            server.command[0] === WARM_MCP_SERVER_CONFIG.command &&
+            server.command.slice(1).every((argument, index) => argument === WARM_MCP_SERVER_CONFIG.args[index]) &&
+            Object.keys(server).length === 2);
+    }
+    return (server.command === WARM_MCP_SERVER_CONFIG.command &&
+        Array.isArray(server.args) &&
+        server.args.length === WARM_MCP_SERVER_CONFIG.args.length &&
+        server.args.every((argument, index) => argument === WARM_MCP_SERVER_CONFIG.args[index]) &&
+        Object.keys(server).length === 2);
+}
+function parseJsonConfig(client, content) {
+    if (!content)
+        return {};
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed))
+        throw new Error(`${client.name} config is not a JSON object.`);
+    return parsed;
+}
+function readJsonConfig(client) {
+    return parseJsonConfig(client, fs.existsSync(client.configPath) ? fs.readFileSync(client.configPath, 'utf8') : '');
+}
+const WARM_TOML_BLOCK = /\n?\[mcp_servers\.warm\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
+const WARM_TOML_ENV_BLOCK = /\n?\[mcp_servers\.warm\.env\][\s\S]*?(?=\n\[[^\n]+\]|\s*$)/g;
+function existingWarmConfig(client) {
+    if (client.format === 'toml') {
+        const content = fs.existsSync(client.configPath)
+            ? fs.readFileSync(client.configPath, 'utf8')
+            : '';
+        const section = content.match(WARM_TOML_BLOCK)?.[0];
+        return {
+            current: Boolean(section) &&
+                section.trim() ===
+                    [
+                        '[mcp_servers.warm]',
+                        `command = "${WARM_MCP_SERVER_CONFIG.command}"`,
+                        `args = ${JSON.stringify(WARM_MCP_SERVER_CONFIG.args)}`,
+                    ].join('\n'),
+            exists: Boolean(section),
+        };
     }
-    return (args.some((value) => isWarmPackageSpecifier(value)) &&
-        args.includes('mcp') &&
-        args.includes('--mode') &&
-        args.includes(mode));
-}
-function getJsonEnvStatus(server, mode) {
-    const env = isRecord(server?.env) ? server.env : undefined;
-    const credential = getCredential(mode);
-    const oppositeCredential = getOppositeCredential(mode);
-    const apiKeyName = credential.apiKeyEnv;
-    const apiKeyFileName = credential.apiKeyFileEnv;
-    const inlineApiKey = typeof env?.[apiKeyName] === 'string' && env[apiKeyName].trim() ? env[apiKeyName].trim() : null;
+    const config = readJsonConfig(client);
+    const servers = client.configDialect === 'openCode'
+        ? isRecord(config.mcp)
+            ? config.mcp
+            : {}
+        : isRecord(config.mcpServers)
+            ? config.mcpServers
+            : {};
     return {
-        apiKeyFileOverride: typeof env?.[apiKeyFileName] === 'string' && env[apiKeyFileName].trim().length > 0
-            ? env[apiKeyFileName].trim()
-            : null,
-        hasIrrelevantCredential: [
-            'WARM_API_KEY',
-            'WARM_API_KEY_FILE',
-            oppositeCredential.apiKeyEnv,
-            oppositeCredential.apiKeyFileEnv,
-        ].some((name) => typeof env?.[name] === 'string' && env[name].trim().length > 0),
-        inlineApiKey,
+        current: isCurrentWarmConfig(client, servers.warm),
+        exists: 'warm' in servers,
     };
 }
-function resolveApiKeyFileOverride(filePath) {
-    if (filePath === '~') {
-        return HOME;
-    }
-    if (filePath.startsWith('~/')) {
-        return join(HOME, filePath.slice(2));
-    }
-    return resolve(filePath);
-}
-function createClientStatus(client, invocationState, envStatus, mode) {
-    const credentialApiKey = envStatus.inlineApiKey ||
-        (envStatus.apiKeyFileOverride
-            ? readConfigFile(resolveApiKeyFileOverride(envStatus.apiKeyFileOverride))
-            : readConfigFile(getWarmApiKeyPath(mode)));
-    const state = invocationState === 'configured' && credentialApiKey && !envStatus.hasIrrelevantCredential
-        ? 'configured'
-        : invocationState === 'missing'
-            ? 'missing'
-            : 'needs_setup';
-    return { client, credentialApiKey, state, ...envStatus };
-}
-function getJsonStatus(client, content, mode) {
+function prepareJsonConfig(client, current) {
+    const config = parseJsonConfig(client, current);
+    if (client.configDialect === 'openCode') {
+        const servers = isRecord(config.mcp) ? config.mcp : {};
+        servers.warm = {
+            type: 'local',
+            command: [WARM_MCP_SERVER_CONFIG.command, ...WARM_MCP_SERVER_CONFIG.args],
+        };
+        config.mcp = servers;
+        delete config.mcpServers;
+        return `${JSON.stringify(config, null, 2)}\n`;
+    }
+    const servers = isRecord(config.mcpServers) ? config.mcpServers : {};
+    servers.warm = {
+        command: WARM_MCP_SERVER_CONFIG.command,
+        args: [...WARM_MCP_SERVER_CONFIG.args],
+    };
+    config.mcpServers = servers;
+    return `${JSON.stringify(config, null, 2)}\n`;
+}
+function prepareTomlConfig(current) {
+    const remaining = current.replace(WARM_TOML_ENV_BLOCK, '').replace(WARM_TOML_BLOCK, '').trimEnd();
+    const next = [
+        remaining,
+        '[mcp_servers.warm]',
+        `command = "${WARM_MCP_SERVER_CONFIG.command}"`,
+        `args = ${JSON.stringify(WARM_MCP_SERVER_CONFIG.args)}`,
+    ]
+        .filter(Boolean)
+        .join('\n\n');
+    return `${next}\n`;
+}
+function snapshotFile(target) {
     try {
-        const parsed = JSON.parse(content);
-        const servers = isRecord(parsed.mcpServers) ? parsed.mcpServers : undefined;
-        const candidate = servers?.[getServerName(mode)];
-        const server = isRecord(candidate) ? candidate : undefined;
-        const envStatus = getJsonEnvStatus(server, mode);
-        if (!server) {
-            return createClientStatus(client, 'missing', envStatus, mode);
-        }
-        const command = typeof server.command === 'string' ? server.command : undefined;
-        const args = getStringArray(server.args);
-        if (isSupportedWarmInvocation(command, args, mode)) {
-            return createClientStatus(client, 'configured', envStatus, mode);
-        }
-        return createClientStatus(client, 'needs_setup', envStatus, mode);
-    }
-    catch {
-        return createClientStatus(client, 'missing', { apiKeyFileOverride: null, hasIrrelevantCredential: false, inlineApiKey: null }, mode);
+        const stat = fs.statSync(target);
+        return {
+            content: fs.readFileSync(target, 'utf8'),
+            exists: true,
+            mode: stat.mode & 0o777,
+        };
     }
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function getTomlSection(content, sectionName) {
-    const pattern = new RegExp(`(?:^|\\r?\\n)\\[${escapeRegExp(sectionName)}\\]\\r?\\n([\\s\\S]*?)(?=\\r?\\n\\[[^\\r\\n]+\\]|\\s*$)`);
-    const match = content.match(pattern);
-    return match ? match[0].replace(/^\r?\n/, '') : null;
-}
-function getTomlStringValue(block, key) {
-    if (!block) {
-        return undefined;
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        return { content: '', exists: false, mode: 0o666 };
     }
-    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*(?:"([^"]*)"|'([^']*)')\\s*$`, 'm');
-    const match = block.match(pattern);
-    return match?.[1] ?? match?.[2];
 }
-function getTomlStringArrayValue(block, key) {
-    if (!block) {
-        return [];
-    }
-    const pattern = new RegExp(`^${escapeRegExp(key)}\\s*=\\s*\\[([\\s\\S]*?)\\]\\s*$`, 'm');
-    const match = block.match(pattern);
-    if (!match) {
-        return [];
-    }
-    const values = [];
-    const valuePattern = /"((?:\\.|[^"])*)"|'((?:\\.|[^'])*)'/g;
-    for (const item of match[1].matchAll(valuePattern)) {
-        values.push(item[1] ?? item[2] ?? '');
-    }
-    return values;
+function prepareClientFile(client) {
+    const snapshot = snapshotFile(client.configPath);
+    return {
+        content: client.format === 'toml'
+            ? prepareTomlConfig(snapshot.content)
+            : prepareJsonConfig(client, snapshot.content),
+        mode: snapshot.mode,
+        snapshot,
+        target: client.configPath,
+    };
 }
-function getTomlEnvStatus(content, mode) {
-    const envBlock = getTomlSection(content, `mcp_servers.${getServerName(mode)}.env`);
-    if (!envBlock) {
-        return {
-            apiKeyFileOverride: null,
-            envLines: [],
-            hasIrrelevantCredential: false,
-            inlineApiKey: null,
-        };
-    }
-    const envLines = envBlock
-        .split(/\r?\n/)
-        .slice(1)
-        .filter((line) => line.trim().length > 0);
-    const credential = getCredential(mode);
-    const oppositeCredential = getOppositeCredential(mode);
-    const apiKeyName = credential.apiKeyEnv;
-    const inlineApiKey = getTomlStringValue(envBlock, apiKeyName)?.trim() || null;
-    const apiKeyFile = getTomlStringValue(envBlock, credential.apiKeyFileEnv);
+function prepareCredentialFile(target, apiKey) {
     return {
-        apiKeyFileOverride: typeof apiKeyFile === 'string' && apiKeyFile.trim() ? apiKeyFile.trim() : null,
-        envLines,
-        hasIrrelevantCredential: [
-            'WARM_API_KEY',
-            'WARM_API_KEY_FILE',
-            oppositeCredential.apiKeyEnv,
-            oppositeCredential.apiKeyFileEnv,
-        ].some((name) => Boolean(getTomlStringValue(envBlock, name)?.trim())),
-        inlineApiKey,
+        content: `${apiKey}\n`,
+        mode: 0o600,
+        snapshot: snapshotFile(target),
+        target,
     };
 }
-function getTomlStatus(client, content, mode) {
-    const warmBlock = getTomlSection(content, `mcp_servers.${getServerName(mode)}`);
-    const envStatus = getTomlEnvStatus(content, mode);
-    if (!warmBlock) {
-        return createClientStatus(client, 'missing', envStatus, mode);
-    }
-    const command = getTomlStringValue(warmBlock, 'command');
-    const args = getTomlStringArrayValue(warmBlock, 'args');
-    if (isSupportedWarmInvocation(command, args, mode)) {
-        return createClientStatus(client, 'configured', envStatus, mode);
+function atomicReplaceFile(target, content, mode) {
+    const directory = path.dirname(target);
+    const temporaryPath = path.join(directory, `.${path.basename(target)}.${randomUUID()}.tmp`);
+    let descriptor;
+    try {
+        fs.mkdirSync(directory, { recursive: true });
+        descriptor = fs.openSync(temporaryPath, 'wx', mode);
+        fs.writeFileSync(descriptor, content, 'utf8');
+        fs.fsyncSync(descriptor);
+        fs.closeSync(descriptor);
+        descriptor = undefined;
+        fs.renameSync(temporaryPath, target);
+    }
+    finally {
+        if (descriptor !== undefined)
+            fs.closeSync(descriptor);
+        if (fs.existsSync(temporaryPath))
+            fs.unlinkSync(temporaryPath);
+    }
+}
+function restorePreparedFile(prepared, replaceFile) {
+    if (prepared.snapshot.exists) {
+        replaceFile(prepared.target, prepared.snapshot.content, prepared.snapshot.mode);
+        return;
     }
-    return createClientStatus(client, 'needs_setup', envStatus, mode);
+    fs.rmSync(prepared.target, { force: true });
 }
-function getClientStatus(client, mode) {
-    if (!existsSync(client.configPath)) {
-        return createClientStatus(client, 'missing', { apiKeyFileOverride: null, hasIrrelevantCredential: false, inlineApiKey: null }, mode);
-    }
-    const content = readFileSync(client.configPath, 'utf-8');
-    if (client.format === 'toml') {
-        return getTomlStatus(client, content, mode);
+function commitPreparedFiles(files, replaceFile) {
+    const replaced = [];
+    try {
+        for (const file of files) {
+            replaceFile(file.target, file.content, file.mode);
+            replaced.push(file);
+        }
     }
-    return getJsonStatus(client, content, mode);
-}
-function configureJson(client, mode, preserveSelectedKeyFile) {
-    let config = {};
-    if (existsSync(client.configPath)) {
-        const content = readFileSync(client.configPath, 'utf-8');
-        let parsed;
+    catch (error) {
         try {
-            parsed = JSON.parse(content);
+            for (const file of [...replaced].reverse())
+                restorePreparedFile(file, replaceFile);
         }
-        catch (error) {
-            throw new Error(`Refusing to overwrite unparsable JSON config ${client.configPath}: ${error instanceof Error ? error.message : String(error)}`);
+        catch {
+            throw new Error('Warm MCP installation failed and rollback could not complete.');
         }
-        if (!isRecord(parsed)) {
-            throw new Error(`Refusing to overwrite JSON config ${client.configPath}: root must be an object.`);
-        }
-        config = parsed;
-    }
-    if (config.mcpServers === undefined) {
-        config.mcpServers = {};
-    }
-    const servers = config.mcpServers;
-    if (!isRecord(servers)) {
-        throw new Error(`Refusing to overwrite JSON config ${client.configPath}: mcpServers must be an object.`);
+        throw error;
     }
-    const serverName = getServerName(mode);
-    const existing = isRecord(servers[serverName]) ? servers[serverName] : undefined;
-    const existingEnv = isRecord(existing?.env) ? existing.env : {};
-    const nextEnv = { ...existingEnv };
-    const existingCommand = typeof existing?.command === 'string' ? existing.command : undefined;
-    const existingArgs = getStringArray(existing?.args);
-    const preserveProjectCommand = client.isProjectLevel &&
-        !!existingCommand &&
-        isSupportedWarmInvocation(existingCommand, existingArgs, mode);
-    const credential = getCredential(mode);
-    const oppositeCredential = getOppositeCredential(mode);
-    const selectedKeyFile = credential.apiKeyFileEnv;
-    for (const name of [
-        'WARM_API_KEY',
-        'WARM_API_KEY_FILE',
-        credential.apiKeyEnv,
-        oppositeCredential.apiKeyEnv,
-        oppositeCredential.apiKeyFileEnv,
-    ]) {
-        delete nextEnv[name];
-    }
-    if (!preserveSelectedKeyFile) {
-        delete nextEnv[selectedKeyFile];
-    }
-    if (preserveProjectCommand) {
-        servers[serverName] = {
-            ...existing,
-            env: Object.keys(nextEnv).length > 0 ? nextEnv : undefined,
-        };
-    }
-    else {
-        servers[serverName] = {
-            ...existing,
-            ...getMcpConfig(mode),
-            env: Object.keys(nextEnv).length > 0 ? nextEnv : undefined,
-        };
-    }
-    mkdirSync(dirname(client.configPath), { recursive: true });
-    writeFileSync(client.configPath, JSON.stringify(config, null, 2) + '\n');
 }
-function configureToml(client, mode, preserveSelectedKeyFile) {
-    let content = '';
-    let lineEnding = '\n';
-    if (existsSync(client.configPath)) {
-        content = readFileSync(client.configPath, 'utf-8');
-        lineEnding = content.includes('\r\n') ? '\r\n' : '\n';
-        if (!content.endsWith('\n')) {
-            content += lineEnding;
-        }
-    }
-    const serverName = getServerName(mode);
-    const serverConfig = WARM_MCP_SERVER_CONFIGS[mode];
-    const tomlCommand = platform() === 'win32' ? 'cmd' : serverConfig.command;
-    const posixArgs = formatTomlStringArray(serverConfig.args);
-    const windowsArgs = formatTomlStringArray(['/c', serverConfig.command, ...serverConfig.args]);
-    const tomlArgs = platform() === 'win32' ? windowsArgs : posixArgs;
-    const warmBlock = `[mcp_servers.${serverName}]${lineEnding}command = "${tomlCommand}"${lineEnding}args = ${tomlArgs}${lineEnding}`;
-    const credential = getCredential(mode);
-    const oppositeCredential = getOppositeCredential(mode);
-    const selectedKeyFile = credential.apiKeyFileEnv;
-    const removedEnvNames = new Set([
-        'WARM_API_KEY',
-        'WARM_API_KEY_FILE',
-        credential.apiKeyEnv,
-        oppositeCredential.apiKeyEnv,
-        oppositeCredential.apiKeyFileEnv,
-        ...(!preserveSelectedKeyFile ? [selectedKeyFile] : []),
-    ]);
-    const preservedEnvLines = getTomlEnvStatus(content, mode).envLines.filter((line) => {
-        const name = line.match(/^\s*([A-Z0-9_]+)\s*=/)?.[1];
-        return !name || !removedEnvNames.has(name);
+function readlinePrompt(question) {
+    return new Promise((resolve) => {
+        const readline = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        readline.question(question, (answer) => {
+            readline.close();
+            resolve(answer.trim());
+        });
     });
-    const escapedServerName = escapeRegExp(serverName);
-    const tomlBlockPattern = new RegExp(`(?:\\r?\\n)?\\[mcp_servers\\.${escapedServerName}\\]\\r?\\n[\\s\\S]*?(?=\\r?\\n\\[[^\\r\\n]+\\]|\\s*$)`, 'g');
-    const tomlEnvBlockPattern = new RegExp(`(?:\\r?\\n)?\\[mcp_servers\\.${escapedServerName}\\.env\\]\\r?\\n[\\s\\S]*?(?=\\r?\\n\\[[^\\r\\n]+\\]|\\s*$)`, 'g');
-    let nextContent = content
-        .replace(tomlEnvBlockPattern, '')
-        .replace(tomlBlockPattern, '')
-        .trimEnd();
-    if (nextContent.length > 0) {
-        nextContent += `${lineEnding}${lineEnding}`;
-    }
-    nextContent += warmBlock;
-    if (preservedEnvLines.length > 0) {
-        nextContent += `${lineEnding}[mcp_servers.${serverName}.env]${lineEnding}${preservedEnvLines.join(lineEnding)}${lineEnding}`;
-    }
-    mkdirSync(dirname(client.configPath), { recursive: true });
-    writeFileSync(client.configPath, nextContent.endsWith('\n') ? nextContent : `${nextContent}${lineEnding}`);
 }
-function configure(client, mode, preserveSelectedKeyFile) {
-    if (client.format === 'json') {
-        configureJson(client, mode, preserveSelectedKeyFile);
-        return;
+async function validateApiKey(apiKey, options) {
+    if (!API_KEY_PATTERN.test(apiKey)) {
+        throw new Error('Warm API key validation failed. Check Warm Settings and try again.');
     }
-    configureToml(client, mode, preserveSelectedKeyFile);
-}
-function shortPath(filePath) {
-    return filePath.replace(HOME, '~').replace(CWD, '.');
-}
-function prompt(question) {
-    return new Promise((resolvePrompt) => {
-        const rl = createInterface({ input: process.stdin, output: process.stdout });
-        rl.question(question, (answer) => {
-            rl.close();
-            resolvePrompt(answer.trim());
-        });
+    const response = await (options.fetchImplementation || fetch)(new URL('/api/verify', options.apiUrl || process.env.WARM_API_URL || API_ORIGIN), {
+        headers: {
+            Accept: 'application/json',
+            Authorization: `Bearer ${apiKey}`,
+        },
     });
-}
-async function validateApiKey(apiKey, mode) {
-    console.log('  Validating API key...');
+    const text = await response.text();
+    let body = null;
     try {
-        const result = await verifyWarmApiKey(apiKey, mode);
-        if (!result.valid) {
-            console.log(`  Validation failed: ${result.status}`);
-            console.log('  Check https://warm.io/settings and try again.');
-            console.log('');
-            return false;
-        }
-        if (result.audience !== mode) {
-            console.log(`  Validation failed: this installer mode requires a ${mode} API key.`);
-            console.log(`  Create a ${mode} key in https://warm.io/settings and try again.`);
-            console.log('');
-            return false;
-        }
-        console.log('  API key verified.');
-        console.log('');
-        return true;
+        body = JSON.parse(text);
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (error instanceof WarmApiError && (error.status === 401 || error.status === 403)) {
-            console.log(`  Validation failed: ${message}`);
-            console.log('');
-            return false;
-        }
-        console.log(`  Could not validate right now: ${message}`);
-        console.log('  Continuing setup with the provided key.');
-        console.log('');
-        return true;
+    catch {
+        /* An invalid response is not a valid key. */
     }
-}
-async function validateEffectiveApiKeys(apiKeys, mode) {
-    const uniqueApiKeys = [...new Set(apiKeys.filter((apiKey) => Boolean(apiKey)))];
-    for (const apiKey of uniqueApiKeys) {
-        if (!(await validateApiKey(apiKey, mode))) {
-            throw new Error(`The ${mode} API key could not be validated.`);
-        }
+    if (!response.ok || !isRecord(body) || body.valid !== true || Object.keys(body).length !== 1) {
+        throw new Error('Warm API key validation failed. Check Warm Settings and try again.');
     }
 }
-function storeApiKey(apiKey, mode) {
-    const apiKeyPath = getWarmApiKeyPath(mode);
-    mkdirSync(dirname(apiKeyPath), { recursive: true });
-    writeFileSync(apiKeyPath, `${apiKey}\n`, { mode: 0o600 });
-    chmodSync(apiKeyPath, 0o600);
+async function requestedApiKey(ask, options) {
+    const apiKey = (await ask('Warm API key: ')).trim();
+    if (!apiKey)
+        throw new Error('A Warm API key is required to configure MCP clients.');
+    await validateApiKey(apiKey, options);
+    return apiKey;
 }
-function getStatusLabel(status, force) {
-    if (force) {
-        return 'not configured';
-    }
-    if (status === 'configured') {
-        return 'configured';
-    }
-    if (status === 'needs_setup') {
-        return 'needs setup';
-    }
-    return 'not configured';
-}
-export async function install(options = {}) {
-    const force = options.force ?? false;
-    const mode = options.mode ?? 'context';
-    const shouldValidateApiKey = options.validateApiKey ?? true;
-    console.log('');
-    console.log('  Warmio Installer');
-    console.log('  ----------------');
-    console.log('');
-    const globalClients = GLOBAL_CLIENTS.filter(isDetected);
-    const projectClients = detectProjectClients();
-    const allClients = [...globalClients, ...projectClients];
-    const clientStatuses = allClients.map((client) => getClientStatus(client, mode));
-    const needsSetup = clientStatuses.filter((status) => force || status.state !== 'configured');
-    console.log('  MCP clients found:');
-    clientStatuses.forEach((status) => {
-        console.log(`    ${status.client.name.padEnd(22)} ${shortPath(status.client.configPath).padEnd(55)} ${getStatusLabel(status.state, force)}`);
-    });
-    console.log('');
-    if (needsSetup.length === 0) {
-        if (shouldValidateApiKey) {
-            await validateEffectiveApiKeys(clientStatuses.map((status) => status.credentialApiKey), mode);
-        }
-        console.log('  All clients already configured!');
-        console.log('  Run with --force to update the API key.');
-        console.log('');
-        return;
-    }
-    const apiKeyPath = getWarmApiKeyPath(mode);
-    const storedApiKey = readConfigFile(apiKeyPath);
-    const migratedApiKey = needsSetup.find((status) => typeof status.inlineApiKey === 'string' && status.inlineApiKey.length > 0)?.inlineApiKey ?? null;
-    const usableApiKeyFileOverride = needsSetup.find((status) => status.apiKeyFileOverride && !status.inlineApiKey && status.credentialApiKey);
-    const targetMissingCredential = needsSetup.some((status) => !status.credentialApiKey);
-    let apiKeyToStore = null;
-    let shouldStoreApiKey = false;
-    let shouldPromptForApiKey = force;
-    if (!shouldPromptForApiKey) {
-        if (storedApiKey) {
-            console.log('  Using stored Warm API key.');
-            console.log('');
-            apiKeyToStore = storedApiKey;
-        }
-        else if (migratedApiKey) {
-            console.log('  Reusing Warm API key from existing client config.');
-            console.log('');
-            apiKeyToStore = migratedApiKey;
-            shouldStoreApiKey = true;
-        }
-        else if (usableApiKeyFileOverride && !targetMissingCredential) {
-            console.log(`  Reusing existing ${getCredential(mode).apiKeyFileEnv} override.`);
-            console.log('');
-        }
-        else {
-            shouldPromptForApiKey = true;
-        }
-    }
-    if (shouldPromptForApiKey) {
-        const apiKey = await prompt('  Warm API key: ');
-        if (!apiKey) {
-            console.log('');
-            console.log('  No key provided. Get one at https://warm.io/settings');
-            console.log('');
-            throw new Error(`A ${mode} API key is required to complete setup.`);
-        }
-        apiKeyToStore = apiKey;
-        shouldStoreApiKey = true;
-    }
-    if (shouldValidateApiKey) {
-        const retainedClientApiKeys = force
-            ? []
-            : clientStatuses
-                .filter((status) => status.state === 'configured' ||
-                Boolean(status.apiKeyFileOverride && status.credentialApiKey))
-                .map((status) => status.credentialApiKey);
-        await validateEffectiveApiKeys([apiKeyToStore, ...retainedClientApiKeys], mode);
+async function resolveApiKey(target, ask, confirm, options) {
+    const storedApiKey = fs.existsSync(target) ? fs.readFileSync(target, 'utf8').trim() : '';
+    if (!storedApiKey || options.force) {
+        return {
+            apiKey: await requestedApiKey(ask, options),
+            replaceStoredKey: true,
+        };
     }
-    if (apiKeyToStore && shouldStoreApiKey) {
-        storeApiKey(apiKeyToStore, mode);
+    try {
+        await validateApiKey(storedApiKey, options);
+        return { apiKey: storedApiKey, replaceStoredKey: false };
     }
-    console.log('  Configuring...');
-    console.log('');
-    const configurationFailures = [];
-    needsSetup.forEach((status) => {
-        try {
-            configure(status.client, mode, !force && Boolean(status.apiKeyFileOverride && status.credentialApiKey));
-            console.log(`    ${status.client.name.padEnd(22)} done`);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.log(`    ${status.client.name.padEnd(22)} failed: ${message}`);
-            configurationFailures.push(`${status.client.name}: ${message}`);
+    catch {
+        if (!(await confirm('Replace the existing stored Warm API key?'))) {
+            throw new Error('Warm API key replacement cancelled.');
         }
-    });
-    console.log('');
-    if (configurationFailures.length > 0) {
-        throw new Error(`Failed to configure MCP clients: ${configurationFailures.join('; ')}`);
-    }
-    if (apiKeyToStore) {
-        console.log(`  Stored ${mode} API key at ${shortPath(apiKeyPath)}`);
+        return {
+            apiKey: await requestedApiKey(ask, options),
+            replaceStoredKey: true,
+        };
     }
-    console.log('  All set! Restart your MCP clients and try:');
-    console.log('    "What\'s my net worth?"');
-    console.log('');
 }
+/** Configure detected supported MCP clients for the local stdio server. */
+export async function install(options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const workingDirectory = options.workingDirectory || process.cwd();
+    const ask = options.prompt || readlinePrompt;
+    const confirm = options.confirm ||
+        (async (question) => /^(y|yes)$/i.test(await ask(`${question} [y/N] `)));
+    const targets = [];
+    for (const client of supportedClients(homeDir, workingDirectory)) {
+        const existing = existingWarmConfig(client);
+        if (existing.current)
+            continue;
+        if (existing.exists &&
+            !options.force &&
+            !(await confirm(`Replace the existing Warm MCP configuration in ${client.name}?`)))
+            continue;
+        targets.push(client);
+    }
+    const target = getWarmApiKeyPath();
+    const { apiKey, replaceStoredKey } = await resolveApiKey(target, ask, confirm, options);
+    const clientFiles = targets.map(prepareClientFile);
+    const files = replaceStoredKey ? [...clientFiles, prepareCredentialFile(target, apiKey)] : clientFiles;
+    commitPreparedFiles(files, options.atomicReplaceFile || atomicReplaceFile);
+}
+//# sourceMappingURL=install.js.map