@kbediako/codex-orchestrator 0.1.38 → 0.2.0

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

@@ -0,0 +1,132 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { formatMcpEnableSummary, runMcpEnable } from './mcpEnable.js';
+const DEFAULT_DEPENDENCIES = {
+    runMcpEnable,
+    formatMcpEnableSummary,
+    log: (line) => console.log(line),
+    setExitCode: (code) => {
+        process.exitCode = code;
+    }
+};
+export async function runMcpEnableCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const allowedEnableFlags = new Set(['yes', 'format', 'servers']);
+    let yesFlag;
+    let formatFlag;
+    let serversFlag;
+    const unexpectedPositionals = [];
+    for (let index = 0; index < params.rawArgs.length; index += 1) {
+        const token = params.rawArgs[index];
+        if (!token) {
+            continue;
+        }
+        if (token === '--') {
+            unexpectedPositionals.push(...params.rawArgs.slice(index + 1));
+            break;
+        }
+        if (!token.startsWith('--')) {
+            unexpectedPositionals.push(token);
+            continue;
+        }
+        const [key, inlineValue] = token.slice(2).split('=', 2);
+        if (!allowedEnableFlags.has(key)) {
+            throw new Error(`Unknown mcp enable flag: --${key}`);
+        }
+        let resolvedValue = true;
+        if (inlineValue !== undefined) {
+            resolvedValue = inlineValue;
+        }
+        else {
+            const nextToken = params.rawArgs[index + 1];
+            if (nextToken && !nextToken.startsWith('--')) {
+                resolvedValue = nextToken;
+                index += 1;
+            }
+        }
+        if (key === 'yes') {
+            if (yesFlag !== undefined) {
+                throw new Error('--yes specified multiple times.');
+            }
+            yesFlag = resolvedValue;
+            continue;
+        }
+        if (key === 'format') {
+            if (formatFlag !== undefined) {
+                throw new Error('--format specified multiple times.');
+            }
+            formatFlag = resolvedValue;
+            continue;
+        }
+        if (serversFlag !== undefined) {
+            throw new Error('--servers specified multiple times.');
+        }
+        serversFlag = resolvedValue;
+    }
+    if (unexpectedPositionals.length > 0) {
+        throw new Error(`mcp enable does not accept positional arguments: ${unexpectedPositionals.join(' ')}`);
+    }
+    const apply = coerceApplyFlag(yesFlag);
+    const format = resolveOutputFormat(formatFlag);
+    const serverNames = resolveServerNames(serversFlag);
+    const result = await dependencies.runMcpEnable({ apply, serverNames });
+    const hasApplyFailures = apply && result.actions.some((action) => action.status !== 'enabled' && action.status !== 'already_enabled');
+    if (format === 'json') {
+        dependencies.log(JSON.stringify(result, null, 2));
+    }
+    else {
+        for (const line of dependencies.formatMcpEnableSummary(result)) {
+            dependencies.log(line);
+        }
+    }
+    if (hasApplyFailures) {
+        dependencies.setExitCode(1);
+    }
+}
+function coerceApplyFlag(yesFlag) {
+    if (yesFlag === true) {
+        return true;
+    }
+    if (typeof yesFlag !== 'string') {
+        return false;
+    }
+    const normalizedYes = yesFlag.trim().toLowerCase();
+    if (normalizedYes === 'true' || normalizedYes === '1' || normalizedYes === 'yes' || normalizedYes === 'on') {
+        return true;
+    }
+    if (normalizedYes === 'false' || normalizedYes === '0' || normalizedYes === 'no' || normalizedYes === 'off') {
+        return false;
+    }
+    throw new Error('--yes expects true/false when provided as --yes=<value>.');
+}
+function resolveOutputFormat(formatFlag) {
+    if (formatFlag === undefined) {
+        return 'text';
+    }
+    if (formatFlag === true) {
+        throw new Error('--format requires a value of "text" or "json".');
+    }
+    if (formatFlag === 'json') {
+        return 'json';
+    }
+    if (formatFlag === 'text') {
+        return 'text';
+    }
+    throw new Error('--format must be "text" or "json".');
+}
+function resolveServerNames(serversFlag) {
+    if (serversFlag === undefined) {
+        return undefined;
+    }
+    if (typeof serversFlag !== 'string') {
+        throw new Error('--servers must include a comma-separated list of MCP server names.');
+    }
+    const serverNames = serversFlag
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    if (serverNames.length === 0) {
+        throw new Error('--servers must include a comma-separated list of MCP server names.');
+    }
+    return serverNames;
+}

package/dist/orchestrator/src/cli/metrics/metricsAggregator.js

@@ -301,8 +301,9 @@ export async function withMetricsLock(env, action, options = {}) {
     const lockPath = getMetricsLockPath(env);
     const staleMs = options.staleMs ?? DEFAULT_LOCK_STALE_MS;
     await cleanupStaleMetricsLock(lockPath, staleMs);
+    let lock = null;
     try {
-        await acquireLockWithRetry({
+        lock = await acquireLockWithRetry({
             taskId: env.taskId,
             lockPath,
             retry: lockRetry,
@@ -323,7 +324,7 @@ export async function withMetricsLock(env, action, options = {}) {
         return { acquired: true, result };
     }
     finally {
-        await rm(lockPath, { force: true });
+        await lock?.release();
     }
 }
 export async function updateMetricsAggregates(env) {

package/dist/orchestrator/src/cli/metrics/metricsRecorder.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { appendFile, mkdir, rename, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { ensureGuardrailStatus, appendSummary, upsertGuardrailSummary } from '../run/manifest.js';
+import { buildRunMemoryObservabilityMetrics, refreshRunMemoryObservability } from '../run/source0.js';
 import { isoTimestamp } from '../utils/time.js';
 import { persistManifest } from '../run/manifestPersister.js';
 import { logger } from '../../logger.js';
@@ -9,6 +10,7 @@ import { ensureMetricsTrailingNewline, mergePendingMetricsEntries, updateMetrics
 import { EnvUtils } from '../../../../packages/shared/config/index.js';
 const TERMINAL_STATES = new Set(['succeeded', 'failed', 'cancelled']);
 const METRICS_PENDING_DIRNAME = 'metrics.pending';
+const PROVIDER_LINEAR_WORKER_PIPELINE_ID = 'provider-linear-worker';
 export async function appendMetricsEntry(env, paths, manifest, persister) {
     if (manifest.metrics_recorded) {
         return;
@@ -33,6 +35,8 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
     const privacyEvents = shouldTruncatePrivacy
         ? privacyDecisions.slice(0, maxPrivacyEvents)
         : privacyDecisions;
+    refreshRunMemoryObservability(manifest);
+    const memoryMetrics = buildRunMemoryObservabilityMetrics(manifest.memory?.observability);
     const metricsRoot = join(env.runsRoot, env.taskId);
     const metricsPath = join(metricsRoot, 'metrics.json');
     const pendingDir = join(metricsRoot, METRICS_PENDING_DIRNAME);
@@ -64,6 +68,7 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
         privacy_event_count: privacyEventCount,
         privacy_events_truncated: shouldTruncatePrivacy ? true : undefined,
         privacy_events: privacyEvents,
+        memory: memoryMetrics,
         handle_count: manifest.handles?.length ?? 0,
         tfgrpo_epoch: manifest.tfgrpo?.epoch ?? null,
         tfgrpo_group_id: manifest.tfgrpo?.group_id ?? null,
@@ -113,6 +118,7 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
         throw new Error(`Failed to create pending metrics entry for ${entry.run_id}`);
     };
     const finalizeManifest = async (metricsRecorded) => {
+        preserveProviderLinearWorkerPrimarySummary(manifest, guardrailStatus);
         if (!guardrailsPresent && guardrailStatus.recommendation) {
             logger.warn(guardrailStatus.recommendation);
             appendSummary(manifest, guardrailStatus.recommendation);
@@ -134,3 +140,53 @@ export async function appendMetricsEntry(env, paths, manifest, persister) {
         logger.warn(`Metrics aggregation skipped for ${env.taskId}: queued metrics entry in ${pendingPath}.`);
     }
 }
+function preserveProviderLinearWorkerPrimarySummary(manifest, guardrailStatus) {
+    const primarySummary = resolveProviderLinearWorkerPrimarySummary(manifest, guardrailStatus);
+    if (!primarySummary) {
+        return;
+    }
+    const currentLines = splitSummaryLines(manifest.summary);
+    const secondaryLines = currentLines.filter((line) => line !== primarySummary);
+    manifest.summary = [primarySummary, ...secondaryLines].join('\n');
+}
+function resolveProviderLinearWorkerPrimarySummary(manifest, guardrailStatus) {
+    if (manifest.status !== 'succeeded' || manifest.pipeline_id !== PROVIDER_LINEAR_WORKER_PIPELINE_ID) {
+        return null;
+    }
+    const providerWorkerCommand = manifest.commands.find((command) => {
+        const id = command.id?.trim().toLowerCase() ?? '';
+        const title = command.title?.trim().toLowerCase() ?? '';
+        const commandLine = command.command?.trim().toLowerCase() ?? '';
+        return (id === PROVIDER_LINEAR_WORKER_PIPELINE_ID ||
+            title.includes('provider linear worker') ||
+            commandLine.includes('providerlinearworkerrunner'));
+    });
+    if (providerWorkerCommand?.status !== 'succeeded') {
+        return null;
+    }
+    const summary = providerWorkerCommand.summary?.trim();
+    if (!summary || isGuardrailCloseoutSummaryLine(summary, guardrailStatus)) {
+        return null;
+    }
+    return summary;
+}
+function splitSummaryLines(summary) {
+    return (summary ?? '')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+function isGuardrailCloseoutSummaryLine(line, guardrailStatus) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return true;
+    }
+    if (trimmed.toLowerCase().startsWith('guardrails:')) {
+        return true;
+    }
+    const recommendation = guardrailStatus.recommendation?.trim();
+    if (recommendation && trimmed === recommendation) {
+        return true;
+    }
+    return trimmed.startsWith('Guardrail command missing;');
+}