@fitlab-ai/agent-infra 0.9.4 → 0.9.5

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

@@ -0,0 +1,211 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent } from './evidence.js';
+const LOCK_RETRY_MS = 10;
+const LOCK_TIMEOUT_MS = 1_000;
+const LOCK_STALE_MS = 30_000;
+function digest(value) {
+    return crypto.createHash('sha256').update(value).digest('hex');
+}
+function readRecord(file) {
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (value.schemaVersion !== 1
+        || !Number.isSafeInteger(value.revision)
+        || value.revision < 1
+        || !value.state
+        || value.state.schemaVersion !== 1) {
+        throw new Error(`Codex lifecycle record '${path.basename(file)}' is invalid`);
+    }
+    return value;
+}
+function recordFiles(root) {
+    if (!fs.existsSync(root))
+        return [];
+    return fs.readdirSync(root)
+        .filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+        .map((name) => path.join(root, name));
+}
+function writeRecord(file, record, expectedRevision) {
+    const temp = `${file}.${process.pid}.${crypto.randomUUID()}.tmp`;
+    fs.writeFileSync(temp, `${JSON.stringify(record, null, 2)}\n`, {
+        encoding: 'utf8',
+        flag: 'wx',
+        mode: 0o600
+    });
+    try {
+        const actualRevision = fs.existsSync(file) ? readRecord(file).revision : 0;
+        if (actualRevision !== expectedRevision) {
+            throw new Error(`Codex lifecycle revision changed from ${expectedRevision} to ${actualRevision}`);
+        }
+        fs.renameSync(temp, file);
+        fs.chmodSync(file, 0o600);
+    }
+    finally {
+        if (fs.existsSync(temp))
+            fs.unlinkSync(temp);
+    }
+}
+function createCodexLifecycleStore(options) {
+    const root = options.root ?? path.join(process.cwd(), '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+    const now = options.now ?? (() => new Date().toISOString());
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    fs.chmodSync(root, 0o700);
+    function withWriteLock(operation) {
+        const lock = path.join(root, '.write.lock');
+        const deadline = Date.now() + LOCK_TIMEOUT_MS;
+        let descriptor = null;
+        while (descriptor === null) {
+            try {
+                descriptor = fs.openSync(lock, 'wx', 0o600);
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                try {
+                    if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
+                        fs.unlinkSync(lock);
+                        continue;
+                    }
+                }
+                catch (lockError) {
+                    if (lockError.code === 'ENOENT')
+                        continue;
+                    throw lockError;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error('Codex lifecycle store is busy');
+                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
+            }
+        }
+        try {
+            return operation();
+        }
+        finally {
+            fs.closeSync(descriptor);
+            fs.unlinkSync(lock);
+        }
+    }
+    function findByChild(childThreadId) {
+        return recordFiles(root).filter((file) => {
+            const child = readRecord(file).state.child;
+            return child?.childThreadId === childThreadId;
+        });
+    }
+    function locate(event) {
+        if (event.type === 'hook-spawn') {
+            return path.join(root, `${digest(`${event.sessionId}\0${event.turnId}\0${event.toolUseId}`)}.json`);
+        }
+        if (event.type === 'hook-child') {
+            const matches = recordFiles(root).filter((file) => {
+                const state = readRecord(file).state;
+                return state.spawn?.sessionId === event.sessionId
+                    && state.spawn.nativeAgent === event.nativeAgent
+                    && (!state.child || state.child.childThreadId === event.childThreadId);
+            });
+            if (matches.length !== 1) {
+                throw new Error(matches.length === 0
+                    ? 'Codex lifecycle parent session and agent correlation was not found'
+                    : 'Codex lifecycle parent session and agent correlation is ambiguous');
+            }
+            return matches[0];
+        }
+        const matches = findByChild(event.childThreadId);
+        if (matches.length !== 1) {
+            throw new Error(matches.length === 0
+                ? `Codex lifecycle child '${event.childThreadId}' was not found`
+                : `Codex lifecycle child '${event.childThreadId}' is ambiguous`);
+        }
+        return matches[0];
+    }
+    function apply(event) {
+        return withWriteLock(() => {
+            const file = locate(event);
+            const current = fs.existsSync(file)
+                ? readRecord(file)
+                : Object.freeze({
+                    schemaVersion: 1,
+                    revision: 0,
+                    state: createCodexLifecycleState(options.cliVersion),
+                    consumer: null,
+                    consumedAt: null,
+                    updatedAt: now()
+                });
+            if (current.consumer)
+                throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+            const nextState = reduceCodexLifecycleEvent(current.state, event);
+            const next = Object.freeze({
+                schemaVersion: 1,
+                revision: current.revision + 1,
+                state: nextState,
+                consumer: null,
+                consumedAt: null,
+                updatedAt: now()
+            });
+            writeRecord(file, next, current.revision);
+            return Object.freeze({ path: file, revision: next.revision, state: next.state });
+        });
+    }
+    function read(childThreadId) {
+        const matches = findByChild(childThreadId);
+        if (matches.length !== 1)
+            throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
+        return readRecord(matches[0]);
+    }
+    function consume(childThreadId, consumer, expectedHookDefinitionHash) {
+        if (!consumer.trim())
+            throw new Error('Codex lifecycle consumer is required');
+        return withWriteLock(() => {
+            const matches = findByChild(childThreadId);
+            if (matches.length !== 1)
+                throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
+            const file = matches[0];
+            const current = readRecord(file);
+            if (current.consumer)
+                throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
+            if (current.state.status !== 'stop-ready')
+                throw new Error('Codex lifecycle evidence is not stop-ready');
+            if (expectedHookDefinitionHash
+                && current.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash)
+                throw new Error('Codex lifecycle hook definition hash is stale');
+            const next = Object.freeze({
+                ...current,
+                revision: current.revision + 1,
+                consumer,
+                consumedAt: now(),
+                updatedAt: now()
+            });
+            writeRecord(file, next, current.revision);
+            return next;
+        });
+    }
+    function expireBefore(cutoff) {
+        return withWriteLock(() => {
+            let changed = 0;
+            for (const file of recordFiles(root)) {
+                const current = readRecord(file);
+                if (current.updatedAt >= cutoff)
+                    continue;
+                if (current.consumer || ['invalid', 'expired', 'stop-ready'].includes(current.state.status)) {
+                    fs.unlinkSync(file);
+                    changed += 1;
+                    continue;
+                }
+                const expiredState = expireCodexLifecycleState(current.state);
+                if (expiredState === current.state)
+                    continue;
+                writeRecord(file, Object.freeze({
+                    ...current,
+                    revision: current.revision + 1,
+                    state: expiredState,
+                    updatedAt: now()
+                }), current.revision);
+                changed += 1;
+            }
+            return changed;
+        });
+    }
+    return Object.freeze({ root, apply, consume, expireBefore, read });
+}
+export { createCodexLifecycleStore };
+//# sourceMappingURL=store.js.map

package/dist/lib/agent-clients/adapters/codex.js

@@ -21,8 +21,8 @@ const codexAdapter = defineAgentClientAdapter({
         guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
     },
     delegationEvidence: {
-        actualModel: 'unavailable',
-        actualReasoningEffort: 'unavailable'
+        actualModel: 'app-server',
+        actualReasoningEffort: 'app-server'
     },
     project: {
         ownedPathPrefixes: ['.codex/'],

package/dist/lib/git/worktree-identity.js

@@ -0,0 +1,64 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function normalizeCanonicalPath(value, platform = process.platform) {
+    return platform === 'win32'
+        ? path.win32.normalize(value).replaceAll('/', '\\').toLowerCase()
+        : path.posix.normalize(value);
+}
+function sameFilesystemEntry(left, right, platform = process.platform) {
+    const leftReal = fs.realpathSync.native(left);
+    const rightReal = fs.realpathSync.native(right);
+    const leftStat = fs.statSync(leftReal, { bigint: true });
+    const rightStat = fs.statSync(rightReal, { bigint: true });
+    if (leftStat.ino !== 0n && rightStat.ino !== 0n) {
+        return leftStat.dev === rightStat.dev && leftStat.ino === rightStat.ino;
+    }
+    return normalizeCanonicalPath(leftReal, platform) === normalizeCanonicalPath(rightReal, platform);
+}
+function git(root, args) {
+    return execFileSync('git', args, {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+}
+function resolveGitWorktreeIdentity(worktreeRoot) {
+    try {
+        const canonical = fs.realpathSync.native(worktreeRoot);
+        const topLevel = fs.realpathSync.native(git(canonical, ['rev-parse', '--show-toplevel']));
+        if (!sameFilesystemEntry(canonical, topLevel)) {
+            throw new Error('worktree root is not the Git top-level directory');
+        }
+        const commonDir = fs.realpathSync.native(git(canonical, [
+            'rev-parse', '--path-format=absolute', '--git-common-dir'
+        ]));
+        const branch = git(canonical, ['symbolic-ref', '--short', 'HEAD']);
+        return { worktreeRoot: canonical, commonDir, branch };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`SANDBOX_CONTROL_WORKTREE_INVALID: ${message}`);
+    }
+}
+function assertGitWorktreeBinding(stateRoot, worktreeRoot, expectedBranch) {
+    const state = resolveGitWorktreeIdentity(stateRoot);
+    const worktree = resolveGitWorktreeIdentity(worktreeRoot);
+    if (!sameFilesystemEntry(state.commonDir, worktree.commonDir)) {
+        throw new Error('SANDBOX_CONTROL_WORKTREE_INVALID: state and worktree roots have different Git common directories');
+    }
+    if (worktree.branch !== expectedBranch) {
+        throw new Error(`SANDBOX_CONTROL_WORKTREE_INVALID: expected branch '${expectedBranch}', got '${worktree.branch}'`);
+    }
+    return worktree;
+}
+function assertGitRepositoryBinding(stateRoot, worktreeRoot) {
+    const state = resolveGitWorktreeIdentity(stateRoot);
+    const worktree = resolveGitWorktreeIdentity(worktreeRoot);
+    if (!sameFilesystemEntry(state.commonDir, worktree.commonDir)) {
+        throw new Error('SANDBOX_CONTROL_WORKTREE_INVALID: state and worktree roots have different Git common directories');
+    }
+    return worktree;
+}
+export { assertGitWorktreeBinding, assertGitRepositoryBinding, normalizeCanonicalPath, resolveGitWorktreeIdentity, sameFilesystemEntry };
+//# sourceMappingURL=worktree-identity.js.map

package/dist/lib/internal/codex-lifecycle.js

@@ -0,0 +1,202 @@
+import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
+import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
+const USAGE = 'Usage: agent-infra-internal codex-lifecycle <hook-event|resolve-start|resolve-stop|preflight|consume> [options]\n';
+const MANAGED_AGENT = /^agent-infra-lifecycle-(executor|reviewer)$/;
+function output(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function failure(code, message) {
+    output({ status: 'failed', changed: false, evidence: null, diagnostics: [], error: { code, message } });
+    process.exitCode = 1;
+}
+function parse(args) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return null;
+    }
+    const operation = args[0];
+    if (!operation) {
+        failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', 'operation is required');
+        return null;
+    }
+    const allowed = {
+        'hook-event': ['--event'],
+        'resolve-start': ['--child-id'],
+        'resolve-stop': ['--child-id'],
+        preflight: ['--format', '--session-id', '--turn-id', '--tool-use-id'],
+        consume: ['--child-id', '--consumer']
+    }[operation];
+    if (!allowed) {
+        failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', 'unknown operation');
+        return null;
+    }
+    const values = {};
+    for (let index = 1; index < args.length; index += 1) {
+        const flag = args[index];
+        if (!allowed.includes(flag) || Object.hasOwn(values, flag)) {
+            failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
+            return null;
+        }
+        const value = args[++index];
+        if (!value || value.startsWith('--')) {
+            failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', `option '${flag}' requires a value`);
+            return null;
+        }
+        values[flag] = value;
+    }
+    return Object.freeze({ operation, values: Object.freeze(values) });
+}
+function cliVersion() {
+    const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+    const version = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(result.stdout ?? '')?.[1];
+    if (result.status !== 0 || !version)
+        throw new Error('Codex CLI version is unavailable');
+    return version;
+}
+function hookDefinitionHash() {
+    const file = path.join(process.cwd(), '.codex', 'hooks.json');
+    return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+}
+async function readStdin() {
+    let input = '';
+    process.stdin.setEncoding('utf8');
+    for await (const chunk of process.stdin) {
+        input += chunk;
+        if (Buffer.byteLength(input) > 64 * 1024)
+            throw new Error('Codex lifecycle input exceeds 64 KiB');
+    }
+    return JSON.parse(input || '{}');
+}
+function recordFromPayload(phase, payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new Error('Codex lifecycle hook payload must be an object');
+    }
+    const value = payload;
+    const text = (key) => typeof value[key] === 'string' ? value[key] : '';
+    if (!MANAGED_AGENT.test(text('nativeAgent')))
+        return null;
+    if (phase === 'pre-tool')
+        return {
+            type: 'hook-spawn',
+            sessionId: text('sessionId'),
+            turnId: text('turnId'),
+            toolUseId: text('toolUseId'),
+            nativeAgent: text('nativeAgent'),
+            ...(text('requestedModel') ? { requestedModel: text('requestedModel') } : {}),
+            ...(text('requestedReasoningEffort') ? { requestedReasoningEffort: text('requestedReasoningEffort') } : {}),
+            hookDefinitionHash: text('hookDefinitionHash')
+        };
+    if (phase === 'subagent-start')
+        return {
+            type: 'hook-child',
+            sessionId: text('sessionId'),
+            turnId: text('turnId'),
+            childThreadId: text('childThreadId'),
+            nativeAgent: text('nativeAgent')
+        };
+    if (phase === 'subagent-stop')
+        return {
+            type: 'hook-stop',
+            sessionId: text('sessionId'),
+            turnId: text('turnId'),
+            childThreadId: text('childThreadId'),
+            nativeAgent: text('nativeAgent')
+        };
+    if (phase === 'post-tool')
+        return null;
+    throw new Error(`unknown Codex lifecycle hook phase '${phase}'`);
+}
+async function codexLifecycle(args = []) {
+    const parsed = parse(args);
+    if (!parsed || process.exitCode)
+        return;
+    try {
+        if (parsed.operation === 'preflight') {
+            const format = parsed.values['--format'] ?? 'json';
+            if (!['text', 'json'].includes(format))
+                throw new Error("format must be 'text' or 'json'");
+            const runtimeFields = [
+                parsed.values['--session-id'],
+                parsed.values['--turn-id'],
+                parsed.values['--tool-use-id']
+            ];
+            if (runtimeFields.some(Boolean) && !runtimeFields.every(Boolean)) {
+                throw new Error('preflight runtime identity requires --session-id, --turn-id, and --tool-use-id together');
+            }
+            const runtimeIdentity = runtimeFields.every(Boolean) ? {
+                sessionId: runtimeFields[0],
+                turnId: runtimeFields[1],
+                toolUseId: runtimeFields[2]
+            } : undefined;
+            const result = await preflightCodexLifecycleEvidence(process.cwd(), runtimeIdentity);
+            if (format === 'text') {
+                process.stdout.write(`Codex lifecycle static preflight: ready\nCLI: ${result.cliVersion}\nRuntime hook liveness: ${result.runtimeLiveness ? 'observed' : 'not-yet-observed'}\n`);
+            }
+            else
+                output({ status: 'ready', changed: false, evidence: result, diagnostics: result.diagnostics, error: null });
+            return;
+        }
+        const store = createCodexLifecycleStore({ cliVersion: cliVersion() });
+        if (parsed.operation === 'hook-event') {
+            const phase = parsed.values['--event'];
+            if (!phase || !['pre-tool', 'subagent-start', 'post-tool', 'subagent-stop'].includes(phase)) {
+                throw new Error('hook-event requires a known --event');
+            }
+            const event = recordFromPayload(phase, await readStdin());
+            if (!event) {
+                output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
+                return;
+            }
+            const result = store.apply(event);
+            output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: [], error: result.state.error });
+            if (result.state.status === 'invalid')
+                process.exitCode = 1;
+            return;
+        }
+        const childThreadId = parsed.values['--child-id'];
+        if (!childThreadId)
+            throw new Error(`operation '${parsed.operation}' requires --child-id`);
+        if (parsed.operation === 'resolve-start') {
+            if (store.read(childThreadId).state.spawn?.hookDefinitionHash !== hookDefinitionHash()) {
+                throw new Error('Codex lifecycle hook definition hash is stale');
+            }
+            const resolved = await resolveCodexThread(childThreadId);
+            let latest = store.apply(resolved.resolution.thread);
+            for (const reroute of resolved.reroutes)
+                latest = store.apply(reroute);
+            latest = store.apply(resolved.resolution.settings);
+            output({ status: latest.state.status, changed: true, evidence: latest.state.startEvidence, diagnostics: resolved.diagnostics, error: latest.state.error });
+            if (latest.state.status !== 'start-ready')
+                process.exitCode = 1;
+            return;
+        }
+        if (parsed.operation === 'resolve-stop') {
+            const terminal = await resolveCodexTerminal(childThreadId);
+            const latest = store.apply(terminal);
+            if (latest.state.status !== 'stop-ready') {
+                throw new Error(`Codex lifecycle stop evidence is not ready (status=${latest.state.status})`);
+            }
+            output({ status: latest.state.status, changed: true, evidence: latest.state.stopEvidence, diagnostics: [], error: latest.state.error });
+            return;
+        }
+        if (parsed.operation === 'consume') {
+            const consumer = parsed.values['--consumer'];
+            if (!consumer)
+                throw new Error('consume requires --consumer');
+            const consumed = store.consume(childThreadId, consumer, hookDefinitionHash());
+            output({ status: 'consumed', changed: true, evidence: {
+                    start: consumed.state.startEvidence,
+                    stop: consumed.state.stopEvidence
+                }, diagnostics: [], error: null });
+        }
+    }
+    catch (error) {
+        failure('CODEX_LIFECYCLE_FAILED', error instanceof Error ? error.message : String(error));
+    }
+}
+export { codexLifecycle };
+//# sourceMappingURL=codex-lifecycle.js.map

package/dist/lib/internal/task-create.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { requestSandboxTaskCreate } from '../sandbox/control/client.js';
+import { SANDBOX_CONTROL_MAX_BYTES } from '../sandbox/control/protocol.js';
+import { validateTaskCreateCandidate } from '../task/create.js';
+import { createTask } from '../task/create-service.js';
+function failed(code, message) {
+    return {
+        status: 'failed', changed: false, task: { id: null, shortId: null }, issue: null,
+        operations: [], warnings: [], error: { code, message, retryable: false }
+    };
+}
+function output(result) {
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    process.exitCode = result.status === 'blocked' ? 2 : result.status === 'failed' ? 1 : 0;
+}
+function taskCreate(args) {
+    const inputIndex = args.indexOf('--input');
+    const input = inputIndex >= 0 ? args[inputIndex + 1] : undefined;
+    if (!input || args.length !== 2 || inputIndex !== 0) {
+        output(failed('TASK_CREATE_PAYLOAD_INVALID', 'Usage: agent-infra-internal task-create --input <candidate.json>'));
+        return;
+    }
+    try {
+        const inputPath = path.resolve(input);
+        const stat = fs.lstatSync(inputPath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error('TASK_CREATE_INPUT_INVALID: input must be a regular file');
+        if (stat.size > SANDBOX_CONTROL_MAX_BYTES)
+            throw new Error('TASK_CREATE_INPUT_TOO_LARGE: input exceeds the control limit');
+        const candidate = validateTaskCreateCandidate(JSON.parse(fs.readFileSync(inputPath, 'utf8')));
+        if (process.env.AGENT_INFRA_CONTROL_TOKEN) {
+            const response = requestSandboxTaskCreate({ candidate });
+            process.stdout.write(response.stdout);
+            process.stderr.write(response.stderr);
+            process.exitCode = response.exitCode;
+            return;
+        }
+        output(createTask(candidate, { repoRoot: process.cwd() }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /^([A-Z][A-Z0-9_]+)/.exec(message)?.[1] ?? 'TASK_CREATE_INPUT_INVALID';
+        output(failed(code, message));
+    }
+}
+export { taskCreate };
+//# sourceMappingURL=task-create.js.map