@fitlab-ai/agent-infra 0.9.13 → 0.9.15

package/dist/lib/defaults.json

@@ -1,110 +1,110 @@
 {
-    "platform": {
-        "type": "github"
+  "platform": {
+    "type": "github"
+  },
+  "agentClients": [
+    {
+      "id": "claude-code",
+      "enabled": true,
+      "installInSandbox": true
     },
-    "agentClients": [
-        {
-            "id": "claude-code",
-            "enabled": true,
-            "installInSandbox": true
-        },
-        {
-            "id": "codex",
-            "enabled": true,
-            "installInSandbox": true
-        },
-        {
-            "id": "antigravity-cli",
-            "enabled": true,
-            "installInSandbox": true
-        },
-        {
-            "id": "opencode",
-            "enabled": true,
-            "installInSandbox": true
-        },
-        {
-            "id": "traecli",
-            "enabled": true,
-            "installInSandbox": true
-        }
-    ],
-    "sandbox": {
-        "engine": null,
-        "runtimes": [
-            "node22"
-        ],
-        "tools": [
-            "agent-infra"
-        ],
-        "refreshIntervalDays": 7,
-        "dockerfile": null,
-        "vm": {
-            "cpu": null,
-            "memory": null,
-            "disk": null
-        }
-    },
-    "task": {
-        "shortIdLength": 2
+    {
+      "id": "codex",
+      "enabled": true,
+      "installInSandbox": true
     },
-    "delivery": {
-        "remote": "origin",
-        "baseRef": "main"
+    {
+      "id": "antigravity-cli",
+      "enabled": true,
+      "installInSandbox": true
     },
-    "labels": {
-        "in": {}
+    {
+      "id": "opencode",
+      "enabled": true,
+      "installInSandbox": true
     },
-    "files": {
-        "managed": [
-            ".agents/QUICKSTART.md",
-            ".agents/README.md",
-            ".agents/hooks/",
-            ".agents/rules/",
-            ".agents/scripts/",
-            ".agents/skills/",
-            ".agents/templates/",
-            ".agents/workflows/",
-            ".git-hooks/check-large-files.cjs",
-            ".git-hooks/check-version-format.sh",
-            ".github/scripts/",
-            ".github/workflows/metadata-sync.yml",
-            ".github/workflows/pr-label.yml",
-            ".github/workflows/status-label.yml"
-        ],
-        "guardedManaged": [
-            ".github/workflows/metadata-sync.yml",
-            ".github/workflows/pr-label.yml",
-            ".github/workflows/status-label.yml"
-        ],
-        "merged": [
-            "**/post-release.*",
-            "**/release.*",
-            "**/test-integration.*",
-            "**/test.*",
-            "**/upgrade-dependency.*",
-            ".agents/rules/testing-discipline.*",
-            ".agents/skills/post-release/SKILL.*",
-            ".agents/skills/release/SKILL.*",
-            ".agents/skills/test-integration/SKILL.*",
-            ".agents/skills/test/SKILL.*",
-            ".agents/skills/upgrade-dependency/SKILL.*",
-            ".git-hooks/pre-commit",
-            ".gitignore"
-        ],
-        "ejected": [],
-        "retiredManaged": [
-            {
-                "path": ".trae/skills/",
-                "templateHashes": []
-            },
-            {
-                "path": ".agents/workspace/README.md",
-                "templateHashes": [
-                    "sha256:967b27ca4008154c5abf99a1df728242f80ed3ace9bd98eb2828bc1c76af826c",
-                    "sha256:15aa21942cf2a1396d27834f1d3d723b61a46f8d14600b706f39f3bebc21aea3"
-                ]
-            }
-        ]
+    {
+      "id": "traecli",
+      "enabled": true,
+      "installInSandbox": true
+    }
+  ],
+  "sandbox": {
+    "engine": null,
+    "runtimes": [
+      "node22"
+    ],
+    "tools": [
+      "agent-infra"
+    ],
+    "refreshIntervalDays": 7,
+    "dockerfile": null,
+    "vm": {
+      "cpu": null,
+      "memory": null,
+      "disk": null
     }
+  },
+  "task": {
+    "shortIdLength": 2
+  },
+  "delivery": {
+    "remote": "origin",
+    "baseRef": "main"
+  },
+  "labels": {
+    "in": {}
+  },
+  "files": {
+    "managed": [
+      ".agents/QUICKSTART.md",
+      ".agents/README.md",
+      ".agents/hooks/",
+      ".agents/rules/",
+      ".agents/scripts/",
+      ".agents/skills/",
+      ".agents/templates/",
+      ".agents/workflows/",
+      ".git-hooks/check-large-files.cjs",
+      ".git-hooks/check-version-format.sh",
+      ".github/scripts/",
+      ".github/workflows/metadata-sync.yml",
+      ".github/workflows/pr-label.yml",
+      ".github/workflows/status-label.yml"
+    ],
+    "guardedManaged": [
+      ".github/workflows/metadata-sync.yml",
+      ".github/workflows/pr-label.yml",
+      ".github/workflows/status-label.yml"
+    ],
+    "merged": [
+      "**/post-release.*",
+      "**/release.*",
+      "**/test-integration.*",
+      "**/test.*",
+      "**/upgrade-dependency.*",
+      ".agents/rules/testing-discipline.*",
+      ".agents/skills/post-release/SKILL.*",
+      ".agents/skills/release/SKILL.*",
+      ".agents/skills/test-integration/SKILL.*",
+      ".agents/skills/test/SKILL.*",
+      ".agents/skills/upgrade-dependency/SKILL.*",
+      ".git-hooks/pre-commit",
+      ".gitignore"
+    ],
+    "ejected": [],
+    "retiredManaged": [
+      {
+        "path": ".trae/skills/",
+        "templateHashes": []
+      },
+      {
+        "path": ".agents/workspace/README.md",
+        "templateHashes": [
+          "sha256:967b27ca4008154c5abf99a1df728242f80ed3ace9bd98eb2828bc1c76af826c",
+          "sha256:15aa21942cf2a1396d27834f1d3d723b61a46f8d14600b706f39f3bebc21aea3"
+        ]
+      }
+    ]
+  }
 }

package/dist/lib/fs/durable-write.js

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+export function fsyncDirectory(directory) {
+    const descriptor = fs.openSync(directory, 'r');
+    try {
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+/** The caller owns directory validation and the meaning of an existing target. */
+export function writeDurableFile(target, content, options) {
+    const directory = path.dirname(target);
+    const temporary = path.join(directory, `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`);
+    try {
+        const descriptor = fs.openSync(temporary, 'wx', options.mode);
+        try {
+            fs.writeFileSync(descriptor, content, { encoding: 'utf8' });
+            fs.fchmodSync(descriptor, options.mode);
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+        if (options.replace)
+            fs.renameSync(temporary, target);
+        else
+            fs.linkSync(temporary, target);
+        fsyncDirectory(directory);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+//# sourceMappingURL=durable-write.js.map

package/dist/lib/fs/file-lock.js

@@ -0,0 +1,111 @@
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+const require = createRequire(import.meta.url);
+export const NATIVE_LOCK_PRIMITIVE = process.platform === 'win32' ? 'LockFileEx'
+    : process.platform === 'linux' ? 'F_OFD_SETLK' : 'flock';
+function loadNative() {
+    try {
+        return require('fs-native-extensions');
+    }
+    catch (error) {
+        throw new Error(`FILE_LOCK_UNSUPPORTED: native lock module is unavailable for Node ${process.version} (${process.platform}-${process.arch}). `
+            + 'Verify that fs-native-extensions includes a prebuilt binary for this platform and reinstall @fitlab-ai/agent-infra. '
+            + `Cause: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function probeNativeLockCapability() {
+    try {
+        loadNative();
+        return {
+            supported: true,
+            primitive: NATIVE_LOCK_PRIMITIVE
+        };
+    }
+    catch (error) {
+        return {
+            supported: false,
+            primitive: 'unavailable',
+            reason: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+/** Hold a stable lock file; callers own its namespace and must never unlink it. */
+export function acquireFileLock(filePath) {
+    const native = loadNative();
+    if (fs.existsSync(filePath)) {
+        const existing = fs.lstatSync(filePath);
+        if (existing.isSymbolicLink() || !existing.isFile()) {
+            throw new Error('FILE_LOCK_UNSUPPORTED: lock object is not a regular file');
+        }
+        if (process.platform !== 'win32' && typeof process.getuid === 'function'
+            && existing.uid !== process.getuid()) {
+            throw new Error('FILE_LOCK_UNSUPPORTED: lock object owner mismatch');
+        }
+    }
+    let fd;
+    try {
+        const noFollow = process.platform !== 'win32' && typeof fs.constants.O_NOFOLLOW === 'number'
+            ? fs.constants.O_NOFOLLOW : 0;
+        fd = fs.openSync(filePath, fs.constants.O_CREAT | fs.constants.O_RDWR | noFollow, 0o600);
+        const opened = fs.fstatSync(fd);
+        if (!opened.isFile())
+            throw new Error('lock object must be a regular file');
+        if (process.platform !== 'win32') {
+            if (typeof process.getuid === 'function' && opened.uid !== process.getuid()) {
+                throw new Error('lock object owner mismatch');
+            }
+            fs.fchmodSync(fd, 0o600);
+        }
+        if (!native.tryLock(fd)) {
+            fs.closeSync(fd);
+            fd = undefined;
+        }
+        else {
+            const current = fs.lstatSync(filePath);
+            if (!current.isFile() || current.dev !== opened.dev || current.ino !== opened.ino) {
+                throw new Error('lock object changed during acquisition');
+            }
+        }
+    }
+    catch (error) {
+        try {
+            if (fd !== undefined)
+                fs.closeSync(fd);
+        }
+        catch {
+            // Preserve the lock acquisition error.
+        }
+        throw new Error(`FILE_LOCK_UNSUPPORTED: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (fd === undefined)
+        throw new Error('FILE_LOCK_BUSY');
+    let released = false;
+    return {
+        release() {
+            if (released)
+                return;
+            released = true;
+            let failure = null;
+            try {
+                if (fd === undefined)
+                    throw new Error('descriptor is missing');
+                native.unlock(fd);
+            }
+            catch (error) {
+                failure = error;
+            }
+            finally {
+                try {
+                    if (fd !== undefined)
+                        fs.closeSync(fd);
+                }
+                catch (error) {
+                    failure ??= error;
+                }
+            }
+            if (failure)
+                throw new Error(`FILE_LOCK_RELEASE_FAILED: ${failure instanceof Error ? failure.message : String(failure)}`);
+        }
+    };
+}
+//# sourceMappingURL=file-lock.js.map

package/dist/lib/host-control/audit.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export const HOST_CONTROL_AUDIT_FILE = 'audit.ndjson';
+export function hostControlAuditPath(endpoint) {
+    return path.join(path.dirname(endpoint), HOST_CONTROL_AUDIT_FILE);
+}
+export function appendHostControlAudit(endpoint, entry, at = Date.now()) {
+    const filePath = hostControlAuditPath(endpoint);
+    const descriptor = fs.openSync(filePath, 'a', 0o600);
+    try {
+        fs.fchmodSync(descriptor, 0o600);
+        fs.writeFileSync(descriptor, `${JSON.stringify({ version: 1, at, ...entry })}\n`, 'utf8');
+        fs.fsyncSync(descriptor);
+    }
+    finally {
+        fs.closeSync(descriptor);
+    }
+}
+//# sourceMappingURL=audit.js.map

package/dist/lib/host-control/client.js

@@ -0,0 +1,142 @@
+import net from 'node:net';
+import { randomUUID } from 'node:crypto';
+import { inspectHostControlEndpoint, resolveHostControlEndpoint } from './path.js';
+export const HOST_CONTROL_MAX_REQUEST_BYTES = 64 * 1024;
+export const HOST_CONTROL_COMMANDS = Object.freeze([
+    'task-lifecycle', 'task-orchestration', 'task-finalization',
+    'task-artifact', 'task-review', 'task-event', 'task-ledger',
+    'task-invalidation', 'task-warning'
+]);
+export const HOST_CONTROL_TEST_ENVIRONMENT_KEYS = Object.freeze([
+    'TZ', 'AGENT_INFRA_GH_BIN', 'AGENT_INFRA_GH_ARGS_JSON', 'GH_FAKE_PR_PATH', 'GH_FAKE_ARGS_PATH'
+]);
+export class HostControlClientError extends Error {
+    code;
+    retryable;
+    changed;
+    constructor(code, message, retryable = false, submitted = false) {
+        super(`${code}: ${message}`);
+        this.name = 'HostControlClientError';
+        this.code = code;
+        this.retryable = retryable && !submitted;
+        this.changed = submitted ? null : false;
+    }
+}
+function reject(message) {
+    throw new HostControlClientError('HOST_CONTROL_REQUEST_INVALID', message);
+}
+export function validateHostControlRequest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        reject('request must be an object');
+    const request = value;
+    if (Object.keys(request).sort().join(',') !== 'generation,id,operation,payload,scope,taskId,version'
+        || request.version !== 1 || typeof request.id !== 'string' || !/^[a-f0-9-]{16,64}$/u.test(request.id)
+        || (request.taskId !== null && (typeof request.taskId !== 'string' || !/^TASK-\d{8}-\d{6}$/u.test(request.taskId)))
+        || (request.generation !== null && (typeof request.generation !== 'string' || !request.generation))
+        || request.scope !== 'host-command' || !HOST_CONTROL_COMMANDS.includes(request.operation))
+        reject('request schema is invalid');
+    const payload = request.payload;
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)
+        || !['args,environment,workingDirectory', 'args,workingDirectory'].includes(Object.keys(payload).sort().join(','))
+        || !Array.isArray(payload.args) || payload.args.length > 128
+        || !payload.args.every((arg) => typeof arg === 'string' && !/[\r\n]/u.test(arg))
+        || typeof payload.workingDirectory !== 'string' || !payload.workingDirectory.startsWith('/'))
+        reject('host-command payload is invalid');
+    if (payload.environment !== undefined) {
+        if (!payload.environment || typeof payload.environment !== 'object' || Array.isArray(payload.environment))
+            reject('host-command environment is invalid');
+        for (const [key, value] of Object.entries(payload.environment)) {
+            if (!HOST_CONTROL_TEST_ENVIRONMENT_KEYS.includes(key)
+                || typeof value !== 'string' || /[\r\n]/u.test(value))
+                reject('host-command environment is invalid');
+        }
+    }
+    return request;
+}
+export function hostControlRequestForCommand(command, args, workingDirectory, environment = {}) {
+    if (!HOST_CONTROL_COMMANDS.includes(command))
+        reject('host-command is unsupported');
+    const taskArg = args[0];
+    const taskId = taskArg && /^TASK-\d{8}-\d{6}$/u.test(taskArg) ? taskArg : null;
+    return validateHostControlRequest({
+        version: 1,
+        id: randomUUID(),
+        taskId,
+        generation: null,
+        operation: command,
+        scope: 'host-command',
+        payload: {
+            workingDirectory,
+            args: [...args],
+            ...(Object.keys(environment).length > 0 ? { environment } : {})
+        }
+    });
+}
+function parseResponse(value, id) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new HostControlClientError('HOST_CONTROL_RESPONSE_INVALID', 'response must be an object');
+    const response = value;
+    if (Object.keys(response).sort().join(',') !== 'error,exitCode,id,status,stderr,stdout,version'
+        || response.version !== 1 || response.id !== id
+        || !['completed', 'rejected', 'unknown'].includes(response.status)
+        || !Number.isSafeInteger(response.exitCode)
+        || typeof response.stdout !== 'string' || typeof response.stderr !== 'string'
+        || (response.error !== null && (!response.error || typeof response.error !== 'object'))) {
+        throw new HostControlClientError('HOST_CONTROL_RESPONSE_INVALID', 'response schema is invalid');
+    }
+    return response;
+}
+export async function requestHostControl(params) {
+    const request = validateHostControlRequest(params.request);
+    const endpoint = params.endpoint ?? resolveHostControlEndpoint();
+    const inspection = inspectHostControlEndpoint(endpoint, { uid: process.getuid?.() });
+    if (!inspection.ok)
+        throw new HostControlClientError(inspection.code ?? 'HOST_CONTROL_UNAVAILABLE', 'fixed host-control endpoint is unavailable', true);
+    const encoded = `${JSON.stringify(request)}\n`;
+    if (Buffer.byteLength(encoded, 'utf8') > HOST_CONTROL_MAX_REQUEST_BYTES)
+        throw new HostControlClientError('HOST_CONTROL_REQUEST_TOO_LARGE', 'request exceeds the control limit');
+    const timeoutMs = params.timeoutMs ?? 30_000;
+    return await new Promise((resolve, rejectPromise) => {
+        const socket = net.createConnection(endpoint);
+        let output = '';
+        let settled = false;
+        let submitted = false;
+        const failure = (code, message, retryable = false) => new HostControlClientError(code, message, retryable, submitted);
+        const finish = (error, response) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            if (error)
+                rejectPromise(error);
+            else
+                resolve(response);
+        };
+        const timer = setTimeout(() => finish(failure('HOST_CONTROL_TIMEOUT', 'host-control did not respond; inspect task state before retrying', true)), timeoutMs);
+        socket.setEncoding('utf8');
+        socket.on('connect', () => { submitted = true; socket.end(encoded); });
+        socket.on('data', (chunk) => {
+            output += chunk;
+            if (Buffer.byteLength(output, 'utf8') > HOST_CONTROL_MAX_REQUEST_BYTES) {
+                finish(failure('HOST_CONTROL_RESPONSE_TOO_LARGE', 'host-control response exceeds the control limit'));
+                return;
+            }
+            const newline = output.indexOf('\n');
+            if (newline < 0)
+                return;
+            try {
+                finish(undefined, parseResponse(JSON.parse(output.slice(0, newline)), request.id));
+            }
+            catch (error) {
+                finish(failure('HOST_CONTROL_RESPONSE_INVALID', String(error)));
+            }
+        });
+        socket.on('error', (error) => finish(failure('HOST_CONTROL_UNAVAILABLE', error.message, true)));
+        socket.on('close', () => {
+            if (!settled)
+                finish(failure('HOST_CONTROL_RESPONSE_INVALID', 'host-control closed without a response'));
+        });
+    });
+}
+//# sourceMappingURL=client.js.map

package/dist/lib/host-control/command.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { readHostControlWorkerToken, resolveHostControlEndpoint } from './path.js';
+export async function dispatchHostControlCommand(request) {
+    const { payload } = request;
+    const compiledEntry = fileURLToPath(new URL('../../bin/internal-cli.js', import.meta.url));
+    const sourceEntry = fileURLToPath(new URL('../../bin/internal-cli.ts', import.meta.url));
+    const entry = fs.existsSync(compiledEntry) ? compiledEntry : sourceEntry;
+    const payloadEnvironment = payload.environment ?? {};
+    const env = { ...process.env, ...payloadEnvironment };
+    for (const key of Object.keys(env)) {
+        if (key.startsWith('AGENT_INFRA_CONTROL_')
+            || key === 'AGENT_INFRA_TASK_ID'
+            || key === 'AGENT_INFRA_RUNTIME_DIR'
+            || key === 'AGENT_INFRA_EXECUTOR_MANIFEST'
+            || key === 'AGENT_INFRA_HOST_CONTROL_SOCKET') {
+            delete env[key];
+        }
+    }
+    delete env.NODE_OPTIONS;
+    delete env.NODE_PATH;
+    delete env.AGENT_INFRA_HOST_CONTROL_WORKER;
+    delete env.AGENT_INFRA_HOST_CONTROL_WORKER_TOKEN;
+    env.AGENT_INFRA_HOST_CONTROL_WORKER = '1';
+    env.AGENT_INFRA_HOST_CONTROL_WORKER_TOKEN = readHostControlWorkerToken(process.env.AGENT_INFRA_TEST_HOST_CONTROL_ENDPOINT ?? resolveHostControlEndpoint());
+    return await new Promise((resolve, reject) => {
+        const runtimeArgs = entry.endsWith('.ts') ? ['--experimental-strip-types', '--no-warnings', entry] : [entry];
+        const child = spawn(process.execPath, [...runtimeArgs, request.operation, ...payload.args], {
+            cwd: payload.workingDirectory,
+            env,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => { stdout += chunk; });
+        child.stderr.on('data', (chunk) => { stderr += chunk; });
+        child.once('error', reject);
+        child.once('close', (code, signal) => {
+            if (signal)
+                reject(new Error(`HOST_CONTROL_WORKER_TERMINATED: ${signal}`));
+            else
+                resolve({ stdout, stderr, exitCode: code ?? 1 });
+        });
+    });
+}
+//# sourceMappingURL=command.js.map