@fitlab-ai/agent-infra 0.10.0 → 0.11.1

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

@@ -1,159 +0,0 @@
-import fs from 'node:fs';
-import net from 'node:net';
-import { createHash } from 'node:crypto';
-import { HOST_CONTROL_DIRECTORY_MODE, HOST_CONTROL_SOCKET_MODE, ensureHostControlWorkerToken, inspectHostControlEndpoint, prepareHostControlDirectory, removeHostControlWorkerToken, resolveHostControlEndpoint } from './path.js';
-import { HOST_CONTROL_MAX_REQUEST_BYTES, validateHostControlRequest } from './client.js';
-import { acquireFileLock } from '../fs/file-lock.js';
-import { appendHostControlAudit } from './audit.js';
-function auditFor(request, phase, outcome) {
-    return {
-        requestId: request.id,
-        taskId: request.taskId,
-        operation: request.operation,
-        scope: request.scope,
-        phase,
-        outcome,
-        authorityKind: 'host-broker',
-        transportKind: 'host-fixed-transport',
-        identityDigest: createHash('sha256').update(`${request.taskId ?? '-'}\0${request.generation ?? '-'}`, 'utf8').digest('hex')
-    };
-}
-function failedResponse(id, status, code, message) {
-    const error = { code, message };
-    const stdout = `${JSON.stringify({ status: 'failed', changed: status === 'rejected' ? false : null, error })}\n`;
-    return { version: 1, id, status, exitCode: 1, stdout, stderr: '', error };
-}
-async function handleConnection(socket, options) {
-    await new Promise((resolve) => {
-        let input = '';
-        let completed = false;
-        let processing = false;
-        socket.setEncoding('utf8');
-        // A disconnected caller does not cancel an already dispatched domain operation.
-        socket.on('error', () => socket.destroy());
-        socket.on('close', () => { if (!processing)
-            resolve(); });
-        socket.on('end', () => { if (!processing)
-            socket.end(); });
-        const finish = (value) => {
-            if (completed || socket.destroyed)
-                return;
-            completed = true;
-            socket.end(`${JSON.stringify(value)}\n`);
-        };
-        socket.on('data', async (chunk) => {
-            if (completed || processing)
-                return;
-            input += chunk;
-            if (Buffer.byteLength(input, 'utf8') > HOST_CONTROL_MAX_REQUEST_BYTES) {
-                finish(failedResponse('invalid', 'rejected', 'HOST_CONTROL_REQUEST_TOO_LARGE', 'request exceeds the control limit'));
-                return;
-            }
-            const newline = input.indexOf('\n');
-            if (newline < 0)
-                return;
-            const raw = input.slice(0, newline);
-            let request;
-            try {
-                request = validateHostControlRequest(JSON.parse(raw));
-            }
-            catch (error) {
-                finish(failedResponse('invalid', 'rejected', 'HOST_CONTROL_REQUEST_INVALID', error instanceof Error ? error.message : String(error)));
-                return;
-            }
-            processing = true;
-            let started = false;
-            try {
-                options.audit?.(auditFor(request, 'accepted', 'in-progress'));
-                started = true;
-                const result = await options.dispatch(request);
-                options.audit?.(auditFor(request, 'completed', result.exitCode === 0 ? 'success' : 'failure'));
-                finish({ version: 1, id: request.id, status: 'completed', ...result, error: null });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const code = /^([A-Z][A-Z0-9_]+)/u.exec(message)?.[1] ?? 'HOST_CONTROL_DISPATCH_FAILED';
-                const status = started ? 'unknown' : 'rejected';
-                try {
-                    options.audit?.(auditFor(request, started ? 'completed' : 'rejected', status));
-                }
-                catch { /* Return the uncertainty even when the audit sink is unavailable. */ }
-                finish(failedResponse(request.id, status, code, message));
-            }
-            finally {
-                resolve();
-            }
-        });
-    });
-}
-export async function startHostControlServer(options) {
-    const endpoint = options.endpoint ?? resolveHostControlEndpoint();
-    const audit = options.audit ?? ((entry) => appendHostControlAudit(endpoint, entry));
-    prepareHostControlDirectory(endpoint);
-    const lock = acquireFileLock(`${endpoint}.lock`);
-    let server;
-    try {
-        ensureHostControlWorkerToken(endpoint);
-        try {
-            const existing = fs.lstatSync(endpoint);
-            if (existing.isSymbolicLink() || !existing.isSocket())
-                throw new Error('HOST_CONTROL_ENDPOINT_INVALID');
-            fs.unlinkSync(endpoint);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        const connections = new Set();
-        server = net.createServer({ allowHalfOpen: true }, (socket) => {
-            const connection = handleConnection(socket, { ...options, audit });
-            connections.add(connection);
-            void connection.finally(() => connections.delete(connection));
-        });
-        const listeningServer = server;
-        await new Promise((resolve, reject) => {
-            listeningServer.once('error', reject);
-            listeningServer.listen(endpoint, () => { listeningServer.off('error', reject); resolve(); });
-        });
-        fs.chmodSync(endpoint, HOST_CONTROL_SOCKET_MODE);
-        const inspection = inspectHostControlEndpoint(endpoint, { uid: process.getuid?.() });
-        if (!inspection.ok) {
-            await new Promise((resolve) => listeningServer.close(() => resolve()));
-            removeHostControlWorkerToken(endpoint);
-            throw new Error(inspection.code ?? 'HOST_CONTROL_ENDPOINT_INVALID');
-        }
-        let closing;
-        return {
-            endpoint,
-            server,
-            close: () => closing ??= (async () => {
-                try {
-                    await new Promise((resolve) => listeningServer.close(() => resolve()));
-                    await Promise.all(connections);
-                    await fs.promises.rm(endpoint, { force: true });
-                    removeHostControlWorkerToken(endpoint);
-                }
-                finally {
-                    lock.release();
-                }
-            })()
-        };
-    }
-    catch (error) {
-        if (server?.listening)
-            await new Promise((resolve) => server.close(() => resolve()));
-        lock.release();
-        throw error;
-    }
-}
-export async function serveHostControl(options, signal) {
-    const running = await startHostControlServer(options);
-    if (!signal)
-        return;
-    if (signal.aborted) {
-        await running.close();
-        return;
-    }
-    await new Promise((resolve) => signal.addEventListener('abort', () => { void running.close().then(resolve); }, { once: true }));
-}
-//# sourceMappingURL=server.js.map

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

@@ -1,112 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { inspectHostControlEndpoint, resolveHostControlEndpoint } from './path.js';
-import { serveHostControl, startHostControlServer } from './server.js';
-function servicePlatform() {
-    if (process.platform === 'linux' || process.platform === 'darwin')
-        return process.platform;
-    return 'unsupported';
-}
-function serviceEntryPoint() {
-    const compiled = fileURLToPath(new URL('../../bin/internal-cli.js', import.meta.url));
-    if (fs.existsSync(compiled))
-        return fs.realpathSync.native(compiled);
-    const candidate = process.argv[1];
-    if (candidate && fs.existsSync(candidate))
-        return fs.realpathSync.native(candidate);
-    return fs.realpathSync.native(fileURLToPath(new URL('../../bin/internal-cli.ts', import.meta.url)));
-}
-function xml(value) {
-    return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
-}
-function systemdArgument(value) {
-    const escaped = value.replace(/[\\"]/g, '\\$&')
-        .replace(/[\x00-\x1f\x7f]/g, (character) => `\\x${character.charCodeAt(0).toString(16).padStart(2, '0')}`)
-        .replaceAll('%', '%%');
-    return `"${escaped}"`;
-}
-function servicePaths(platform = servicePlatform()) {
-    if (platform === 'linux')
-        return { unit: path.join(os.homedir(), '.config', 'systemd', 'user', 'agent-infra-host-control.service') };
-    if (platform === 'darwin')
-        return { plist: path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.fitlab-ai.agent-infra.host-control.plist') };
-    throw new Error('HOST_CONTROL_UNSUPPORTED_PLATFORM');
-}
-export function installHostControlService(platform = servicePlatform()) {
-    const paths = servicePaths(platform);
-    const entry = serviceEntryPoint();
-    if (paths.unit) {
-        // mkdir only applies mode to directories it creates, and this one usually
-        // already exists, so restate the intended mode explicitly.
-        fs.mkdirSync(path.dirname(paths.unit), { recursive: true, mode: 0o700 });
-        fs.chmodSync(path.dirname(paths.unit), 0o700);
-        fs.writeFileSync(paths.unit, [
-            '[Unit]',
-            'Description=agent-infra host-control service',
-            '',
-            '[Service]',
-            // The ':' executable prefix disables environment expansion for literal paths.
-            `ExecStart=${systemdArgument(`:${process.execPath}`)} ${systemdArgument(entry)} host-control serve`,
-            'Restart=on-failure',
-            'NoNewPrivileges=true',
-            // Workers receive host paths, including working directories and inputs under /tmp.
-            'PrivateTmp=false',
-            '',
-            '[Install]',
-            'WantedBy=default.target',
-            ''
-        ].join('\n'), { mode: 0o600 });
-        fs.chmodSync(paths.unit, 0o600);
-        return paths.unit;
-    }
-    const plist = paths.plist;
-    fs.mkdirSync(path.dirname(plist), { recursive: true, mode: 0o700 });
-    fs.chmodSync(path.dirname(plist), 0o700);
-    const argumentsXml = [process.execPath, entry, 'host-control', 'serve']
-        .map((argument) => `    <string>${xml(argument)}</string>`)
-        .join('\n');
-    fs.writeFileSync(plist, [
-        '<?xml version="1.0" encoding="UTF-8"?>',
-        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-        '<plist version="1.0">',
-        '<dict>',
-        '  <key>Label</key>',
-        '  <string>com.fitlab-ai.agent-infra.host-control</string>',
-        '  <key>ProgramArguments</key>',
-        '  <array>',
-        argumentsXml,
-        '  </array>',
-        '  <key>RunAtLoad</key>',
-        '  <true/>',
-        '  <key>KeepAlive</key>',
-        '  <true/>',
-        '</dict>',
-        '</plist>',
-        ''
-    ].join('\n'), { mode: 0o600 });
-    fs.chmodSync(plist, 0o600);
-    return plist;
-}
-export function uninstallHostControlService(platform = servicePlatform()) {
-    const paths = servicePaths(platform);
-    const target = paths.unit ?? paths.plist;
-    fs.rmSync(target, { force: true });
-    return target;
-}
-export function hostControlServiceEndpoint(options = {}) {
-    return options.endpoint ?? resolveHostControlEndpoint(options);
-}
-export async function startHostControlService(options) {
-    return startHostControlServer({ endpoint: hostControlServiceEndpoint(options), dispatch: options.dispatch, ...(options.audit ? { audit: options.audit } : {}) });
-}
-export async function serveHostControlService(options, signal) {
-    await serveHostControl({ endpoint: hostControlServiceEndpoint(options), dispatch: options.dispatch, ...(options.audit ? { audit: options.audit } : {}) }, signal);
-}
-export function hostControlServiceStatus(options = {}) {
-    const endpoint = hostControlServiceEndpoint(options);
-    const result = inspectHostControlEndpoint(endpoint, { uid: options.uid ?? process.getuid?.() });
-    return { endpoint, available: result.ok, code: result.code };
-}
-//# sourceMappingURL=service.js.map

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

@@ -1,28 +0,0 @@
-import { dispatchHostControlCommand } from '../host-control/command.js';
-import { hostControlServiceStatus, installHostControlService, serveHostControlService, uninstallHostControlService } from '../host-control/service.js';
-import { internalHandlerRoute } from './cli-route-inventory.js';
-export async function hostControl(args) {
-    const action = args[0] ?? '';
-    if (internalHandlerRoute('host-control', 'serve', action)) {
-        const controller = new AbortController();
-        process.once('SIGINT', () => controller.abort());
-        process.once('SIGTERM', () => controller.abort());
-        await serveHostControlService({ dispatch: dispatchHostControlCommand }, controller.signal);
-        return;
-    }
-    if (internalHandlerRoute('host-control', 'status', action)) {
-        process.stdout.write(`${JSON.stringify(hostControlServiceStatus())}\n`);
-        return;
-    }
-    if (internalHandlerRoute('host-control', 'install', action)) {
-        process.stdout.write(`${JSON.stringify({ status: 'completed', path: installHostControlService() })}\n`);
-        return;
-    }
-    if (internalHandlerRoute('host-control', 'uninstall', action)) {
-        process.stdout.write(`${JSON.stringify({ status: 'completed', path: uninstallHostControlService() })}\n`);
-        return;
-    }
-    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'HOST_CONTROL_COMMAND_INVALID', message: 'usage: host-control <serve|status|install|uninstall>' } })}\n`);
-    process.exitCode = 1;
-}
-//# sourceMappingURL=host-control.js.map

package/lib/host-control/audit.ts

@@ -1,22 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import type { HostControlAudit } from './server.ts';
-
-export const HOST_CONTROL_AUDIT_FILE = 'audit.ndjson';
-
-export function hostControlAuditPath(endpoint: string): string {
-  return path.join(path.dirname(endpoint), HOST_CONTROL_AUDIT_FILE);
-}
-
-export function appendHostControlAudit(endpoint: string, entry: HostControlAudit, at = Date.now()): void {
-  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);
-  }
-}

package/lib/host-control/client.ts

@@ -1,172 +0,0 @@
-import net from 'node:net';
-import { randomUUID } from 'node:crypto';
-
-import {
-  inspectHostControlEndpoint,
-  resolveHostControlEndpoint
-} from './path.ts';
-
-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'
-] as const);
-export type HostControlCommand = typeof HOST_CONTROL_COMMANDS[number];
-
-export type HostControlCommandPayload = Readonly<{
-  workingDirectory: string;
-  args: readonly string[];
-  environment?: Readonly<Record<string, string>>;
-}>;
-
-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'
-] as const);
-
-export type HostControlRequest = Readonly<{
-  version: 1;
-  id: string;
-  taskId: string | null;
-  generation: string | null;
-  operation: HostControlCommand;
-  scope: 'host-command';
-  payload: HostControlCommandPayload;
-}>;
-
-export type HostControlResponse = Readonly<{
-  version: 1;
-  id: string;
-  status: 'completed' | 'rejected' | 'unknown';
-  exitCode: number;
-  stdout: string;
-  stderr: string;
-  error: Readonly<{ code: string; message: string }> | null;
-}>;
-
-export class HostControlClientError extends Error {
-  readonly code: string;
-  readonly retryable: boolean;
-  readonly changed: false | null;
-  constructor(code: string, message: string, 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: string): never {
-  throw new HostControlClientError('HOST_CONTROL_REQUEST_INVALID', message);
-}
-
-export function validateHostControlRequest(value: unknown): HostControlRequest {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) reject('request must be an object');
-  const request = value as HostControlRequest;
-  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 as HostControlCommand)) 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 as typeof HOST_CONTROL_TEST_ENVIRONMENT_KEYS[number])
-        || typeof value !== 'string' || /[\r\n]/u.test(value)) reject('host-command environment is invalid');
-    }
-  }
-  return request;
-}
-
-export function hostControlRequestForCommand(
-  command: HostControlCommand,
-  args: readonly string[],
-  workingDirectory: string,
-  environment: Readonly<Record<string, string>> = {}
-): HostControlRequest {
-  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: unknown, id: string): HostControlResponse {
-  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new HostControlClientError('HOST_CONTROL_RESPONSE_INVALID', 'response must be an object');
-  const response = value as Record<string, unknown>;
-  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 as string)
-    || !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 as HostControlResponse;
-}
-
-export async function requestHostControl(params: Readonly<{
-  request: HostControlRequest;
-  endpoint?: string;
-  timeoutMs?: number;
-}>): Promise<HostControlResponse> {
-  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<HostControlResponse>((resolve, rejectPromise) => {
-    const socket = net.createConnection(endpoint);
-    let output = '';
-    let settled = false;
-    let submitted = false;
-    const failure = (code: string, message: string, retryable = false) =>
-      new HostControlClientError(code, message, retryable, submitted);
-    const finish = (error?: Error, response?: HostControlResponse): void => {
-      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: string) => {
-      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'));
-    });
-  });
-}

package/lib/host-control/command.ts

@@ -1,60 +0,0 @@
-import { spawn } from 'node:child_process';
-import fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-import type { HostControlRequest } from './client.ts';
-import { readHostControlWorkerToken, resolveHostControlEndpoint } from './path.ts';
-
-type HostCommandResult = Readonly<{
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}>;
-
-export async function dispatchHostControlCommand(
-  request: Pick<HostControlRequest, 'operation' | 'payload'>
-): Promise<HostCommandResult> {
-  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<HostCommandResult>((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: string) => { stdout += chunk; });
-    child.stderr.on('data', (chunk: string) => { 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 });
-    });
-  });
-}