@agentconnect/cli 0.1.0

package/dist/providers/codex.js

@@ -0,0 +1,509 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { buildInstallCommandAuto, buildLoginCommand, buildStatusCommand, checkCommandVersion, commandExists, createLineParser, debugLog, resolveWindowsCommand, resolveCommandPath, runCommand, } from './utils.js';
+const CODEX_PACKAGE = '@openai/codex';
+const DEFAULT_LOGIN = 'codex login';
+const DEFAULT_STATUS = 'codex login status';
+const CODEX_MODELS_CACHE_TTL_MS = 60_000;
+let codexModelsCache = null;
+let codexModelsCacheAt = 0;
+function trimOutput(value, limit = 400) {
+    const cleaned = value.trim();
+    if (!cleaned)
+        return '';
+    if (cleaned.length <= limit)
+        return cleaned;
+    return `${cleaned.slice(0, limit)}...`;
+}
+function buildCodexExecArgs(options) {
+    const { prompt, cdTarget, resumeSessionId, model, reasoningEffort, mode } = options;
+    const args = ['exec', '--skip-git-repo-check'];
+    if (mode === 'legacy') {
+        args.push('--json', '-C', cdTarget);
+    }
+    else {
+        args.push('--experimental-json', '--cd', cdTarget);
+    }
+    args.push('--yolo');
+    if (model) {
+        args.push('--model', String(model));
+    }
+    if (reasoningEffort) {
+        args.push('--config', `model_reasoning_effort=${reasoningEffort}`);
+    }
+    if (resumeSessionId) {
+        args.push('resume', resumeSessionId);
+    }
+    args.push(prompt);
+    return args;
+}
+function shouldFallbackToLegacy(lines) {
+    const combined = lines.join(' ').toLowerCase();
+    if (!(combined.includes('unknown flag') ||
+        combined.includes('unknown option') ||
+        combined.includes('unrecognized option') ||
+        combined.includes('unknown argument') ||
+        combined.includes('unexpected argument') ||
+        combined.includes('invalid option') ||
+        combined.includes('invalid argument'))) {
+        return false;
+    }
+    return combined.includes('experimental-json') || combined.includes('--cd');
+}
+export function getCodexCommand() {
+    const override = process.env.AGENTCONNECT_CODEX_COMMAND;
+    const base = override || 'codex';
+    const resolved = resolveCommandPath(base);
+    return resolved || resolveWindowsCommand(base);
+}
+export async function ensureCodexInstalled() {
+    const command = getCodexCommand();
+    const versionCheck = await checkCommandVersion(command, [['--version'], ['-V']]);
+    if (versionCheck.ok) {
+        return { installed: true, version: versionCheck.version || undefined };
+    }
+    if (commandExists(command)) {
+        return { installed: true, version: undefined };
+    }
+    const install = await buildInstallCommandAuto(CODEX_PACKAGE);
+    if (!install.command) {
+        return { installed: false, version: undefined, packageManager: install.packageManager };
+    }
+    debugLog('Codex', 'install', { command: install.command, args: install.args });
+    const installResult = await runCommand(install.command, install.args, {
+        shell: process.platform === 'win32',
+    });
+    debugLog('Codex', 'install-result', {
+        code: installResult.code,
+        stderr: trimOutput(installResult.stderr),
+    });
+    const after = await checkCommandVersion(command, [['--version'], ['-V']]);
+    // Invalidate models cache after installation so fresh models are fetched
+    codexModelsCache = null;
+    codexModelsCacheAt = 0;
+    return {
+        installed: after.ok,
+        version: after.version || undefined,
+        packageManager: install.packageManager,
+    };
+}
+export async function getCodexStatus() {
+    const command = getCodexCommand();
+    const versionCheck = await checkCommandVersion(command, [['--version'], ['-V']]);
+    const installed = versionCheck.ok || commandExists(command);
+    let loggedIn = false;
+    if (installed) {
+        const status = buildStatusCommand('AGENTCONNECT_CODEX_STATUS', DEFAULT_STATUS);
+        if (status.command) {
+            const statusCommand = resolveWindowsCommand(status.command);
+            const result = await runCommand(statusCommand, status.args);
+            loggedIn = result.code === 0;
+        }
+    }
+    return { installed, loggedIn, version: versionCheck.version || undefined };
+}
+export async function loginCodex() {
+    const login = buildLoginCommand('AGENTCONNECT_CODEX_LOGIN', DEFAULT_LOGIN);
+    if (!login.command) {
+        return { loggedIn: false };
+    }
+    const command = resolveWindowsCommand(login.command);
+    debugLog('Codex', 'login', { command, args: login.args });
+    const result = await runCommand(command, login.args, { env: { ...process.env, CI: '1' } });
+    debugLog('Codex', 'login-result', { code: result.code, stderr: trimOutput(result.stderr) });
+    const status = await getCodexStatus();
+    codexModelsCache = null;
+    codexModelsCacheAt = 0;
+    return { loggedIn: status.loggedIn };
+}
+function safeJsonParse(line) {
+    try {
+        return JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+}
+function extractSessionId(ev) {
+    const t = String(ev.type ?? '');
+    if (t === 'thread.started') {
+        return typeof ev.thread_id === 'string' ? ev.thread_id : null;
+    }
+    const id = ev.thread_id ?? ev.threadId ?? ev.session_id ?? ev.sessionId;
+    return typeof id === 'string' ? id : null;
+}
+function extractUsage(ev) {
+    const usage = ev.usage ?? ev.token_usage ?? ev.tokens ?? ev.tokenUsage;
+    if (!usage || typeof usage !== 'object')
+        return null;
+    const toNumber = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+    const input = toNumber(usage.input_tokens ?? usage.prompt_tokens ?? usage.inputTokens ?? usage.promptTokens);
+    const output = toNumber(usage.output_tokens ?? usage.completion_tokens ?? usage.outputTokens ?? usage.completionTokens);
+    const total = toNumber(usage.total_tokens ?? usage.totalTokens);
+    const cached = toNumber(usage.cached_input_tokens ?? usage.cachedInputTokens);
+    const out = {};
+    if (input !== undefined)
+        out.input_tokens = input;
+    if (output !== undefined)
+        out.output_tokens = output;
+    if (total !== undefined)
+        out.total_tokens = total;
+    if (cached !== undefined)
+        out.cached_input_tokens = cached;
+    return Object.keys(out).length ? out : null;
+}
+function normalizeItem(raw) {
+    if (!raw || typeof raw !== 'object')
+        return raw;
+    const item = raw;
+    const type = item.type;
+    const id = item.id;
+    if (type === 'command_execution' && id) {
+        return {
+            id,
+            type,
+            command: item.command || '',
+            aggregated_output: item.aggregated_output,
+            exit_code: item.exit_code,
+            status: item.status,
+        };
+    }
+    if (type === 'reasoning' && id) {
+        return { id, type, text: item.text || '' };
+    }
+    if (type === 'agent_message' && id) {
+        return { id, type, text: item.text || '' };
+    }
+    return raw;
+}
+function normalizeEvent(raw) {
+    const type = typeof raw.type === 'string' ? raw.type : 'unknown';
+    if (type === 'item.started' || type === 'item.completed') {
+        return { type, item: normalizeItem(raw.item) };
+    }
+    if (type === 'agent_message') {
+        return { type, text: raw.text || '' };
+    }
+    if (type === 'error') {
+        return { type, message: raw.message || 'Unknown error' };
+    }
+    return { ...raw, type };
+}
+function isTerminalEvent(ev) {
+    const t = String(ev.type ?? '');
+    return t === 'turn.completed' || t === 'turn.failed';
+}
+function normalizeEffortId(raw) {
+    if (!raw)
+        return null;
+    return String(raw).trim().toLowerCase();
+}
+function formatEffortLabel(id) {
+    if (!id)
+        return '';
+    const normalized = String(id).trim().toLowerCase();
+    if (normalized === 'xhigh')
+        return 'X-High';
+    if (normalized === 'none')
+        return 'None';
+    if (normalized === 'minimal')
+        return 'Minimal';
+    if (normalized === 'low')
+        return 'Low';
+    if (normalized === 'medium')
+        return 'Medium';
+    if (normalized === 'high')
+        return 'High';
+    return normalized.toUpperCase();
+}
+function normalizeEffortOptions(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const options = raw
+        .map((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return null;
+        const opt = entry;
+        const id = normalizeEffortId(opt.reasoning_effort ?? opt.reasoningEffort ?? opt.effort ?? opt.level);
+        if (!id)
+            return null;
+        const label = formatEffortLabel(id);
+        return { id, label };
+    })
+        .filter((x) => x !== null);
+    const seen = new Set();
+    return options.filter((option) => {
+        if (seen.has(option.id))
+            return false;
+        seen.add(option.id);
+        return true;
+    });
+}
+function normalizeCodexModels(raw) {
+    const response = raw;
+    const list = Array.isArray(response?.data)
+        ? response.data
+        : Array.isArray(response?.items)
+            ? response.items
+            : [];
+    const mapped = [];
+    for (const item of list) {
+        if (!item || typeof item !== 'object')
+            continue;
+        const id = item.id || item.model;
+        if (!id)
+            continue;
+        const displayName = item.displayName || item.display_name || item.name || item.title || String(id);
+        const reasoningEfforts = normalizeEffortOptions(item.supportedReasoningEfforts ||
+            item.supported_reasoning_efforts ||
+            item.supportedReasoningLevels ||
+            item.supported_reasoning_levels);
+        const defaultReasoningEffort = normalizeEffortId(item.defaultReasoningEffort || item.default_reasoning_effort);
+        mapped.push({
+            id: String(id),
+            provider: 'codex',
+            displayName: String(displayName),
+            reasoningEfforts: reasoningEfforts.length ? reasoningEfforts : undefined,
+            defaultReasoningEffort: defaultReasoningEffort || undefined,
+        });
+    }
+    if (!mapped.length)
+        return [];
+    const seen = new Set();
+    return mapped.filter((model) => {
+        const key = model.id;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+async function fetchCodexModels(command) {
+    return new Promise((resolve) => {
+        const child = spawn(command, ['app-server'], {
+            env: { ...process.env },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let settled = false;
+        const initId = 1;
+        const listId = 2;
+        const timeout = setTimeout(() => {
+            finalize(null);
+        }, 8000);
+        const finalize = (models) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            child.kill('SIGTERM');
+            resolve(models);
+        };
+        const handleLine = (line) => {
+            const parsed = safeJsonParse(line);
+            if (!parsed || typeof parsed !== 'object')
+                return;
+            if (parsed.id === listId && parsed.result) {
+                finalize(normalizeCodexModels(parsed.result));
+            }
+            if (parsed.id === listId && parsed.error) {
+                finalize(null);
+            }
+        };
+        const stdoutParser = createLineParser(handleLine);
+        child.stdout?.on('data', stdoutParser);
+        child.stderr?.on('data', () => { });
+        child.on('error', () => finalize(null));
+        child.on('close', () => finalize(null));
+        if (!child.stdin) {
+            finalize(null);
+            return;
+        }
+        const initialize = {
+            method: 'initialize',
+            id: initId,
+            params: {
+                clientInfo: { name: 'agentconnect', title: 'AgentConnect', version: '0.1.0' },
+            },
+        };
+        const initialized = { method: 'initialized' };
+        const listRequest = { method: 'model/list', id: listId, params: { cursor: null, limit: null } };
+        const payload = `${JSON.stringify(initialize)}\n${JSON.stringify(initialized)}\n${JSON.stringify(listRequest)}\n`;
+        child.stdin.write(payload);
+    });
+}
+export async function listCodexModels() {
+    if (codexModelsCache && Date.now() - codexModelsCacheAt < CODEX_MODELS_CACHE_TTL_MS) {
+        return codexModelsCache;
+    }
+    const command = getCodexCommand();
+    const versionCheck = await checkCommandVersion(command, [['--version'], ['-V']]);
+    if (!versionCheck.ok) {
+        // Codex not installed - return empty, don't cache
+        return [];
+    }
+    const models = await fetchCodexModels(command);
+    if (models && models.length) {
+        codexModelsCache = models;
+        codexModelsCacheAt = Date.now();
+        return models;
+    }
+    // Fetch failed - return empty, don't cache so it retries next time
+    return [];
+}
+export function runCodexPrompt({ prompt, resumeSessionId, model, reasoningEffort, repoRoot, cwd, onEvent, signal, }) {
+    return new Promise((resolve) => {
+        const command = getCodexCommand();
+        const resolvedRepoRoot = repoRoot ? path.resolve(repoRoot) : null;
+        const resolvedCwd = cwd ? path.resolve(cwd) : null;
+        const runDir = resolvedCwd || resolvedRepoRoot || process.cwd();
+        const cdTarget = resolvedRepoRoot || resolvedCwd || '.';
+        const runAttempt = (mode) => new Promise((attemptResolve) => {
+            const args = buildCodexExecArgs({
+                prompt,
+                cdTarget,
+                resumeSessionId,
+                model,
+                reasoningEffort,
+                mode,
+            });
+            const argsPreview = [...args];
+            if (argsPreview.length > 0) {
+                argsPreview[argsPreview.length - 1] = '[prompt]';
+            }
+            debugLog('Codex', 'spawn', { command, args: argsPreview, cwd: runDir, mode });
+            const child = spawn(command, args, {
+                cwd: runDir,
+                env: { ...process.env },
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            if (signal) {
+                signal.addEventListener('abort', () => {
+                    child.kill('SIGTERM');
+                });
+            }
+            let aggregated = '';
+            let finalSessionId = null;
+            let didFinalize = false;
+            let sawError = false;
+            const emitError = (message) => {
+                if (sawError)
+                    return;
+                sawError = true;
+                onEvent({ type: 'error', message });
+            };
+            let sawJson = false;
+            const stdoutLines = [];
+            const stderrLines = [];
+            const pushLine = (list, line) => {
+                if (!line)
+                    return;
+                list.push(line);
+                if (list.length > 12)
+                    list.shift();
+            };
+            const handleLine = (line, source) => {
+                const parsed = safeJsonParse(line);
+                if (!parsed || typeof parsed !== 'object') {
+                    if (source === 'stdout') {
+                        pushLine(stdoutLines, line);
+                    }
+                    else {
+                        pushLine(stderrLines, line);
+                    }
+                    return;
+                }
+                sawJson = true;
+                const ev = parsed;
+                const normalized = normalizeEvent(ev);
+                const sid = extractSessionId(ev);
+                if (sid)
+                    finalSessionId = sid;
+                const usage = extractUsage(ev);
+                if (usage) {
+                    onEvent({
+                        type: 'usage',
+                        inputTokens: usage.input_tokens,
+                        outputTokens: usage.output_tokens,
+                    });
+                }
+                if (normalized.type === 'agent_message') {
+                    const text = normalized.text;
+                    if (typeof text === 'string' && text) {
+                        aggregated += text;
+                        onEvent({ type: 'delta', text });
+                    }
+                }
+                else if (normalized.type === 'item.completed') {
+                    const item = normalized.item;
+                    if (item && typeof item === 'object') {
+                        if (item.type === 'command_execution' && typeof item.aggregated_output === 'string') {
+                            onEvent({ type: 'delta', text: item.aggregated_output });
+                        }
+                        if (item.type === 'agent_message' && typeof item.text === 'string') {
+                            aggregated += item.text;
+                            onEvent({ type: 'delta', text: item.text });
+                        }
+                    }
+                }
+                if (isTerminalEvent(ev) && !didFinalize) {
+                    if (ev.type === 'turn.failed') {
+                        const message = ev.error?.message;
+                        emitError(typeof message === 'string' ? message : 'Codex run failed');
+                        didFinalize = true;
+                        return;
+                    }
+                    if (!sawError) {
+                        didFinalize = true;
+                        onEvent({ type: 'final', text: aggregated });
+                    }
+                }
+            };
+            const stdoutParser = createLineParser((line) => handleLine(line, 'stdout'));
+            const stderrParser = createLineParser((line) => handleLine(line, 'stderr'));
+            child.stdout?.on('data', stdoutParser);
+            child.stderr?.on('data', stderrParser);
+            child.on('close', (code) => {
+                if (!didFinalize) {
+                    if (code && code !== 0) {
+                        const hint = stderrLines.at(-1) || stdoutLines.at(-1) || '';
+                        const suffix = hint ? `: ${hint}` : '';
+                        const fallback = mode === 'modern' && !sawJson && shouldFallbackToLegacy([
+                            ...stderrLines,
+                            ...stdoutLines,
+                        ]);
+                        debugLog('Codex', 'exit', {
+                            code,
+                            stderr: stderrLines,
+                            stdout: stdoutLines,
+                            fallback,
+                        });
+                        if (fallback) {
+                            attemptResolve({ sessionId: finalSessionId, fallback: true });
+                            return;
+                        }
+                        emitError(`Codex exited with code ${code}${suffix}`);
+                    }
+                    else if (!sawError) {
+                        onEvent({ type: 'final', text: aggregated });
+                    }
+                }
+                attemptResolve({ sessionId: finalSessionId, fallback: false });
+            });
+            child.on('error', (err) => {
+                debugLog('Codex', 'spawn-error', { message: err?.message });
+                emitError(err?.message ?? 'Codex failed to start');
+                attemptResolve({ sessionId: finalSessionId, fallback: false });
+            });
+        });
+        void (async () => {
+            const primary = await runAttempt('modern');
+            if (primary.fallback) {
+                debugLog('Codex', 'fallback', { from: 'modern', to: 'legacy' });
+                const legacy = await runAttempt('legacy');
+                resolve({ sessionId: legacy.sessionId });
+                return;
+            }
+            resolve({ sessionId: primary.sessionId });
+        })();
+    });
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,5 @@
+import type { Provider, ProviderId, ModelInfo } from '../types.js';
+export declare const providers: Record<ProviderId, Provider>;
+export declare function listModels(): Promise<ModelInfo[]>;
+export declare function listRecentModels(providerId?: ProviderId): Promise<ModelInfo[]>;
+export declare function resolveProviderForModel(model: string | undefined): ProviderId;

package/dist/providers/index.js

@@ -0,0 +1,90 @@
+import { ensureClaudeInstalled, getClaudeStatus, listClaudeModels, listClaudeRecentModels, loginClaude, runClaudePrompt, } from './claude.js';
+import { ensureCodexInstalled, getCodexStatus, listCodexModels, loginCodex, runCodexPrompt, } from './codex.js';
+import { ensureLocalInstalled, getLocalStatus, listLocalModels, loginLocal, runLocalPrompt, } from './local.js';
+export const providers = {
+    claude: {
+        id: 'claude',
+        name: 'Claude',
+        ensureInstalled: ensureClaudeInstalled,
+        status: getClaudeStatus,
+        login: loginClaude,
+        logout: async () => { },
+        runPrompt: runClaudePrompt,
+    },
+    codex: {
+        id: 'codex',
+        name: 'Codex',
+        ensureInstalled: ensureCodexInstalled,
+        status: getCodexStatus,
+        login: loginCodex,
+        logout: async () => { },
+        runPrompt: runCodexPrompt,
+    },
+    local: {
+        id: 'local',
+        name: 'Local',
+        ensureInstalled: ensureLocalInstalled,
+        status: getLocalStatus,
+        login: loginLocal,
+        logout: async () => { },
+        runPrompt: runLocalPrompt,
+    },
+};
+export async function listModels() {
+    const claudeModels = await listClaudeModels();
+    const codexModels = await listCodexModels();
+    const base = [
+        ...claudeModels,
+        { id: 'local', provider: 'local', displayName: 'Local Model' },
+    ];
+    const envModels = process.env.AGENTCONNECT_LOCAL_MODELS;
+    if (envModels) {
+        try {
+            const parsed = JSON.parse(envModels);
+            if (Array.isArray(parsed)) {
+                for (const entry of parsed) {
+                    if (typeof entry === 'string' && entry) {
+                        base.push({ id: entry, provider: 'local', displayName: entry });
+                    }
+                }
+            }
+        }
+        catch {
+            // ignore invalid json
+        }
+    }
+    const discovered = await listLocalModels();
+    const all = [...base, ...codexModels, ...discovered.filter((entry) => entry.id !== 'local')];
+    const seen = new Set();
+    return all.filter((entry) => {
+        const key = `${entry.provider}:${entry.id}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export async function listRecentModels(providerId) {
+    if (providerId && providerId !== 'claude')
+        return [];
+    const recent = await listClaudeRecentModels();
+    return recent.filter((entry) => entry.provider === 'claude');
+}
+export function resolveProviderForModel(model) {
+    const lower = String(model || '').toLowerCase();
+    if (lower.includes('codex'))
+        return 'codex';
+    if (lower.startsWith('gpt') ||
+        lower.startsWith('o1') ||
+        lower.startsWith('o3') ||
+        lower.startsWith('o4')) {
+        return 'codex';
+    }
+    if (lower.includes('local'))
+        return 'local';
+    if (lower.includes('opus') || lower.includes('sonnet') || lower.includes('haiku'))
+        return 'claude';
+    if (lower.includes('claude'))
+        return 'claude';
+    return 'claude';
+}

package/dist/providers/local.d.ts

@@ -0,0 +1,8 @@
+import type { ProviderStatus, ProviderLoginOptions, ModelInfo, RunPromptOptions, RunPromptResult, InstallResult } from '../types.js';
+export declare function ensureLocalInstalled(): Promise<InstallResult>;
+export declare function getLocalStatus(): Promise<ProviderStatus>;
+export declare function loginLocal(options?: ProviderLoginOptions): Promise<{
+    loggedIn: boolean;
+}>;
+export declare function listLocalModels(): Promise<ModelInfo[]>;
+export declare function runLocalPrompt({ prompt, model, onEvent, }: RunPromptOptions): Promise<RunPromptResult>;