codex-orchestrator 2.0.3 → 2.0.5

package/dist/src/v2/runtime.js

@@ -1,11 +1,12 @@
 import { constants } from 'node:fs';
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { lstat, mkdir, open, readFile, readdir, readlink, realpath, rm } from 'node:fs/promises';
+import { access, lstat, mkdir, open, readFile, readdir, readlink, realpath, rm } from 'node:fs/promises';
 import { homedir, hostname } from 'node:os';
-import { dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, posix, relative, resolve } from 'node:path';
 import { writeDurableAtomicFile } from './adapters/durable-atomic-file.js';
 import { GitWorktreeManager } from './adapters/worktree.js';
+import { ReviewFeedbackCoordinator } from './review-feedback-coordinator.js';
 import { defaultProcessExecutor } from './adapters/command.js';
 import { AcceptanceProof, ProofQuiescenceError } from './acceptance-proof.js';
 import { createCheckedChangeCapabilities } from './checked-change.js';
@@ -13,7 +14,7 @@ import { InjectedContainedReportOperation } from './contained-report-operation.j
 import { ContainedImplementationReviewer } from './implementation-reviewer.js';
 import { parseAgentAutoConfig } from './config.js';
 import { WaitingHumanCoordinator } from './waiting-human-coordinator.js';
-import { canonicalJson, containmentArgvPolicySha256, containmentCertificatePath, parseJsonWithoutDuplicateKeys, readContainmentCertificate, sha256, } from './containment.js';
+import { assertContainmentCertificateMatchesRuntime, canonicalJson, containmentArgvPolicySha256, containmentCertificatePath, parseJsonWithoutDuplicateKeys, readContainmentCertificate, sha256, } from './containment.js';
 import { FileProofRecordWriter } from './proof-store.js';
 import { acquireOwnerControlLock, OwnerControlLockBlockedError } from './owner-control-lock.js';
 import { decodeAgentReportForValidation } from './report-envelope.js';
@@ -47,6 +48,30 @@ export class LocalGitRunIssueAdapter {
             requiredBaseSha: input.baseSha,
         });
     }
+    async ensureContinuationWorktree(input) {
+        const localHead = (await this.git([
+            '-C', input.targetRoot, 'rev-parse', '--verify', `refs/heads/${input.branchName}`,
+        ])).trim();
+        const remoteHead = await this.getRemoteBranchSha(input.targetRoot, input.branchName);
+        if (localHead !== input.publishedHeadSha || remoteHead !== input.publishedHeadSha) {
+            throw new Error('continuation branch refs do not exactly match the published head');
+        }
+        await this.worktrees.ensureIssueWorktree({
+            targetRoot: input.targetRoot,
+            workspacePath: input.worktreePath,
+            branchName: input.branchName,
+            baseBranch: input.baseBranch,
+            requiredBaseSha: input.publishedHeadSha,
+            allowResume: true,
+        });
+        const observed = await this.inspectWorktree({
+            worktreePath: input.worktreePath,
+            branchName: input.branchName,
+            baseSha: input.publishedHeadSha,
+        });
+        if (observed !== 'matching')
+            throw new Error('continuation worktree does not match the published head');
+    }
     async inspectWorktree(input) {
         try {
             const stat = await lstat(input.worktreePath);
@@ -110,6 +135,9 @@ export class LocalGitRunIssueAdapter {
     listChangedFiles(worktreePath) {
         return this.worktrees.listChangedFiles(worktreePath);
     }
+    listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot) {
+        return this.worktrees.listChangedFilesIgnoringUntrackedRoot(worktreePath, ignoredRoot);
+    }
     async fingerprintChangedFiles(worktreePath, changedFiles) {
         const root = await realpath(worktreePath);
         const entries = [];
@@ -193,6 +221,12 @@ export class ContainedImplementationAgent {
             bootId: this.dependencies.bootId,
         });
         const baseline = await this.dependencies.git.snapshot(input.worktreePath);
+        await input.onPrepared?.({
+            attemptId,
+            reportPath: attempt.reportPath,
+            preparedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
+            baseline,
+        });
         try {
             const result = await (this.dependencies.process ?? new CodexProcess()).run({
                 codexPath: config.codex.command,
@@ -210,6 +244,8 @@ export class ContainedImplementationAgent {
                     `The operation's immutable workflow root is ${attempt.workflowRoot}.`,
                     `Implement issue #${input.issue.number}: ${input.issue.title}`,
                     `Implementation cycle: ${input.cycle}.`,
+                    ...(input.reviewFeedbackRound ? [`Pull-request feedback repair round: ${input.reviewFeedbackRound}.`] : []),
+                    ...(input.reviewFeedback?.length ? [`Frozen trusted pull-request feedback: ${canonicalJson(input.reviewFeedback)}`] : []),
                     `Frozen acceptance criteria: ${canonicalJson(input.frozenCriteria)}`,
                     ...(input.reworkFindings.length > 0 ? [`Repair these verified findings: ${canonicalJson(input.reworkFindings)}`] : []),
                     ...(input.repairOnly ? ['Report repair only: do not modify any worktree file; emit a schema-valid implementation report for the existing change.'] : []),
@@ -219,6 +255,9 @@ export class ContainedImplementationAgent {
                 idleTimeoutMs: config.codex.idleTimeoutMs,
                 operationPolicy: attempt.policy,
                 executionProfile: attempt.profile,
+                ...(input.onLaunched ? { onSpawned: ({ pid, processGroupId }) => input.onLaunched({
+                        attemptId, pid, processGroupId, launchedAt: (this.dependencies.now ?? (() => new Date().toISOString()))(),
+                    }) } : {}),
             }, input.signal);
             if (result.kind === 'cancelled')
                 return { kind: 'cancelled' };
@@ -248,6 +287,26 @@ export class ContainedImplementationAgent {
             };
         }
     }
+    async recover(input) {
+        const expected = join(resolve(this.dependencies.orchestratorHome), 'v2', sha256(input.canonicalRepository), 'runs', input.runId, 'attempts', input.invocation.attemptId, 'report.json');
+        if (resolve(input.invocation.reportPath) !== expected) {
+            throw new Error('review feedback implementation report path is not attempt-owned');
+        }
+        let bytes;
+        try {
+            bytes = await readRegularFile(expected);
+        }
+        catch (error) {
+            if (isErrorCode(error, 'ENOENT'))
+                return undefined;
+            throw error;
+        }
+        return {
+            kind: 'completed',
+            attemptId: input.invocation.attemptId,
+            report: decodeAgentReportForValidation(bytes),
+        };
+    }
 }
 export class ContainedProofAgent {
     dependencies;
@@ -347,11 +406,43 @@ export class ContainedProofAgent {
         }
     }
 }
+export async function resolveCodexExecutable(command, safePath) {
+    if (command.length === 0 || safePath.length === 0)
+        throw new Error('Codex command and safe path must be non-empty');
+    if (!isAbsolute(command) && command.includes('/'))
+        throw new Error('relative Codex command paths are not supported');
+    const candidates = isAbsolute(command)
+        ? [command]
+        : safePath.split(':').filter((entry) => entry.length > 0).map((entry) => join(entry, command));
+    for (const candidate of candidates) {
+        try {
+            const canonical = await realpath(candidate);
+            const stat = await lstat(canonical);
+            if (!stat.isFile())
+                continue;
+            await access(canonical, constants.X_OK);
+            return canonical;
+        }
+        catch {
+            // Try the next safe-path entry.
+        }
+    }
+    throw new Error('Codex executable is unavailable in the configured safe path');
+}
 export function createV2Runtime(input) {
     const targetRoot = resolve(input.targetRoot);
     const orchestratorHome = resolve(input.orchestratorHome);
     const now = input.now ?? (() => new Date().toISOString());
     const commandExecutor = input.processExecutor ?? defaultProcessExecutor;
+    const runtimeSafePath = requireRuntimeString(input.safePath, 'safePath');
+    let codexExecutable;
+    const resolveRuntimeCodex = async (command) => {
+        if (codexExecutable?.command === command)
+            return codexExecutable.path;
+        const path = await resolveCodexExecutable(command, runtimeSafePath);
+        codexExecutable = { command, path };
+        return path;
+    };
     const git = input.git ?? new LocalGitRunIssueAdapter(commandExecutor);
     const proofFreshnessGit = git;
     const controller = new AbortController();
@@ -369,7 +460,7 @@ export function createV2Runtime(input) {
         config: () => requireConfig(currentConfig),
         orchestratorHome,
         parentCodexHome: requireRuntimeString(input.parentCodexHome, 'parentCodexHome'),
-        safePath: requireRuntimeString(input.safePath, 'safePath'),
+        safePath: runtimeSafePath,
         bootId: input.bootId,
         process: containedProcess,
         createAttemptId: input.createAttemptId,
@@ -676,7 +767,11 @@ export function createV2Runtime(input) {
         if (resolve(requestedRoot) !== targetRoot)
             throw new Error('runtime target root mismatch');
         const bytes = await readRegularFile(join(targetRoot, '.codex-orchestrator', 'config.json'));
-        const config = parseAgentAutoConfig(parseJsonWithoutDuplicateKeys(bytes.toString('utf8')));
+        const parsed = parseAgentAutoConfig(parseJsonWithoutDuplicateKeys(bytes.toString('utf8')));
+        const config = {
+            ...parsed,
+            codex: { ...parsed.codex, command: await resolveRuntimeCodex(parsed.codex.command) },
+        };
         const path = join(targetRoot, config.runner.stateDir, 'v2', 'run-state.json');
         if (!runRecords)
             runRecords = new FileRunRecordWriter(path);
@@ -744,14 +839,17 @@ export function createV2Runtime(input) {
         readConfig,
         validateContainment: async (config) => {
             const certificate = await readContainmentCertificate(containmentCertificatePath(orchestratorHome));
-            if (certificate.packageVersion !== input.packageVersion)
-                throw new Error('containment package version mismatch');
-            if (certificate.argvPolicySha256 !== containmentArgvPolicySha256())
-                throw new Error('containment argv policy mismatch');
-            const version = await commandExecutor(config.codex.command, ['--version']);
-            if (version.exitCode !== 0 || version.stdout.trim() !== `codex-cli ${config.codex.requiredVersion}`) {
-                throw new Error('current Codex version does not match the containment certificate');
-            }
+            const executablePath = await resolveRuntimeCodex(config.codex.command);
+            const version = await commandExecutor(executablePath, ['--version']);
+            if (version.exitCode !== 0)
+                throw new Error('Codex version is unavailable');
+            assertContainmentCertificateMatchesRuntime(certificate, {
+                codexVersion: version.stdout.trim(),
+                codexExecutablePath: executablePath,
+                codexExecutableSha256: sha256(await readFile(executablePath)),
+                packageVersion: input.packageVersion,
+                argvPolicySha256: containmentArgvPolicySha256(),
+            });
         },
         ownerLock: {
             acquire: async ({ canonicalRepository }) => acquireOwnerLock({
@@ -797,10 +895,26 @@ export function createV2Runtime(input) {
                 if (matches.length > 1)
                     throw new Error('multiple open pull requests match publication intent');
                 const match = matches[0];
-                return match ? { url: match.url, body: match.body } : undefined;
+                if (!match)
+                    return undefined;
+                const reviewTarget = await input.pullRequests.getReviewTarget(match.number);
+                return {
+                    url: match.url,
+                    body: match.body,
+                    number: match.number,
+                    nodeId: match.nodeId,
+                    ...(reviewTarget ? { headSha: reviewTarget.headRefOid } : {}),
+                };
             },
             createDraft: async ({ title, body, headBranch, baseBranch }) => input.pullRequests.createDraftPullRequest({ title, body, headBranch, baseBranch }),
+            listConversationComments: async (number) => (await input.pullRequests.listConversationComments(number))
+                .map((comment) => ({ id: comment.id, body: comment.body })),
+            postConversationComment: async (number, body) => {
+                const comment = await input.pullRequests.postConversationComment(number, body);
+                return { id: comment.id, body: comment.body };
+            },
         },
+        reviewFeedback: new ReviewFeedbackCoordinator({ pullRequests: input.pullRequests, issues: input.issues, now }),
         git,
         routeCoordinator: {
             run: ({ state, ...routeInput }) => new RouteCoordinator({
@@ -1070,7 +1184,7 @@ async function prepareContainedAttempt(input) {
         bootId: input.bootId,
     });
     const reportOnly = input.operationId === 'triage' || input.operationId === 'ambiguity-review'
-        || input.operationId === 'cleanup-review' || input.operationId === 'code-review' || input.operationId === 'spec-review';
+        || input.operationId === 'code-review' || input.operationId === 'spec-review';
     if ((reportOnly
         ? snapshot.policy.sandboxMode !== 'read-only'
             || snapshot.policy.worktreeAccess !== 'read-only'
@@ -1194,56 +1308,135 @@ async function waitForProcessGroupAbsent(processGroupId) {
     }
 }
 export async function materializeReportReadView(input) {
+    await assertDisjointReadViewPaths(input.worktreePath, input.destination);
+    const deniedPaths = normalizeReadViewDeniedPaths(input.deniedPaths);
     await rm(input.destination, { recursive: true, force: true });
     await mkdir(input.destination, { recursive: true, mode: 0o700 });
-    await extractHeadArchive(input.worktreePath, input.destination);
-    for (const relativePath of input.deniedPaths) {
-        if (isAbsolute(relativePath))
+    await materializeCurrentReadView(input.worktreePath, input.destination, deniedPaths);
+    await scrubReportReadView(input.destination);
+    return input.destination;
+}
+async function assertDisjointReadViewPaths(worktreePath, destination) {
+    const worktree = await realpath(resolve(worktreePath));
+    const readView = await canonicalProspectivePath(destination);
+    if (isPathWithin(worktree, readView) || isPathWithin(readView, worktree)) {
+        throw new Error('report read-view destination must not overlap its source worktree');
+    }
+}
+async function canonicalProspectivePath(path) {
+    let current = resolve(path);
+    const suffix = [];
+    while (true) {
+        try {
+            return resolve(await realpath(current), ...suffix);
+        }
+        catch (error) {
+            if (!isErrorCode(error, 'ENOENT'))
+                throw error;
+            const parent = dirname(current);
+            if (parent === current)
+                throw error;
+            suffix.unshift(basename(current));
+            current = parent;
+        }
+    }
+}
+function isPathWithin(parent, child) {
+    const contained = relative(parent, child);
+    return contained === '' || (contained !== '..' && !contained.startsWith('../') && !isAbsolute(contained));
+}
+function normalizeReadViewDeniedPaths(paths) {
+    return paths.flatMap((path) => {
+        if (isAbsolute(path))
+            return [];
+        if (path.length === 0 || posix.normalize(path) !== path
+            || path.split('/').some((segment) => segment === '' || segment === '.' || segment === '..')) {
+            throw new Error('report read-view denied path escapes destination');
+        }
+        return [path];
+    });
+}
+async function materializeCurrentReadView(worktreePath, destination, deniedPaths) {
+    const paths = new Set(await readGitPathList(worktreePath, ['ls-files', '--cached', '--others', '--exclude-standard', '-z']));
+    for (const path of [...paths].sort()) {
+        if (isExcludedReadViewPath(path, deniedPaths))
             continue;
-        const deniedPath = resolve(input.destination, relativePath);
-        const contained = relative(input.destination, deniedPath);
+        const target = resolve(destination, path);
+        const contained = relative(destination, target);
         if (contained === '' || contained === '..' || contained.startsWith('../') || isAbsolute(contained)) {
-            throw new Error('report read-view denied path escapes destination');
+            throw new Error('report read-view path escapes destination');
+        }
+        const source = resolve(worktreePath, path);
+        let metadata;
+        try {
+            metadata = await lstat(source);
+        }
+        catch (error) {
+            if (!isErrorCode(error, 'ENOENT'))
+                throw error;
+            await rm(target, { recursive: true, force: true });
+            continue;
         }
-        await rm(deniedPath, { recursive: true, force: true });
+        if (!metadata.isFile() || metadata.isSymbolicLink()) {
+            await rm(target, { recursive: true, force: true });
+            continue;
+        }
+        await copyRegularFileNoFollow(source, target, metadata.mode);
     }
-    await scrubReportReadView(input.destination);
-    return input.destination;
 }
-async function extractHeadArchive(worktreePath, destination) {
-    await new Promise((resolveExtract, reject) => {
-        const archive = spawn('git', ['-C', worktreePath, 'archive', '--format=tar', 'HEAD'], { stdio: ['ignore', 'pipe', 'pipe'] });
-        const extract = spawn('tar', ['-xf', '-', '-C', destination], { stdio: ['pipe', 'ignore', 'pipe'] });
-        const failures = [];
-        archive.once('error', reject);
-        extract.once('error', reject);
-        archive.stderr.on('data', (chunk) => {
-            if (failures.join('').length < 8 * 1024)
-                failures.push(chunk.toString('utf8'));
-        });
-        extract.stderr.on('data', (chunk) => {
-            if (failures.join('').length < 8 * 1024)
-                failures.push(chunk.toString('utf8'));
-        });
-        archive.stdout.pipe(extract.stdin);
-        let archiveCode = null;
-        let extractCode = null;
-        const settle = () => {
-            if (archiveCode === null || extractCode === null)
+function isExcludedReadViewPath(path, deniedPaths) {
+    if (path.split('/').some((segment) => segment.startsWith('.env')))
+        return true;
+    return deniedPaths.some((deniedPath) => path === deniedPath || path.startsWith(`${deniedPath}/`));
+}
+async function readGitPathList(worktreePath, args) {
+    return new Promise((resolvePaths, reject) => {
+        const child = spawn('git', ['-C', worktreePath, ...args], { stdio: ['ignore', 'pipe', 'pipe'] });
+        const stdout = [];
+        const stderr = [];
+        child.once('error', reject);
+        child.stdout.on('data', (chunk) => { stdout.push(chunk); });
+        child.stderr.on('data', (chunk) => { stderr.push(chunk); });
+        child.once('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`report read-view inventory failed: ${Buffer.concat(stderr).toString('utf8').slice(0, 8 * 1024)}`));
                 return;
-            if (archiveCode !== 0 || extractCode !== 0)
-                reject(new Error(`report read-view archive failed: ${failures.join('').slice(0, 8 * 1024)}`));
-            else
-                resolveExtract();
-        };
-        archive.once('close', (code) => { archiveCode = code ?? 1; settle(); });
-        extract.once('close', (code) => { extractCode = code ?? 1; settle(); });
+            }
+            resolvePaths(Buffer.concat(stdout).toString('utf8').split('\0').filter((path) => path.length > 0));
+        });
     });
 }
+async function copyRegularFileNoFollow(sourcePath, targetPath, mode) {
+    const source = await open(sourcePath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    let target;
+    try {
+        const metadata = await source.stat();
+        if (!metadata.isFile())
+            throw new Error('report read-view source must be a regular file');
+        await rm(targetPath, { recursive: true, force: true });
+        await mkdir(dirname(targetPath), { recursive: true, mode: 0o700 });
+        target = await open(targetPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, mode & 0o777);
+        const buffer = Buffer.allocUnsafe(64 * 1024);
+        while (true) {
+            const { bytesRead } = await source.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            let offset = 0;
+            while (offset < bytesRead) {
+                const { bytesWritten } = await target.write(buffer, offset, bytesRead - offset, null);
+                offset += bytesWritten;
+            }
+        }
+    }
+    finally {
+        await target?.close();
+        await source.close();
+    }
+}
 async function scrubReportReadView(directory) {
     for (const entry of await readdir(directory, { withFileTypes: true })) {
         const path = join(directory, entry.name);
-        if (entry.name === '.env' || entry.name.startsWith('.env.') || entry.isSymbolicLink()) {
+        if (entry.name.startsWith('.env') || entry.isSymbolicLink()) {
             await rm(path, { recursive: true, force: true });
         }
         else if (entry.isDirectory()) {