@fitlab-ai/agent-infra 0.11.13 → 0.11.15

package/dist/lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.js

@@ -1,345 +0,0 @@
-import crypto from 'node:crypto';
-import { spawn, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import semver from 'semver';
-import * as toml from 'smol-toml';
-import { requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify } from './controller-client.js';
-import { getProcessStartTime } from '../../../server/process-state.js';
-import { LIFECYCLE_PROTOCOL_VERSION } from './build-identity.js';
-import { contextFromControllerLease, controllerProofFromContext, verifyCodexSandboxControllerContextWithWarnings as verifyContextFileWithWarnings, writeCodexSandboxControllerContext } from './controller-context.js';
-function copyRegular(source, destination, mode) {
-    const stat = fs.lstatSync(source);
-    if (!stat.isFile() || stat.isSymbolicLink()) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_INPUT_INVALID');
-    }
-    fs.mkdirSync(path.dirname(destination), { recursive: true, mode: 0o700 });
-    fs.copyFileSync(source, destination);
-    fs.chmodSync(destination, mode);
-}
-function controlFromEnvironment() {
-    const token = process.env.AGENT_INFRA_CONTROL_TOKEN;
-    const generation = process.env.AGENT_INFRA_CONTROL_GENERATION;
-    const rootId = process.env.AGENT_INFRA_CONTROL_ROOT_ID;
-    const channelDir = process.env.AGENT_INFRA_CONTROL_DIR;
-    const statusDir = process.env.AGENT_INFRA_CONTROL_STATUS_DIR;
-    const runtimeDir = process.env.AGENT_INFRA_RUNTIME_DIR;
-    if (!token || !generation || !rootId || !channelDir || !statusDir || !runtimeDir) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTROL_MISSING');
-    }
-    return { token, generation, rootId, channelDir, statusDir, runtimeDir };
-}
-function verifyRuntime(runtimeDir) {
-    let stat;
-    try {
-        stat = fs.lstatSync(runtimeDir);
-    }
-    catch {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-    }
-    if (!stat.isDirectory() || stat.isSymbolicLink()) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-    }
-    const probe = path.join(runtimeDir, `.controller-${process.pid}-${crypto.randomUUID()}.probe`);
-    try {
-        fs.writeFileSync(probe, 'runtime-probe\n', { encoding: 'utf8', flag: 'wx', mode: 0o600 });
-        if (fs.readFileSync(probe, 'utf8') !== 'runtime-probe\n') {
-            throw new Error('probe mismatch');
-        }
-    }
-    catch {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_RUNTIME_UNAVAILABLE');
-    }
-    finally {
-        fs.rmSync(probe, { force: true });
-    }
-}
-function verifyControllerBinding(context, control, requestControllerVerify) {
-    verifyRuntime(control.runtimeDir);
-    const verified = requestControllerVerify({
-        controllerProof: controllerProofFromContext(context),
-        ...control,
-        timeoutMs: 30_000
-    });
-    if (verified.binding.controlGeneration !== context.controlGeneration
-        || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_TASK_BINDING_INVALID');
-    }
-}
-function verifyCodexSandboxControllerContextWithWarnings(contextPath, options = {}) {
-    const control = options.control ?? controlFromEnvironment();
-    const fileVerification = verifyContextFileWithWarnings(contextPath, {
-        repoRoot: options.repoRoot,
-        now: options.now,
-        generation: control.generation,
-        probeProcess: options.probeProcess
-    });
-    const context = fileVerification.context;
-    const verified = (options.requestControllerVerify ?? requestCodexControllerVerify)({
-        controllerProof: controllerProofFromContext(context),
-        ...control,
-        timeoutMs: 30_000
-    });
-    if (verified.binding.controlGeneration !== context.controlGeneration
-        || verified.binding.controllerInstanceDigest !== context.controllerInstanceDigest) {
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-    }
-    return Object.freeze({
-        context,
-        warnings: fileVerification.warnings
-    });
-}
-function detectedCodexVersion() {
-    const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
-    const version = /codex-cli\s+(\d+\.\d+\.\d+)/u.exec(result.stdout ?? '')?.[1];
-    if (result.status !== 0 || !version)
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNAVAILABLE');
-    return version;
-}
-function sanitizedConfig(source, destination, sourceHome, targetHome) {
-    if (!fs.existsSync(source))
-        return [];
-    const parsed = toml.parse(fs.readFileSync(source, 'utf8'));
-    const allowed = new Set([
-        'model',
-        'model_provider',
-        'model_providers',
-        'model_reasoning_effort',
-        'model_auto_compact_token_limit',
-        'preferred_auth_method'
-    ]);
-    const output = Object.fromEntries(Object.entries(parsed).filter(([key]) => allowed.has(key)));
-    const catalog = parsed.model_catalog_json;
-    if (typeof catalog === 'string' && catalog.trim()) {
-        const resolved = path.resolve(sourceHome, catalog.replace(/^~[/\\]/u, ''));
-        const relative = path.relative(sourceHome, resolved);
-        if (relative.startsWith('..') || path.isAbsolute(relative)) {
-            throw new Error('CODEX_SANDBOX_CONTROLLER_CONFIG_PATH_INVALID');
-        }
-        const target = path.join(targetHome, 'model-catalogs', path.basename(resolved));
-        copyRegular(resolved, target, 0o600);
-        output.model_catalog_json = target;
-    }
-    fs.writeFileSync(destination, `${toml.stringify(output)}\n`, { mode: 0o600 });
-    const providerEnvironment = new Set();
-    const providers = output.model_providers;
-    if (providers && typeof providers === 'object' && !Array.isArray(providers)) {
-        for (const provider of Object.values(providers)) {
-            if (!provider || typeof provider !== 'object' || Array.isArray(provider))
-                continue;
-            for (const key of ['env_key', 'envKey']) {
-                const name = provider[key];
-                if (typeof name === 'string' && /^[A-Z][A-Z0-9_]{1,127}$/u.test(name)) {
-                    providerEnvironment.add(name);
-                }
-            }
-        }
-    }
-    return Object.freeze([...providerEnvironment]);
-}
-function isolatedEnvironment(home, shimDir, contextPath, taskId, control, providerEnvironment, sourceEnvironment) {
-    const inherited = new Set([
-        'LANG', 'LC_ALL', 'TERM', 'COLORTERM',
-        'HTTP_PROXY', 'HTTPS_PROXY', 'NO_PROXY',
-        'http_proxy', 'https_proxy', 'no_proxy',
-        'SSL_CERT_FILE', 'SSL_CERT_DIR', 'NODE_EXTRA_CA_CERTS',
-        'CODEX_CI',
-        ...providerEnvironment
-    ]);
-    const env = {};
-    for (const key of inherited) {
-        if (sourceEnvironment[key] !== undefined)
-            env[key] = sourceEnvironment[key];
-    }
-    return {
-        ...env,
-        HOME: home,
-        CODEX_HOME: home,
-        PATH: `${shimDir}${path.delimiter}${sourceEnvironment.PATH ?? ''}`,
-        AGENT_INFRA_TASK_ID: taskId,
-        AGENT_INFRA_CONTROL_TOKEN: control.token,
-        AGENT_INFRA_CONTROL_GENERATION: control.generation,
-        ...(control.rootId || sourceEnvironment.AGENT_INFRA_CONTROL_ROOT_ID
-            ? { AGENT_INFRA_CONTROL_ROOT_ID: control.rootId ?? sourceEnvironment.AGENT_INFRA_CONTROL_ROOT_ID }
-            : {}),
-        AGENT_INFRA_CONTROL_DIR: control.channelDir,
-        AGENT_INFRA_CONTROL_STATUS_DIR: control.statusDir,
-        AGENT_INFRA_RUNTIME_DIR: control.runtimeDir,
-        AGENT_INFRA_CODEX_CONTROLLER_CONTEXT: contextPath
-    };
-}
-function shellQuote(value) {
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
-function prepareCodexSandboxController(input, options = {}) {
-    const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
-    const sourceHome = path.resolve(options.codexHome ?? process.env.CODEX_HOME ?? path.join(os.homedir(), '.codex'));
-    const control = options.control ?? controlFromEnvironment();
-    const version = (options.codexVersion ?? detectedCodexVersion)();
-    if (!semver.gte(version, '0.147.0'))
-        throw new Error('CODEX_SANDBOX_CONTROLLER_CODEX_UNSUPPORTED');
-    const runtimeRoot = path.resolve(options.temporaryRoot
-        ?? path.join(os.tmpdir(), 'agent-infra-codex-controllers'));
-    fs.mkdirSync(runtimeRoot, { recursive: true, mode: 0o700 });
-    fs.chmodSync(runtimeRoot, 0o700);
-    const key = crypto.createHash('sha256')
-        .update(`${process.pid}\0${control.generation}`)
-        .digest('hex');
-    const parentStartTime = getProcessStartTime(process.pid);
-    if (!parentStartTime)
-        throw new Error('CODEX_SANDBOX_CONTROLLER_PROCESS_IDENTITY_INVALID');
-    const home = fs.mkdtempSync(path.join(runtimeRoot, `${key}-`));
-    fs.chmodSync(home, 0o700);
-    let cleaned = false;
-    let context = null;
-    const cleanup = () => {
-        if (cleaned)
-            return;
-        cleaned = true;
-        if (context) {
-            try {
-                (options.closeController ?? requestCodexControllerClose)({
-                    controllerProcess: context.controllerProcess,
-                    controllerProof: controllerProofFromContext(context),
-                    ...control,
-                    timeoutMs: 30_000
-                });
-            }
-            catch {
-                // The wrapper is exiting; dead-process recovery safely handles an unknown close result.
-            }
-        }
-        const relative = path.relative(runtimeRoot, home);
-        if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
-            fs.rmSync(home, { recursive: true, force: true });
-        }
-    };
-    try {
-        const auth = path.join(sourceHome, 'auth.json');
-        if (fs.existsSync(auth))
-            copyRegular(auth, path.join(home, 'auth.json'), 0o600);
-        const providerEnvironment = sanitizedConfig(path.join(sourceHome, 'config.toml'), path.join(home, 'config.toml'), sourceHome, home);
-        const hooks = path.join(repoRoot, '.codex', 'hooks.json');
-        const executor = path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-executor.toml');
-        const reviewer = path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-reviewer.toml');
-        copyRegular(hooks, path.join(home, 'hooks.json'), 0o600);
-        copyRegular(executor, path.join(home, 'agents', path.basename(executor)), 0o600);
-        copyRegular(reviewer, path.join(home, 'agents', path.basename(reviewer)), 0o600);
-        const opened = (options.openController ?? requestCodexControllerOpen)({
-            controllerProcess: { pid: process.pid, startTime: parentStartTime },
-            ...control,
-            timeoutMs: 30_000
-        });
-        const taskId = opened.lease.taskId;
-        if (opened.lease.buildIdentity.protocolVersion !== LIFECYCLE_PROTOCOL_VERSION) {
-            throw new Error('CODEX_LIFECYCLE_PROTOCOL_MISMATCH: Codex lifecycle protocol version does not match');
-        }
-        context = contextFromControllerLease(opened.lease, {
-            hookDefinitionHash: crypto.createHash('sha256').update(fs.readFileSync(hooks)).digest('hex')
-        });
-        if (opened.lease.controlGeneration !== control.generation
-            || opened.lease.controllerProcess.pid !== process.pid
-            || opened.lease.controllerProcess.startTime !== parentStartTime) {
-            throw new Error('SANDBOX_CONTROL_RESULT_INVALID');
-        }
-        verifyControllerBinding(context, control, options.verifyController ?? requestCodexControllerVerify);
-        const contextPath = path.join(home, 'controller-context.json');
-        writeCodexSandboxControllerContext(contextPath, context);
-        const shimDir = path.join(home, 'bin');
-        fs.mkdirSync(shimDir, { mode: 0o700 });
-        const internalCli = path.resolve(process.argv[1] ?? path.join(repoRoot, 'bin', 'internal-cli.ts'));
-        const launcherPrefix = ['#!/bin/sh', 'set -eu', 'unset NODE_OPTIONS NODE_PATH'].join('\n') + '\n';
-        const source = internalCli.endsWith('.ts')
-            ? `${launcherPrefix}exec ${shellQuote(process.execPath)} --experimental-strip-types ${shellQuote(internalCli)} "$@"\n`
-            : `${launcherPrefix}exec ${shellQuote(process.execPath)} ${shellQuote(internalCli)} "$@"\n`;
-        fs.writeFileSync(path.join(shimDir, 'agent-infra-internal'), source, { mode: 0o700 });
-        const policy = [
-            input.executorModel ? `--executor-model ${input.executorModel}` : '',
-            input.executorReasoningEffort ? `--executor-reasoning-effort ${input.executorReasoningEffort}` : '',
-            input.reviewerModel ? `--reviewer-model ${input.reviewerModel}` : '',
-            input.reviewerReasoningEffort ? `--reviewer-reasoning-effort ${input.reviewerReasoningEffort}` : ''
-        ].filter(Boolean).join(' ');
-        const prompt = `$run-task ${taskId}${policy ? ` ${policy}` : ''}`;
-        const args = Object.freeze([
-            'exec',
-            '--enable', 'hooks',
-            '--enable', 'multi_agent',
-            '--dangerously-bypass-hook-trust',
-            '--dangerously-bypass-approvals-and-sandbox',
-            '--json',
-            '-C', repoRoot,
-            prompt
-        ]);
-        const env = isolatedEnvironment(home, shimDir, contextPath, taskId, control, providerEnvironment, options.environment ?? process.env);
-        return Object.freeze({
-            command: 'codex',
-            args,
-            env,
-            home,
-            contextPath,
-            context,
-            cleanup
-        });
-    }
-    catch (error) {
-        cleanup();
-        throw error;
-    }
-}
-async function runCodexSandboxController(input, options = {}) {
-    const prepared = prepareCodexSandboxController(input, options);
-    try {
-        const child = spawn(prepared.command, [...prepared.args], {
-            cwd: options.repoRoot ?? process.cwd(),
-            env: prepared.env,
-            stdio: 'inherit',
-            detached: process.platform !== 'win32'
-        });
-        let forceKill;
-        const terminate = () => {
-            if (child.pid && process.platform !== 'win32') {
-                try {
-                    process.kill(-child.pid, 'SIGTERM');
-                }
-                catch {
-                    child.kill('SIGTERM');
-                }
-            }
-            else
-                child.kill('SIGTERM');
-            forceKill = setTimeout(() => {
-                if (child.pid && process.platform !== 'win32') {
-                    try {
-                        process.kill(-child.pid, 'SIGKILL');
-                    }
-                    catch {
-                        child.kill('SIGKILL');
-                    }
-                }
-                else
-                    child.kill('SIGKILL');
-            }, 5_000);
-            forceKill.unref();
-        };
-        process.once('SIGINT', terminate);
-        process.once('SIGTERM', terminate);
-        try {
-            return await new Promise((resolve, reject) => {
-                child.once('error', reject);
-                child.once('exit', (code, signal) => resolve(code ?? (signal ? 1 : 0)));
-            });
-        }
-        finally {
-            if (forceKill)
-                clearTimeout(forceKill);
-            process.off('SIGINT', terminate);
-            process.off('SIGTERM', terminate);
-        }
-    }
-    finally {
-        prepared.cleanup();
-    }
-}
-export { prepareCodexSandboxController, runCodexSandboxController, verifyCodexSandboxControllerContextWithWarnings, controllerProofFromContext };
-//# sourceMappingURL=sandbox-controller.js.map

package/dist/lib/runtime/agent-runtime.js

@@ -1,33 +0,0 @@
-import path from 'node:path';
-import { resolveTaskRuntimeRoot } from '../task/runtime-paths.js';
-function runtimeError(code, message) {
-    const error = new Error(`${code}: ${message}`);
-    error.name = code;
-    return error;
-}
-function boundControlContext(env) {
-    return [
-        'AGENT_INFRA_CONTROL_TOKEN',
-        'AGENT_INFRA_CONTROL_GENERATION',
-        'AGENT_INFRA_EXECUTOR_MANIFEST'
-    ].some((key) => typeof env[key] === 'string' && env[key].length > 0);
-}
-export function resolveAgentRuntimeRoot(options = {}) {
-    const env = options.env ?? process.env;
-    const configured = env.AGENT_INFRA_RUNTIME_DIR;
-    if (configured !== undefined && configured.length > 0) {
-        if (!path.isAbsolute(configured)) {
-            throw runtimeError('AGENT_INFRA_RUNTIME_DIR_INVALID', 'runtime directory must be absolute');
-        }
-        return path.resolve(configured);
-    }
-    const taskId = env.AGENT_INFRA_TASK_ID;
-    if (taskId) {
-        return resolveTaskRuntimeRoot(taskId, { repoRoot: options.repoRoot });
-    }
-    if (boundControlContext(env)) {
-        throw runtimeError('AGENT_INFRA_RUNTIME_DIR_REQUIRED', 'task-bound control context requires AGENT_INFRA_RUNTIME_DIR');
-    }
-    return path.join(path.resolve(options.repoRoot ?? process.cwd()), '.agents', 'workspace', '.runtime');
-}
-//# sourceMappingURL=agent-runtime.js.map

package/dist/lib/sandbox/control/agent-operation.js

@@ -1,34 +0,0 @@
-import { getAgentClientAdapter } from '../../agent-clients/registry.js';
-function operationFor(request) {
-    const adapter = getAgentClientAdapter(request.agentClient);
-    const operation = adapter.sandboxControlOperation;
-    if (!operation)
-        throw new Error('SANDBOX_CONTROL_AGENT_OPERATION_UNSUPPORTED');
-    return operation;
-}
-function validateAgentClientOperation(request, manifest) {
-    operationFor(request).validate({
-        operation: request.operation,
-        payload: request.payload,
-        manifest
-    });
-}
-function executeAgentClientOperation(request, manifest, manifestPath, override) {
-    return (override ?? operationFor(request)).execute({
-        operation: request.operation,
-        payload: request.payload,
-        manifest,
-        manifestPath
-    });
-}
-function recoverAgentClientOperation(params) {
-    const operation = operationFor(params.request);
-    return operation.recover?.({
-        operation: params.request.operation,
-        manifest: params.manifest,
-        manifestPath: params.manifestPath,
-        stdout: params.stdout
-    }) ?? { consistent: false };
-}
-export { executeAgentClientOperation, recoverAgentClientOperation, validateAgentClientOperation };
-//# sourceMappingURL=agent-operation.js.map

package/dist/lib/task/runtime-paths.js

@@ -1,10 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveTaskRef } from './resolve-ref.js';
-export function resolveTaskRuntimeRoot(taskRef, options = {}) {
-    const resolved = resolveTaskRef(taskRef, options);
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    return path.join(fs.realpathSync.native(resolved.taskDir), '.runtime');
-}
-//# sourceMappingURL=runtime-paths.js.map

package/lib/agent-clients/adapters/codex-lifecycle/controller-client.ts

@@ -1,158 +0,0 @@
-import { SandboxControlClientError, requestSandboxAgentOperation } from '../../../sandbox/control/client.ts';
-import type { SandboxControlResponse } from '../../../sandbox/control/protocol.ts';
-import type { ProcessIdentity } from '../../../server/process-state.ts';
-import type { CodexControllerLeaseProofV1, CodexControllerOpened } from './controller-registration.ts';
-
-type ControllerClosed = Readonly<{ version: 1; status: 'closed'; changed: boolean; lease: null; error: null }>;
-type ControllerVerified = Readonly<{
-  version: 1; status: 'verified'; changed: false; lease: null;
-  binding: Readonly<{ taskId: string; controlGeneration: string; controllerInstanceDigest: string }>;
-  error: null;
-}>;
-type ControllerResult = CodexControllerOpened | ControllerClosed | ControllerVerified;
-
-function fail(code: string, message: string, accepted = true): never {
-  throw new SandboxControlClientError({ code, message: `${code}: ${message}`, retryable: false }, accepted);
-}
-
-function exactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
-  return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
-}
-
-function validProcess(value: unknown): value is ProcessIdentity {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const process = value as Record<string, unknown>;
-  return exactKeys(process, ['pid', 'startTime'])
-    && Number.isSafeInteger(process.pid) && (process.pid as number) > 0
-    && Number.isSafeInteger(process.startTime) && (process.startTime as number) >= 0;
-}
-
-function validBuild(value: unknown): boolean {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const build = value as Record<string, unknown>;
-  return exactKeys(build, ['internalExecutableBuildHash', 'lifecycleContractHash', 'packageVersion', 'protocolVersion'])
-    && build.protocolVersion === 3
-    && typeof build.packageVersion === 'string' && build.packageVersion.length > 0
-    && typeof build.internalExecutableBuildHash === 'string' && /^[a-f0-9]{64}$/u.test(build.internalExecutableBuildHash)
-    && typeof build.lifecycleContractHash === 'string' && /^[a-f0-9]{64}$/u.test(build.lifecycleContractHash);
-}
-
-function parseCodexControllerResult(response: SandboxControlResponse): ControllerResult {
-  if (response.phase !== 'completed' || response.error !== null || response.stderr !== '') {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller result outer response is invalid');
-  }
-  let value: unknown;
-  try {
-    if (!response.stdout.endsWith('\n') || response.stdout.slice(0, -1).includes('\n')) throw new Error('not canonical');
-    value = JSON.parse(response.stdout);
-  } catch {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller result payload is invalid');
-  }
-  if (!value || typeof value !== 'object' || Array.isArray(value)) {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller result payload is invalid');
-  }
-  const result = value as Record<string, unknown>;
-  const keys = result.status === 'verified'
-    ? ['binding', 'changed', 'error', 'lease', 'status', 'version']
-    : ['changed', 'error', 'lease', 'status', 'version'];
-  if (!exactKeys(result, keys) || result.version !== 1
-    || !['opened', 'closed', 'failed', 'verified'].includes(result.status as string)) {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller result schema is invalid');
-  }
-  if (result.status === 'failed') {
-    const error = result.error as Record<string, unknown> | null;
-    if (response.exitCode !== 1 || result.changed !== false || result.lease !== null || !error
-      || !exactKeys(error, ['code', 'message', 'retryable'])
-      || typeof error.code !== 'string' || !/^[A-Z][A-Z0-9_]+$/u.test(error.code)
-      || typeof error.message !== 'string' || error.retryable !== false) {
-      fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller failure result is invalid');
-    }
-    fail(error.code, error.message);
-  }
-  if (response.exitCode !== 0 || result.error !== null) {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller success result is invalid');
-  }
-  if (result.status === 'closed') {
-    if (typeof result.changed !== 'boolean' || result.lease !== null) fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller close result is invalid');
-    return result as unknown as ControllerClosed;
-  }
-  if (result.status === 'verified') {
-    const binding = result.binding as Record<string, unknown> | null;
-    if (result.changed !== false || result.lease !== null || !binding
-      || !exactKeys(binding, ['controllerInstanceDigest', 'controlGeneration', 'taskId'])
-      || typeof binding.taskId !== 'string' || binding.taskId.length === 0
-      || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0
-      || typeof binding.controllerInstanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.controllerInstanceDigest)) {
-      fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller verify result is invalid');
-    }
-    return result as unknown as ControllerVerified;
-  }
-  const lease = result.lease as Record<string, unknown> | null;
-  if (result.changed !== true || !lease
-    || !exactKeys(lease, ['buildIdentity', 'controlGeneration', 'controllerInstanceDigest', 'controllerProcess', 'expiresAt', 'issuedAt', 'leaseId', 'leaseSecret', 'taskId', 'version'])
-    || lease.version !== 1 || typeof lease.leaseId !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.leaseId)
-    || typeof lease.leaseSecret !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.leaseSecret)
-    || typeof lease.taskId !== 'string' || lease.taskId.length === 0
-    || typeof lease.controlGeneration !== 'string' || lease.controlGeneration.length === 0
-    || typeof lease.controllerInstanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(lease.controllerInstanceDigest)
-    || !validProcess(lease.controllerProcess) || !validBuild(lease.buildIdentity)
-    || !Number.isSafeInteger(lease.issuedAt) || !Number.isSafeInteger(lease.expiresAt)
-    || (lease.expiresAt as number) <= (lease.issuedAt as number)) {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller open result is invalid');
-  }
-  return result as unknown as CodexControllerOpened;
-}
-
-function requestController(params: Readonly<{
-  command: 'open' | 'close' | 'verify';
-  controllerProcess: ProcessIdentity;
-  controllerProof: CodexControllerLeaseProofV1 | null;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-}>): ControllerResult {
-  const result = parseCodexControllerResult(requestSandboxAgentOperation({
-    agentClient: 'codex',
-    operation: `controller.${params.command}`,
-    payload: params.command === 'open'
-      ? { controllerProcess: params.controllerProcess }
-      : { proof: params.controllerProof },
-    ...params
-  }));
-  if (result.status === 'opened'
-    && (result.lease.controlGeneration !== (params.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION)
-      || result.lease.controllerProcess.pid !== params.controllerProcess.pid
-      || result.lease.controllerProcess.startTime !== params.controllerProcess.startTime)) {
-    fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller result does not match the request');
-  }
-  return result;
-}
-
-function requestCodexControllerOpen(params: Omit<Parameters<typeof requestController>[0], 'command' | 'controllerProof'>): CodexControllerOpened {
-  const result = requestController({ ...params, command: 'open', controllerProof: null });
-  if (result.status !== 'opened') fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller open returned the wrong result');
-  return result;
-}
-
-function requestCodexControllerClose(params: Omit<Parameters<typeof requestController>[0], 'command'>): ControllerClosed {
-  const result = requestController({ ...params, command: 'close' });
-  if (result.status !== 'closed') fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller close returned the wrong result');
-  return result;
-}
-
-function requestCodexControllerVerify(params: Readonly<{
-  controllerProof: CodexControllerLeaseProofV1;
-  channelDir?: string;
-  statusDir?: string;
-  token?: string;
-  generation?: string;
-  timeoutMs?: number;
-}>): ControllerVerified {
-  const result = requestController({ ...params, controllerProcess: params.controllerProof.controllerProcess, command: 'verify' });
-  if (result.status !== 'verified') fail('SANDBOX_CONTROL_RESULT_INVALID', 'controller verify returned the wrong result');
-  return result;
-}
-
-export { parseCodexControllerResult, requestCodexControllerClose, requestCodexControllerOpen, requestCodexControllerVerify };