@fitlab-ai/agent-infra 0.5.10 → 0.6.1

package/dist/lib/sandbox/commands/vm.js

@@ -0,0 +1,144 @@
+import { parseArgs } from 'node:util';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { loadConfig } from "../config.js";
+import { parsePositiveIntegerOption } from "../constants.js";
+import { ENGINES, detectEngine, engineDisplayName, isManagedEngine, startManagedVm, stopManagedVm } from "../engine.js";
+import { runOk, runSafe } from "../shell.js";
+const USAGE = `Usage: ai sandbox vm <status|start|stop> [--cpu <n>] [--memory <n>]`;
+export function ensureManagedVm(engine) {
+    if (engine === ENGINES.NATIVE) {
+        throw new Error("Linux native Docker does not use a managed VM. Use 'ai sandbox create' directly.");
+    }
+    if (!isManagedEngine(engine)) {
+        throw new Error(`VM management is unavailable for engine '${engineDisplayName(engine)}'. `
+            + (engine === ENGINES.DOCKER_DESKTOP
+                ? 'Docker Desktop is managed via its GUI (Settings -> Resources).'
+                : ''));
+    }
+}
+export function wsl2BackendStatus({ runOkFn = runOk } = {}) {
+    const wslAvailable = runOkFn('wsl.exe', ['--status']) || runOkFn('wsl.exe', ['--', 'true']);
+    const dockerAvailable = wslAvailable && runOkFn('wsl.exe', ['--', 'docker', 'info']);
+    return { wslAvailable, dockerAvailable };
+}
+function status() {
+    const config = loadConfig();
+    const engine = detectEngine(config);
+    const name = engineDisplayName(engine);
+    ensureManagedVm(engine);
+    p.intro(pc.cyan('Sandbox VM status'));
+    if (engine === ENGINES.WSL2) {
+        const backend = wsl2BackendStatus();
+        if (backend.wslAvailable) {
+            p.log.info('WSL2 is available');
+        }
+        else {
+            p.log.warn('WSL2 is not available. Install WSL2 and configure a default Linux distribution.');
+        }
+        if (backend.dockerAvailable) {
+            p.log.info('Docker Desktop WSL integration is available');
+        }
+        else {
+            p.log.warn('Docker is not available inside WSL2. Start Docker Desktop and enable WSL integration.');
+        }
+        return;
+    }
+    if (engine === ENGINES.COLIMA) {
+        if (runOk('colima', ['status'])) {
+            process.stdout.write(`${runSafe('colima', ['status'])}\n`);
+        }
+        else {
+            p.log.warn('Colima VM is not running');
+        }
+        return;
+    }
+    if (!runOk('orb', ['status'])) {
+        p.log.warn(`${name} VM is not running`);
+        return;
+    }
+    process.stdout.write(`${runSafe('orb', ['status'])}\n`);
+}
+async function start(args) {
+    const { values } = parseArgs({
+        args,
+        allowPositionals: true,
+        strict: true,
+        options: {
+            cpu: { type: 'string' },
+            memory: { type: 'string' },
+            help: { type: 'boolean', short: 'h' }
+        }
+    });
+    if (values.help) {
+        process.stdout.write(`${USAGE}\n`);
+        return;
+    }
+    const config = loadConfig();
+    const engine = detectEngine(config);
+    ensureManagedVm(engine);
+    p.intro(pc.cyan('Starting sandbox VM'));
+    if (engine === ENGINES.WSL2) {
+        p.log.warn('WSL2 Docker backend is managed by Docker Desktop. '
+            + 'Start it from Docker Desktop GUI, then run "ai sandbox vm status" to check readiness.');
+        return;
+    }
+    const effectiveConfig = {
+        ...config,
+        vm: {
+            ...config.vm,
+            cpu: parsePositiveIntegerOption(values.cpu, '--cpu') ?? config.vm.cpu,
+            memory: parsePositiveIntegerOption(values.memory, '--memory') ?? config.vm.memory
+        }
+    };
+    const onMessage = (detail) => {
+        p.log.info(detail);
+    };
+    startManagedVm(effectiveConfig, { onMessage });
+    p.outro(pc.green('VM ready'));
+}
+function stop() {
+    const config = loadConfig();
+    const engine = detectEngine(config);
+    const name = engineDisplayName(engine);
+    ensureManagedVm(engine);
+    p.intro(pc.cyan('Stopping sandbox VM'));
+    if (engine === ENGINES.WSL2) {
+        p.log.warn('Windows uses Docker Desktop with WSL2. Stop it from Docker Desktop or run "wsl --shutdown" manually.');
+        return;
+    }
+    if (engine === ENGINES.COLIMA && !runOk('colima', ['status'])) {
+        p.log.warn(`${name} VM is not running`);
+        return;
+    }
+    if (engine === ENGINES.ORBSTACK && !runOk('orb', ['status'])) {
+        p.log.warn(`${name} VM is not running`);
+        return;
+    }
+    stopManagedVm(config);
+    p.outro(pc.green('VM stopped'));
+}
+export async function vm(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === '--help' || subcommand === '-h') {
+        process.stdout.write(`${USAGE}\n`);
+        if (!subcommand) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    switch (subcommand) {
+        case 'status':
+            status();
+            break;
+        case 'start':
+            await start(rest);
+            break;
+        case 'stop':
+            stop();
+            break;
+        default:
+            throw new Error(USAGE);
+    }
+}
+//# sourceMappingURL=vm.js.map

package/dist/lib/sandbox/config.js

@@ -0,0 +1,85 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { homedir, platform } from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { validateSandboxEngine } from "./engine.js";
+import { hostJoin } from "./engines/wsl2-paths.js";
+const DEFAULTS = Object.freeze({
+    engine: null,
+    runtimes: ['node20'],
+    tools: ['claude-code', 'codex', 'gemini-cli', 'opencode'],
+    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 asPositiveNumberOrNull(value) {
+    return typeof value === 'number' ? value : null;
+}
+function cloneDefaults() {
+    return {
+        engine: DEFAULTS.engine,
+        runtimes: [...DEFAULTS.runtimes],
+        tools: [...DEFAULTS.tools],
+        dockerfile: DEFAULTS.dockerfile,
+        vm: { ...DEFAULTS.vm }
+    };
+}
+export function loadConfig({ platformFn = platform } = {}) {
+    const repoRoot = detectRepoRoot();
+    const home = homedir();
+    if (!home) {
+        throw new Error('sandbox: home directory 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, { platformFn });
+    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: typeof airc.org === 'string' ? airc.org : '',
+        home,
+        containerPrefix: `${project}-dev`,
+        imageName: `${project}-sandbox:latest`,
+        worktreeBase: hostJoin(home, '.agent-infra', 'worktrees', project),
+        shareBase: hostJoin(home, '.agent-infra', 'share', project),
+        dotfilesDir: hostJoin(home, '.agent-infra', 'dotfiles'),
+        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: typeof sandbox.dockerfile === 'string' ? sandbox.dockerfile : defaults.dockerfile ?? null,
+        vm: {
+            cpu: asPositiveNumberOrNull(sandbox.vm?.cpu) ?? defaults.vm.cpu,
+            memory: asPositiveNumberOrNull(sandbox.vm?.memory) ?? defaults.vm.memory,
+            disk: asPositiveNumberOrNull(sandbox.vm?.disk) ?? defaults.vm.disk
+        }
+    };
+}
+//# sourceMappingURL=config.js.map

package/dist/lib/sandbox/constants.js

@@ -0,0 +1,104 @@
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { hostJoin } from "./engines/wsl2-paths.js";
+const validatedBranches = new Set();
+function dedupe(items) {
+    return [...new Set(items)];
+}
+export function assertValidBranchName(branch) {
+    if (validatedBranches.has(branch)) {
+        return;
+    }
+    if (!branch || branch.trim().length === 0) {
+        throw new Error('Branch name is required');
+    }
+    if (!/^[A-Za-z0-9._/-]+$/.test(branch)) {
+        throw new Error(`Invalid branch name '${branch}': only letters, digits, ., _, -, and / are allowed`);
+    }
+    try {
+        execFileSync('git', ['check-ref-format', '--branch', branch], {
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+    }
+    catch {
+        throw new Error(`Invalid branch name '${branch}': does not satisfy git branch naming rules`);
+    }
+    validatedBranches.add(branch);
+}
+export function sanitizeBranchName(branch) {
+    assertValidBranchName(branch);
+    return branch.replace(/\//g, '..');
+}
+export function legacySanitizeBranchName(branch) {
+    assertValidBranchName(branch);
+    return branch.replace(/\//g, '-');
+}
+export function safeNameCandidates(branch) {
+    return dedupe([sanitizeBranchName(branch), legacySanitizeBranchName(branch)]);
+}
+export function containerName(config, branch) {
+    return `${config.containerPrefix}-${sanitizeBranchName(branch)}`;
+}
+export function containerNameCandidates(config, branch) {
+    return safeNameCandidates(branch).map((name) => `${config.containerPrefix}-${name}`);
+}
+export function worktreeDir(config, branch) {
+    return hostJoin(config.worktreeBase, sanitizeBranchName(branch));
+}
+export function worktreeDirCandidates(config, branch) {
+    return safeNameCandidates(branch).map((name) => hostJoin(config.worktreeBase, name));
+}
+export function shareDir(config) {
+    return config.shareBase;
+}
+export function shareCommonDir(config) {
+    return hostJoin(config.shareBase, 'common');
+}
+export function shareBranchDir(config, branch) {
+    return hostJoin(config.shareBase, 'branches', sanitizeBranchName(branch));
+}
+export function sandboxLabel(config) {
+    return `${config.project}.sandbox`;
+}
+export function sandboxBranchLabel(config) {
+    return `${sandboxLabel(config)}.branch`;
+}
+export function sandboxImageConfigLabel(config) {
+    return `${sandboxLabel(config)}.image-config`;
+}
+export function parsePositiveIntegerOption(value, optionName) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${optionName} must be a positive integer, got: ${value}`);
+    }
+    return parsed;
+}
+export function detectHostResources() {
+    // Resource hints are for engines that pre-allocate a managed VM. macOS uses
+    // sysctl for Colima defaults, while the generic fallback supports WSL2 or
+    // other direct callers that need conservative CPU and memory defaults.
+    if (process.platform === 'darwin') {
+        try {
+            const hostCpu = Number(execFileSync('sysctl', ['-n', 'hw.ncpu'], { encoding: 'utf8' }).trim());
+            const hostMemBytes = Number(execFileSync('sysctl', ['-n', 'hw.memsize'], { encoding: 'utf8' }).trim());
+            const hostMemGb = Math.floor(hostMemBytes / 1024 / 1024 / 1024);
+            return {
+                cpu: Math.max(1, hostCpu - 2),
+                memory: Math.max(2, Math.floor(hostMemGb / 2))
+            };
+        }
+        catch {
+            // Fall through to generic detection below.
+        }
+    }
+    const hostCpu = os.cpus()?.length ?? 4;
+    const hostMemGb = Math.floor(os.totalmem() / 1024 / 1024 / 1024);
+    return {
+        cpu: Math.max(1, Math.min(hostCpu, hostCpu - 1 || 1)),
+        memory: Math.max(2, Math.floor(hostMemGb / 2))
+    };
+}
+//# sourceMappingURL=constants.js.map