@fitlab-ai/agent-infra 0.5.9 → 0.6.0

package/lib/sandbox/commands/enter.js

@@ -1,79 +0,0 @@
-import { loadConfig } from '../config.js';
-import { assertValidBranchName, containerNameCandidates } from '../constants.js';
-import { runInteractive, runSafe } from '../shell.js';
-import { resolveTaskBranch } from '../task-resolver.js';
-
-const USAGE = `Usage: ai sandbox exec <branch> [cmd...]`;
-export const TMUX_ENTRY_SCRIPT = `
-SESSION=work
-
-if ! command -v tmux >/dev/null 2>&1; then
-  exec bash
-fi
-
-if ! tmux has-session -t "$SESSION" 2>/dev/null; then
-  exec tmux new-session -s "$SESSION"
-fi
-
-tmux list-sessions -F '#{session_name} #{session_attached}' 2>/dev/null | \\
-  while read -r name attached; do
-    [ "$name" = "$SESSION" ] && continue
-    case "$name" in
-      ''|*[!0-9]*) continue ;;
-    esac
-    [ "$attached" = "0" ] && tmux kill-session -t "$name" 2>/dev/null || true
-  done
-
-exec tmux new-session -t "$SESSION"
-`.trim();
-
-// Terminal-detection variables that interactive TUIs (e.g. claude-code)
-// inspect to enable progressive enhancements such as the kitty keyboard
-// protocol, which is what makes Shift+Enter distinguishable from Enter.
-// `docker exec` does not forward these by default, so we must pass them
-// through explicitly.
-const FORWARDED_TERMINAL_ENV = [
-  'TERM_PROGRAM',
-  'TERM_PROGRAM_VERSION',
-  'LC_TERMINAL',
-  'LC_TERMINAL_VERSION'
-];
-
-export function terminalEnvFlags(env = process.env) {
-  const flags = [];
-  for (const name of FORWARDED_TERMINAL_ENV) {
-    const value = env[name];
-    if (value) {
-      flags.push('-e', `${name}=${value}`);
-    }
-  }
-  return flags;
-}
-
-export function enter(args) {
-  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
-    process.stdout.write(`${USAGE}\n`);
-    if (args.length === 0) {
-      return 1;
-    }
-    return 0;
-  }
-
-  const config = loadConfig();
-  const [branchOrTaskId, ...cmd] = args;
-  const branch = resolveTaskBranch(branchOrTaskId, config.repoRoot);
-  assertValidBranchName(branch);
-  const running = runSafe('docker', ['ps', '--format', '{{.Names}}']).split('\n');
-  const container = containerNameCandidates(config, branch).find((name) => running.includes(name));
-
-  if (!container) {
-    throw new Error(`No running sandbox found for branch '${branch}'`);
-  }
-
-  const envFlags = terminalEnvFlags();
-  if (cmd.length === 0) {
-    return runInteractive('docker', ['exec', '-it', ...envFlags, container, 'bash', '-c', TMUX_ENTRY_SCRIPT]);
-  }
-
-  return runInteractive('docker', ['exec', '-it', ...envFlags, container, ...cmd]);
-}

package/lib/sandbox/commands/rebuild.js

@@ -1,102 +0,0 @@
-import { parseArgs } from 'node:util';
-import { createHash } from 'node:crypto';
-import * as p from '@clack/prompts';
-import pc from 'picocolors';
-import { loadConfig } from '../config.js';
-import { prepareDockerfile } from '../dockerfile.js';
-import { sandboxImageConfigLabel, sandboxLabel } from '../constants.js';
-import { ensureDocker } from '../engine.js';
-import { run, runOk, runVerbose } from '../shell.js';
-import { resolveTools, toolNpmPackagesArg } from '../tools.js';
-
-const USAGE = `Usage: ai sandbox rebuild [--quiet]`;
-
-function buildSignature(preparedDockerfile, tools) {
-  return createHash('sha256')
-    .update(JSON.stringify({
-      dockerfile: preparedDockerfile.signature,
-      tools: tools.map((tool) => tool.npmPackage)
-    }))
-    .digest('hex')
-    .slice(0, 12);
-}
-
-function buildArgs(config, tools, dockerfilePath, imageSignature) {
-  const hostUid = run('id', ['-u']);
-  const hostGid = run('id', ['-g']);
-
-  return [
-    'build',
-    '-t',
-    config.imageName,
-    '--build-arg',
-    `HOST_UID=${hostUid}`,
-    '--build-arg',
-    `HOST_GID=${hostGid}`,
-    '--build-arg',
-    `AI_TOOL_PACKAGES=${toolNpmPackagesArg(tools)}`,
-    '--label',
-    sandboxLabel(config),
-    '--label',
-    `${sandboxImageConfigLabel(config)}=${imageSignature}`,
-    '-f',
-    dockerfilePath,
-    config.repoRoot
-  ];
-}
-
-function removeImageIfPresent(imageName) {
-  if (runOk('docker', ['image', 'inspect', imageName])) {
-    run('docker', ['rmi', imageName]);
-  }
-}
-
-export async function rebuild(args) {
-  const { values } = parseArgs({
-    args,
-    allowPositionals: true,
-    strict: true,
-    options: {
-      quiet: { type: 'boolean', short: 'q' },
-      help: { type: 'boolean', short: 'h' }
-    }
-  });
-
-  if (values.help) {
-    process.stdout.write(`${USAGE}\n`);
-    return;
-  }
-
-  const config = loadConfig();
-  const tools = resolveTools(config);
-  const preparedDockerfile = prepareDockerfile(config);
-  const imageSignature = buildSignature(preparedDockerfile, tools);
-  const quiet = values.quiet ?? false;
-
-  await ensureDocker(config);
-  p.intro(pc.cyan('Rebuilding sandbox image'));
-
-  try {
-    if (quiet) {
-      const spinner = p.spinner();
-      spinner.start(`Removing old image ${config.imageName}...`);
-      removeImageIfPresent(config.imageName);
-      spinner.stop('Old image removed');
-      spinner.start('Building image...');
-      run('docker', buildArgs(config, tools, preparedDockerfile.path, imageSignature), { cwd: config.repoRoot });
-      spinner.stop(pc.green('Sandbox image rebuilt'));
-    } else {
-      p.log.step(`Removing old image ${config.imageName}`);
-      removeImageIfPresent(config.imageName);
-      p.log.step('Building image');
-      runVerbose(
-        'docker',
-        buildArgs(config, tools, preparedDockerfile.path, imageSignature),
-        { cwd: config.repoRoot }
-      );
-      p.log.success(pc.green('Sandbox image rebuilt'));
-    }
-  } finally {
-    preparedDockerfile.cleanup();
-  }
-}

package/lib/sandbox/config.js

@@ -1,84 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { execFileSync } from 'node:child_process';
-import { validateSandboxEngine } from './engine.js';
-
-const DEFAULTS = Object.freeze({
-  engine: null,
-  runtimes: ['node20'],
-  tools: ['claude-code', 'codex', 'opencode', 'gemini-cli'],
-  dockerfile: null,
-  vm: {
-    cpu: null,
-    memory: null,
-    disk: null
-  }
-});
-
-function detectRepoRoot() {
-  try {
-    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'pipe']
-    }).trim();
-  } catch {
-    throw new Error('sandbox: current directory is not inside a git repository');
-  }
-}
-
-function cloneDefaults() {
-  return {
-    engine: DEFAULTS.engine,
-    runtimes: [...DEFAULTS.runtimes],
-    tools: [...DEFAULTS.tools],
-    dockerfile: DEFAULTS.dockerfile,
-    vm: { ...DEFAULTS.vm }
-  };
-}
-
-export function loadConfig() {
-  const repoRoot = detectRepoRoot();
-  const home = process.env.HOME;
-
-  if (!home) {
-    throw new Error('sandbox: HOME environment variable is required');
-  }
-
-  const configPath = path.join(repoRoot, '.agents', '.airc.json');
-  if (!fs.existsSync(configPath)) {
-    throw new Error('No .agents/.airc.json found. Run "ai init" first.');
-  }
-
-  const airc = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  const defaults = cloneDefaults();
-  const sandbox = airc.sandbox ?? {};
-  const engine = validateSandboxEngine(sandbox.engine ?? defaults.engine);
-  const project = airc.project;
-
-  if (!project || typeof project !== 'string') {
-    throw new Error('sandbox: .agents/.airc.json is missing a valid "project" field');
-  }
-
-  return {
-    repoRoot,
-    configPath,
-    project,
-    org: airc.org ?? '',
-    home,
-    containerPrefix: `${project}-dev`,
-    imageName: `${project}-sandbox:latest`,
-    worktreeBase: path.join(home, '.agent-infra', 'worktrees', project),
-    engine,
-    runtimes: Array.isArray(sandbox.runtimes) && sandbox.runtimes.length > 0
-      ? [...sandbox.runtimes]
-      : defaults.runtimes,
-    tools: Array.isArray(sandbox.tools) && sandbox.tools.length > 0
-      ? [...sandbox.tools]
-      : defaults.tools,
-    dockerfile: sandbox.dockerfile ?? defaults.dockerfile,
-    vm: {
-      ...defaults.vm,
-      ...(sandbox.vm ?? {})
-    }
-  };
-}

package/lib/sandbox/engine.js

@@ -1,256 +0,0 @@
-import { platform } from 'node:os';
-import { detectHostResources } from './constants.js';
-import { run, runOk, runSafe, runVerbose } from './shell.js';
-
-export const ENGINES = Object.freeze({
-  COLIMA: 'colima',
-  ORBSTACK: 'orbstack',
-  DOCKER_DESKTOP: 'docker-desktop'
-});
-
-export const ENGINE_DOCKER_CONTEXT = Object.freeze({
-  [ENGINES.COLIMA]: 'colima',
-  [ENGINES.ORBSTACK]: 'orbstack',
-  [ENGINES.DOCKER_DESKTOP]: 'desktop-linux'
-});
-
-const VALID_CONFIG_ENGINES = new Set(Object.values(ENGINES));
-
-function applyDockerContext(engine) {
-  const context = ENGINE_DOCKER_CONTEXT[engine];
-  if (context) {
-    process.env.DOCKER_CONTEXT = context;
-  }
-}
-
-export function validateSandboxEngine(engine) {
-  if (engine === null || engine === undefined) {
-    return null;
-  }
-
-  if (VALID_CONFIG_ENGINES.has(engine)) {
-    return engine;
-  }
-
-  throw new Error(
-    `sandbox: invalid "sandbox.engine" value "${engine}". `
-    + 'Expected one of: null, colima, orbstack, docker-desktop. '
-    + 'This setting only affects macOS sandbox engine selection.'
-  );
-}
-
-export function detectEngine(config = {}, { platformFn = platform } = {}) {
-  const configured = validateSandboxEngine(config.engine);
-  const os = platformFn();
-  if (os === 'linux') {
-    return 'native';
-  }
-  if (os === 'win32') {
-    return 'wsl2';
-  }
-  if (os === 'darwin') {
-    if (configured) {
-      return configured;
-    }
-
-    return ENGINES.COLIMA;
-  }
-  return 'unsupported';
-}
-
-function colimaArgs(config, runSafeFn = runSafe) {
-  const arch = runSafeFn('uname', ['-m']);
-  const defaults = detectHostResources();
-  const vm = config.vm ?? {};
-  const cpu = vm.cpu ?? defaults.cpu;
-  const memory = vm.memory ?? defaults.memory;
-  const disk = vm.disk ?? 60;
-  const args = ['start', '--cpu', String(cpu), '--memory', String(memory), '--disk', String(disk)];
-
-  if (arch === 'arm64') {
-    args.push('--arch', 'aarch64', '--vm-type=vz', '--mount-type=virtiofs');
-  } else {
-    args.push('--arch', 'x86_64');
-  }
-
-  return args;
-}
-
-export async function ensureColima(
-  config,
-  onMessage,
-  { runOkFn = runOk, runSafeFn = runSafe, runVerboseFn = runVerbose } = {}
-) {
-  applyDockerContext(ENGINES.COLIMA);
-
-  if (!runOkFn('which', ['colima'])) {
-    onMessage?.('Installing colima + docker via Homebrew...');
-    runVerboseFn('brew', ['install', 'colima', 'docker']);
-  }
-
-  if (!runOkFn('colima', ['status'])) {
-    onMessage?.('Starting Colima VM...');
-    runVerboseFn('colima', colimaArgs(config, runSafeFn));
-  }
-
-  if (!runOkFn('docker', ['info'])) {
-    throw new Error('Docker daemon is not available after starting Colima');
-  }
-}
-
-export async function ensureOrbStack(
-  _config,
-  onMessage,
-  { runOkFn = runOk, runVerboseFn = runVerbose } = {}
-) {
-  applyDockerContext(ENGINES.ORBSTACK);
-
-  if (!runOkFn('which', ['orb'])) {
-    onMessage?.('Installing OrbStack via Homebrew...');
-    runVerboseFn('brew', ['install', '--cask', 'orbstack']);
-  }
-
-  if (!runOkFn('docker', ['info'])) {
-    onMessage?.('Starting OrbStack...');
-    runVerboseFn('orb', ['start']);
-  }
-
-  if (!runOkFn('docker', ['info'])) {
-    throw new Error('Docker daemon is not available after starting OrbStack');
-  }
-}
-
-export async function ensureDockerDesktop(
-  _config,
-  onMessage,
-  { runOkFn = runOk } = {}
-) {
-  applyDockerContext(ENGINES.DOCKER_DESKTOP);
-
-  if (!runOkFn('docker', ['info'])) {
-    throw new Error('Docker Desktop is not running. Please start Docker Desktop manually.');
-  }
-}
-
-export async function ensureNativeDocker(
-  _config,
-  _onMessage,
-  { runOkFn = runOk, runSafeFn = runSafe } = {}
-) {
-  if (!runOkFn('which', ['docker'])) {
-    throw new Error([
-      'Docker is not installed.',
-      'Install Docker Engine for your distribution: https://docs.docker.com/engine/install/',
-      'Then start the daemon with: sudo systemctl enable --now docker',
-      'If you want to run Docker without sudo, add your user to the docker group: sudo usermod -aG docker $USER'
-    ].join('\n'));
-  }
-
-  if (runOkFn('docker', ['info'])) {
-    return;
-  }
-
-  const serverVersion = runSafeFn('docker', ['version', '--format', '{{.Server.Version}}']);
-  if (!serverVersion) {
-    throw new Error([
-      'Docker daemon is not running or is unreachable.',
-      'Start it with: sudo systemctl start docker',
-      'Enable it on boot with: sudo systemctl enable docker',
-      'If you use rootless or remote Docker, verify DOCKER_HOST points at a reachable socket.',
-      'Then retry: ai sandbox create <branch>'
-    ].join('\n'));
-  }
-
-  throw new Error([
-    'Docker is installed, but the current user may lack permission to use the daemon.',
-    'Add your user to the docker group: sudo usermod -aG docker $USER',
-    'Open a new login shell or run: newgrp docker',
-    'For rootless Docker, make sure DOCKER_HOST points at the rootless daemon socket.'
-  ].join('\n'));
-}
-
-export async function ensureDocker(config, onMessage) {
-  const engine = detectEngine(config);
-
-  if (engine === ENGINES.COLIMA) {
-    await ensureColima(config, onMessage);
-    return;
-  }
-
-  if (engine === ENGINES.ORBSTACK) {
-    await ensureOrbStack(config, onMessage);
-    return;
-  }
-
-  if (engine === ENGINES.DOCKER_DESKTOP) {
-    await ensureDockerDesktop(config, onMessage);
-    return;
-  }
-
-  if (engine === 'native') {
-    await ensureNativeDocker(config, onMessage);
-    return;
-  }
-
-  if (engine === 'wsl2') {
-    throw new Error('Windows sandbox support is reserved for a future WSL2 implementation.');
-  }
-
-  throw new Error(`Unsupported sandbox engine: ${engine}`);
-}
-
-export function isVmManaged(config = {}, dependencies = {}) {
-  const engine = detectEngine(config, dependencies);
-  return isManagedEngine(engine);
-}
-
-export function isManagedEngine(engine) {
-  return engine === ENGINES.COLIMA || engine === ENGINES.ORBSTACK;
-}
-
-export function engineDisplayName(engine) {
-  const names = {
-    [ENGINES.COLIMA]: 'Colima',
-    [ENGINES.ORBSTACK]: 'OrbStack',
-    [ENGINES.DOCKER_DESKTOP]: 'Docker Desktop',
-    native: 'native Docker',
-    wsl2: 'WSL2'
-  };
-  return names[engine] ?? engine;
-}
-
-export function startManagedVm(
-  config,
-  { platformFn = platform, runOkFn = runOk, runVerboseFn = runVerbose } = {}
-) {
-  const engine = detectEngine(config, { platformFn });
-  if (!isManagedEngine(engine)) {
-    throw new Error(`VM management is unavailable for engine '${engineDisplayName(engine)}'.`);
-  }
-
-  if (engine === ENGINES.COLIMA && runOkFn('colima', ['status'])) {
-    return 'already-running';
-  }
-  if (engine === ENGINES.ORBSTACK && runOkFn('orb', ['status'])) {
-    return 'already-running';
-  }
-
-  if (engine === ENGINES.COLIMA) {
-    runVerboseFn('colima', colimaArgs(config));
-  } else if (engine === ENGINES.ORBSTACK) {
-    runVerboseFn('orb', ['start']);
-  }
-  return 'started';
-}
-
-export function stopManagedVm(config, { platformFn = platform, runFn = run } = {}) {
-  const engine = detectEngine(config, { platformFn });
-  if (engine === ENGINES.COLIMA) {
-    runFn('colima', ['stop']);
-    return 'stopped';
-  } else if (engine === ENGINES.ORBSTACK) {
-    runFn('orb', ['stop']);
-    return 'stopped';
-  }
-  throw new Error(`VM management is unavailable for engine '${engineDisplayName(engine)}'.`);
-}

package/lib/sandbox/shell.js

@@ -1,122 +0,0 @@
-import { execFileSync, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
-
-function normalizeOptions(opts = {}, stdio) {
-  return {
-    cwd: opts.cwd,
-    encoding: opts.encoding,
-    stdio,
-    timeout: opts.timeout ?? DEFAULT_TIMEOUT_MS
-  };
-}
-
-function resolveCommand(cmd) {
-  if (process.platform !== 'win32' || path.extname(cmd)) {
-    return cmd;
-  }
-
-  const pathValue = process.env.Path || process.env.PATH || '';
-  const extensions = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
-    .split(';')
-    .filter(Boolean);
-
-  for (const dir of pathValue.split(path.delimiter).filter(Boolean)) {
-    for (const extension of extensions) {
-      const candidate = path.join(dir, `${cmd}${extension.toLowerCase()}`);
-      if (fs.existsSync(candidate)) {
-        return candidate;
-      }
-      const upperCandidate = path.join(dir, `${cmd}${extension.toUpperCase()}`);
-      if (fs.existsSync(upperCandidate)) {
-        return upperCandidate;
-      }
-    }
-  }
-
-  return cmd;
-}
-
-function commandOptions(cmd, opts) {
-  if (process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(cmd)) {
-    return { ...opts, shell: true };
-  }
-  return opts;
-}
-
-export function run(cmd, args, opts = {}) {
-  const resolved = resolveCommand(cmd);
-  return execFileSync(resolved, args, commandOptions(resolved, {
-    ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
-    encoding: 'utf8'
-  })).trim();
-}
-
-export function runOk(cmd, args, opts = {}) {
-  const resolved = resolveCommand(cmd);
-  const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'pipe')));
-  return result.status === 0;
-}
-
-export function restoreTerminal() {
-  if (!process.stdout.isTTY) {
-    return;
-  }
-
-  try {
-    process.stdout.write([
-      '\x1b[?1049l',
-      '\x1b[?25h',
-      '\x1b>',
-      '\x1b[?1000l',
-      '\x1b[?1002l',
-      '\x1b[?1003l',
-      '\x1b[?1006l'
-    ].join(''));
-  } catch {
-    // Best-effort cleanup only; preserve the original command result.
-  }
-
-  if (process.platform === 'win32') {
-    return;
-  }
-
-  try {
-    execFileSync('stty', ['sane'], { stdio: 'inherit' });
-  } catch {
-    // Some environments do not provide stty or reject sane; ANSI reset still helps.
-  }
-}
-
-export function runInteractive(cmd, args, opts = {}) {
-  const resolved = resolveCommand(cmd);
-  try {
-    const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
-    return result.status ?? 1;
-  } finally {
-    restoreTerminal();
-  }
-}
-
-export function runVerbose(cmd, args, opts = {}) {
-  const resolved = resolveCommand(cmd);
-  const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
-
-  if (result.status !== 0) {
-    if (result.signal === 'SIGTERM') {
-      throw new Error(`Command timed out after ${opts.timeout ?? DEFAULT_TIMEOUT_MS}ms: ${cmd} ${args.join(' ')}`);
-    }
-    throw new Error(`Command failed with exit code ${result.status}: ${cmd} ${args.join(' ')}`);
-  }
-}
-
-export function runSafe(cmd, args, opts = {}) {
-  const resolved = resolveCommand(cmd);
-  const result = spawnSync(resolved, args, commandOptions(resolved, {
-    ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
-    encoding: 'utf8',
-  }));
-  return (result.stdout ?? '').trim();
-}

package/templates/.agents/scripts/platform-adapters/find-existing-task.js

@@ -1,5 +0,0 @@
-import { pathToFileURL } from "node:url";
-
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
-  console.log(JSON.stringify({ found: false }, null, 2));
-}