@fitlab-ai/agent-infra 0.10.0 → 0.11.1

package/lib/host-control/path.ts

@@ -1,167 +0,0 @@
-import fs from 'node:fs';
-import { randomBytes } from 'node:crypto';
-import os from 'node:os';
-import path from 'node:path';
-
-export const HOST_CONTROL_DIRECTORY_MODE = 0o700;
-export const HOST_CONTROL_SOCKET_MODE = 0o600;
-export const HOST_CONTROL_WORKER_TOKEN_MODE = 0o600;
-
-export type HostControlPlatform = 'linux' | 'darwin' | 'unsupported';
-
-export type HostControlEndpointOptions = Readonly<{
-  platform?: HostControlPlatform;
-  uid?: number;
-  username?: string;
-}>;
-
-function currentPlatform(): HostControlPlatform {
-  if (process.platform === 'linux' || process.platform === 'darwin') return process.platform;
-  return 'unsupported';
-}
-
-function validUid(uid: number | undefined): number {
-  const resolved = uid ?? process.getuid?.();
-  if (!Number.isInteger(resolved) || resolved === undefined || resolved < 0) {
-    throw new Error('HOST_CONTROL_ENDPOINT_INVALID: uid is unavailable');
-  }
-  return resolved;
-}
-
-function validUsername(username: string | undefined): string {
-  const resolved = username ?? os.userInfo({ encoding: 'utf8' }).username;
-  if (!/^[A-Za-z0-9._-]+$/u.test(resolved)) {
-    throw new Error('HOST_CONTROL_ENDPOINT_INVALID: username is invalid');
-  }
-  return resolved;
-}
-
-export function resolveHostControlEndpoint(options: HostControlEndpointOptions = {}): string {
-  const platform = options.platform ?? currentPlatform();
-  if (platform === 'linux') return `/run/user/${validUid(options.uid)}/agent-infra/host-control.sock`;
-  if (platform === 'darwin') return path.posix.join(
-    '/Users',
-    validUsername(options.username),
-    'Library',
-    'Application Support',
-    'agent-infra',
-    'run',
-    'host-control.sock'
-  );
-  throw new Error('HOST_CONTROL_UNSUPPORTED_PLATFORM');
-}
-
-export function hostControlWorkerTokenPath(endpoint: string): string {
-  return `${endpoint}.worker-token`;
-}
-
-function assertWorkerTokenFile(tokenPath: string, uid = process.getuid?.()): string {
-  const stat = fs.lstatSync(tokenPath);
-  if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('HOST_CONTROL_WORKER_TOKEN_INVALID');
-  if ((stat.mode & 0o777) !== HOST_CONTROL_WORKER_TOKEN_MODE) throw new Error('HOST_CONTROL_WORKER_TOKEN_MODE_INVALID');
-  if (uid !== undefined && stat.uid !== uid) throw new Error('HOST_CONTROL_WORKER_TOKEN_OWNER_INVALID');
-  const token = fs.readFileSync(tokenPath, 'utf8').trim();
-  if (!/^[a-f0-9]{64}$/u.test(token)) throw new Error('HOST_CONTROL_WORKER_TOKEN_INVALID');
-  return token;
-}
-
-export function ensureHostControlWorkerToken(endpoint: string, uid = process.getuid?.()): string {
-  const tokenPath = hostControlWorkerTokenPath(endpoint);
-  try {
-    return assertWorkerTokenFile(tokenPath, uid);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-  }
-  const token = randomBytes(32).toString('hex');
-  try {
-    const fd = fs.openSync(tokenPath, 'wx', HOST_CONTROL_WORKER_TOKEN_MODE);
-    try {
-      fs.writeFileSync(fd, `${token}\n`, 'utf8');
-      fs.fchmodSync(fd, HOST_CONTROL_WORKER_TOKEN_MODE);
-      if (uid !== undefined && process.getuid?.() === uid) fs.fchownSync(fd, uid, process.getgid?.() ?? -1);
-    } finally {
-      fs.closeSync(fd);
-    }
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') throw error;
-  }
-  return assertWorkerTokenFile(tokenPath, uid);
-}
-
-export function readHostControlWorkerToken(endpoint: string, uid = process.getuid?.()): string {
-  return assertWorkerTokenFile(hostControlWorkerTokenPath(endpoint), uid);
-}
-
-export function removeHostControlWorkerToken(endpoint: string): void {
-  try {
-    fs.unlinkSync(hostControlWorkerTokenPath(endpoint));
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-  }
-}
-
-export type HostControlEndpointInspection = Readonly<{
-  ok: boolean;
-  code: string | null;
-  ownerUid?: number;
-  mode?: number;
-  parentMode?: number;
-}>;
-
-export function inspectHostControlEndpoint(
-  endpoint: string,
-  expected: Readonly<{ uid?: number }> = {}
-): HostControlEndpointInspection {
-  let endpointStat: fs.Stats;
-  let parentStat: fs.Stats;
-  try {
-    endpointStat = fs.lstatSync(endpoint);
-    parentStat = fs.lstatSync(path.dirname(endpoint));
-  } catch {
-    return { ok: false, code: 'HOST_CONTROL_ENDPOINT_MISSING' };
-  }
-  if (endpointStat.isSymbolicLink()) return { ok: false, code: 'HOST_CONTROL_ENDPOINT_SYMLINK' };
-  if (!endpointStat.isSocket()) return { ok: false, code: 'HOST_CONTROL_ENDPOINT_NOT_SOCKET' };
-  if (!parentStat.isDirectory() || parentStat.isSymbolicLink()) {
-    return { ok: false, code: 'HOST_CONTROL_PARENT_INVALID' };
-  }
-  let ancestor = path.dirname(endpoint);
-  while (true) {
-    let stat: fs.Stats;
-    try { stat = fs.lstatSync(ancestor); } catch { return { ok: false, code: 'HOST_CONTROL_PARENT_INVALID' }; }
-    if (!stat.isDirectory() || stat.isSymbolicLink()) return { ok: false, code: 'HOST_CONTROL_PARENT_INVALID' };
-    const next = path.dirname(ancestor);
-    if (next === ancestor) break;
-    ancestor = next;
-  }
-  const mode = endpointStat.mode & 0o777;
-  const parentMode = parentStat.mode & 0o777;
-  if (mode !== HOST_CONTROL_SOCKET_MODE) return { ok: false, code: 'HOST_CONTROL_ENDPOINT_MODE_INVALID', ownerUid: endpointStat.uid, mode, parentMode };
-  if (parentMode !== HOST_CONTROL_DIRECTORY_MODE) return { ok: false, code: 'HOST_CONTROL_PARENT_MODE_INVALID', ownerUid: endpointStat.uid, mode, parentMode };
-  if (expected.uid !== undefined && endpointStat.uid !== expected.uid) {
-    return { ok: false, code: 'HOST_CONTROL_ENDPOINT_OWNER_INVALID', ownerUid: endpointStat.uid, mode, parentMode };
-  }
-  if (expected.uid !== undefined && parentStat.uid !== expected.uid) {
-    return { ok: false, code: 'HOST_CONTROL_PARENT_OWNER_INVALID', ownerUid: parentStat.uid, mode, parentMode };
-  }
-  return { ok: true, code: null, ownerUid: endpointStat.uid, mode, parentMode };
-}
-
-export function prepareHostControlDirectory(endpoint: string, uid = process.getuid?.()): string {
-  const directory = path.dirname(endpoint);
-  const segments = path.resolve(directory).split(path.sep);
-  let current = path.isAbsolute(directory) ? path.sep : '';
-  for (const segment of segments.filter(Boolean)) {
-    current = path.join(current, segment);
-    try {
-      const stat = fs.lstatSync(current);
-      if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error('HOST_CONTROL_PARENT_INVALID');
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-    }
-  }
-  fs.mkdirSync(directory, { recursive: true, mode: HOST_CONTROL_DIRECTORY_MODE });
-  fs.chmodSync(directory, HOST_CONTROL_DIRECTORY_MODE);
-  if (uid !== undefined && process.getuid?.() === uid) fs.chownSync(directory, uid, process.getgid?.() ?? -1);
-  return directory;
-}

package/lib/host-control/server.ts

@@ -1,180 +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.ts';
-import {
-  HOST_CONTROL_MAX_REQUEST_BYTES,
-  validateHostControlRequest,
-  type HostControlRequest,
-  type HostControlResponse
-} from './client.ts';
-import { acquireFileLock } from '../fs/file-lock.ts';
-import { appendHostControlAudit } from './audit.ts';
-
-export type HostControlDispatch = (request: HostControlRequest) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
-
-export type HostControlAudit = Readonly<{
-  requestId: string;
-  taskId: string | null;
-  operation: string;
-  scope: string;
-  phase: 'accepted' | 'completed' | 'rejected';
-  outcome: string;
-  authorityKind: 'host-broker';
-  transportKind: 'host-fixed-transport';
-  identityDigest: string;
-}>;
-
-export type HostControlServerOptions = Readonly<{
-  endpoint?: string;
-  dispatch: HostControlDispatch;
-  audit?: (entry: HostControlAudit) => void;
-}>;
-
-function auditFor(request: HostControlRequest, phase: HostControlAudit['phase'], outcome: string): HostControlAudit {
-  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: string, status: 'rejected' | 'unknown', code: string, message: string): HostControlResponse {
-  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: net.Socket, options: HostControlServerOptions): Promise<void> {
-  await new Promise<void>((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: HostControlResponse): void => {
-      if (completed || socket.destroyed) return;
-      completed = true;
-      socket.end(`${JSON.stringify(value)}\n`);
-    };
-    socket.on('data', async (chunk: string) => {
-      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: HostControlRequest;
-      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 type RunningHostControlServer = Readonly<{
-  endpoint: string;
-  server: net.Server;
-  close: () => Promise<void>;
-}>;
-
-export async function startHostControlServer(options: HostControlServerOptions): Promise<RunningHostControlServer> {
-  const endpoint = options.endpoint ?? resolveHostControlEndpoint();
-  const audit = options.audit ?? ((entry: HostControlAudit) => appendHostControlAudit(endpoint, entry));
-  prepareHostControlDirectory(endpoint);
-  const lock = acquireFileLock(`${endpoint}.lock`);
-  let server: net.Server | undefined;
-  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 as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
-    }
-    const connections = new Set<Promise<void>>();
-    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<void>((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<void>((resolve) => listeningServer.close(() => resolve()));
-      removeHostControlWorkerToken(endpoint);
-      throw new Error(inspection.code ?? 'HOST_CONTROL_ENDPOINT_INVALID');
-    }
-    let closing: Promise<void> | undefined;
-    return {
-      endpoint,
-      server,
-      close: () => closing ??= (async () => {
-        try {
-          await new Promise<void>((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<void>((resolve) => server!.close(() => resolve()));
-    lock.release();
-    throw error;
-  }
-}
-
-export async function serveHostControl(options: HostControlServerOptions, signal?: AbortSignal): Promise<void> {
-  const running = await startHostControlServer(options);
-  if (!signal) return;
-  if (signal.aborted) { await running.close(); return; }
-  await new Promise<void>((resolve) => signal.addEventListener('abort', () => { void running.close().then(resolve); }, { once: true }));
-}

package/lib/host-control/service.ts

@@ -1,133 +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,
-  type HostControlPlatform
-} from './path.ts';
-import { serveHostControl, startHostControlServer, type HostControlDispatch, type RunningHostControlServer } from './server.ts';
-
-export type HostControlServiceOptions = Readonly<{
-  platform?: HostControlPlatform;
-  uid?: number;
-  username?: string;
-  endpoint?: string;
-  dispatch: HostControlDispatch;
-  audit?: Parameters<typeof startHostControlServer>[0]['audit'];
-}>;
-
-export type HostControlServicePlatform = 'linux' | 'darwin' | 'unsupported';
-
-function servicePlatform(): HostControlServicePlatform {
-  if (process.platform === 'linux' || process.platform === 'darwin') return process.platform;
-  return 'unsupported';
-}
-
-function serviceEntryPoint(): string {
-  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: string): string {
-  return value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;');
-}
-
-function systemdArgument(value: string): string {
-  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: HostControlServicePlatform = servicePlatform()): Readonly<{ unit?: string; plist?: string }> {
-  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: HostControlServicePlatform = servicePlatform()): string {
-  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: HostControlServicePlatform = servicePlatform()): string {
-  const paths = servicePaths(platform);
-  const target = paths.unit ?? paths.plist!;
-  fs.rmSync(target, { force: true });
-  return target;
-}
-
-export function hostControlServiceEndpoint(options: Pick<HostControlServiceOptions, 'platform' | 'uid' | 'username' | 'endpoint'> = {}): string {
-  return options.endpoint ?? resolveHostControlEndpoint(options);
-}
-
-export async function startHostControlService(options: HostControlServiceOptions): Promise<RunningHostControlServer> {
-  return startHostControlServer({ endpoint: hostControlServiceEndpoint(options), dispatch: options.dispatch, ...(options.audit ? { audit: options.audit } : {}) });
-}
-
-export async function serveHostControlService(options: HostControlServiceOptions, signal?: AbortSignal): Promise<void> {
-  await serveHostControl({ endpoint: hostControlServiceEndpoint(options), dispatch: options.dispatch, ...(options.audit ? { audit: options.audit } : {}) }, signal);
-}
-
-export function hostControlServiceStatus(options: Pick<HostControlServiceOptions, 'platform' | 'uid' | 'username' | 'endpoint'> = {}): Readonly<{ endpoint: string; available: boolean; code: string | null }> {
-  const endpoint = hostControlServiceEndpoint(options);
-  const result = inspectHostControlEndpoint(endpoint, { uid: options.uid ?? process.getuid?.() });
-  return { endpoint, available: result.ok, code: result.code };
-}

package/lib/internal/host-control.ts

@@ -1,28 +0,0 @@
-import { dispatchHostControlCommand } from '../host-control/command.ts';
-import { hostControlServiceStatus, installHostControlService, serveHostControlService, uninstallHostControlService } from '../host-control/service.ts';
-import { internalHandlerRoute } from './cli-route-inventory.ts';
-
-export async function hostControl(args: readonly string[]): Promise<void> {
-  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;
-}