@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/dist/lib/sandbox/control/executor.js

@@ -1,12 +1,12 @@
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 import { getProcessStartTime } from '../../server/process-state.js';
-import { createTask } from '../../task/create-service.js';
+import { createTask, projectTaskCreateResult, taskCreateExitCode, taskCreateFailure } from '../../task/create-service.js';
 import { applyTaskFinalization } from '../../task/finalization.js';
 import { bindSandboxControlTask, validateSandboxControlRequest } from './protocol.js';
-import { atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
+import { appendSandboxControlAudit, atomicWriteJson, executionPath, readActiveLease, terminateSandboxControlExecution } from './state.js';
 import { createSandboxExecutorExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../../task/control-authority.js';
 import { assertSandboxControlBrokerOwner, readSandboxControlManifest } from './lifecycle.js';
 import { computeLifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.js';
@@ -30,6 +30,57 @@ export function assertSandboxControlExecutorAuthority(manifest, gateOwner) {
 function safeEnv(env) {
     return Object.fromEntries(Object.entries(env).filter(([key]) => !key.toUpperCase().startsWith('AGENT_INFRA_CONTROL_')));
 }
+function safeRealpath(value) {
+    try {
+        return fs.realpathSync.native(value);
+    }
+    catch {
+        return null;
+    }
+}
+function appendExecutorAudit(manifest, event, fields = {}) {
+    try {
+        appendSandboxControlAudit(manifest, event, { source: 'executor', ...fields });
+    }
+    catch {
+        // Diagnostics must never change the control protocol.
+    }
+}
+function requestAuditFields(manifest, manifestPath, request) {
+    const args = 'args' in request ? request.args : [];
+    const encodedArgs = JSON.stringify(args);
+    return {
+        requestId: request.id,
+        requestFamily: request.family,
+        sandboxTaskId: manifest.taskId,
+        requestGeneration: request.generation,
+        requestIssuedAt: request.issuedAt,
+        requestExpiresAt: request.expiresAt,
+        requestArgCount: args.length,
+        requestArgsSha256: createHash('sha256').update(encodedArgs, 'utf8').digest('hex'),
+        requestTaskRef: args[0] ?? null,
+        requestCommand: args[1] ?? null,
+        controllerProofPresent: request.controllerProof !== null,
+        hostCwd: process.cwd(),
+        manifestPath,
+        manifestPathRealpath: safeRealpath(manifestPath),
+        repoRoot: manifest.repoRoot,
+        repoRootRealpath: safeRealpath(manifest.repoRoot),
+        worktreeRoot: manifest.worktreeRoot,
+        worktreeRootRealpath: safeRealpath(manifest.worktreeRoot),
+        runtimeDir: manifest.runtimeDir,
+        runtimeDirRealpath: safeRealpath(manifest.runtimeDir)
+    };
+}
+function resultAuditFields(result) {
+    return {
+        exitCode: result.exitCode,
+        stdoutBytes: Buffer.byteLength(result.stdout, 'utf8'),
+        stderrBytes: Buffer.byteLength(result.stderr, 'utf8'),
+        stdoutSha256: createHash('sha256').update(result.stdout, 'utf8').digest('hex'),
+        stderrSha256: createHash('sha256').update(result.stderr, 'utf8').digest('hex')
+    };
+}
 export function nodeEntryArgs(entry, args) {
     return path.extname(entry) === '.ts'
         ? ['--experimental-strip-types', '--no-warnings', entry, ...args]
@@ -174,6 +225,20 @@ function lifecycleFailure(code, message) {
         stderr: ''
     };
 }
+function taskCreateExecutionResult(result) {
+    return {
+        exitCode: taskCreateExitCode(result),
+        stdout: `${JSON.stringify(result)}\n`,
+        stderr: ''
+    };
+}
+function taskCreateExecutionFailure(requestId, code, message) {
+    return taskCreateExecutionResult(taskCreateFailure({ code, message, retryable: false }, {
+        requestId,
+        accepted: true,
+        recovery: 'inspect-domain-state'
+    }));
+}
 function finalizationResult(result) {
     const payload = {
         version: 1,
@@ -189,14 +254,21 @@ function finalizationResult(result) {
         stderr: ''
     };
 }
-export async function executeRequest(manifest, manifestPath, request, options = {}) {
+async function executeRequestInner(manifest, manifestPath, request, options = {}) {
     if (request.family === 'task-create') {
-        const result = createTask(request.candidate, { repoRoot: manifest.repoRoot });
-        return {
-            exitCode: result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0,
-            stdout: `${JSON.stringify(result)}\n`,
-            stderr: ''
-        };
+        try {
+            const result = await createTask(request.candidate, { repoRoot: manifest.repoRoot });
+            return taskCreateExecutionResult(projectTaskCreateResult(result, {
+                requestId: request.id,
+                accepted: true,
+                recovery: 'none'
+            }));
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            const code = /^([A-Z][A-Z0-9_]+)/u.exec(detail)?.[1] ?? 'TASK_CREATE_EXECUTION_FAILED';
+            return taskCreateExecutionFailure(request.id, code, detail);
+        }
     }
     if (request.family === 'codex-controller') {
         try {
@@ -239,6 +311,16 @@ export async function executeRequest(manifest, manifestPath, request, options =
             return { exitCode: 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
         }
         catch (error) {
+            const errorCode = error instanceof CodexControllerRegistrationError
+                ? error.code
+                : /^([A-Z][A-Z0-9_]+)/u.exec(error instanceof Error ? error.message : String(error))?.[1]
+                    ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
+            appendExecutorAudit(manifest, 'controller-operation-failed', {
+                ...requestAuditFields(manifest, manifestPath, request),
+                controllerCommand: request.command,
+                errorCode,
+                errorType: error instanceof Error ? error.name : typeof error,
+            });
             return controllerFailure(error);
         }
     }
@@ -255,7 +337,7 @@ export async function executeRequest(manifest, manifestPath, request, options =
             manifestPath,
             requestId: request.id
         }), operation);
-        return finalizationResult(result);
+        return finalizationResult(await result);
     }
     const boundArgs = bindSandboxControlTask(request, manifest.taskId);
     if (request.family === 'task-orchestration') {
@@ -300,6 +382,14 @@ export async function executeRequest(manifest, manifestPath, request, options =
             return orchestrationFailure('CODEX_SANDBOX_CONTROLLER_PROOF_INVALID', 'Controller proof is only accepted for canonical Codex prepare');
         }
     }
+    const diagnosticLog = (event, fields) => {
+        appendExecutorAudit(manifest, event.startsWith('orchestration-') ? event : `orchestration-${event}`, {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            ...fields
+        });
+    };
     const context = createSandboxExecutorExecutionContext({
         repoRoot: manifest.repoRoot,
         worktreeRoot: manifest.worktreeRoot,
@@ -308,6 +398,7 @@ export async function executeRequest(manifest, manifestPath, request, options =
         generation: manifest.generation,
         manifestPath,
         requestId: request.id,
+        diagnosticLog,
         ...(controllerBinding ? { controllerBinding } : {})
     });
     const format = (value) => {
@@ -325,7 +416,30 @@ export async function executeRequest(manifest, manifestPath, request, options =
     }
     if (operation.family !== 'task-lifecycle')
         throw new Error('SANDBOX_CONTROL_LIFECYCLE_OPERATION_INVALID');
-    return format(dispatchTaskControlOperation(context, operation));
+    return format(await dispatchTaskControlOperation(context, operation));
+}
+export async function executeRequest(manifest, manifestPath, request, options = {}) {
+    const fields = requestAuditFields(manifest, manifestPath, request);
+    appendExecutorAudit(manifest, 'executor-request-start', fields);
+    try {
+        const result = await executeRequestInner(manifest, manifestPath, request, options);
+        appendExecutorAudit(manifest, 'executor-request-finished', {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            ...resultAuditFields(result)
+        });
+        return result;
+    }
+    catch (error) {
+        appendExecutorAudit(manifest, 'executor-request-failed', {
+            requestId: request.id,
+            requestFamily: request.family,
+            sandboxTaskId: manifest.taskId,
+            errorType: error instanceof Error ? error.name : typeof error,
+        });
+        throw error;
+    }
 }
 export async function runSandboxControlExecutor(requestPath, nonce) {
     const gateOwner = await waitForGate(nonce);
@@ -335,14 +449,29 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         throw new Error('SANDBOX_CONTROL_EXECUTOR_MANIFEST_MISSING');
     const manifest = readSandboxControlManifest(manifestPath);
     const root = fs.realpathSync.native(process.cwd());
-    if (fs.realpathSync.native(manifest.repoRoot) !== root)
+    const expectedRoot = safeRealpath(manifest.repoRoot);
+    if (expectedRoot !== root) {
+        appendExecutorAudit(manifest, 'executor-root-validation-failed', {
+            hostCwd: process.cwd(),
+            observedRoot: root,
+            expectedRoot
+        });
         throw new Error('SANDBOX_CONTROL_EXECUTOR_ROOT_INVALID');
+    }
     const raw = JSON.parse(fs.readFileSync(requestPath, 'utf8'));
     const request = validateSandboxControlRequest(raw, manifest);
+    appendExecutorAudit(manifest, 'executor-request-validated', requestAuditFields(manifest, manifestPath, request));
     const requestDirectory = path.resolve(path.dirname(requestPath));
     const processingDirectory = path.resolve(path.join(manifest.processingDir, request.id));
     const channelRequestDirectory = path.resolve(path.join(manifest.channelDir, 'requests'));
     if (requestDirectory !== processingDirectory && requestDirectory !== channelRequestDirectory) {
+        appendExecutorAudit(manifest, 'executor-request-path-validation-failed', {
+            ...requestAuditFields(manifest, manifestPath, request),
+            requestPath,
+            requestDirectory,
+            processingDirectory,
+            channelRequestDirectory
+        });
         throw new Error('SANDBOX_CONTROL_EXECUTOR_REQUEST_INVALID');
     }
     let result;
@@ -351,6 +480,10 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
         result = await executeRequest(manifest, manifestPath, request);
     }
     catch (error) {
+        appendExecutorAudit(manifest, 'executor-authority-or-dispatch-failed', {
+            ...requestAuditFields(manifest, manifestPath, request),
+            errorType: error instanceof Error ? error.name : typeof error,
+        });
         const detail = error instanceof Error ? error.message : String(error);
         const code = /^([A-Z][A-Z0-9_]+)/u.exec(detail)?.[1] ?? 'SANDBOX_CONTROL_EXECUTOR_FAILED';
         result = request.family === 'task-finalization'
@@ -362,9 +495,11 @@ export async function runSandboxControlExecutor(requestPath, nonce) {
                 })}\n`,
                 stderr: ''
             }
-            : request.family === 'task-lifecycle'
-                ? lifecycleFailure(code, detail)
-                : orchestrationFailure(code, detail);
+            : request.family === 'task-create'
+                ? taskCreateExecutionFailure(request.id, code, detail)
+                : request.family === 'task-lifecycle'
+                    ? lifecycleFailure(code, detail)
+                    : orchestrationFailure(code, detail);
     }
     process.stdout.write(result.stdout);
     process.stderr.write(result.stderr);