@fitlab-ai/agent-infra 0.11.11 → 0.11.13

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

@@ -0,0 +1,158 @@
+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 };

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

@@ -3,7 +3,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 
 import { getProcessIdentityState, type ProcessIdentity } from '../../../server/process-state.ts';
-import type { CodexControllerLeaseProofV1, CodexControllerLeaseV1 } from '../../../sandbox/control/controller-registration.ts';
+import type { CodexControllerLeaseProofV1, CodexControllerLeaseV1 } from './controller-registration.ts';
 import {
   computeLifecycleBuildIdentity,
   verifyLifecycleBuildIdentity,

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

@@ -0,0 +1,151 @@
+import type { ProcessIdentity } from '../../../server/process-state.ts';
+import {
+  closeCodexControllerRegistration,
+  CodexControllerRegistrationError,
+  openCodexControllerRegistration,
+  readCodexControllerRegistration,
+  resolveCodexControllerBinding,
+  type CodexControllerLeaseProofV1
+} from './controller-registration.ts';
+import { computeLifecycleBuildIdentity } from './build-identity.ts';
+
+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 Object.keys(process).sort().join(',') === 'pid,startTime'
+    && Number.isSafeInteger(process.pid) && (process.pid as number) > 0
+    && Number.isSafeInteger(process.startTime) && (process.startTime as number) >= 0;
+}
+
+function validProof(value: unknown): value is CodexControllerLeaseProofV1 {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const proof = value as Record<string, unknown>;
+  return Object.keys(proof).sort().join(',') === 'controllerProcess,leaseId,leaseSecret,version'
+    && proof.version === 1
+    && typeof proof.leaseId === 'string' && /^[a-f0-9]{64}$/u.test(proof.leaseId)
+    && typeof proof.leaseSecret === 'string' && /^[a-f0-9]{64}$/u.test(proof.leaseSecret)
+    && validProcess(proof.controllerProcess);
+}
+
+function validate(params: Readonly<{
+  operation: string;
+  payload: Record<string, unknown>;
+  manifest: { mode: string; taskId: string | null };
+}>): void {
+  const { operation, payload, manifest } = params;
+  const expectedKeys = operation === 'controller.open' ? ['controllerProcess'] : ['proof'];
+  if (!['controller.open', 'controller.close', 'controller.verify'].includes(operation)
+    || Object.keys(payload).sort().join(',') !== expectedKeys.sort().join(',')
+    || (operation === 'controller.open'
+      ? !validProcess(payload.controllerProcess)
+      : !validProof(payload.proof))) {
+    throw new Error('SANDBOX_CONTROL_REQUEST_INVALID: controller operation payload is invalid');
+  }
+  if (manifest.mode !== 'task-bound' || !manifest.taskId) {
+    throw new Error('SANDBOX_CONTROL_BRANCH_ONLY: controller operations require a task-bound sandbox');
+  }
+}
+
+async function execute(params: Readonly<{
+  operation: string;
+  payload: Record<string, unknown>;
+  manifest: Parameters<typeof openCodexControllerRegistration>[0]['manifest'];
+  manifestPath: string;
+}>): Promise<Readonly<{ exitCode: number; stdout: string; stderr: string }>> {
+  const { operation, payload, manifest, manifestPath } = params;
+  try {
+    const result = operation === 'controller.open'
+      ? openCodexControllerRegistration({
+        manifest,
+        manifestPath,
+        controllerProcess: payload.controllerProcess as ProcessIdentity,
+        buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
+      })
+      : operation === 'controller.close'
+        ? closeCodexControllerRegistration({
+          manifest,
+          manifestPath,
+          proof: payload.proof as CodexControllerLeaseProofV1
+        })
+        : (() => {
+          const binding = resolveCodexControllerBinding({
+            manifest,
+            manifestPath,
+            proof: payload.proof as CodexControllerLeaseProofV1,
+            buildIdentity: computeLifecycleBuildIdentity(manifest.repoRoot)
+          });
+          return {
+            version: 1,
+            status: 'verified',
+            changed: false,
+            lease: null,
+            binding: {
+              taskId: manifest.taskId,
+              controlGeneration: binding.controlGeneration,
+              controllerInstanceDigest: binding.instanceDigest
+            },
+            error: null
+          };
+        })();
+    return { exitCode: 0, stdout: `${JSON.stringify(result)}\n`, stderr: '' };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof CodexControllerRegistrationError
+      ? error.code
+      : /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'CODEX_SANDBOX_CONTROLLER_FAILED';
+    return {
+      exitCode: 1,
+      stdout: `${JSON.stringify({
+        version: 1,
+        status: 'failed',
+        changed: false,
+        lease: null,
+        error: { code, message, retryable: false }
+      })}\n`,
+      stderr: ''
+    };
+  }
+}
+
+function recover(params: Readonly<{
+  operation: string;
+  manifest: Parameters<typeof openCodexControllerRegistration>[0]['manifest'];
+  manifestPath: string;
+  stdout: string | null;
+}>): Readonly<Record<string, unknown>> {
+  if (params.stdout === null) return { consistent: false };
+  let output: Record<string, unknown>;
+  try {
+    const parsed: unknown = JSON.parse(params.stdout);
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return { consistent: false };
+    output = parsed as Record<string, unknown>;
+  } catch {
+    return { consistent: false };
+  }
+  if (output.error !== null || typeof output.status !== 'string') return { consistent: false };
+  try {
+    const registration = readCodexControllerRegistration(params.manifestPath);
+    if (params.operation === 'controller.open') {
+      const lease = output.lease as Record<string, unknown> | null;
+      return { consistent: output.status === 'opened' && output.changed === true
+        && lease?.controlGeneration === registration.controlGeneration
+        && lease?.controllerInstanceDigest === registration.controllerInstanceDigest
+        && registration.controlGeneration === params.manifest.generation };
+    }
+    if (params.operation === 'controller.verify') {
+      const binding = output.binding as Record<string, unknown> | null;
+      return { consistent: output.status === 'verified' && output.changed === false
+        && binding?.controlGeneration === registration.controlGeneration
+        && binding?.controllerInstanceDigest === registration.controllerInstanceDigest };
+    }
+    return { consistent: false };
+  } catch (error) {
+    return { consistent: params.operation === 'controller.close'
+      && (error as { code?: string }).code === 'CODEX_SANDBOX_CONTROLLER_REGISTRATION_MISSING'
+      && output.status === 'closed' && typeof output.changed === 'boolean' };
+  }
+}
+
+const codexControllerOperation = Object.freeze({ validate, execute, recover });
+
+export { codexControllerOperation };

package/lib/{sandbox/control → agent-clients/adapters/codex-lifecycle}/controller-registration.ts

@@ -2,10 +2,10 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
-import type { LifecycleBuildIdentity } from '../../agent-clients/adapters/codex-lifecycle/build-identity.ts';
-import { parseLinuxProcessStat, type ProcessIdentity, type ProcessIdentityState } from '../../server/process-state.ts';
-import { commandForEngine, runProbe } from '../shell.ts';
-import type { SandboxControlManifest } from './protocol.ts';
+import type { LifecycleBuildIdentity } from './build-identity.ts';
+import { parseLinuxProcessStat, type ProcessIdentity, type ProcessIdentityState } from '../../../server/process-state.ts';
+import { commandForEngine, runProbe } from '../../../sandbox/shell.ts';
+import type { SandboxControlManifest } from '../../../sandbox/control/protocol.ts';
 
 const CONTROLLER_TTL_MS = 4 * 60 * 60 * 1_000;
 const HEX_256 = /^[a-f0-9]{64}$/u;

package/lib/agent-clients/adapters/codex-lifecycle/evidence.ts

@@ -1,3 +1,5 @@
+import type { CodexLifecycleTaskBinding } from './binding.ts';
+
 type CodexEvidenceSource =
   | 'codex-hook'
   | 'codex-app-server-thread'
@@ -15,6 +17,7 @@ type CodexLifecycleEvent =
       requestedModel?: string;
       requestedReasoningEffort?: string;
       hookDefinitionHash: string;
+      taskBinding?: CodexLifecycleTaskBinding;
     }>
   | Readonly<{
       type: 'hook-child';
@@ -98,6 +101,44 @@ type CodexLifecycleStatus =
 
 type CodexEvidenceError = Readonly<{ code: string; message: string }>;
 
+function isCodexLifecycleActivationEvidence(value: unknown, parentId: string): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const state = value as Record<string, unknown>;
+  const evidence = state.activationEvidence;
+  if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return false;
+  const activation = evidence as Record<string, unknown>;
+  return activation.kind === 'codex-lifecycle-v2'
+    && typeof activation.hookDefinitionHash === 'string'
+    && activation.hookDefinitionHash.trim() !== ''
+    && Number.isSafeInteger(activation.startRevision)
+    && (activation.startRevision as number) >= 1
+    && activation.capabilitySessionId === parentId;
+}
+
+function isCodexDelegationReceiptEvidence(value: unknown): boolean {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const receipt = value as Record<string, unknown>;
+  if (receipt.client !== 'codex' || typeof receipt.id !== 'string') return false;
+  const status = receipt.status;
+  if (!['activated', 'stage-completed', 'sealed', 'consumed', 'aborted'].includes(status as string)) return true;
+  const adapterEvidence = receipt.adapterEvidence;
+  if (!adapterEvidence || typeof adapterEvidence !== 'object' || Array.isArray(adapterEvidence)) return false;
+  const codex = (adapterEvidence as Record<string, unknown>).codex;
+  if (!codex || typeof codex !== 'object' || Array.isArray(codex)) return false;
+  const state = codex as Record<string, unknown>;
+  if (!isCodexLifecycleActivationEvidence(state, String(receipt.parentId ?? ''))) return false;
+  if (!['sealed', 'consumed', 'aborted'].includes(status as string)) return true;
+  const records = state.records;
+  if (!records || typeof records !== 'object' || Array.isArray(records)) return false;
+  return Object.values(records as Record<string, unknown>).some((record) => {
+    if (!record || typeof record !== 'object' || Array.isArray(record)) return false;
+    const evidence = record as Record<string, unknown>;
+    return evidence.consumer === receipt.id
+      && typeof evidence.consumedAt === 'string'
+      && evidence.consumedAt.trim() !== '';
+  });
+}
+
 type CodexLifecycleState = Readonly<{
   schemaVersion: 1;
   cliVersion: string;
@@ -329,6 +370,8 @@ function expireCodexLifecycleState(state: CodexLifecycleState): CodexLifecycleSt
 export {
   createCodexLifecycleState,
   expireCodexLifecycleState,
+  isCodexLifecycleActivationEvidence,
+  isCodexDelegationReceiptEvidence,
   reduceCodexLifecycleEvent
 };
 export type {

package/lib/agent-clients/adapters/codex-lifecycle/manifest-files.json

@@ -1,25 +1,28 @@
 {
   "executableFiles": [
     "bin/internal-cli.ts",
-    "lib/internal/codex-lifecycle.ts",
-    "lib/internal/codex-sandbox-controller.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/cli.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller-cli.ts",
     "lib/internal/sandbox-control.ts",
     "lib/internal/task-orchestration.ts",
-    "lib/task/codex-orchestration.ts",
+    "lib/agent-clients/adapters/codex-orchestration.ts",
     "lib/task/delegation-receipts.ts",
     "lib/task/orchestration.ts",
     "lib/agent-clients/adapters/codex-lifecycle/build-identity.ts",
-    "lib/agent-clients/adapters/codex-lifecycle/capability-store.ts",
     "lib/agent-clients/adapters/codex-lifecycle/sandbox-controller.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/controller-client.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/controller-operation.ts",
     "lib/agent-clients/adapters/codex-lifecycle/controller-context.ts",
     "lib/agent-clients/adapters/codex-lifecycle/app-server.ts",
+    "lib/agent-clients/adapters/codex-lifecycle/binding.ts",
     "lib/agent-clients/adapters/codex-lifecycle/evidence.ts",
     "lib/agent-clients/adapters/codex-lifecycle/store.ts",
     "lib/agent-clients/adapters/codex-lifecycle/manifest-files.json",
+    "lib/agent-clients/adapters/codex-lifecycle/controller-registration.ts",
     "lib/sandbox/control/protocol.ts",
+    "lib/sandbox/control/agent-operation.ts",
     "lib/sandbox/control/client.ts",
     "lib/sandbox/control/executor.ts",
-    "lib/sandbox/control/controller-registration.ts",
     "lib/server/process-state.ts",
     "lib/sandbox/shell.ts"
   ],