@fitlab-ai/agent-infra 0.7.6 → 0.8.0

package/lib/server/daemon.ts

@@ -0,0 +1,110 @@
+import { VERSION } from '../version.ts';
+import { loadServerConfig } from './config.ts';
+import { createLogger } from './logger.ts';
+import { loadAdapters, unloadAdapters } from './plugin-loader.ts';
+import type { InboundMessage } from './adapters/_contract.ts';
+import { authorize } from './auth.ts';
+import { commandHelp, parseCommand } from './protocol.ts';
+import { runAi } from './runner.ts';
+import { streamCommand } from './streamer.ts';
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// The daemon main loop. Runs in the detached child spawned by
+// process-control.start(), or in the foreground for debugging.
+//
+// Lifecycle (keep-alive / shutdown model):
+//   - The heartbeat interval is kept *ref'd*. It is both the keep-alive that
+//     holds the event loop open while subtask A has no adapters, and the
+//     observable signal that `ai server logs -f` shows.
+//   - runDaemon() awaits a shutdown promise that only resolves once a
+//     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
+//     the only keep-alive timer (that would let the process exit immediately).
+export async function runDaemon(): Promise<void> {
+  let config;
+  try {
+    config = loadServerConfig();
+  } catch (error) {
+    process.stderr.write(`${errorMessage(error)}\n`);
+    process.exit(1);
+  }
+
+  const logger = createLogger(config.log);
+  logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
+
+  const abortController = new AbortController();
+  let resolveShutdown: () => void = () => {};
+  const shutdown = new Promise<void>((resolve) => {
+    resolveShutdown = resolve;
+  });
+
+  const dispatch = async (message: InboundMessage): Promise<void> => {
+    const plan = parseCommand(message.text);
+    if (plan.kind === 'ignore') return;
+    if (plan.kind === 'error') {
+      await message.reply(plan.message);
+      logger.info(`command rejected from ${message.adapter}:${message.userId}: ${plan.message}`);
+      return;
+    }
+    if (plan.kind === 'builtin' && plan.name === 'ping') {
+      await message.reply(`pong ${VERSION}`);
+      return;
+    }
+    if (plan.kind === 'builtin' && plan.name === 'help') {
+      await message.reply(commandHelp());
+      return;
+    }
+    if (plan.kind === 'builtin' && plan.name === 'version') {
+      await message.reply(`agent-infra ${VERSION}`);
+      return;
+    }
+    if (plan.kind === 'ai') {
+      const allowed = authorize(
+        { adapter: message.adapter, userId: message.userId },
+        plan.role,
+        config.auth
+      );
+      if (!allowed.ok) {
+        await message.reply(allowed.message);
+        logger.info(`unauthorized command from ${message.adapter}:${message.userId}: ${allowed.message}`);
+        return;
+      }
+      await streamCommand(
+        {
+          title: `ai ${plan.argv.join(' ')}`,
+          chunkChars: typeof config.stream?.chunkChars === 'number' ? config.stream.chunkChars : 4000,
+          throttleMs: typeof config.stream?.throttleMs === 'number' ? config.stream.throttleMs : 1500
+        },
+        (emit) => runAi(plan.argv, { onChunk: emit }),
+        (text) => message.reply(text)
+      );
+    }
+  };
+
+  const ctx = { config, logger, dispatch, signal: abortController.signal };
+  const adapters = await loadAdapters(config, ctx);
+  logger.ok(`loaded ${adapters.length} adapter(s)`);
+
+  const heartbeat = setInterval(() => logger.info('heartbeat'), config.heartbeatMs);
+
+  let shuttingDown = false;
+  const handleSignal = (signal: NodeJS.Signals): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    logger.info(`received ${signal}, shutting down`);
+    abortController.abort();
+    void (async () => {
+      await unloadAdapters(adapters);
+      clearInterval(heartbeat);
+      logger.close();
+      resolveShutdown();
+    })();
+  };
+  process.on('SIGINT', () => handleSignal('SIGINT'));
+  process.on('SIGTERM', () => handleSignal('SIGTERM'));
+
+  await shutdown;
+  process.exit(0);
+}

package/lib/server/index.ts

@@ -0,0 +1,50 @@
+import { runDaemon } from './daemon.ts';
+import { start, stop, status, logs } from './process-control.ts';
+
+const USAGE = `Usage: ai server <command> [options]
+
+Commands:
+  start [--foreground]   Start the local daemon (detached; --foreground stays attached for debugging)
+  stop                   Stop the running daemon
+  status                 Show whether the daemon is running
+  logs [-f | --follow]   Print the daemon log ('-f' to follow new lines)
+  help                   Show this help message
+
+The daemon hosts IM adapters and command routing for agent-infra.`;
+
+export async function runServer(args: string[]): Promise<void> {
+  const [subcommand, ...rest] = args;
+
+  if (!subcommand) {
+    process.stdout.write(`${USAGE}\n`);
+    process.exitCode = 1;
+    return;
+  }
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
+    process.stdout.write(`${USAGE}\n`);
+    return;
+  }
+
+  switch (subcommand) {
+    case 'start':
+      await start({ foreground: rest.includes('--foreground') });
+      break;
+    case 'stop':
+      await stop();
+      break;
+    case 'status':
+      status();
+      break;
+    case 'logs':
+      await logs({ follow: rest.includes('-f') || rest.includes('--follow') });
+      break;
+    // Internal entry point for the detached daemon child (not shown in USAGE).
+    case '__daemon':
+      await runDaemon();
+      break;
+    default:
+      process.stderr.write(`Unknown server command: ${subcommand}\n`);
+      process.stdout.write(`${USAGE}\n`);
+      process.exitCode = 1;
+  }
+}

package/lib/server/logger.ts

@@ -0,0 +1,48 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export type LoggerOptions = {
+  path: string;
+  rotateAtBytes: number;
+};
+
+export type Logger = {
+  info: (message: string) => void;
+  ok: (message: string) => void;
+  err: (message: string) => void;
+  close: () => void;
+};
+
+// Startup-only rotation: if the existing log already exceeds the threshold,
+// move it aside to `<path>.1` before the daemon starts appending. We do not
+// rotate again while running — keeping a single append stream is simpler and
+// good enough for a local daemon log.
+function rotateIfOversized(logPath: string, rotateAtBytes: number): void {
+  try {
+    const { size } = fs.statSync(logPath);
+    if (size > rotateAtBytes) {
+      fs.renameSync(logPath, `${logPath}.1`);
+    }
+  } catch {
+    // No existing log file (or stat failed) → nothing to rotate.
+  }
+}
+
+export function createLogger({ path: logPath, rotateAtBytes }: LoggerOptions): Logger {
+  fs.mkdirSync(path.dirname(logPath), { recursive: true });
+  rotateIfOversized(logPath, rotateAtBytes);
+
+  const write = (level: string, message: string): void => {
+    const line = `[${new Date().toISOString()}] [${level}] ${message}\n`;
+    fs.appendFileSync(logPath, line);
+  };
+
+  return {
+    info: (message) => write('INFO', message),
+    ok: (message) => write('OK', message),
+    err: (message) => write('ERROR', message),
+    // Synchronous appendFileSync keeps no open handle to flush; close() exists
+    // so the daemon shutdown path has a single, stable hook to call.
+    close: () => {}
+  };
+}

package/lib/server/plugin-loader.ts

@@ -0,0 +1,84 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import type { ServerConfig } from './config.ts';
+import type { Adapter, AdapterCtx } from './adapters/_contract.ts';
+
+export type ImportAdapter = (name: string) => Promise<unknown>;
+
+export type LoadAdaptersOptions = {
+  // Test seam: override how an adapter module is resolved so enabled-adapter
+  // loading can be exercised without writing a fake adapter into the source
+  // tree. Production resolves `./adapters/<name>/index.ts`.
+  importAdapter?: ImportAdapter;
+};
+
+const defaultImportAdapter: ImportAdapter = (name) => {
+  // Test-only seam: when AGENT_INFRA_SERVER_TEST_ADAPTERS_DIR is set (never in
+  // production), resolve the named adapter as a plain ESM `.js` from that
+  // fixtures dir. This lets a built daemon (`node dist/bin/cli.js`) load a test
+  // injection adapter on any node>=22 without depending on type stripping.
+  const testDir = process.env.AGENT_INFRA_SERVER_TEST_ADAPTERS_DIR;
+  if (testDir) {
+    return import(pathToFileURL(path.join(testDir, name, 'index.js')).href);
+  }
+  return import(`./adapters/${name}/index.ts`);
+};
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isAdapter(value: unknown): value is Adapter {
+  if (typeof value !== 'object' || value === null) return false;
+  const candidate = value as Record<string, unknown>;
+  return (
+    typeof candidate.name === 'string' &&
+    typeof candidate.start === 'function' &&
+    typeof candidate.stop === 'function' &&
+    typeof candidate.sendMessage === 'function'
+  );
+}
+
+// Load every adapter whose config has `enabled === true`. Each adapter is
+// loaded, instantiated and started in isolation: a failure in one adapter is
+// logged and skipped so it never blocks the others.
+export async function loadAdapters(
+  config: ServerConfig,
+  ctx: AdapterCtx,
+  options: LoadAdaptersOptions = {}
+): Promise<Adapter[]> {
+  const importAdapter = options.importAdapter ?? defaultImportAdapter;
+  const loaded: Adapter[] = [];
+
+  for (const [name, adapterConfig] of Object.entries(config.adapters)) {
+    if (adapterConfig?.enabled !== true) continue;
+    try {
+      const mod = (await importAdapter(name)) as { default?: unknown };
+      const factory = mod?.default;
+      if (typeof factory !== 'function') {
+        throw new Error(`adapter "${name}" has no default export factory`);
+      }
+      const instance: unknown = factory(adapterConfig);
+      if (!isAdapter(instance)) {
+        throw new Error(`adapter "${name}" does not satisfy the Adapter contract`);
+      }
+      await instance.start(ctx);
+      loaded.push(instance);
+    } catch (error) {
+      ctx.logger.err(`failed to load adapter "${name}": ${errorMessage(error)}`);
+    }
+  }
+
+  return loaded;
+}
+
+// Stop adapters in reverse load order, isolating per-adapter stop failures.
+export async function unloadAdapters(adapters: Adapter[]): Promise<void> {
+  for (const adapter of [...adapters].reverse()) {
+    try {
+      await adapter.stop();
+    } catch {
+      // A failing stop must not block the rest of shutdown.
+    }
+  }
+}

package/lib/server/process-control.ts

@@ -0,0 +1,225 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn, execFileSync } from 'node:child_process';
+import { loadServerConfig } from './config.ts';
+import type { ServerConfig } from './config.ts';
+import { runDaemon } from './daemon.ts';
+
+export type StartOptions = { foreground?: boolean };
+export type LogsOptions = { follow?: boolean };
+
+// How to terminate the daemon on a given platform. Pure + exported so the
+// win32 branch can be asserted without running on Windows.
+export type StopCommand =
+  | { kind: 'signal'; signal: NodeJS.Signals }
+  | { kind: 'exec'; command: string; args: string[] };
+
+export function buildStopCommand(pid: number, platform: NodeJS.Platform): StopCommand {
+  if (platform === 'win32') {
+    return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
+  }
+  return { kind: 'signal', signal: 'SIGTERM' };
+}
+
+
+// Liveness check that treats an exited-but-unreaped daemon as dead.
+//
+// The daemon is spawned detached and re-parented to init when `ai server start`
+// exits. After it terminates, `process.kill(pid, 0)` still succeeds until init
+// reaps the zombie. On Linux we therefore also check /proc state so status/stop
+// /start don't treat an already-exited daemon as running. macOS reaps orphans
+// via launchd and Windows has no zombies, so the kill(pid, 0) result is enough.
+export function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+  } catch (error) {
+    // EPERM means the process exists but we may not signal it → still alive.
+    return (error as NodeJS.ErrnoException).code === 'EPERM';
+  }
+  if (process.platform === 'linux') {
+    try {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+      // The process state is the first token after the parenthesised comm.
+      const state = stat.slice(stat.lastIndexOf(')') + 1).trim().charAt(0);
+      if (state === 'Z') return false;
+    } catch {
+      return false; // /proc entry vanished → not alive
+    }
+  }
+  return true;
+}
+
+function readPid(pidFile: string): number | null {
+  try {
+    const raw = fs.readFileSync(pidFile, 'utf8').trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function removePidFile(pidFile: string): void {
+  try {
+    fs.unlinkSync(pidFile);
+  } catch {
+    // Already gone.
+  }
+}
+
+function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+function enabledAdapterNames(config: ServerConfig): string[] {
+  return Object.entries(config.adapters)
+    .filter(([, adapter]) => adapter?.enabled === true)
+    .map(([name]) => name);
+}
+
+export async function start({ foreground = false }: StartOptions = {}): Promise<void> {
+  const config = loadServerConfig();
+  const pidPath = config.pidFile;
+
+  // Zombie PID cleanup: a stale PID file from a crashed daemon must not block a
+  // fresh start.
+  const existing = readPid(pidPath);
+  if (existing !== null && isProcessAlive(existing)) {
+    process.stdout.write(`server already running (pid ${existing})\n`);
+    return;
+  }
+  if (existing !== null) {
+    removePidFile(pidPath);
+  }
+
+  if (foreground) {
+    await runDaemon();
+    return;
+  }
+
+  const cliEntry = process.argv[1];
+  if (!cliEntry) {
+    throw new Error('server: unable to determine CLI entry point for daemon spawn');
+  }
+
+  // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
+  // (node --experimental-strip-types ./bin/cli.ts) and the built path
+  // (node dist/bin/cli.js) both work.
+  const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.unref();
+
+  if (typeof child.pid !== 'number') {
+    throw new Error('server: failed to spawn daemon process');
+  }
+  fs.mkdirSync(path.dirname(pidPath), { recursive: true });
+  fs.writeFileSync(pidPath, `${child.pid}\n`);
+  process.stdout.write(`server started (pid ${child.pid})\n`);
+}
+
+export async function stop(): Promise<void> {
+  const config = loadServerConfig();
+  const pid = readPid(config.pidFile);
+
+  if (pid === null) {
+    process.stdout.write('server is not running (no pid file)\n');
+    return;
+  }
+  if (!isProcessAlive(pid)) {
+    removePidFile(config.pidFile);
+    process.stdout.write('server is not running (removed stale pid file)\n');
+    return;
+  }
+
+  const command = buildStopCommand(pid, process.platform);
+  if (command.kind === 'exec') {
+    execFileSync(command.command, command.args);
+  } else {
+    process.kill(pid, command.signal);
+    const deadline = Date.now() + 5000;
+    while (isProcessAlive(pid) && Date.now() < deadline) {
+      await delay(100);
+    }
+    if (isProcessAlive(pid)) {
+      process.kill(pid, 'SIGKILL');
+    }
+  }
+
+  removePidFile(config.pidFile);
+  process.stdout.write(`server stopped (pid ${pid})\n`);
+}
+
+export function status(): void {
+  const config = loadServerConfig();
+  const pid = readPid(config.pidFile);
+
+  if (pid === null || !isProcessAlive(pid)) {
+    process.stdout.write('server: stopped\n');
+    if (pid !== null) {
+      process.stdout.write(`  (stale pid file references pid ${pid})\n`);
+    }
+    return;
+  }
+
+  let startedAt = 'unknown';
+  try {
+    startedAt = fs.statSync(config.pidFile).mtime.toISOString();
+  } catch {
+    // Leave as unknown.
+  }
+  const adapters = enabledAdapterNames(config);
+  process.stdout.write(
+    `server: running\n` +
+      `  pid: ${pid}\n` +
+      `  started: ${startedAt}\n` +
+      `  adapters: ${adapters.length > 0 ? adapters.join(', ') : '(none)'}\n` +
+      `  pid file: ${config.pidFile}\n` +
+      `  log: ${config.log.path}\n`
+  );
+}
+
+export async function logs({ follow = false }: LogsOptions = {}): Promise<void> {
+  const config = loadServerConfig();
+  const logPath = config.log.path;
+
+  if (!fs.existsSync(logPath)) {
+    process.stdout.write('server: no log file yet\n');
+    return;
+  }
+
+  const initial = fs.readFileSync(logPath, 'utf8');
+  process.stdout.write(initial);
+  if (!follow) return;
+
+  let position = Buffer.byteLength(initial);
+  const watcher = fs.watch(logPath, () => {
+    try {
+      const { size } = fs.statSync(logPath);
+      if (size < position) position = 0; // truncated or rotated
+      if (size > position) {
+        const fd = fs.openSync(logPath, 'r');
+        try {
+          const buffer = Buffer.alloc(size - position);
+          fs.readSync(fd, buffer, 0, buffer.length, position);
+          process.stdout.write(buffer.toString('utf8'));
+        } finally {
+          fs.closeSync(fd);
+        }
+        position = size;
+      }
+    } catch {
+      // Transient read error during rotation; ignore and wait for next event.
+    }
+  });
+
+  await new Promise<void>((resolve) => {
+    process.on('SIGINT', () => {
+      watcher.close();
+      resolve();
+    });
+  });
+}

package/lib/server/protocol.ts

@@ -0,0 +1,79 @@
+import { VERSION } from '../version.ts';
+import { getSkillRunSpec } from '../run/skills.ts';
+import type { CommandRole } from './auth.ts';
+
+export type CommandPlan =
+  | { kind: 'ignore' }
+  | { kind: 'error'; message: string }
+  | { kind: 'builtin'; name: 'ping' | 'help' | 'version'; role: 'read'; args: string[] }
+  | { kind: 'ai'; role: CommandRole; argv: string[] };
+
+const TASK_READ = new Set(['ls', 'list', 'status', 'show', 'log', 'decisions']);
+const SANDBOX_READ = new Set(['ls', 'list', 'show']);
+const SANDBOX_WRITE = new Set(['create', 'start']);
+
+function splitWords(text: string): string[] {
+  return text.trim().split(/\s+/).filter(Boolean);
+}
+
+function taskSubcommand(subcommand: string): string {
+  return subcommand === 'list' ? 'ls' : subcommand;
+}
+
+export function commandHelp(): string {
+  return [
+    `agent-infra ${VERSION}`,
+    'Built-ins: /help, /ping, /version',
+    'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
+    'Write: /sandbox create|start',
+    'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+  ].join('\n');
+}
+
+export function parseCommand(text: string): CommandPlan {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith('/')) return { kind: 'ignore' };
+  const words = splitWords(trimmed);
+  const [command = '', subcommand = '', ...rest] = words;
+
+  if (command === '/help') return { kind: 'builtin', name: 'help', role: 'read', args: rest };
+  if (command === '/ping') return { kind: 'builtin', name: 'ping', role: 'read', args: rest };
+  if (command === '/version') return { kind: 'builtin', name: 'version', role: 'read', args: rest };
+
+  if (command === '/decide') {
+    return { kind: 'ai', role: 'exec', argv: ['decide', subcommand, ...rest] };
+  }
+
+  if (command === '/task') {
+    if (!TASK_READ.has(subcommand)) return { kind: 'error', message: 'Unknown /task command' };
+    return { kind: 'ai', role: 'read', argv: ['task', taskSubcommand(subcommand), ...rest] };
+  }
+
+  if (command === '/sandbox') {
+    if (subcommand === 'vm') {
+      if (rest[0] !== 'status') return { kind: 'error', message: 'Only /sandbox vm status is allowed' };
+      return { kind: 'ai', role: 'read', argv: ['sandbox', 'vm', 'status'] };
+    }
+    if (SANDBOX_READ.has(subcommand)) {
+      return { kind: 'ai', role: 'read', argv: ['sandbox', taskSubcommand(subcommand), ...rest] };
+    }
+    if (SANDBOX_WRITE.has(subcommand)) {
+      return { kind: 'ai', role: 'write', argv: ['sandbox', subcommand, ...rest] };
+    }
+    if (subcommand === 'rm') {
+      return {
+        kind: 'error',
+        message: '/sandbox rm is not available from IM because it requires interactive confirmation'
+      };
+    }
+    return { kind: 'error', message: 'Unknown /sandbox command' };
+  }
+
+  if (command === '/run') {
+    const spec = getSkillRunSpec(subcommand);
+    if (!spec) return { kind: 'error', message: `Unknown skill: ${subcommand}` };
+    return { kind: 'ai', role: spec.role, argv: ['run', subcommand, ...rest] };
+  }
+
+  return { kind: 'error', message: `Unknown command: ${command}` };
+}

package/lib/server/redact.ts

@@ -0,0 +1,12 @@
+const SECRET_PATTERNS = [
+  /\b(token|secret|password|passwd|api[_-]?key)=([^\s]+)/gi,
+  /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/g
+];
+
+export function redactSecrets(text: string): string {
+  let out = text;
+  for (const pattern of SECRET_PATTERNS) {
+    out = out.replace(pattern, (_match, prefix) => `${prefix}=<redacted>`);
+  }
+  return out;
+}