@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -0,0 +1,274 @@
+import process from 'node:process';
+import { logger } from '../logger.js';
+export const MAX_MCP_MESSAGE_BYTES = 1024 * 1024;
+export const MAX_MCP_HEADER_BYTES = 16 * 1024;
+const MCP_HEADER_DELIMITER = '\r\n\r\n';
+const MCP_HEADER_DELIMITER_BYTES = MCP_HEADER_DELIMITER.length;
+const MCP_HEADER_DELIMITER_BUFFER = Buffer.from(MCP_HEADER_DELIMITER, 'utf8');
+const MAX_MCP_BUFFER_BYTES = (MAX_MCP_MESSAGE_BYTES + MAX_MCP_HEADER_BYTES + MCP_HEADER_DELIMITER_BYTES) * 2;
+export async function runJsonRpcServer(handler, options = {}) {
+    let buffer = Buffer.alloc(0);
+    let expectedLength = null;
+    let processing = Promise.resolve();
+    let halted = false;
+    let inFlightRequests = 0;
+    const input = options.stdin ?? process.stdin;
+    const output = options.stdout ?? process.stdout;
+    const idleTimeoutMs = typeof options.idleTimeoutMs === 'number' && Number.isFinite(options.idleTimeoutMs)
+        ? Math.max(0, Math.floor(options.idleTimeoutMs))
+        : 0;
+    let idleTimer = null;
+    const clearIdleTimer = () => {
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+        }
+    };
+    const armIdleTimer = () => {
+        clearIdleTimer();
+        if (halted || idleTimeoutMs <= 0 || inFlightRequests > 0) {
+            return;
+        }
+        idleTimer = setTimeout(() => {
+            if (halted || inFlightRequests > 0) {
+                return;
+            }
+            halted = true;
+            if (typeof input.pause === 'function') {
+                input.pause();
+            }
+            if (options.onIdleTimeout) {
+                options.onIdleTimeout();
+                return;
+            }
+            process.exit(0);
+        }, idleTimeoutMs);
+        idleTimer.unref?.();
+    };
+    const handleProtocolViolation = (message) => {
+        if (halted) {
+            return;
+        }
+        halted = true;
+        clearIdleTimer();
+        logger.warn(message);
+        process.exitCode = 1;
+        buffer = Buffer.alloc(0);
+        expectedLength = null;
+        if (typeof input.pause === 'function') {
+            input.pause();
+        }
+    };
+    const handleInputError = (error) => {
+        if (halted) {
+            return;
+        }
+        halted = true;
+        clearIdleTimer();
+        const detail = error instanceof Error ? error.message : String(error);
+        logger.error(`MCP input stream error: ${detail}`);
+        process.exitCode = 1;
+        buffer = Buffer.alloc(0);
+        expectedLength = null;
+        if (typeof input.pause === 'function') {
+            input.pause();
+        }
+    };
+    input.on('data', (chunk) => {
+        if (halted) {
+            return;
+        }
+        clearIdleTimer();
+        buffer = Buffer.concat([buffer, Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)]);
+        if (buffer.length > MAX_MCP_BUFFER_BYTES) {
+            handleProtocolViolation(`Rejecting MCP buffer larger than ${MAX_MCP_BUFFER_BYTES} bytes`);
+            return;
+        }
+        processing = processing
+            .then(async () => {
+            await processBuffer();
+            if (!halted) {
+                armIdleTimer();
+            }
+        })
+            .catch((error) => {
+            logger.error(`Failed to process MCP buffer: ${error?.message ?? error}`);
+        });
+    });
+    input.on('end', clearIdleTimer);
+    input.on('close', clearIdleTimer);
+    input.on('error', handleInputError);
+    armIdleTimer();
+    async function processBuffer() {
+        while (buffer.length > 0) {
+            if (halted) {
+                return;
+            }
+            if (expectedLength !== null) {
+                if (buffer.length < expectedLength) {
+                    return;
+                }
+                const body = buffer.slice(0, expectedLength);
+                buffer = buffer.slice(expectedLength);
+                expectedLength = null;
+                await handleMessage(body.toString('utf8'), 'framed');
+                continue;
+            }
+            const headerEnd = buffer.indexOf('\r\n\r\n');
+            if (headerEnd === -1) {
+                const newlineIndex = buffer.indexOf('\n');
+                if (newlineIndex !== -1) {
+                    const lineBuffer = buffer.slice(0, newlineIndex);
+                    const line = lineBuffer.toString('utf8').trim();
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (!line) {
+                        continue;
+                    }
+                    const normalizedLine = line.trimStart();
+                    const looksLikeHeaderLine = /^[A-Za-z0-9-]+:/.test(normalizedLine);
+                    const looksLikeJson = normalizedLine.startsWith('{') || normalizedLine.startsWith('[');
+                    const isContentLength = normalizedLine.toLowerCase().startsWith('content-length:');
+                    let restoredHeader = false;
+                    if (!looksLikeJson && looksLikeHeaderLine) {
+                        buffer = Buffer.concat([Buffer.from(lineBuffer), Buffer.from('\n'), buffer]);
+                        restoredHeader = true;
+                    }
+                    else if (!isContentLength) {
+                        const lineBytes = Buffer.byteLength(line, 'utf8');
+                        if (lineBytes > MAX_MCP_MESSAGE_BYTES) {
+                            handleProtocolViolation(`Rejecting MCP payload (${lineBytes} bytes) larger than ${MAX_MCP_MESSAGE_BYTES}`);
+                            return;
+                        }
+                        await handleMessage(line, 'jsonl');
+                        continue;
+                    }
+                    if (!restoredHeader && isContentLength) {
+                        buffer = Buffer.concat([Buffer.from(lineBuffer), Buffer.from('\n'), buffer]);
+                    }
+                }
+                else if (buffer.length > MAX_MCP_MESSAGE_BYTES) {
+                    handleProtocolViolation(`Rejecting MCP payload (${buffer.length} bytes) larger than ${MAX_MCP_MESSAGE_BYTES}`);
+                    return;
+                }
+                if (buffer.length > MAX_MCP_HEADER_BYTES) {
+                    const overflow = buffer.slice(MAX_MCP_HEADER_BYTES);
+                    const allowedPrefix = MCP_HEADER_DELIMITER_BUFFER.subarray(0, overflow.length);
+                    if (overflow.length > MCP_HEADER_DELIMITER_BYTES || !overflow.equals(allowedPrefix)) {
+                        handleProtocolViolation(`Rejecting MCP header larger than ${MAX_MCP_HEADER_BYTES} bytes`);
+                    }
+                }
+                return;
+            }
+            if (headerEnd > MAX_MCP_HEADER_BYTES) {
+                handleProtocolViolation(`Rejecting MCP header larger than ${MAX_MCP_HEADER_BYTES} bytes`);
+                return;
+            }
+            const header = buffer.slice(0, headerEnd).toString('utf8');
+            const parsed = parseContentLengthHeader(header);
+            if (parsed.error) {
+                handleProtocolViolation(parsed.error);
+                return;
+            }
+            if (parsed.length === null) {
+                const lines = header.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+                if (lines.length === 0) {
+                    buffer = buffer.slice(headerEnd + 4);
+                    continue;
+                }
+                const allJsonLike = lines.every((line) => line.startsWith('{') || line.startsWith('['));
+                if (allJsonLike) {
+                    buffer = buffer.slice(headerEnd + 4);
+                    for (const line of lines) {
+                        await handleMessage(line, 'jsonl');
+                    }
+                    continue;
+                }
+                handleProtocolViolation('Missing Content-Length header in MCP message');
+                return;
+            }
+            const length = parsed.length;
+            if (!Number.isFinite(length) || length < 0) {
+                handleProtocolViolation('Invalid Content-Length for MCP payload');
+                return;
+            }
+            if (length > MAX_MCP_MESSAGE_BYTES) {
+                handleProtocolViolation(`Rejecting MCP payload (${length} bytes) larger than ${MAX_MCP_MESSAGE_BYTES}`);
+                return;
+            }
+            expectedLength = length;
+            buffer = buffer.slice(headerEnd + 4);
+        }
+    }
+    async function handleMessage(raw, format) {
+        clearIdleTimer();
+        inFlightRequests += 1;
+        let request;
+        try {
+            request = JSON.parse(raw);
+        }
+        catch (error) {
+            logger.error(`Failed to parse MCP message: ${error?.message ?? error}`);
+            inFlightRequests -= 1;
+            armIdleTimer();
+            return;
+        }
+        if (typeof request.method !== 'string') {
+            inFlightRequests -= 1;
+            armIdleTimer();
+            return;
+        }
+        const id = request.id ?? null;
+        try {
+            const result = await handler(request);
+            if (id !== null && typeof id !== 'undefined') {
+                sendResponse({ jsonrpc: '2.0', id, result }, output, format);
+            }
+        }
+        catch (error) {
+            if (id !== null && typeof id !== 'undefined') {
+                sendResponse({
+                    jsonrpc: '2.0',
+                    id,
+                    error: { code: -32603, message: error?.message ?? String(error) }
+                }, output, format);
+            }
+        }
+        finally {
+            inFlightRequests = Math.max(0, inFlightRequests - 1);
+            armIdleTimer();
+        }
+    }
+}
+export function parseContentLengthHeader(header) {
+    const lines = header.split(/\r?\n/);
+    let contentLength = null;
+    for (const line of lines) {
+        const separator = line.indexOf(':');
+        if (separator === -1) {
+            continue;
+        }
+        const name = line.slice(0, separator).trim().toLowerCase();
+        if (name !== 'content-length') {
+            continue;
+        }
+        if (contentLength !== null) {
+            return { length: null, error: 'Multiple Content-Length headers in MCP message' };
+        }
+        const value = line.slice(separator + 1).trim();
+        if (!/^\d+$/.test(value)) {
+            return { length: null, error: 'Invalid Content-Length header in MCP message' };
+        }
+        contentLength = Number(value);
+    }
+    return { length: contentLength };
+}
+function sendResponse(response, output = process.stdout, format = 'framed') {
+    const payload = JSON.stringify(response);
+    if (format === 'jsonl') {
+        output.write(`${payload}\n`);
+        return;
+    }
+    const buffer = Buffer.from(payload, 'utf8');
+    const header = Buffer.from(`Content-Length: ${buffer.length}\r\n\r\n`, 'utf8');
+    output.write(Buffer.concat([header, buffer]));
+}

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

@@ -1,16 +1,22 @@
-import { spawn, spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import process from 'node:process';
-import { existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { resolveCodexCliBin } from './utils/codexCli.js';
 import { resolveCodexHome } from './utils/codexPaths.js';
 import { buildCommandPreview } from './utils/commandPreview.js';
+import { readDelegationFallbackConfig } from './utils/delegationConfigParser.js';
+import { classifyDelegationTransport, inspectDelegationMcpConfig, readPinnedRepo, resolveDelegationServerInvocation } from './utils/delegationMcpHealth.js';
 export async function runDelegationSetup(options = {}) {
     const env = options.env ?? process.env;
     const repoRoot = resolve(options.repoRoot ?? process.cwd());
     const codexBin = resolveCodexCliBin(env);
     const codexHome = resolveCodexHome(env);
     const configPath = join(codexHome, 'config.toml');
+    const delegateServer = resolveDelegationServerInvocation({
+        allowMissingDist: !options.apply,
+        env,
+        execPath: process.execPath
+    });
     const plan = {
         codexBin,
         codexHome,
@@ -20,13 +26,13 @@ export async function runDelegationSetup(options = {}) {
             'add',
             'delegation',
             '--',
-            'codex-orchestrator',
-            'delegate-server',
+            delegateServer.command,
+            ...delegateServer.args,
             '--repo',
             repoRoot
         ])
     };
-    const probe = inspectDelegationReadiness({ codexBin, configPath, repoRoot, env });
+    const probe = inspectDelegationReadiness({ configPath, repoRoot, env });
     const readiness = { configured: probe.configured, configPath };
     if (!options.apply) {
         return { status: 'planned', plan, readiness };
@@ -35,7 +41,7 @@ export async function runDelegationSetup(options = {}) {
         return { status: 'skipped', reason: probe.reason ?? 'Delegation MCP is already configured.', plan, readiness };
     }
     await applyDelegationSetup({ codexBin, repoRoot, removeExisting: probe.removeExisting, envVars: probe.envVars }, env);
-    const configuredAfter = inspectDelegationReadiness({ codexBin, configPath, repoRoot, env }).configured;
+    const configuredAfter = inspectDelegationReadiness({ configPath, repoRoot, env }).configured;
     return {
         status: 'applied',
         reason: probe.reason,
@@ -59,7 +65,8 @@ export function formatDelegationSetupSummary(result) {
 }
 function inspectDelegationReadiness(options) {
     const requestedRepo = resolve(options.repoRoot);
-    const existing = readDelegationMcpServer(options.codexBin, options.env);
+    const snapshot = inspectDelegationMcpConfig(options.env);
+    const existing = snapshot.entry;
     if (existing) {
         const envVars = existing.envVars;
         const isDelegationServer = existing.args.includes('delegate-server') || existing.args.includes('delegation-server');
@@ -71,6 +78,15 @@ function inspectDelegationReadiness(options) {
                 reason: 'Existing delegation MCP entry does not point to codex-orchestrator delegate-server; reconfiguring.'
             };
         }
+        const transport = classifyDelegationTransport(existing);
+        if (transport.status !== 'safe') {
+            return {
+                configured: false,
+                removeExisting: true,
+                envVars,
+                reason: `Existing delegation MCP entry uses ${transport.kind} transport; reconfiguring to the direct dist entrypoint.`
+            };
+        }
         if (existing.pinnedRepo) {
             const pinnedRepo = resolve(existing.pinnedRepo);
             if (pinnedRepo !== requestedRepo) {
@@ -99,6 +115,7 @@ function inspectDelegationReadiness(options) {
     return inspectDelegationReadinessFallback(options.configPath, requestedRepo);
 }
 function applyDelegationSetup(plan, env) {
+    const delegateServer = resolveDelegationServerInvocation({ env, execPath: process.execPath });
     const envFlags = [];
     for (const [key, value] of Object.entries(plan.envVars ?? {})) {
         envFlags.push('--env', `${key}=${value}`);
@@ -111,8 +128,8 @@ function applyDelegationSetup(plan, env) {
                 'delegation',
                 ...envFlags,
                 '--',
-                'codex-orchestrator',
-                'delegate-server',
+                delegateServer.command,
+                ...delegateServer.args,
                 '--repo',
                 plan.repoRoot
             ], { stdio: 'inherit', env });
@@ -142,55 +159,36 @@ function applyDelegationSetup(plan, env) {
         });
     });
 }
-function readDelegationMcpServer(codexBin, env) {
-    const result = spawnSync(codexBin, ['mcp', 'get', 'delegation', '--json'], {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe'],
-        timeout: 5000,
-        env
-    });
-    if (result.error || result.status !== 0) {
-        return null;
-    }
-    const stdout = String(result.stdout ?? '').trim();
-    if (!stdout) {
-        return null;
-    }
-    try {
-        const parsed = JSON.parse(stdout);
-        const transport = parsed.transport;
-        const args = Array.isArray(transport?.args)
-            ? transport.args.filter((value) => typeof value === 'string')
-            : [];
-        const envVars = {};
-        const envRecord = transport?.env;
-        if (envRecord && typeof envRecord === 'object' && !Array.isArray(envRecord)) {
-            for (const [key, value] of Object.entries(envRecord)) {
-                if (typeof value === 'string') {
-                    envVars[key] = value;
-                }
-            }
-        }
-        const pinnedRepo = readPinnedRepo(args);
-        return { args, pinnedRepo, envVars };
-    }
-    catch {
-        return null;
-    }
-}
-function readPinnedRepo(args) {
-    const index = args.indexOf('--repo');
-    if (index === -1) {
-        return null;
-    }
-    const candidate = args[index + 1];
-    return typeof candidate === 'string' && candidate.trim().length > 0 ? candidate.trim() : null;
-}
 function inspectDelegationReadinessFallback(configPath, requestedRepo) {
     const config = readDelegationFallbackConfig(configPath);
     if (!config) {
         return { configured: false, removeExisting: false, envVars: {} };
     }
+    const isDelegationServer = config.args.includes('delegate-server') || config.args.includes('delegation-server');
+    if (!isDelegationServer) {
+        return {
+            configured: false,
+            removeExisting: true,
+            envVars: config.envVars,
+            reason: 'Existing delegation MCP entry does not point to codex-orchestrator delegate-server; reconfiguring.'
+        };
+    }
+    const transport = classifyDelegationTransport({
+        source: 'fallback',
+        command: config.command,
+        args: config.args,
+        envVars: config.envVars,
+        pinnedRepo: readPinnedRepo(config.args),
+        commandLine: buildCommandPreview(config.command ?? '<missing>', config.args)
+    });
+    if (transport.status !== 'safe') {
+        return {
+            configured: false,
+            removeExisting: true,
+            envVars: config.envVars,
+            reason: `Existing delegation MCP entry uses ${transport.kind} transport; reconfiguring to the direct dist entrypoint.`
+        };
+    }
     const pinnedRepo = readPinnedRepo(config.args);
     if (!pinnedRepo) {
         return {
@@ -216,121 +214,3 @@ function inspectDelegationReadinessFallback(configPath, requestedRepo) {
         reason: `Delegation MCP is already configured (pinned to ${pinnedRepo}).`
     };
 }
-function readDelegationFallbackConfig(configPath) {
-    if (!existsSync(configPath)) {
-        return null;
-    }
-    try {
-        const raw = readFileSync(configPath, 'utf8');
-        if (!hasMcpServerEntry(raw, 'delegation')) {
-            return null;
-        }
-        return {
-            args: readDelegationArgsFromConfig(raw),
-            envVars: readDelegationEnvVarsFromConfig(raw)
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function readDelegationArgsFromConfig(raw) {
-    const sectionMatch = raw.match(/\[mcp_servers(?:\.delegation|\."delegation"|.'delegation')\]([\s\S]*?)(?=\n\[|$)/u);
-    if (!sectionMatch) {
-        return [];
-    }
-    const section = sectionMatch[1] ?? '';
-    const argsMatch = section.match(/^\s*args\s*=\s*\[([\s\S]*?)\]/mu);
-    if (!argsMatch) {
-        return [];
-    }
-    const argsRaw = argsMatch[1] ?? '';
-    const args = [];
-    const tokenPattern = /"((?:\\"|[^"])*)"|'((?:\\'|[^'])*)'/gu;
-    let token = tokenPattern.exec(argsRaw);
-    while (token) {
-        const quoted = token[1] ?? token[2] ?? '';
-        const decoded = quoted.replace(/\\"/gu, '"').replace(/\\'/gu, '\'');
-        args.push(decoded);
-        token = tokenPattern.exec(argsRaw);
-    }
-    return args;
-}
-function readDelegationEnvVarsFromConfig(raw) {
-    const envVars = {};
-    const sectionMatch = raw.match(/\[mcp_servers(?:\.delegation|\."delegation"|.'delegation')\.env\]([\s\S]*?)(?=\n\[|$)/u);
-    if (!sectionMatch) {
-        return envVars;
-    }
-    const section = sectionMatch[1] ?? '';
-    const linePattern = /^\s*([A-Za-z0-9_.-]+)\s*=\s*("(?:\\"|[^"])*"|'(?:\\'|[^'])*')\s*$/gmu;
-    let match = linePattern.exec(section);
-    while (match) {
-        const key = match[1];
-        const rawValue = match[2] ?? '';
-        if (key) {
-            const unquoted = rawValue.slice(1, -1);
-            const decoded = unquoted.replace(/\\"/gu, '"').replace(/\\'/gu, '\'');
-            envVars[key] = decoded;
-        }
-        match = linePattern.exec(section);
-    }
-    return envVars;
-}
-function hasMcpServerEntry(raw, serverName) {
-    const lines = raw.split('\n');
-    let currentTable = null;
-    for (const line of lines) {
-        const trimmed = stripTomlComment(line).trim();
-        if (!trimmed) {
-            continue;
-        }
-        const tableMatch = trimmed.match(/^\[(.+)\]$/u);
-        if (tableMatch) {
-            currentTable = tableMatch[1]?.trim() ?? null;
-            if (currentTable === `mcp_servers.${serverName}` ||
-                currentTable === `mcp_servers."${serverName}"` ||
-                currentTable === `mcp_servers.'${serverName}'`) {
-                return true;
-            }
-            continue;
-        }
-        if (trimmed.startsWith('mcp_servers.')) {
-            if (trimmed.startsWith(`mcp_servers."${serverName}".`)) {
-                return true;
-            }
-            if (trimmed.startsWith(`mcp_servers.'${serverName}'.`)) {
-                return true;
-            }
-            if (trimmed.startsWith(`mcp_servers.${serverName}.`)) {
-                return true;
-            }
-            if (trimmed.startsWith(`mcp_servers."${serverName}"=`)) {
-                return true;
-            }
-            if (trimmed.startsWith(`mcp_servers.'${serverName}'=`)) {
-                return true;
-            }
-            if (trimmed.startsWith(`mcp_servers.${serverName}=`)) {
-                return true;
-            }
-        }
-        if (currentTable === 'mcp_servers') {
-            const entryPattern = new RegExp(`^"?${escapeRegExp(serverName)}"?\\s*=`, 'u');
-            if (entryPattern.test(trimmed)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function stripTomlComment(line) {
-    const index = line.indexOf('#');
-    if (index === -1) {
-        return line;
-    }
-    return line.slice(0, index);
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}

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

@@ -0,0 +1,34 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import { formatDevtoolsSetupSummary, runDevtoolsSetup } from './devtoolsSetup.js';
+const DEFAULT_DEPENDENCIES = {
+    runDevtoolsSetup,
+    formatDevtoolsSetupSummary,
+    log: (line) => console.log(line)
+};
+export async function runDevtoolsCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const positionals = [...params.positionals];
+    const subcommand = positionals.shift();
+    if (!subcommand) {
+        throw new Error('devtools requires a subcommand (setup).');
+    }
+    if (subcommand !== 'setup') {
+        throw new Error(`Unknown devtools subcommand: ${subcommand}`);
+    }
+    const format = resolveOutputFormat(params.flags);
+    const apply = Boolean(params.flags['yes']);
+    if (format === 'json' && apply) {
+        throw new Error('devtools setup does not support --format json with --yes.');
+    }
+    const result = await dependencies.runDevtoolsSetup({ apply });
+    if (format === 'json') {
+        dependencies.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    for (const line of dependencies.formatDevtoolsSetupSummary(result)) {
+        dependencies.log(line);
+    }
+}
+function resolveOutputFormat(flags) {
+    return flags['format'] === 'json' ? 'json' : 'text';
+}