@kbediako/codex-orchestrator 0.1.38 → 0.2.1

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

@@ -0,0 +1,239 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+// This shell preserves the existing CLI output contract, which is rendered via console writes in text/json mode.
+const FLOW_TARGET_PIPELINE_SCOPES = new Set(['docs-review', 'implementation-gate']);
+function isFlowTargetPipelineScope(scope) {
+    return FLOW_TARGET_PIPELINE_SCOPES.has(scope);
+}
+function normalizeFlowTargetToken(candidate) {
+    const trimmed = candidate.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const tokens = trimmed.split(':');
+    if (tokens.length > 1 && !(tokens[0] ?? '').trim()) {
+        return null;
+    }
+    let scoped = false;
+    let scopeToken = null;
+    let suffixToken = trimmed;
+    if (tokens.length > 1) {
+        const candidateScope = (tokens[0] ?? '').trim().toLowerCase();
+        if (isFlowTargetPipelineScope(candidateScope)) {
+            scoped = true;
+            scopeToken = candidateScope;
+            suffixToken = (tokens[tokens.length - 1] ?? '').trim();
+        }
+    }
+    if (!suffixToken) {
+        return null;
+    }
+    return {
+        literalLower: trimmed.toLowerCase(),
+        stageTokenLower: suffixToken.toLowerCase(),
+        scopeLower: scopeToken,
+        scoped
+    };
+}
+function flowPlanItemPipelineId(item) {
+    const metadataPipelineId = item.metadata && typeof item.metadata['pipelineId'] === 'string'
+        ? item.metadata['pipelineId'].trim().toLowerCase()
+        : '';
+    if (metadataPipelineId) {
+        return metadataPipelineId;
+    }
+    const delimiterIndex = item.id.indexOf(':');
+    if (delimiterIndex <= 0) {
+        return null;
+    }
+    return item.id.slice(0, delimiterIndex).trim().toLowerCase() || null;
+}
+function flowPlanItemMatchesTarget(item, candidate) {
+    const normalized = normalizeFlowTargetToken(candidate);
+    if (!normalized) {
+        return false;
+    }
+    if (item.id.toLowerCase() === normalized.literalLower) {
+        return true;
+    }
+    if (normalized.scoped && normalized.scopeLower) {
+        const itemPipelineId = flowPlanItemPipelineId(item);
+        if (itemPipelineId && itemPipelineId !== normalized.scopeLower) {
+            return false;
+        }
+    }
+    const metadataStageId = item.metadata && typeof item.metadata['stageId'] === 'string'
+        ? item.metadata['stageId'].toLowerCase()
+        : null;
+    const aliases = Array.isArray(item.metadata?.['aliases'])
+        ? item.metadata?.['aliases']
+        : [];
+    const aliasTokens = aliases.filter((alias) => typeof alias === 'string').map((alias) => alias.toLowerCase());
+    if (normalized.scoped) {
+        if (metadataStageId
+            && (metadataStageId === normalized.literalLower || metadataStageId === normalized.stageTokenLower)) {
+            return true;
+        }
+        return aliasTokens.some((alias) => alias === normalized.literalLower || alias === normalized.stageTokenLower);
+    }
+    if (item.id.toLowerCase().endsWith(`:${normalized.stageTokenLower}`)) {
+        return true;
+    }
+    if (metadataStageId
+        && (metadataStageId === normalized.stageTokenLower
+            || metadataStageId.endsWith(`:${normalized.stageTokenLower}`))) {
+        return true;
+    }
+    return aliasTokens.some((alias) => alias === normalized.stageTokenLower || alias.endsWith(`:${normalized.stageTokenLower}`));
+}
+function planIncludesStageId(plan, stageId) {
+    if (!stageId.trim()) {
+        return false;
+    }
+    return plan.plan.items.some((item) => flowPlanItemMatchesTarget(item, stageId));
+}
+function resolveFlowTargetScope(stageId) {
+    const delimiterIndex = stageId.indexOf(':');
+    if (delimiterIndex <= 0) {
+        return null;
+    }
+    const scope = stageId.slice(0, delimiterIndex).trim().toLowerCase();
+    if (!isFlowTargetPipelineScope(scope)) {
+        return null;
+    }
+    return scope;
+}
+export async function resolveFlowTargetStageSelection(orchestrator, taskId, requestedTargetStageId) {
+    if (!requestedTargetStageId) {
+        return {};
+    }
+    const [docsPlan, implementationPlan] = (await Promise.all([
+        orchestrator.plan({ pipelineId: 'docs-review', taskId }),
+        orchestrator.plan({ pipelineId: 'implementation-gate', taskId })
+    ]));
+    const requestedScope = resolveFlowTargetScope(requestedTargetStageId);
+    const docsScopeMatch = !requestedScope || requestedScope === 'docs-review';
+    const implementationScopeMatch = !requestedScope || requestedScope === 'implementation-gate';
+    const docsReviewTargetStageId = docsScopeMatch && planIncludesStageId(docsPlan, requestedTargetStageId)
+        ? requestedTargetStageId
+        : undefined;
+    const implementationGateTargetStageId = implementationScopeMatch && planIncludesStageId(implementationPlan, requestedTargetStageId)
+        ? requestedTargetStageId
+        : undefined;
+    if (!docsReviewTargetStageId && !implementationGateTargetStageId) {
+        throw new Error(`Target stage "${requestedTargetStageId}" is not defined in docs-review or implementation-gate.`);
+    }
+    return { docsReviewTargetStageId, implementationGateTargetStageId };
+}
+export async function runFlowCliShell(params) {
+    try {
+        const { docsReviewTargetStageId, implementationGateTargetStageId } = await resolveFlowTargetStageSelection(params.orchestrator, params.taskId, params.targetStageId);
+        await params.runWithUi(async (runEvents) => {
+            const docsReviewResult = await params.orchestrator.start({
+                pipelineId: 'docs-review',
+                taskId: params.taskId,
+                parentRunId: params.parentRunId,
+                approvalPolicy: params.approvalPolicy,
+                targetStageId: docsReviewTargetStageId,
+                executionMode: params.executionMode,
+                runtimeMode: params.runtimeMode,
+                runEvents
+            });
+            const docsPayload = params.toRunOutputPayload(docsReviewResult);
+            if (params.format === 'text') {
+                params.emitRunOutput(docsReviewResult, params.format, 'Docs-review run');
+            }
+            if (docsReviewResult.manifest.status !== 'succeeded') {
+                const issueLogCapture = await params.maybeCaptureAutoIssueLog({
+                    enabled: params.autoIssueLogEnabled,
+                    issueTitle: 'Auto issue log: flow docs-review failed',
+                    issueNotes: `Automatic failure capture for docs-review run ${docsReviewResult.manifest.run_id} (${docsReviewResult.manifest.status}).`,
+                    taskFilter: params.resolveTaskFilter(docsReviewResult.manifest.task_id ?? undefined, params.taskId)
+                });
+                process.exitCode = 1;
+                if (params.format === 'json') {
+                    console.log(JSON.stringify({
+                        status: docsReviewResult.manifest.status,
+                        failed_stage: 'docs-review',
+                        docs_review: docsPayload,
+                        implementation_gate: null,
+                        issue_log: issueLogCapture.issueLog,
+                        issue_log_error: issueLogCapture.issueLogError
+                    }, null, 2));
+                }
+                else {
+                    console.log('Flow halted: docs-review failed.');
+                    if (issueLogCapture.issueLog) {
+                        for (const line of params.formatIssueLogSummary(issueLogCapture.issueLog)) {
+                            console.log(line);
+                        }
+                    }
+                    if (issueLogCapture.issueLogError) {
+                        console.log(`Auto issue log: failed (${issueLogCapture.issueLogError})`);
+                    }
+                }
+                return;
+            }
+            const implementationGateResult = await params.orchestrator.start({
+                pipelineId: 'implementation-gate',
+                taskId: params.taskId,
+                parentRunId: docsReviewResult.manifest.run_id,
+                approvalPolicy: params.approvalPolicy,
+                targetStageId: implementationGateTargetStageId,
+                executionMode: params.executionMode,
+                runtimeMode: params.runtimeMode,
+                runEvents
+            });
+            const implementationPayload = params.toRunOutputPayload(implementationGateResult);
+            const issueLogCapture = implementationGateResult.manifest.status !== 'succeeded'
+                ? await params.maybeCaptureAutoIssueLog({
+                    enabled: params.autoIssueLogEnabled,
+                    issueTitle: 'Auto issue log: flow implementation-gate failed',
+                    issueNotes: `Automatic failure capture for implementation-gate run ${implementationGateResult.manifest.run_id} (${implementationGateResult.manifest.status}).`,
+                    taskFilter: params.resolveTaskFilter(implementationGateResult.manifest.task_id ?? undefined, params.taskId)
+                })
+                : { issueLog: null, issueLogError: null };
+            if (params.format === 'json') {
+                console.log(JSON.stringify({
+                    status: implementationGateResult.manifest.status,
+                    failed_stage: implementationGateResult.manifest.status === 'succeeded' ? null : 'implementation-gate',
+                    docs_review: docsPayload,
+                    implementation_gate: implementationPayload,
+                    issue_log: issueLogCapture.issueLog,
+                    issue_log_error: issueLogCapture.issueLogError
+                }, null, 2));
+                if (implementationGateResult.manifest.status !== 'succeeded') {
+                    process.exitCode = 1;
+                }
+                return;
+            }
+            params.emitRunOutput(implementationGateResult, params.format, 'Implementation-gate run');
+            if (implementationGateResult.manifest.status !== 'succeeded') {
+                process.exitCode = 1;
+                console.log('Flow halted: implementation-gate failed.');
+                if (issueLogCapture.issueLog) {
+                    for (const line of params.formatIssueLogSummary(issueLogCapture.issueLog)) {
+                        console.log(line);
+                    }
+                }
+                if (issueLogCapture.issueLogError) {
+                    console.log(`Auto issue log: failed (${issueLogCapture.issueLogError})`);
+                }
+                return;
+            }
+            console.log('Flow complete: docs-review -> implementation-gate.');
+            await params.maybeEmitRunAdoptionHint({
+                format: params.format,
+                taskFilter: params.resolveTaskFilter(implementationGateResult.manifest.task_id ?? undefined, params.taskId)
+            });
+        });
+    }
+    catch (error) {
+        const issueLogCapture = await params.maybeCaptureAutoIssueLog({
+            enabled: params.autoIssueLogEnabled,
+            issueTitle: 'Auto issue log: flow failed before run manifest',
+            issueNotes: 'Automatic failure capture for flow setup failure before run manifest creation.',
+            taskFilter: params.resolveTaskFilter(undefined, params.taskId)
+        });
+        throw params.withAutoIssueLogContext(error, issueLogCapture);
+    }
+}

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

@@ -0,0 +1,80 @@
+import process from 'node:process';
+import { REPO_CONFIG_REQUIRED_ENV_KEY } from './config/repoConfigPolicy.js';
+import { runFrontendTestCliShell } from './frontendTestCliShell.js';
+import { PROVIDER_OVERRIDE_MARKER_ENV_KEYS, PROVIDER_OVERRIDE_ENV_KEYS, sanitizeProviderOverrideEnv } from './utils/providerOverrideEnv.js';
+const DEFAULT_DEPENDENCIES = {
+    runFrontendTestCliShell
+};
+export async function runFrontendTestCliRequestShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const format = resolveOutputFormat(params.flags);
+    const devtoolsEnabled = Boolean(params.flags['devtools']);
+    const runtimeMode = params.resolveRuntimeModeFlag(params.flags);
+    const restoreProcessEnv = applyProviderOverrideSanitizationToProcessEnv();
+    try {
+        params.applyRepoConfigRequiredPolicy(params.flags);
+        if (params.positionals.length > 0) {
+            params.warn(`[frontend-test] ignoring extra arguments: ${params.positionals.join(' ')}`);
+        }
+        await dependencies.runFrontendTestCliShell({
+            orchestrator: params.orchestrator,
+            format,
+            devtoolsEnabled,
+            runtimeMode,
+            taskId: readRawStringFlagValue(params.flags['task']),
+            parentRunId: readRawStringFlagValue(params.flags['parent-run']),
+            approvalPolicy: readRawStringFlagValue(params.flags['approval-policy']),
+            targetStageId: params.resolveTargetStageId(params.flags),
+            runWithUi: async (action) => await params.runWithUi(format, action),
+            emitRunOutput: params.emitRunOutput
+        });
+    }
+    finally {
+        restoreProcessEnv();
+    }
+}
+function resolveOutputFormat(flags) {
+    return flags['format'] === 'json' ? 'json' : 'text';
+}
+function readRawStringFlagValue(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function applyProviderOverrideSanitizationToProcessEnv(env = process.env) {
+    const previous = {
+        trackedOverrides: Object.fromEntries([...PROVIDER_OVERRIDE_ENV_KEYS, ...PROVIDER_OVERRIDE_MARKER_ENV_KEYS].map((key) => [key, env[key]])),
+        repoConfigRequired: env[REPO_CONFIG_REQUIRED_ENV_KEY]
+    };
+    const sanitized = sanitizeProviderOverrideEnv(env);
+    for (const key of [...PROVIDER_OVERRIDE_ENV_KEYS, ...PROVIDER_OVERRIDE_MARKER_ENV_KEYS]) {
+        const value = sanitized[key];
+        if (value === undefined) {
+            delete env[key];
+        }
+        else {
+            env[key] = value;
+        }
+    }
+    if (sanitized[REPO_CONFIG_REQUIRED_ENV_KEY] === undefined) {
+        delete env[REPO_CONFIG_REQUIRED_ENV_KEY];
+    }
+    else {
+        env[REPO_CONFIG_REQUIRED_ENV_KEY] = sanitized[REPO_CONFIG_REQUIRED_ENV_KEY];
+    }
+    return () => {
+        for (const key of [...PROVIDER_OVERRIDE_ENV_KEYS, ...PROVIDER_OVERRIDE_MARKER_ENV_KEYS]) {
+            const value = previous.trackedOverrides[key];
+            if (value === undefined) {
+                delete env[key];
+            }
+            else {
+                env[key] = value;
+            }
+        }
+        if (previous.repoConfigRequired === undefined) {
+            delete env[REPO_CONFIG_REQUIRED_ENV_KEY];
+        }
+        else {
+            env[REPO_CONFIG_REQUIRED_ENV_KEY] = previous.repoConfigRequired;
+        }
+    };
+}

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

@@ -0,0 +1,41 @@
+import process from 'node:process';
+const DEFAULT_DEPENDENCIES = {
+    env: process.env,
+    setExitCode: (code) => {
+        process.exitCode = code;
+    }
+};
+export async function runFrontendTestCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const originalDevtools = dependencies.env.CODEX_REVIEW_DEVTOOLS;
+    if (params.devtoolsEnabled) {
+        dependencies.env.CODEX_REVIEW_DEVTOOLS = '1';
+    }
+    try {
+        await params.runWithUi(async (runEvents) => {
+            const result = await params.orchestrator.start({
+                pipelineId: 'frontend-testing',
+                taskId: params.taskId,
+                parentRunId: params.parentRunId,
+                approvalPolicy: params.approvalPolicy,
+                targetStageId: params.targetStageId,
+                runtimeMode: params.runtimeMode,
+                runEvents
+            });
+            params.emitRunOutput(result, params.format, 'Run started');
+            if (result.manifest.status === 'failed' || result.manifest.status === 'cancelled') {
+                dependencies.setExitCode(1);
+            }
+        });
+    }
+    finally {
+        if (params.devtoolsEnabled) {
+            if (originalDevtools === undefined) {
+                delete dependencies.env.CODEX_REVIEW_DEVTOOLS;
+            }
+            else {
+                dependencies.env.CODEX_REVIEW_DEVTOOLS = originalDevtools;
+            }
+        }
+    }
+}

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

@@ -1,12 +1,21 @@
-import { copyFile, mkdir, readdir, stat } from 'node:fs/promises';
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
 import { dirname, join, relative } from 'node:path';
+import process from 'node:process';
+import { resolveCodexHome } from './utils/codexPaths.js';
+import { resolveCodexCliBin } from './utils/codexCli.js';
+import { codexFeatureProbeDisablesMultiAgentV2, codexFeatureProbeRejectsAgentMaxThreads, readCodexFeatureProbe } from './utils/codexFeatures.js';
 import { findPackageRoot } from './utils/packageInfo.js';
 const CODEX_TEMPLATE = 'codex';
 const CODEX_PIPELINE_CONFIG = 'codex.orchestrator.json';
+const CODEX_CONFIG_TEMPLATE = join('.codex', 'config.toml');
+const require = createRequire(import.meta.url);
+let tomlLibrary;
 export async function initCodexTemplates(options) {
     const root = findPackageRoot();
     const templateRoot = join(root, 'templates', options.template);
+    const env = options.env ?? process.env;
     const written = [];
     const skipped = [];
     await assertDirectory(templateRoot);
@@ -16,6 +25,10 @@ export async function initCodexTemplates(options) {
         skipped
     });
     if (options.template === CODEX_TEMPLATE) {
+        const configPath = join(options.cwd, CODEX_CONFIG_TEMPLATE);
+        if (written.includes(configPath) && await isMultiAgentV2Enabled(env)) {
+            await omitAgentMaxThreads(configPath);
+        }
         await copyTemplateFile(join(root, CODEX_PIPELINE_CONFIG), join(options.cwd, CODEX_PIPELINE_CONFIG), {
             force: options.force,
             written,
@@ -24,6 +37,86 @@ export async function initCodexTemplates(options) {
     }
     return { written, skipped, templateRoot };
 }
+async function isMultiAgentV2Enabled(env) {
+    const featureProbe = readCodexFeatureProbe(resolveCodexCliBin(env), env);
+    if (featureProbe.flags?.multi_agent_v2 === true) {
+        return true;
+    }
+    if (codexFeatureProbeDisablesMultiAgentV2(featureProbe)) {
+        return false;
+    }
+    if (codexFeatureProbeRejectsAgentMaxThreads(featureProbe)) {
+        return true;
+    }
+    const configPath = join(resolveCodexHome(env), 'config.toml');
+    if (!existsSync(configPath)) {
+        return false;
+    }
+    let raw;
+    try {
+        raw = await readFile(configPath, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    let parsed;
+    try {
+        parsed = getTomlLibrary().parse(raw);
+    }
+    catch {
+        return false;
+    }
+    if (!isRecord(parsed) || !isRecord(parsed.features)) {
+        return false;
+    }
+    return parsed.features.multi_agent_v2 === true;
+}
+async function omitAgentMaxThreads(configPath) {
+    const raw = await readFile(configPath, 'utf8');
+    const { removed, text } = removeAgentMaxThreadsFromToml(raw);
+    if (!removed) {
+        return;
+    }
+    await writeFile(configPath, text, 'utf8');
+}
+function removeAgentMaxThreadsFromToml(raw) {
+    const lines = raw.split(/(?<=\n)/u);
+    let inAgentsTable = false;
+    let removed = false;
+    const kept = [];
+    for (const line of lines) {
+        const withoutEol = line.replace(/\r?\n$/u, '');
+        const trimmed = withoutEol.trim();
+        if (/^\[[^\]]+\]\s*(?:#.*)?$/u.test(trimmed)) {
+            inAgentsTable = /^\[agents\]\s*(?:#.*)?$/u.test(trimmed);
+        }
+        if (inAgentsTable && /^[ \t]*max_threads\s*=/u.test(withoutEol)) {
+            removed = true;
+            continue;
+        }
+        kept.push(line);
+    }
+    return { removed, text: kept.join('') };
+}
+function getTomlLibrary() {
+    if (tomlLibrary) {
+        return tomlLibrary;
+    }
+    if (tomlLibrary === null) {
+        throw new Error('Failed to load @iarna/toml.');
+    }
+    try {
+        tomlLibrary = require('@iarna/toml');
+        return tomlLibrary;
+    }
+    catch (error) {
+        tomlLibrary = null;
+        throw error;
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
 async function assertDirectory(path) {
     const info = await stat(path).catch(() => null);
     if (!info || !info.isDirectory()) {
@@ -84,6 +177,7 @@ export function formatInitSummary(result, cwd) {
     }
     lines.push('Next steps (recommended):');
     lines.push('  - Review codex.orchestrator.json and adjust pipeline commands to your repository toolchain');
+    lines.push('  - Review .codex/providers/provider.env.example and .codex/providers/control.example.json');
     lines.push('  - codex-orchestrator setup --yes  # installs bundled skills + configures delegation/devtools wiring');
     lines.push('  - codex-orchestrator codex setup  # optional managed/pinned Codex CLI (activate with CODEX_CLI_USE_MANAGED=1; stock codex is default)');
     return lines;

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

@@ -0,0 +1,50 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { formatCodexCliSetupSummary, runCodexCliSetup } from './codexCliSetup.js';
+import { formatInitSummary, initCodexTemplates } from './init.js';
+const DEFAULT_DEPENDENCIES = {
+    initCodexTemplates,
+    formatInitSummary,
+    runCodexCliSetup,
+    formatCodexCliSetupSummary,
+    getCwd: () => process.cwd(),
+    log: (line) => console.log(line)
+};
+export async function runInitCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const template = params.positionals[0];
+    if (!template) {
+        throw new Error('init requires a template name (e.g. init codex).');
+    }
+    if (template !== 'codex') {
+        throw new Error(`Unknown init template: ${template}`);
+    }
+    const cwd = readStringFlag(params.flags, 'cwd') ?? dependencies.getCwd();
+    const force = Boolean(params.flags['force']);
+    const result = await dependencies.initCodexTemplates({ template, cwd, force });
+    for (const line of dependencies.formatInitSummary(result, cwd)) {
+        dependencies.log(line);
+    }
+    if (params.flags['codex-cli'] !== true) {
+        return;
+    }
+    const setupResult = await dependencies.runCodexCliSetup({
+        apply: Boolean(params.flags['yes']),
+        force: Boolean(params.flags['codex-force']),
+        source: readStringFlag(params.flags, 'codex-source'),
+        ref: readStringFlag(params.flags, 'codex-ref'),
+        downloadUrl: readStringFlag(params.flags, 'codex-download-url'),
+        downloadSha256: readStringFlag(params.flags, 'codex-download-sha256')
+    });
+    for (const line of dependencies.formatCodexCliSetupSummary(setupResult)) {
+        dependencies.log(line);
+    }
+}
+function readStringFlag(flags, key) {
+    const value = flags[key];
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}