@fitlab-ai/agent-infra 0.11.11 → 0.11.13

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

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { validateTaskCreateCandidate } from '../../task/create.js';
-import { normalizeAgentToken } from '../../agent-clients/tokens.js';
+import { isAgentClientId } from '../../agent-clients/types.js';
 export const SANDBOX_CONTROL_MAX_BYTES = 64 * 1024;
 export const SANDBOX_CONTROL_MAX_LOGICAL_RECORDS = 1024;
 export const SANDBOX_CONTROL_MAX_RESPONSE_BYTES = 64 * 1024 * 1024;
@@ -10,7 +10,7 @@ export const SANDBOX_CONTROL_ADMISSION_WINDOW_MS = 2_000;
 export const SANDBOX_CONTROL_STATUS_INTERVAL_MS = 250;
 export const SANDBOX_CONTROL_STATUS_STALE_MS = 1_500;
 export const SANDBOX_CONTROL_FUTURE_SKEW_MS = 1_000;
-export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-finalization', 'task-create', 'codex-controller'];
+export const SANDBOX_CONTROL_FAMILIES = ['task-lifecycle', 'task-create', 'agent-client'];
 export const DEFAULT_SANDBOX_CONTROL_TIMING = Object.freeze({
     controlTickMs: 250,
     parkedBindingInitialMs: 1_000,
@@ -131,85 +131,46 @@ export function validateSandboxControlRequest(value, manifest, options = {}) {
         fail('SANDBOX_CONTROL_REQUEST_TOO_LARGE', 'request exceeds the control limit');
     }
     if (request.family === 'task-create') {
-        const expected = ['candidate', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
+        const expected = ['candidate', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
         if (Object.keys(request).sort().join(',') !== expected.sort().join(',')) {
             fail('SANDBOX_CONTROL_REQUEST_INVALID', 'request schema or authorization is invalid');
         }
-        if (request.controllerProcess !== null || request.controllerProof !== null) {
-            fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-create cannot carry controller authority');
-        }
         return { ...request, candidate: validateTaskCreateCandidate(request.candidate) };
     }
-    if (request.family === 'codex-controller') {
-        const expected = ['args', 'command', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
-        if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
-            || !Array.isArray(request.args) || request.args.length !== 0
-            || !['open', 'close', 'verify'].includes(request.command)
-            || !validControllerProcess(request.controllerProcess)
-            || (request.command === 'open' && request.controllerProof !== null)
-            || (request.command !== 'open' && !validControllerProof(request.controllerProof))
-            || (request.command === 'verify'
-                && JSON.stringify(request.controllerProcess) !== JSON.stringify(request.controllerProof.controllerProcess))) {
-            fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller request schema is invalid');
-        }
-        if (manifest.mode !== 'task-bound' || !manifest.taskId) {
-            fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot register a Codex controller');
-        }
-        return request;
-    }
-    if (request.family === 'task-finalization') {
-        const expected = ['agent', 'args', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'operation', 'token', 'version'];
+    if (request.family === 'agent-client') {
+        const expected = ['agentClient', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'operation', 'payload', 'token', 'version'];
         if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
-            || request.operation !== 'complete'
-            || !Array.isArray(request.args) || request.args.length !== 0
-            || typeof request.agent !== 'string' || normalizeAgentToken(request.agent) !== request.agent
-            || request.controllerProcess !== null || request.controllerProof !== null) {
-            fail('SANDBOX_CONTROL_REQUEST_INVALID', 'task-finalization request schema or authorization is invalid');
+            || !isAgentClientId(request.agentClient)
+            || typeof request.operation !== 'string' || !/^[a-z][a-z0-9.-]{0,63}$/u.test(request.operation)
+            || !request.payload || typeof request.payload !== 'object' || Array.isArray(request.payload)) {
+            fail('SANDBOX_CONTROL_REQUEST_INVALID', 'agent-client request schema is invalid');
         }
         if (manifest.mode !== 'task-bound' || !manifest.taskId) {
-            fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot finalize tasks');
+            fail('SANDBOX_CONTROL_BRANCH_ONLY', 'branch-only sandboxes cannot coordinate agent clients');
         }
         return request;
     }
-    const expected = ['args', 'controllerProcess', 'controllerProof', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
+    const expected = ['args', 'expiresAt', 'family', 'generation', 'id', 'issuedAt', 'token', 'version'];
     if (Object.keys(request).sort().join(',') !== expected.sort().join(',')
         || !Array.isArray(request.args) || !request.args.every((arg) => typeof arg === 'string')) {
         fail('SANDBOX_CONTROL_REQUEST_INVALID', 'request schema or authorization is invalid');
     }
+    if (request.args[1] === 'complete') {
+        fail('SANDBOX_CONTROL_COMMAND_DENIED', 'complete must use task-finalization');
+    }
     if (manifest.mode !== 'task-bound' || !manifest.taskId) {
         fail('SANDBOX_CONTROL_BRANCH_ONLY', "branch-only sandboxes cannot coordinate tasks; return to the host and run 'ai sandbox start --recreate <task-ref-or-correct-branch>'");
     }
-    if (request.controllerProcess !== null || request.controllerProof !== null) {
-        fail('SANDBOX_CONTROL_REQUEST_INVALID', 'controller authority is invalid');
-    }
     return request;
 }
 export function bindSandboxControlTask(request, taskId) {
-    if (request.family === 'task-create' || request.family === 'codex-controller' || request.family === 'task-finalization') {
+    if (request.family === 'task-create' || request.family === 'agent-client') {
         fail('SANDBOX_CONTROL_REQUEST_INVALID', `${request.family} requests do not bind a current task`);
     }
     if (request.args.length === 0)
         fail('SANDBOX_CONTROL_REQUEST_INVALID', 'command arguments are required');
     return [taskId, ...request.args.slice(1)];
 }
-function validControllerProcess(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const processValue = value;
-    return Object.keys(processValue).sort().join(',') === 'pid,startTime'
-        && Number.isSafeInteger(processValue.pid) && processValue.pid > 0
-        && Number.isSafeInteger(processValue.startTime) && processValue.startTime >= 0;
-}
-function validControllerProof(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const proof = value;
-    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)
-        && validControllerProcess(proof.controllerProcess);
-}
 export function controlError(error) {
     if (error instanceof SandboxControlProtocolError) {
         return { code: error.code, message: error.message, retryable: error.retryable };