@kbediako/codex-orchestrator 0.1.12 → 0.1.14-alpha.1

package/dist/orchestrator/src/cli/codexCliSetup.js

@@ -0,0 +1,294 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream, existsSync } from 'node:fs';
+import { chmod, copyFile, mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { resolveCodexCliBinPath, resolveCodexCliConfigPath, resolveCodexCliReadiness, resolveCodexCliRoot } from './utils/codexCli.js';
+import { resolveCodexHome } from './utils/codexPaths.js';
+export async function runCodexCliSetup(options = {}) {
+    const env = options.env ?? process.env;
+    const plan = buildCodexCliSetupPlan(options, env);
+    const readiness = resolveCodexCliReadiness(env);
+    if (!options.apply) {
+        return { status: 'planned', plan, readiness, install: readiness.install ?? null };
+    }
+    if (readiness.status === 'ok' && !options.force) {
+        return {
+            status: 'skipped',
+            reason: 'CO-managed Codex CLI already installed.',
+            plan,
+            readiness,
+            install: readiness.install ?? null
+        };
+    }
+    if (readiness.config.status === 'invalid' && !options.force) {
+        throw new Error(`codex-cli config is invalid: ${readiness.config.path}`);
+    }
+    if (plan.method === 'download') {
+        if (!plan.downloadUrl) {
+            throw new Error('codex setup requires --download-url (or CODEX_CLI_DOWNLOAD_URL) when using download mode.');
+        }
+        if (!plan.downloadSha256) {
+            throw new Error('codex setup requires --download-sha256 (or CODEX_CLI_DOWNLOAD_SHA256) for download mode.');
+        }
+        await downloadCodexCli(plan.downloadUrl, plan.binPath, plan.downloadSha256);
+    }
+    else {
+        if (!plan.source) {
+            throw new Error('codex setup requires --source (or CODEX_CLI_SOURCE) when using build mode.');
+        }
+        const workspace = await prepareSource(plan.source, plan.ref, plan.installRoot);
+        try {
+            await buildCodexCli(workspace);
+        }
+        catch (error) {
+            throw formatCargoMissingHint(error);
+        }
+        const builtBinary = join(workspace, 'target', 'release', codexBinaryName());
+        if (!existsSync(builtBinary)) {
+            throw new Error(`codex CLI binary not found at ${builtBinary}`);
+        }
+        await ensureParentDir(plan.binPath);
+        await copyFile(builtBinary, plan.binPath);
+        await chmod(plan.binPath, 0o755);
+    }
+    const install = await writeCodexCliConfig(plan, env);
+    const updatedReadiness = resolveCodexCliReadiness(env);
+    return { status: 'applied', plan, readiness: updatedReadiness, install };
+}
+export function formatCodexCliSetupSummary(result) {
+    const lines = [];
+    lines.push(`Codex CLI setup: ${result.status}`);
+    if (result.reason) {
+        lines.push(`Note: ${result.reason}`);
+    }
+    lines.push(`- Codex home: ${result.plan.codexHome}`);
+    lines.push(`- Install root: ${result.plan.installRoot}`);
+    lines.push(`- Binary: ${result.plan.binPath}`);
+    lines.push(`- Config: ${result.plan.configPath}`);
+    lines.push(`- Method: ${result.plan.method}`);
+    if (result.plan.source) {
+        lines.push(`- Source: ${result.plan.source}`);
+    }
+    if (result.plan.ref) {
+        lines.push(`- Ref: ${result.plan.ref}`);
+    }
+    if (result.plan.downloadUrl) {
+        lines.push(`- Download URL: ${result.plan.downloadUrl}`);
+    }
+    if (result.plan.downloadSha256) {
+        lines.push(`- Download SHA256: ${result.plan.downloadSha256}`);
+    }
+    if (result.install?.sha256) {
+        lines.push(`- Installed SHA256: ${result.install.sha256}`);
+    }
+    lines.push(`- Command: ${result.plan.commandLine}`);
+    if (result.status === 'planned') {
+        lines.push('Run with --yes to apply this setup.');
+    }
+    return lines;
+}
+function buildCodexCliSetupPlan(options, env) {
+    const codexHome = resolveCodexHome(env);
+    const installRoot = resolveCodexCliRoot(env);
+    const binPath = resolveCodexCliBinPath(env);
+    const configPath = resolveCodexCliConfigPath(env);
+    const source = firstNonEmpty(options.source, env.CODEX_CLI_SOURCE);
+    const ref = firstNonEmpty(options.ref, env.CODEX_CLI_REF);
+    const downloadUrl = firstNonEmpty(options.downloadUrl, env.CODEX_CLI_DOWNLOAD_URL);
+    const downloadSha256 = firstNonEmpty(options.downloadSha256, env.CODEX_CLI_DOWNLOAD_SHA256);
+    const method = downloadUrl ? 'download' : 'build';
+    const commandLine = method === 'download'
+        ? `download ${downloadUrl ?? '<download-url>'} (sha256: ${downloadSha256 ?? '<sha256>'})`
+        : `cargo build -p codex-cli --release (cwd: ${source ?? '<source>'})`;
+    return {
+        codexHome,
+        installRoot,
+        binPath,
+        configPath,
+        method,
+        source,
+        ref,
+        downloadUrl,
+        downloadSha256,
+        commandLine
+    };
+}
+async function downloadCodexCli(url, destination, expectedSha256) {
+    await ensureParentDir(destination);
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to download codex CLI: ${response.status} ${response.statusText}`);
+    }
+    const body = response.body;
+    if (!body) {
+        throw new Error('Download response has no body.');
+    }
+    const tempPath = `${destination}.tmp`;
+    try {
+        await pipeline(Readable.fromWeb(body), createWriteStream(tempPath));
+        await chmod(tempPath, 0o755);
+        const actualSha256 = await sha256File(tempPath);
+        if (actualSha256 !== expectedSha256) {
+            throw new Error(`codex CLI sha256 mismatch: expected ${expectedSha256}, got ${actualSha256}`);
+        }
+        await rename(tempPath, destination);
+    }
+    catch (error) {
+        await rm(tempPath, { force: true });
+        throw error;
+    }
+}
+async function prepareSource(source, ref, root) {
+    const resolved = resolve(source);
+    if (existsSync(resolved)) {
+        const workspace = await resolveWorkspace(resolved);
+        if (!workspace) {
+            throw new Error(`codex source missing Cargo workspace at ${resolved}`);
+        }
+        return workspace;
+    }
+    const cloneDir = join(root, 'src');
+    if (!existsSync(cloneDir)) {
+        await runCommand('git', ['clone', source, cloneDir]);
+    }
+    else {
+        await runCommand('git', ['-C', cloneDir, 'fetch', '--all', '--prune']);
+    }
+    if (ref) {
+        await runCommand('git', ['-C', cloneDir, 'checkout', ref]);
+    }
+    const workspace = await resolveWorkspace(cloneDir);
+    if (!workspace) {
+        throw new Error(`codex source missing Cargo workspace at ${cloneDir}`);
+    }
+    return workspace;
+}
+async function resolveWorkspace(sourceRoot) {
+    const nested = join(sourceRoot, 'codex-rs', 'Cargo.toml');
+    if (existsSync(nested)) {
+        return join(sourceRoot, 'codex-rs');
+    }
+    const rootCargo = join(sourceRoot, 'Cargo.toml');
+    if (existsSync(rootCargo)) {
+        return sourceRoot;
+    }
+    return null;
+}
+async function buildCodexCli(workspace) {
+    await runCommand('cargo', ['build', '-p', 'codex-cli', '--release'], { cwd: workspace });
+}
+async function runCommand(command, args, options = {}) {
+    await new Promise((resolvePromise, reject) => {
+        const env = { ...process.env };
+        if (process.stdin?.isTTY !== true) {
+            env.GIT_TERMINAL_PROMPT = env.GIT_TERMINAL_PROMPT ?? '0';
+            env.GIT_ASKPASS = env.GIT_ASKPASS ?? 'echo';
+            env.GCM_INTERACTIVE = env.GCM_INTERACTIVE ?? 'never';
+        }
+        const child = spawn(command, args, { stdio: 'inherit', cwd: options.cwd, env });
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise();
+            }
+            else {
+                reject(new Error(`${command} exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+}
+async function writeCodexCliConfig(plan, env) {
+    const config = {
+        binary_path: plan.binPath,
+        method: plan.method,
+        source: plan.source,
+        ref: plan.ref,
+        installed_at: new Date().toISOString()
+    };
+    if (plan.downloadUrl) {
+        config.source = plan.downloadUrl;
+    }
+    const sha256 = await sha256File(plan.binPath);
+    config.sha256 = sha256;
+    const version = await probeCodexCliVersion(plan.binPath, env);
+    if (version) {
+        config.version = version;
+    }
+    await ensureParentDir(plan.configPath);
+    await writeFile(plan.configPath, JSON.stringify(config, null, 2));
+    return config;
+}
+async function probeCodexCliVersion(binaryPath, env) {
+    try {
+        const output = await execCommand(binaryPath, ['--version'], env);
+        const trimmed = output.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function execCommand(command, args, env) {
+    return await new Promise((resolvePromise, reject) => {
+        const child = spawn(command, args, { env, stdio: ['ignore', 'pipe', 'pipe'] });
+        let stdout = '';
+        let stderr = '';
+        child.stdout?.on('data', (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr += String(chunk);
+        });
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise(stdout);
+            }
+            else {
+                reject(new Error(stderr || `${command} exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+}
+async function ensureParentDir(path) {
+    await mkdir(dirname(path), { recursive: true });
+}
+async function sha256File(path) {
+    return await new Promise((resolvePromise, reject) => {
+        const hash = createHash('sha256');
+        const stream = createReadStream(path);
+        stream.on('data', (chunk) => hash.update(chunk));
+        stream.on('end', () => resolvePromise(hash.digest('hex')));
+        stream.on('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+    });
+}
+function codexBinaryName() {
+    return process.platform === 'win32' ? 'codex.exe' : 'codex';
+}
+function formatCargoMissingHint(error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const message = err.message ?? '';
+    if (isCargoMissingError(err, message)) {
+        return new Error('cargo was not found in PATH. If you installed via rustup, add "$HOME/.cargo/bin" to PATH and retry.');
+    }
+    return err;
+}
+function isCargoMissingError(error, message) {
+    const err = error;
+    if (err.code === 'ENOENT' && message.includes('cargo')) {
+        return true;
+    }
+    return message.includes('spawn cargo ENOENT');
+}
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (value && value.trim()) {
+            return value.trim();
+        }
+    }
+    return undefined;
+}

package/dist/orchestrator/src/cli/init.js

@@ -60,5 +60,8 @@ export function formatInitSummary(result, cwd) {
     if (lines.length === 0) {
         lines.push('No files written.');
     }
+    lines.push('Next steps (recommended):');
+    lines.push(`  - codex mcp add delegation -- codex-orchestrator delegate-server --repo ${cwd}`);
+    lines.push('  - codex-orchestrator codex setup  # optional: CO-managed Codex CLI for collab JSONL');
     return lines;
 }

package/dist/orchestrator/src/cli/mcp.js

@@ -3,6 +3,7 @@ import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import process from 'node:process';
 import { logger } from '../logger.js';
+import { resolveCodexCliBin } from './utils/codexCli.js';
 const MCP_HEADER_TOKEN = 'Content-Length:';
 const MCP_HEADER_DELIMITER = '\r\n\r\n';
 export async function serveMcp(options) {
@@ -12,11 +13,12 @@ export async function serveMcp(options) {
     }
     if (options.dryRun) {
         logger.warn(`[mcp] repo root: ${repoRoot}`);
-        logger.warn('[mcp] codex CLI must be available in PATH.');
+        logger.warn(`[mcp] codex CLI must be available at: ${resolveCodexCliBin()}`);
         return;
     }
     const args = ['-C', repoRoot, 'mcp-server', ...options.extraArgs];
-    const child = spawn('codex', args, { stdio: ['inherit', 'pipe', 'pipe'] });
+    const command = resolveCodexCliBin();
+    const child = spawn(command, args, { stdio: ['inherit', 'pipe', 'pipe'] });
     if (child.stdout) {
         if (isStrictMcpStdout()) {
             attachMcpStdoutGuard(child.stdout);