invokora 0.1.0

package/dist/cli/mcp_setup.js

@@ -0,0 +1,225 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { DEFAULT_MCP_CONFIG_PATHS } from './constants.js';
+const MCP_SERVER_NAME = 'invokora';
+const CLI_NPM_PACKAGE = 'invokora';
+export class McpConfigService {
+    prompts;
+    constructor(prompts) {
+        this.prompts = prompts;
+    }
+    buildServerConfig(_config) {
+        return {
+            command: 'npx',
+            args: ['-y', CLI_NPM_PACKAGE, 'mcp', 'serve'],
+        };
+    }
+    parseSetupArgs(args) {
+        const targets = [];
+        const paths = [];
+        let yes = false;
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg === '--target') {
+                const value = args[i + 1];
+                if (!value)
+                    throw new Error('Missing value for --target');
+                if (!this.isMcpTarget(value))
+                    throw new Error(`Unsupported target: ${value}`);
+                targets.push(value);
+                i++;
+                continue;
+            }
+            if (arg === '--yes') {
+                yes = true;
+                continue;
+            }
+            if (arg === '--path') {
+                const value = args[i + 1];
+                if (!value)
+                    throw new Error('Missing value for --path');
+                paths.push(value);
+                i++;
+                continue;
+            }
+            throw new Error(`Unknown mcp setup option: ${arg}`);
+        }
+        return {
+            targets: this.uniqueTargets(targets),
+            yes,
+            paths,
+        };
+    }
+    async resolveTargets(parsed) {
+        if (parsed.targets.length > 0) {
+            return parsed.targets;
+        }
+        if (parsed.yes) {
+            throw new Error('--yes requires at least one --target');
+        }
+        return this.prompts.pickMcpTargets();
+    }
+    mapPathsToTargets(targets, paths) {
+        const mapping = new Map();
+        if (paths.length === 0)
+            return mapping;
+        if (targets.length === 0) {
+            throw new Error('--path requires explicit --target in non-interactive mode');
+        }
+        if (paths.length === 1 && targets.length === 1) {
+            mapping.set(targets[0], paths[0]);
+            return mapping;
+        }
+        if (paths.length === targets.length) {
+            targets.forEach((target, index) => mapping.set(target, paths[index]));
+            return mapping;
+        }
+        throw new Error('--path count must be 1 (for single target) or match --target count');
+    }
+    async setupTargetConfig(params) {
+        const pathToWrite = params.explicitPath ?? this.resolveClientConfigPath(params.target);
+        if (params.target === 'codex') {
+            const exists = existsSync(pathToWrite);
+            if (!exists && !params.explicitPath && params.yes) {
+                throw new Error('Codex config not found. Use --path to create in non-interactive mode.');
+            }
+            if (!exists && !params.yes) {
+                const confirmed = await this.prompts.yesNo(`Codex config not found at ${pathToWrite}. Create it?`, false);
+                if (!confirmed)
+                    return { status: 'skipped', path: pathToWrite };
+            }
+            this.writeCodexMcpConfig(pathToWrite, params.serverConfig);
+            return { status: 'updated', path: pathToWrite };
+        }
+        this.writeJsonMcpConfig(pathToWrite, params.serverConfig);
+        return { status: 'updated', path: pathToWrite };
+    }
+    resolveClientConfigPath(target) {
+        return DEFAULT_MCP_CONFIG_PATHS[target]();
+    }
+    writeJsonMcpConfig(filePath, serverConfig) {
+        const current = this.loadOrInitMcpConfig(filePath);
+        const next = this.upsertInvokoraServer(current, serverConfig);
+        this.writeSecureFile(filePath, JSON.stringify(next, null, 2) + '\n');
+    }
+    loadOrInitMcpConfig(filePath) {
+        if (!existsSync(filePath))
+            return {};
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            throw new Error(`Invalid JSON in ${filePath}`);
+        }
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error(`Invalid MCP JSON root in ${filePath}`);
+        }
+        return parsed;
+    }
+    upsertInvokoraServer(configJson, serverConfig) {
+        const next = { ...configJson };
+        const rawServers = next.mcpServers;
+        const servers = rawServers && typeof rawServers === 'object' && !Array.isArray(rawServers) ? { ...rawServers } : {};
+        // setup 只接管当前 Invokora 入口，不能顺手覆盖用户别的 MCP 服务配置。
+        servers[MCP_SERVER_NAME] = serverConfig;
+        next.mcpServers = servers;
+        return next;
+    }
+    writeCodexMcpConfig(filePath, serverConfig) {
+        const existing = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+        if (existing && this.isLikelyJson(existing)) {
+            throw new Error(`Codex config expects TOML, but ${filePath} looks like JSON`);
+        }
+        const section = this.renderCodexInvokoraSection(serverConfig);
+        const updated = this.upsertTomlSection(existing, `mcp_servers.${MCP_SERVER_NAME}`, section);
+        this.writeSecureFile(filePath, updated);
+    }
+    writeSecureFile(filePath, content) {
+        mkdirSync(dirname(filePath), { recursive: true });
+        const mode = this.resolveSecureFileMode(filePath);
+        const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+        try {
+            writeFileSync(tmpPath, content, { encoding: 'utf-8', mode });
+            renameSync(tmpPath, filePath);
+        }
+        catch (error) {
+            rmSync(tmpPath, { force: true });
+            throw error;
+        }
+    }
+    resolveSecureFileMode(filePath) {
+        if (!existsSync(filePath)) {
+            return 0o600;
+        }
+        const currentMode = lstatSync(filePath).mode & 0o777;
+        const tightenedMode = currentMode & 0o600;
+        return tightenedMode === 0 ? 0o600 : tightenedMode;
+    }
+    renderCodexInvokoraSection(serverConfig) {
+        const envEntries = Object.entries(serverConfig.env ?? {})
+            .map(([key, value]) => `${key} = "${this.escapeTomlString(value)}"`)
+            .join(', ');
+        const lines = [
+            `[mcp_servers.${MCP_SERVER_NAME}]`,
+            `command = "${this.escapeTomlString(serverConfig.command)}"`,
+            `args = [${serverConfig.args.map((arg) => `"${this.escapeTomlString(arg)}"`).join(', ')}]`,
+        ];
+        if (envEntries !== '') {
+            lines.push(`env = { ${envEntries} }`);
+        }
+        return lines.join('\n');
+    }
+    escapeTomlString(value) {
+        return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    }
+    isLikelyJson(content) {
+        const trimmed = content.trimStart();
+        if (trimmed.startsWith('{'))
+            return true;
+        if (!trimmed.startsWith('['))
+            return false;
+        try {
+            JSON.parse(trimmed);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    upsertTomlSection(content, sectionHeader, sectionContent) {
+        const normalized = content.replace(/\r\n/g, '\n');
+        const lines = normalized.split('\n');
+        const header = `[${sectionHeader}]`;
+        let start = -1;
+        for (let i = 0; i < lines.length; i++) {
+            if (lines[i].trim() === header) {
+                start = i;
+                break;
+            }
+        }
+        const replacementLines = sectionContent.trimEnd().split('\n');
+        if (start >= 0) {
+            let end = lines.length;
+            for (let i = start + 1; i < lines.length; i++) {
+                const trimmed = lines[i].trim();
+                if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                    end = i;
+                    break;
+                }
+            }
+            const merged = [...lines.slice(0, start), ...replacementLines, ...lines.slice(end)].join('\n').trimEnd();
+            return `${merged}\n`;
+        }
+        const base = normalized.trimEnd();
+        if (base.length === 0)
+            return `${sectionContent.trimEnd()}\n`;
+        return `${base}\n\n${sectionContent.trimEnd()}\n`;
+    }
+    isMcpTarget(value) {
+        return value === 'claude' || value === 'cursor' || value === 'codex';
+    }
+    uniqueTargets(targets) {
+        return [...new Set(targets)];
+    }
+}

package/dist/cli/oauth.d.ts

@@ -0,0 +1,45 @@
+import type { LoginCommandOptions, OAuthCallbackPayload, OAuthExchangeResponse, OAuthLoopbackListener, OAuthStartResponse, RunOAuthBrowserLoginParams } from './types.js';
+export declare function base64UrlEncode(input: Buffer): string;
+export declare function generateOAuthState(): string;
+export declare function generateCodeVerifier(): string;
+export declare function buildS256CodeChallenge(codeVerifier: string): string;
+export declare function parseLoginCommandOptions(args: string[]): LoginCommandOptions;
+export declare function chooseLoopbackHost(address: string): string;
+export declare function openBrowserURL(url: string): Promise<boolean>;
+export declare function normalizeCallbackError(payload: OAuthCallbackPayload): string;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutMessage: string): Promise<T>;
+export declare class OAuthLoopbackServer implements OAuthLoopbackListener {
+    private readonly expectedState;
+    private readonly timeoutMs;
+    private readonly server;
+    private closed;
+    private settled;
+    private redirectUrl;
+    private resolveCallback;
+    private readonly callbackPromise;
+    private constructor();
+    static create(expectedState: string, timeoutMs: number): Promise<OAuthLoopbackServer>;
+    get redirectURI(): string;
+    waitForCallback(): Promise<OAuthCallbackPayload>;
+    close(): Promise<void>;
+    private listen;
+    private buildRedirectURI;
+    private complete;
+    private handleRequest;
+}
+export declare function createOAuthLoopbackListener(expectedState: string, timeoutMs: number): Promise<OAuthLoopbackListener>;
+export declare class OAuthCLIClient {
+    private readonly backendUrl;
+    private readonly fetchImpl;
+    constructor(backendUrl: string, fetchImpl?: typeof fetch);
+    start(redirectURI: string, state: string, codeChallenge: string): Promise<OAuthStartResponse>;
+    exchange(state: string, codeVerifier: string, code: string): Promise<OAuthExchangeResponse>;
+}
+export declare function startOAuthCLI(backendUrl: string, redirectURI: string, state: string, codeChallenge: string, fetchImpl: typeof fetch): Promise<OAuthStartResponse>;
+export declare function exchangeOAuthCode(backendUrl: string, state: string, codeVerifier: string, code: string, fetchImpl: typeof fetch): Promise<OAuthExchangeResponse>;
+export declare class OAuthBrowserLoginFlow {
+    private readonly params;
+    constructor(params: RunOAuthBrowserLoginParams);
+    run(): Promise<OAuthExchangeResponse>;
+}
+export declare function runOAuthBrowserLogin(params: RunOAuthBrowserLoginParams): Promise<OAuthExchangeResponse>;