@fitlab-ai/agent-infra 0.6.5 → 0.7.1

package/dist/lib/sandbox/tools.js

@@ -1,11 +1,12 @@
 import { safeNameCandidates, sanitizeBranchName } from "./constants.js";
 import { hostJoin } from "./engines/wsl2-paths.js";
+const TOOL_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 function createBuiltinTools(home, project) {
     return {
         'claude-code': {
             id: 'claude-code',
             name: 'Claude Code',
-            npmPackage: '@anthropic-ai/claude-code@stable',
+            install: { type: 'npm', cmd: '@anthropic-ai/claude-code@stable' },
             sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'claude-code'),
             containerMount: '/home/devuser/.claude',
             versionCmd: 'claude --version',
@@ -35,7 +36,7 @@ function createBuiltinTools(home, project) {
         codex: {
             id: 'codex',
             name: 'Codex',
-            npmPackage: '@openai/codex',
+            install: { type: 'npm', cmd: '@openai/codex' },
             sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'codex'),
             containerMount: '/home/devuser/.codex',
             versionCmd: 'codex --version',
@@ -50,7 +51,7 @@ function createBuiltinTools(home, project) {
         opencode: {
             id: 'opencode',
             name: 'OpenCode',
-            npmPackage: 'opencode-ai',
+            install: { type: 'npm', cmd: 'opencode-ai' },
             sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'opencode'),
             containerMount: '/home/devuser/.local/share/opencode',
             versionCmd: 'opencode version',
@@ -69,7 +70,7 @@ function createBuiltinTools(home, project) {
         'gemini-cli': {
             id: 'gemini-cli',
             name: 'Gemini CLI',
-            npmPackage: '@google/gemini-cli',
+            install: { type: 'npm', cmd: '@google/gemini-cli' },
             sandboxBase: hostJoin(home, '.agent-infra', 'sandboxes', 'gemini-cli'),
             containerMount: '/home/devuser/.gemini',
             versionCmd: 'gemini --version',
@@ -84,15 +85,200 @@ function createBuiltinTools(home, project) {
         }
     };
 }
+export function builtinToolIds() {
+    return Object.keys(createBuiltinTools('', ''));
+}
 function validateTool(tool) {
-    if (!tool.npmPackage || !tool.containerMount.startsWith('/')) {
-        throw new Error(`Invalid sandbox tool descriptor: ${tool.id}`);
+    if (!tool.id || !TOOL_ID_PATTERN.test(tool.id)) {
+        throw new Error(`Invalid sandbox tool id: ${String(tool.id)}`);
+    }
+    if (!tool.install || (tool.install.type !== 'npm' && tool.install.type !== 'shell')) {
+        throw new Error(`Sandbox tool ${tool.id} has invalid install.type`);
+    }
+    if (!tool.install.cmd) {
+        throw new Error(`Sandbox tool ${tool.id} has empty install.cmd`);
+    }
+    if (!tool.containerMount || !tool.containerMount.startsWith('/')) {
+        throw new Error(`Sandbox tool ${tool.id} containerMount must be an absolute path`);
+    }
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function asString(value, field, context) {
+    if (typeof value !== 'string') {
+        throw new Error(`${context}: field "${field}" must be a string`);
+    }
+    return value;
+}
+function asOptionalNonEmptyString(value, field, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`${context}: field "${field}" must be a string when provided`);
+    }
+    if (value.length === 0) {
+        throw new Error(`${context}: field "${field}" must be non-empty when provided`);
+    }
+    return value;
+}
+function asStringRecord(value, field, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPlainObject(value)) {
+        throw new Error(`${context}: field "${field}" must be an object when provided`);
+    }
+    const out = {};
+    for (const [key, val] of Object.entries(value)) {
+        if (typeof val !== 'string') {
+            throw new Error(`${context}: field "${field}.${key}" must be a string`);
+        }
+        out[key] = val;
+    }
+    return out;
+}
+function asStringArray(value, field, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: field "${field}" must be an array when provided`);
+    }
+    return value.map((item, index) => {
+        if (typeof item !== 'string') {
+            throw new Error(`${context}: field "${field}[${index}]" must be a string`);
+        }
+        return item;
+    });
+}
+function parseInstall(value, context) {
+    if (!isPlainObject(value)) {
+        throw new Error(`${context}: field "install" must be an object`);
+    }
+    const type = value.type;
+    if (type !== 'npm' && type !== 'shell') {
+        throw new Error(`${context}: field "install.type" must be "npm" or "shell"`);
+    }
+    const cmd = asString(value.cmd, 'install.cmd', context);
+    if (!cmd) {
+        throw new Error(`${context}: field "install.cmd" must be non-empty`);
+    }
+    return { type, cmd };
+}
+function parseHostPreSeedFiles(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: field "hostPreSeedFiles" must be an array when provided`);
     }
+    return value.map((item, index) => {
+        if (!isPlainObject(item)) {
+            throw new Error(`${context}: field "hostPreSeedFiles[${index}]" must be an object`);
+        }
+        return {
+            hostPath: asString(item.hostPath, `hostPreSeedFiles[${index}].hostPath`, context),
+            sandboxName: asString(item.sandboxName, `hostPreSeedFiles[${index}].sandboxName`, context)
+        };
+    });
+}
+function parseHostPreSeedDirs(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: field "hostPreSeedDirs" must be an array when provided`);
+    }
+    return value.map((item, index) => {
+        if (!isPlainObject(item)) {
+            throw new Error(`${context}: field "hostPreSeedDirs[${index}]" must be an object`);
+        }
+        return {
+            hostDir: asString(item.hostDir, `hostPreSeedDirs[${index}].hostDir`, context),
+            sandboxSubdir: asString(item.sandboxSubdir, `hostPreSeedDirs[${index}].sandboxSubdir`, context)
+        };
+    });
+}
+function parseHostLiveMounts(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${context}: field "hostLiveMounts" must be an array when provided`);
+    }
+    return value.map((item, index) => {
+        if (!isPlainObject(item)) {
+            throw new Error(`${context}: field "hostLiveMounts[${index}]" must be an object`);
+        }
+        return {
+            hostPath: asString(item.hostPath, `hostLiveMounts[${index}].hostPath`, context),
+            containerSubpath: asString(item.containerSubpath, `hostLiveMounts[${index}].containerSubpath`, context)
+        };
+    });
+}
+export function parseCustomTool(entry, index, options) {
+    const context = `customTools[${index}]`;
+    if (!isPlainObject(entry)) {
+        throw new Error(`${context} must be an object`);
+    }
+    const id = asString(entry.id, 'id', context);
+    if (!TOOL_ID_PATTERN.test(id)) {
+        throw new Error(`${context}: field "id" must match ${TOOL_ID_PATTERN.source}`);
+    }
+    const containerMount = asOptionalNonEmptyString(entry.containerMount, 'containerMount', context)
+        ?? `/home/devuser/.${id}`;
+    if (!containerMount.startsWith('/')) {
+        throw new Error(`${context}: field "containerMount" must be an absolute path`);
+    }
+    const tool = {
+        id,
+        name: asOptionalNonEmptyString(entry.name, 'name', context) ?? id,
+        install: parseInstall(entry.install, context),
+        sandboxBase: hostJoin(options.home, '.agent-infra', 'sandboxes', id),
+        containerMount,
+        versionCmd: asOptionalNonEmptyString(entry.versionCmd, 'versionCmd', context) ?? `which ${id}`,
+        setupHint: asOptionalNonEmptyString(entry.setupHint, 'setupHint', context)
+            ?? `Run \`${id}\` inside the container to set up.`,
+        envVars: asStringRecord(entry.envVars, 'envVars', context),
+        hostPreSeedFiles: parseHostPreSeedFiles(entry.hostPreSeedFiles, context),
+        hostPreSeedDirs: parseHostPreSeedDirs(entry.hostPreSeedDirs, context),
+        pathRewriteFiles: asStringArray(entry.pathRewriteFiles, 'pathRewriteFiles', context),
+        hostLiveMounts: parseHostLiveMounts(entry.hostLiveMounts, context),
+        postSetupCmds: asStringArray(entry.postSetupCmds, 'postSetupCmds', context)
+    };
+    validateTool(tool);
+    return tool;
+}
+export function parseCustomTools(value, options) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('sandbox: "customTools" must be an array');
+    }
+    return value.map((entry, index) => parseCustomTool(entry, index, options));
 }
 export function resolveTools(config) {
     const builtins = createBuiltinTools(config.home, config.project);
+    const customs = config.customTools ?? [];
+    const seen = new Set();
+    for (const tool of customs) {
+        if (builtins[tool.id]) {
+            throw new Error(`Custom sandbox tool id "${tool.id}" collides with a built-in tool`);
+        }
+        if (seen.has(tool.id)) {
+            throw new Error(`Duplicate sandbox tool id "${tool.id}" in customTools`);
+        }
+        seen.add(tool.id);
+    }
+    const merged = { ...builtins };
+    for (const tool of customs) {
+        merged[tool.id] = tool;
+    }
     return config.tools.map((id) => {
-        const tool = builtins[id];
+        const tool = merged[id];
         if (!tool) {
             throw new Error(`Unknown sandbox tool: ${id}`);
         }
@@ -110,6 +296,25 @@ export function toolProjectDirCandidates(tool, project) {
     return [hostJoin(tool.sandboxBase, project)];
 }
 export function toolNpmPackagesArg(tools) {
-    return tools.map((tool) => tool.npmPackage).join(' ');
+    return tools
+        .filter((tool) => tool.install.type === 'npm')
+        .map((tool) => tool.install.cmd)
+        .join(' ');
+}
+export function toolShellInstallScript(tools) {
+    const blocks = tools
+        .filter((tool) => tool.install.type === 'shell')
+        .map((tool) => `# install: ${tool.id}\n${tool.install.cmd}`);
+    if (blocks.length === 0) {
+        return '';
+    }
+    return ['#!/bin/bash', 'set -e', '', ...blocks, ''].join('\n');
+}
+export function toolShellInstallScriptBase64(tools) {
+    const script = toolShellInstallScript(tools);
+    return script ? Buffer.from(script, 'utf8').toString('base64') : '';
+}
+export function imageSignatureFields(tools) {
+    return tools.map((tool) => ({ id: tool.id, install: tool.install }));
 }
 //# sourceMappingURL=tools.js.map

package/dist/lib/update.js

@@ -3,6 +3,7 @@ import path from 'node:path';
 import { info, ok, err } from "./log.js";
 import { resolveTemplateDir } from "./paths.js";
 import { renderFile, copySkillDir, KNOWN_PLATFORMS } from "./render.js";
+import { isPathOwnedByDisabledTUI, resolveEnabledTUIs } from "./builtin-tuis.js";
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const CONFIG_DIR = '.agents';
 const CONFIG_PATH = path.join(CONFIG_DIR, '.airc.json');
@@ -15,7 +16,7 @@ function isPathOwnedByOtherPlatform(relativePath, platformType) {
         return false;
     return candidate !== platformType;
 }
-function syncFileRegistry(config, platformType) {
+function syncFileRegistry(config, platformType, enabledTUIs) {
     config.files ||= {};
     const before = JSON.stringify({
         files: {
@@ -36,6 +37,8 @@ function syncFileRegistry(config, platformType) {
     for (const entry of defaults.files.managed) {
         if (isPathOwnedByOtherPlatform(entry, platformType))
             continue;
+        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
+            continue;
         if (!allExisting.includes(entry)) {
             config.files.managed.push(entry);
             added.managed.push(entry);
@@ -44,6 +47,8 @@ function syncFileRegistry(config, platformType) {
     for (const entry of defaults.files.merged) {
         if (isPathOwnedByOtherPlatform(entry, platformType))
             continue;
+        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
+            continue;
         if (!allExisting.includes(entry)) {
             config.files.merged.push(entry);
             added.merged.push(entry);
@@ -82,6 +87,7 @@ async function cmdUpdate() {
     const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     const { project, org, language } = config;
     const platformType = config.platform?.type || defaults.platform.type;
+    const enabledTUIs = resolveEnabledTUIs(config.tuis);
     const replacements = { project, org };
     info(`Updating seed files for: ${project}`);
     console.log('');
@@ -106,21 +112,29 @@ async function cmdUpdate() {
     catch {
         // Ignore missing legacy script from pre-ESM installs.
     }
-    // update Claude command
-    renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Updated .claude/commands/update-agent-infra.md');
-    // update Gemini command
-    renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
-    ok(`Updated .gemini/commands/${project}/update-agent-infra.toml`);
-    // update OpenCode command
-    renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
-    ok('Updated .opencode/commands/update-agent-infra.md');
+    // update Claude command (only if enabled)
+    if (enabledTUIs.has('claude-code')) {
+        renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Updated .claude/commands/update-agent-infra.md');
+    }
+    // update Gemini command (only if enabled)
+    if (enabledTUIs.has('gemini-cli')) {
+        renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
+        ok(`Updated .gemini/commands/${project}/update-agent-infra.toml`);
+    }
+    // update OpenCode command (only if enabled)
+    if (enabledTUIs.has('opencode')) {
+        renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
+        ok('Updated .opencode/commands/update-agent-infra.md');
+    }
     // sync file registry
-    const { added, changed } = syncFileRegistry(config, platformType);
+    const { added, changed } = syncFileRegistry(config, platformType, enabledTUIs);
     const hasNewEntries = added.managed.length > 0 || added.merged.length > 0;
     const platformAdded = !config.platform;
     const sandboxAdded = !config.sandbox;
+    const taskAdded = !config.task;
     const labelsAdded = !config.labels;
+    const requiresPullRequestAdded = config.requiresPullRequest === undefined;
     let configChanged = changed;
     if (platformAdded) {
         config.platform = structuredClone(defaults.platform);
@@ -130,10 +144,18 @@ async function cmdUpdate() {
         config.sandbox = structuredClone(defaults.sandbox);
         configChanged = true;
     }
+    if (taskAdded) {
+        config.task = structuredClone(defaults.task);
+        configChanged = true;
+    }
     if (labelsAdded) {
         config.labels = structuredClone(defaults.labels);
         configChanged = true;
     }
+    if (requiresPullRequestAdded) {
+        config.requiresPullRequest = defaults.requiresPullRequest;
+        configChanged = true;
+    }
     if (configChanged) {
         console.log('');
         if (hasNewEntries) {
@@ -145,16 +167,22 @@ async function cmdUpdate() {
                 ok(`  merged: ${entry}`);
             }
         }
-        else if (platformAdded || sandboxAdded || labelsAdded) {
+        else if (platformAdded || sandboxAdded || taskAdded || labelsAdded || requiresPullRequestAdded) {
             if (platformAdded) {
                 info(`Default platform config added to ${CONFIG_PATH}.`);
             }
             if (sandboxAdded) {
                 info(`Default sandbox config added to ${CONFIG_PATH}.`);
             }
+            if (taskAdded) {
+                info(`Default task.shortIdLength=${defaults.task.shortIdLength} added to ${CONFIG_PATH}.`);
+            }
             if (labelsAdded) {
                 info(`Default labels.in config added to ${CONFIG_PATH}.`);
             }
+            if (requiresPullRequestAdded) {
+                info(`Default requiresPullRequest=${defaults.requiresPullRequest} added to ${CONFIG_PATH}.`);
+            }
         }
         else {
             info(`File registry changed in ${CONFIG_PATH}.`);
@@ -162,12 +190,18 @@ async function cmdUpdate() {
         if (hasNewEntries && sandboxAdded) {
             info(`Default sandbox config added to ${CONFIG_PATH}.`);
         }
+        if (hasNewEntries && taskAdded) {
+            info(`Default task.shortIdLength=${defaults.task.shortIdLength} added to ${CONFIG_PATH}.`);
+        }
         if (hasNewEntries && labelsAdded) {
             info(`Default labels.in config added to ${CONFIG_PATH}.`);
         }
         if (hasNewEntries && platformAdded) {
             info(`Default platform config added to ${CONFIG_PATH}.`);
         }
+        if (hasNewEntries && requiresPullRequestAdded) {
+            info(`Default requiresPullRequest=${defaults.requiresPullRequest} added to ${CONFIG_PATH}.`);
+        }
         fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
         ok(`Updated ${CONFIG_PATH}`);
     }
@@ -175,12 +209,30 @@ async function cmdUpdate() {
     console.log('');
     ok('Seed files updated successfully!');
     console.log('');
-    console.log('  Next step: run the full update in your AI TUI:');
-    console.log('');
-    console.log('    Claude Code / OpenCode:  /update-agent-infra');
-    console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
-    console.log('    Codex CLI:               $update-agent-infra');
-    console.log('');
+    if (enabledTUIs.size === 0) {
+        console.log('  No built-in TUI enabled (tuis: []).');
+        console.log(`  Configure "customTUIs" in ${CONFIG_PATH} if needed.`);
+        console.log('');
+    }
+    else {
+        console.log('  Next step: run the full update in your AI TUI:');
+        console.log('');
+        const claudeOrOpencode = [];
+        if (enabledTUIs.has('claude-code'))
+            claudeOrOpencode.push('Claude Code');
+        if (enabledTUIs.has('opencode'))
+            claudeOrOpencode.push('OpenCode');
+        if (claudeOrOpencode.length > 0) {
+            console.log(`    ${claudeOrOpencode.join(' / ')}:  /update-agent-infra`);
+        }
+        if (enabledTUIs.has('gemini-cli')) {
+            console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
+        }
+        if (enabledTUIs.has('codex')) {
+            console.log('    Codex CLI:               $update-agent-infra');
+        }
+        console.log('');
+    }
 }
 export { cmdUpdate };
 //# sourceMappingURL=update.js.map

package/lib/builtin-tuis.ts

@@ -0,0 +1,55 @@
+const BUILTIN_TUI_IDS = ['claude-code', 'codex', 'gemini-cli', 'opencode'] as const;
+type BuiltinTUIId = (typeof BUILTIN_TUI_IDS)[number];
+
+const BUILTIN_TUI_DISPLAY: Record<BuiltinTUIId, string> = {
+  'claude-code': 'Claude Code',
+  'codex': 'Codex',
+  'gemini-cli': 'Gemini CLI',
+  'opencode': 'OpenCode'
+};
+
+const BUILTIN_TUI_OWNED_PATH_PREFIXES: Record<BuiltinTUIId, string[]> = {
+  'claude-code': ['.claude/'],
+  'codex': ['.codex/'],
+  'gemini-cli': ['.gemini/'],
+  'opencode': ['.opencode/']
+};
+
+function isBuiltinTUIId(value: unknown): value is BuiltinTUIId {
+  return typeof value === 'string' && (BUILTIN_TUI_IDS as readonly string[]).includes(value);
+}
+
+function resolveEnabledTUIs(value: unknown): Set<BuiltinTUIId> {
+  // Missing field / null / non-array → full set (backward compat for legacy
+  // .airc.json predating the `tuis` field).
+  if (!Array.isArray(value)) return new Set(BUILTIN_TUI_IDS);
+  // Empty array is a meaningful, user-set value: "no built-in TUI managed".
+  // This supports the customTUI-only project layout.
+  const set = new Set<BuiltinTUIId>();
+  for (const v of value) {
+    if (isBuiltinTUIId(v)) set.add(v);
+  }
+  return set;
+}
+
+function isPathOwnedByDisabledTUI(rel: string, enabled: Set<BuiltinTUIId>): boolean {
+  const normalized = String(rel || '').replace(/\\/g, '/').replace(/^\.\//, '');
+  for (const tui of BUILTIN_TUI_IDS) {
+    if (enabled.has(tui)) continue;
+    for (const prefix of BUILTIN_TUI_OWNED_PATH_PREFIXES[tui]) {
+      const trimmed = prefix.replace(/\/$/, '');
+      if (normalized === trimmed || normalized.startsWith(prefix)) return true;
+    }
+  }
+  return false;
+}
+
+export {
+  BUILTIN_TUI_IDS,
+  BUILTIN_TUI_DISPLAY,
+  BUILTIN_TUI_OWNED_PATH_PREFIXES,
+  isBuiltinTUIId,
+  resolveEnabledTUIs,
+  isPathOwnedByDisabledTUI
+};
+export type { BuiltinTUIId };

package/lib/defaults.json

@@ -2,6 +2,7 @@
   "platform": {
     "type": "github"
   },
+  "requiresPullRequest": true,
   "sandbox": {
     "engine": null,
     "runtimes": [
@@ -20,6 +21,9 @@
       "disk": null
     }
   },
+  "task": {
+    "shortIdLength": 2
+  },
   "labels": {
     "in": {}
   },