@fitlab-ai/agent-infra 0.9.3 → 0.9.5

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/sandbox-control.js

@@ -0,0 +1,24 @@
+import { requestSandboxControl } from '../sandbox/control/client.js';
+import { serveSandboxControl } from '../sandbox/control/server.js';
+function sandboxControl(args) {
+    const [operation, ...rest] = args;
+    if (operation === 'serve') {
+        const manifestIndex = rest.indexOf('--manifest');
+        const manifest = manifestIndex >= 0 ? rest[manifestIndex + 1] : undefined;
+        if (!manifest)
+            throw new Error('sandbox-control serve requires --manifest');
+        serveSandboxControl(manifest);
+        return;
+    }
+    if (operation === 'client') {
+        const [family = '', ...commandArgs] = rest;
+        const response = requestSandboxControl({ family, args: commandArgs });
+        process.stdout.write(response.stdout);
+        process.stderr.write(response.stderr);
+        process.exitCode = response.exitCode;
+        return;
+    }
+    throw new Error('Usage: agent-infra-internal sandbox-control serve --manifest <path> | client <family> [args...]');
+}
+export { sandboxControl };
+//# sourceMappingURL=sandbox-control.js.map

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

@@ -1,11 +1,27 @@
-import { applyActivityAppendIntent } from '../task/activity-intent.js';
-const USAGE = `Usage: agent-infra-internal task-activity <task-ref> append --step <step> --agent <agent> --note <note> [--artifact <canonical.md>] [--dry-run]
+import { applyPrReviewActivityIntent, inspectPrReviewActivity } from '../task/activity-intent.js';
+const USAGE = `Usage: agent-infra-internal task-activity <task-ref> pr-review-inspect
+       agent-infra-internal task-activity <task-ref> pr-review-start --agent <agent> --artifact <canonical.md> --head <40hex> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-complete --agent <agent> --artifact <canonical.md> --head <40hex> --verdict <approved|changes-requested|commented> --blockers <N> --major <N> --minor <N> [--dry-run]
+       agent-infra-internal task-activity <task-ref> pr-review-terminate --agent <agent> --artifact <canonical.md> --head <40hex> --outcome <aborted|superseded> --reason <single-line> [--dry-run]
 `;
+const OPERATIONS = new Set(['pr-review-inspect', 'pr-review-start', 'pr-review-complete', 'pr-review-terminate']);
 const FLAGS = {
-    '--step': 'step',
     '--agent': 'agent',
-    '--note': 'note',
-    '--artifact': 'artifact'
+    '--artifact': 'artifact',
+    '--head': 'head',
+    '--verdict': 'verdict',
+    '--blockers': 'blockers',
+    '--major': 'major',
+    '--minor': 'minor',
+    '--outcome': 'outcome',
+    '--reason': 'reason'
+};
+const COMMON = ['agent', 'artifact', 'head'];
+const ALLOWED = {
+    'pr-review-inspect': new Set(['kind', 'taskRef']),
+    'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun']),
+    'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun']),
+    'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun'])
 };
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
@@ -18,8 +34,8 @@ function taskActivity(args = []) {
         return;
     }
     const [taskRef, kind] = args;
-    if (!taskRef || taskRef.startsWith('--') || !kind || kind !== 'append') {
-        usageFailure('task ref and the append intent are required');
+    if (!taskRef || taskRef.startsWith('--') || !kind || !OPERATIONS.has(kind)) {
+        usageFailure('task ref and a supported PR review intent are required');
         return;
     }
     const values = { kind, taskRef };
@@ -50,21 +66,37 @@ function taskActivity(args = []) {
             return;
         }
         seen.add(flag);
-        values[key] = value;
+        values[key] = ['blockers', 'major', 'minor'].includes(key) ? Number(value) : value;
     }
-    const allowed = new Set(['kind', 'taskRef', 'dryRun', 'step', 'agent', 'note', 'artifact']);
+    const allowed = ALLOWED[kind];
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     if (unexpected) {
-        usageFailure(`append does not accept '${unexpected}'`);
+        usageFailure(`${kind} does not accept '${unexpected}'`);
+        return;
+    }
+    if (kind === 'pr-review-inspect') {
+        const result = inspectPrReviewActivity(values);
+        process.stdout.write(`${JSON.stringify(result)}\n`);
+        if (result.status === 'failed')
+            process.exitCode = 1;
         return;
     }
-    for (const key of ['step', 'agent', 'note']) {
+    for (const key of COMMON) {
+        if (values[key] === undefined) {
+            usageFailure(`${kind} requires '${key}'`);
+            return;
+        }
+    }
+    const operationRequired = kind === 'pr-review-complete'
+        ? ['verdict', 'blockers', 'major', 'minor']
+        : kind === 'pr-review-terminate' ? ['outcome', 'reason'] : [];
+    for (const key of operationRequired) {
         if (values[key] === undefined) {
-            usageFailure(`append requires '${key}'`);
+            usageFailure(`${kind} requires '${key}'`);
             return;
         }
     }
-    const result = applyActivityAppendIntent(values);
+    const result = applyPrReviewActivityIntent(values);
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;

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

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

@@ -6,9 +6,10 @@ const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [inte
 const FLAGS = {
     '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
     '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
-    '--status': 'status', '--artifact': 'artifact'
+    '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
+const BOOLEAN = new Set(['needsImplementation']);
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LEDGER_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -55,8 +56,12 @@ function taskLedger(args = []) {
             usageFailure(`option '${flag}' requires a value`);
             return;
         }
+        if (BOOLEAN.has(key) && value !== 'true' && value !== 'false') {
+            usageFailure(`option '${flag}' must be true or false`);
+            return;
+        }
         seen.add(flag);
-        values[key] = NUMERIC.has(key) ? Number(value) : value;
+        values[key] = NUMERIC.has(key) ? Number(value) : BOOLEAN.has(key) ? value === 'true' : value;
     }
     const required = {
         'finding-upsert': ['stage', 'reviewArtifact', 'ordinal', 'severity', 'evidence'],
@@ -66,7 +71,11 @@ function taskLedger(args = []) {
         'decision-upsert': ['id', 'stage', 'artifact'],
         'stage-status': ['stage']
     };
-    const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]]);
+    const optional = {
+        'finding-review': ['needsImplementation'],
+        'decision-upsert': ['needsImplementation']
+    };
+    const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...(optional[kind] ?? [])]);
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     const missing = required[kind].find((key) => values[key] === undefined);
     if (unexpected) {

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

@@ -1,5 +1,7 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\n`;
 const FLAGS = {
     '--agent': 'agent', '--reason': 'reason', '--unblock-condition': 'unblockCondition',
@@ -56,7 +58,23 @@ function taskLifecycle(args = []) {
         return;
     }
     values.agent = agent;
-    const result = applyTaskLifecycle(values);
+    const resolved = resolveTaskRef(String(values.taskRef));
+    if (!resolved.ok) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    let result;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-lifecycle.${String(values.intent)}`, () => applyTaskLifecycle(values));
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
     process.stdout.write(`${JSON.stringify(result)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;