@fitlab-ai/agent-infra 0.5.10 → 0.6.0

package/lib/sandbox/{index.js → index.ts}

@@ -11,7 +11,7 @@ Commands:
 
 Run 'ai sandbox <command> --help' for details.`;
 
-export async function runSandbox(args) {
+export async function runSandbox(args: string[]): Promise<void> {
   const [subcommand, ...rest] = args;
 
   if (!subcommand) {
@@ -27,12 +27,12 @@ export async function runSandbox(args) {
 
   switch (subcommand) {
     case 'create': {
-      const { create } = await import('./commands/create.js');
+      const { create } = await import('./commands/create.ts');
       await create(rest);
       break;
     }
     case 'exec': {
-      const { enter } = await import('./commands/enter.js');
+      const { enter } = await import('./commands/enter.ts');
       const exitCode = enter(rest);
       if (typeof exitCode === 'number' && exitCode !== 0) {
         process.exitCode = exitCode;
@@ -40,7 +40,7 @@ export async function runSandbox(args) {
       break;
     }
     case 'refresh': {
-      const { refresh } = await import('./commands/refresh.js');
+      const { refresh } = await import('./commands/refresh.ts');
       const exitCode = await refresh(rest);
       if (typeof exitCode === 'number' && exitCode !== 0) {
         process.exitCode = exitCode;
@@ -48,22 +48,22 @@ export async function runSandbox(args) {
       break;
     }
     case 'ls': {
-      const { ls } = await import('./commands/ls.js');
+      const { ls } = await import('./commands/ls.ts');
       ls(rest);
       break;
     }
     case 'rm': {
-      const { rm } = await import('./commands/rm.js');
+      const { rm } = await import('./commands/rm.ts');
       await rm(rest);
       break;
     }
     case 'vm': {
-      const { vm } = await import('./commands/vm.js');
+      const { vm } = await import('./commands/vm.ts');
       await vm(rest);
       break;
     }
     case 'rebuild': {
-      const { rebuild } = await import('./commands/rebuild.js');
+      const { rebuild } = await import('./commands/rebuild.ts');
       await rebuild(rest);
       break;
     }

package/lib/sandbox/{shell.js → shell.ts}

@@ -1,10 +1,23 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
+import type { ExecFileSyncOptions, StdioOptions, SpawnSyncOptions, SpawnSyncReturns } from 'node:child_process';
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;
 
-function normalizeOptions(opts = {}, stdio) {
+type CommandOptions = {
+  cwd?: string;
+  encoding?: BufferEncoding;
+  stdio?: StdioOptions;
+  timeout?: number;
+  shell?: boolean;
+};
+
+type RunProbeOptions = CommandOptions & {
+  spawnFn?: typeof spawnSync;
+};
+
+function normalizeOptions(opts: CommandOptions = {}, stdio: StdioOptions): CommandOptions {
   return {
     cwd: opts.cwd,
     encoding: opts.encoding,
@@ -13,7 +26,7 @@ function normalizeOptions(opts = {}, stdio) {
   };
 }
 
-function resolveCommand(cmd) {
+function resolveCommand(cmd: string): string {
   if (process.platform !== 'win32' || path.extname(cmd)) {
     return cmd;
   }
@@ -39,14 +52,14 @@ function resolveCommand(cmd) {
   return cmd;
 }
 
-function commandOptions(cmd, opts) {
+function commandOptions<T extends CommandOptions>(cmd: string, opts: T): T | (T & { shell: true }) {
   if (process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(cmd)) {
     return { ...opts, shell: true };
   }
   return opts;
 }
 
-export function run(cmd, args, opts = {}) {
+export function run(cmd: string, args: string[], opts: CommandOptions = {}): string {
   const resolved = resolveCommand(cmd);
   return execFileSync(resolved, args, commandOptions(resolved, {
     ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
@@ -54,13 +67,13 @@ export function run(cmd, args, opts = {}) {
   })).trim();
 }
 
-export function runOk(cmd, args, opts = {}) {
+export function runOk(cmd: string, args: string[], opts: CommandOptions = {}): boolean {
   const resolved = resolveCommand(cmd);
   const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'pipe')));
   return result.status === 0;
 }
 
-export function restoreTerminal() {
+export function restoreTerminal(): void {
   if (!process.stdout.isTTY) {
     return;
   }
@@ -90,7 +103,7 @@ export function restoreTerminal() {
   }
 }
 
-export function runInteractive(cmd, args, opts = {}) {
+export function runInteractive(cmd: string, args: string[], opts: CommandOptions = {}): number {
   const resolved = resolveCommand(cmd);
   try {
     const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
@@ -100,7 +113,7 @@ export function runInteractive(cmd, args, opts = {}) {
   }
 }
 
-export function runVerbose(cmd, args, opts = {}) {
+export function runVerbose(cmd: string, args: string[], opts: CommandOptions = {}): void {
   const resolved = resolveCommand(cmd);
   const result = spawnSync(resolved, args, commandOptions(resolved, normalizeOptions(opts, 'inherit')));
 
@@ -112,7 +125,7 @@ export function runVerbose(cmd, args, opts = {}) {
   }
 }
 
-export function runSafe(cmd, args, opts = {}) {
+export function runSafe(cmd: string, args: string[], opts: CommandOptions = {}): string {
   const resolved = resolveCommand(cmd);
   const result = spawnSync(resolved, args, commandOptions(resolved, {
     ...normalizeOptions(opts, ['pipe', 'pipe', 'pipe']),
@@ -124,7 +137,7 @@ export function runSafe(cmd, args, opts = {}) {
   return (result.stdout ?? '').trim();
 }
 
-export function commandForEngine(engine, cmd, args = []) {
+export function commandForEngine(engine: string, cmd: string, args: string[] = []): { cmd: string; args: string[] } {
   if (engine === 'wsl2') {
     const resolvedWrapper = resolveCommand('wsl.exe');
     return { cmd: resolvedWrapper, args: ['--', cmd, ...args] };
@@ -133,37 +146,37 @@ export function commandForEngine(engine, cmd, args = []) {
   return { cmd, args };
 }
 
-export function runEngine(engine, cmd, args, opts = {}) {
+export function runEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): string {
   const command = commandForEngine(engine, cmd, args);
   return run(command.cmd, command.args, opts);
 }
 
-export function execEngine(engine, cmd, args, opts = {}) {
+export function execEngine(engine: string, cmd: string, args: string[], opts: ExecFileSyncOptions = {}) {
   const command = commandForEngine(engine, cmd, args);
   return execFileSync(command.cmd, command.args, opts);
 }
 
-export function runOkEngine(engine, cmd, args, opts = {}) {
+export function runOkEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): boolean {
   const command = commandForEngine(engine, cmd, args);
   return runOk(command.cmd, command.args, opts);
 }
 
-export function runSafeEngine(engine, cmd, args, opts = {}) {
+export function runSafeEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): string {
   const command = commandForEngine(engine, cmd, args);
   return runSafe(command.cmd, command.args, opts);
 }
 
-export function runVerboseEngine(engine, cmd, args, opts = {}) {
+export function runVerboseEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): void {
   const command = commandForEngine(engine, cmd, args);
   return runVerbose(command.cmd, command.args, opts);
 }
 
-export function runInteractiveEngine(engine, cmd, args, opts = {}) {
+export function runInteractiveEngine(engine: string, cmd: string, args: string[], opts: CommandOptions = {}): number {
   const command = commandForEngine(engine, cmd, args);
   return runInteractive(command.cmd, command.args, opts);
 }
 
-export function runProbe(cmd, args, opts = {}) {
+export function runProbe(cmd: string, args: string[], opts: RunProbeOptions = {}): SpawnSyncReturns<string | Buffer> {
   const { spawnFn = spawnSync, ...commandOpts } = opts;
   const resolved = resolveCommand(cmd);
   return spawnFn(resolved, args, commandOptions(resolved, normalizeOptions(

package/lib/sandbox/{task-resolver.js → task-resolver.ts}

@@ -4,11 +4,11 @@ import path from 'node:path';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
 const WORKSPACE_DIRS = ['active', 'completed', 'blocked', 'archive'];
 
-function stripQuotes(value) {
+function stripQuotes(value: string): string {
   return value.replace(/^(["'])(.*)\1$/, '$2');
 }
 
-function readTaskContent(repoRoot, taskId) {
+function readTaskContent(repoRoot: string, taskId: string): string {
   for (const dir of WORKSPACE_DIRS) {
     const taskPath = path.join(repoRoot, '.agents', 'workspace', dir, taskId, 'task.md');
     if (fs.existsSync(taskPath)) {
@@ -18,21 +18,21 @@ function readTaskContent(repoRoot, taskId) {
   throw new Error(`Task not found: ${taskId}`);
 }
 
-function resolveBranchFromTaskContent(content, taskId) {
+function resolveBranchFromTaskContent(content: string, taskId: string): string {
   const frontmatterBranch = content.match(/^branch:\s*(.+)$/m);
-  if (frontmatterBranch && frontmatterBranch[1].trim()) {
+  if (frontmatterBranch?.[1]?.trim()) {
     return stripQuotes(frontmatterBranch[1].trim());
   }
 
   const contextBranch = content.match(/^- \*\*(?:分支|Branch)\*\*：[ \t]*`?([^`\n]+)`?$/m);
-  if (contextBranch && contextBranch[1].trim()) {
+  if (contextBranch?.[1]?.trim()) {
     return stripQuotes(contextBranch[1].trim());
   }
 
   throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
 
-export function resolveTaskBranch(arg, repoRoot) {
+export function resolveTaskBranch(arg: string, repoRoot: string): string {
   if (!TASK_ID_RE.test(arg)) {
     return arg;
   }

package/lib/sandbox/{tools.js → tools.ts}

@@ -1,25 +1,29 @@
-import { safeNameCandidates, sanitizeBranchName } from './constants.js';
-import { hostJoin } from './engines/wsl2-paths.js';
+import { safeNameCandidates, sanitizeBranchName } from './constants.ts';
+import { hostJoin } from './engines/wsl2-paths.ts';
 
-/**
- * @typedef {Object} SandboxTool
- * @property {string} id
- * @property {string} name
- * @property {string} npmPackage
- * @property {string} sandboxBase
- * @property {string} containerMount
- * @property {string} versionCmd
- * @property {string} setupHint
- * @property {Record<string, string>=} envVars
- * @property {Array<{ hostPath: string, sandboxName: string }>=} hostPreSeedFiles
- * @property {Array<{ hostDir: string, sandboxSubdir: string }>=} hostPreSeedDirs
- * @property {string[]=} pathRewriteFiles
- * @property {Array<{ hostPath: string, containerSubpath: string }>=} hostLiveMounts
- * @property {string[]=} postSetupCmds
- */
+export type SandboxTool = {
+  id: string;
+  name: string;
+  npmPackage: string;
+  sandboxBase: string;
+  containerMount: string;
+  versionCmd: string;
+  setupHint: string;
+  envVars?: Record<string, string>;
+  hostPreSeedFiles?: Array<{ hostPath: string; sandboxName: string }>;
+  hostPreSeedDirs?: Array<{ hostDir: string; sandboxSubdir: string }>;
+  pathRewriteFiles?: string[];
+  hostLiveMounts?: Array<{ hostPath: string; containerSubpath: string }>;
+  postSetupCmds?: string[];
+};
 
-function createBuiltinTools(home, project) {
-  /** @type {Record<string, SandboxTool>} */
+type ToolsConfig = {
+  home: string;
+  project: string;
+  tools: string[];
+};
+
+function createBuiltinTools(home: string, project: string): Record<string, SandboxTool> {
   return {
     'claude-code': {
       id: 'claude-code',
@@ -104,13 +108,13 @@ function createBuiltinTools(home, project) {
   };
 }
 
-function validateTool(tool) {
+function validateTool(tool: SandboxTool): void {
   if (!tool.npmPackage || !tool.containerMount.startsWith('/')) {
     throw new Error(`Invalid sandbox tool descriptor: ${tool.id}`);
   }
 }
 
-export function resolveTools(config) {
+export function resolveTools(config: ToolsConfig): SandboxTool[] {
   const builtins = createBuiltinTools(config.home, config.project);
   return config.tools.map((id) => {
     const tool = builtins[id];
@@ -122,18 +126,18 @@ export function resolveTools(config) {
   });
 }
 
-export function toolConfigDir(tool, project, branch) {
+export function toolConfigDir(tool: SandboxTool, project: string, branch: string): string {
   return hostJoin(tool.sandboxBase, project, sanitizeBranchName(branch));
 }
 
-export function toolConfigDirCandidates(tool, project, branch) {
+export function toolConfigDirCandidates(tool: SandboxTool, project: string, branch: string): string[] {
   return safeNameCandidates(branch).map((name) => hostJoin(tool.sandboxBase, project, name));
 }
 
-export function toolProjectDirCandidates(tool, project) {
+export function toolProjectDirCandidates(tool: SandboxTool, project: string): string[] {
   return [hostJoin(tool.sandboxBase, project)];
 }
 
-export function toolNpmPackagesArg(tools) {
+export function toolNpmPackagesArg(tools: SandboxTool[]): string {
   return tools.map((tool) => tool.npmPackage).join(' ');
 }

package/lib/{update.js → update.ts}

@@ -1,18 +1,41 @@
 import fs from 'node:fs';
 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 { info, ok, err } from './log.ts';
+import { resolveTemplateDir } from './paths.ts';
+import { renderFile, copySkillDir, KNOWN_PLATFORMS } from './render.ts';
+
+type FileRegistry = {
+  managed: string[];
+  merged: string[];
+  ejected: string[];
+};
+
+type UpdateConfig = {
+  project: string;
+  org: string;
+  language: string;
+  platform?: { type?: string };
+  sandbox?: Record<string, unknown>;
+  labels?: Record<string, unknown>;
+  files?: Partial<FileRegistry>;
+};
+
+type Defaults = {
+  platform: { type: string };
+  sandbox: Record<string, unknown>;
+  labels: Record<string, unknown>;
+  files: FileRegistry;
+};
 
 const defaults = JSON.parse(
   fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8')
-);
+) as Defaults;
 
 const CONFIG_DIR = '.agents';
 const CONFIG_PATH = path.join(CONFIG_DIR, '.airc.json');
 
-function isPathOwnedByOtherPlatform(relativePath, platformType) {
-  const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0];
+function isPathOwnedByOtherPlatform(relativePath: string, platformType: string): boolean {
+  const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
   if (!top.startsWith('.')) return false;
 
   const candidate = top.slice(1);
@@ -20,7 +43,7 @@ function isPathOwnedByOtherPlatform(relativePath, platformType) {
   return candidate !== platformType;
 }
 
-function syncFileRegistry(config, platformType) {
+function syncFileRegistry(config: UpdateConfig, platformType: string) {
   config.files ||= {};
   const before = JSON.stringify({
     files: {
@@ -38,7 +61,7 @@ function syncFileRegistry(config, platformType) {
     ...config.files.merged,
     ...config.files.ejected
   ];
-  const added = { managed: [], merged: [] };
+  const added: Pick<FileRegistry, 'managed' | 'merged'> = { managed: [], merged: [] };
 
   for (const entry of defaults.files.managed) {
     if (isPathOwnedByOtherPlatform(entry, platformType)) continue;
@@ -66,7 +89,7 @@ function syncFileRegistry(config, platformType) {
   return { added, changed: before !== after };
 }
 
-async function cmdUpdate() {
+async function cmdUpdate(): Promise<void> {
   console.log('');
   console.log('  agent-infra update');
   console.log('  ==================================');
@@ -90,7 +113,7 @@ async function cmdUpdate() {
   }
 
   // read project config
-  const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8')) as UpdateConfig;
   const { project, org, language } = config;
   const platformType = config.platform?.type || defaults.platform.type;
   const replacements = { project, org };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fitlab-ai/agent-infra",
-  "version": "0.5.10",
+  "version": "0.6.0",
   "description": "Bootstrap tool for AI multi-tool collaboration infrastructure — works with Claude Code, Codex, Gemini CLI, and OpenCode",
   "license": "MIT",
   "type": "module",
@@ -18,11 +18,13 @@
     "registry": "https://registry.npmjs.org/"
   },
   "bin": {
-    "agent-infra": "./bin/cli.js",
-    "ai": "./bin/cli.js"
+    "agent-infra": "./dist/bin/cli.js",
+    "ai": "./dist/bin/cli.js"
   },
   "files": [
-    "bin/cli.js",
+    "dist/",
+    "!dist/**/*.map",
+    "bin/cli.ts",
     "lib/",
     "templates/"
   ],
@@ -47,12 +49,18 @@
     "smol-toml": "^1.6.1"
   },
   "scripts": {
-    "build": "node scripts/build-inline.js",
+    "build": "tsc -p tsconfig.json && node scripts/build.js && node scripts/build-inline.js",
     "demo:regen": "sh scripts/demo-regen.sh",
     "prepare": "git config core.hooksPath .git-hooks || true",
-    "test:smoke": "node scripts/build-inline.js --check && node --test tests/templates/*.test.js tests/core/airc.test.js tests/core/release.test.js tests/core/metadata-sync-workflow.test.js tests/core/pr-label-workflow.test.js tests/core/status-label-workflow.test.js tests/core/test-tier-coverage.test.js tests/cli/lib.test.js tests/cli/sync-templates.test.js tests/scripts/sync-templates-platform-gating.test.js",
-    "test:core": "node scripts/build-inline.js --check && node --test tests/templates/*.test.js tests/core/airc.test.js tests/core/release.test.js tests/core/metadata-sync-workflow.test.js tests/core/pr-label-workflow.test.js tests/core/status-label-workflow.test.js tests/core/test-tier-coverage.test.js tests/cli/lib.test.js tests/cli/sync-templates.test.js tests/scripts/sync-templates-platform-gating.test.js tests/cli/cli.test.js tests/cli/merge.test.js tests/cli/sandbox.test.js tests/core/custom-skills.test.js tests/core/custom-tuis.test.js tests/core/demo-regen.test.js tests/scripts/find-existing-task.test.js tests/scripts/platform-adapter-defaults.test.js",
-    "test": "node scripts/build-inline.js --check && node --test tests/cli/*.test.js tests/templates/*.test.js tests/core/*.test.js tests/scripts/*.test.js",
-    "prepublishOnly": "node scripts/build-inline.js --check && node --test tests/cli/*.test.js tests/templates/*.test.js tests/core/*.test.js tests/scripts/*.test.js"
+    "typecheck": "tsc -p tsconfig.test.json --noEmit && tsc -p tsconfig.jschecks.json --noEmit",
+    "test:smoke": "npm run build && node --experimental-strip-types --no-warnings --test tests/templates/*.test.ts tests/core/airc.test.ts tests/core/release.test.ts tests/core/metadata-sync-workflow.test.ts tests/core/pr-label-workflow.test.ts tests/core/status-label-workflow.test.ts tests/core/test-tier-coverage.test.ts tests/cli/lib.test.ts tests/cli/sync-templates.test.ts tests/scripts/sync-templates-platform-gating.test.ts",
+    "test:core": "npm run build && node --experimental-strip-types --no-warnings --test tests/templates/*.test.ts tests/core/airc.test.ts tests/core/release.test.ts tests/core/metadata-sync-workflow.test.ts tests/core/pr-label-workflow.test.ts tests/core/status-label-workflow.test.ts tests/core/test-tier-coverage.test.ts tests/cli/lib.test.ts tests/cli/sync-templates.test.ts tests/scripts/sync-templates-platform-gating.test.ts tests/cli/cli.test.ts tests/cli/merge.test.ts tests/cli/sandbox.test.ts tests/core/custom-skills.test.ts tests/core/custom-tuis.test.ts tests/core/demo-regen.test.ts tests/scripts/find-existing-task.test.ts tests/scripts/platform-adapter-defaults.test.ts",
+    "test": "npm run build && node --experimental-strip-types --no-warnings --test tests/cli/*.test.ts tests/templates/*.test.ts tests/core/*.test.ts tests/scripts/*.test.ts",
+    "prepublishOnly": "npm run build && node --experimental-strip-types --no-warnings --test tests/cli/*.test.ts tests/templates/*.test.ts tests/core/*.test.ts tests/scripts/*.test.ts"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.19.19",
+    "typescript": "~5.9"
   }
 }

package/lib/paths.js

@@ -1,9 +0,0 @@
-import fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-function resolveTemplateDir() {
-  const bundledDir = fileURLToPath(new URL('../templates', import.meta.url));
-  return fs.existsSync(bundledDir) ? bundledDir : null;
-}
-
-export { resolveTemplateDir };

package/lib/sandbox/engines/index.js

@@ -1,27 +0,0 @@
-import { colimaAdapter } from './colima.js';
-import { dockerDesktopAdapter } from './docker-desktop.js';
-import { nativeAdapter } from './native.js';
-import { orbstackAdapter } from './orbstack.js';
-import { wsl2Adapter } from './wsl2.js';
-
-export const ADAPTERS = Object.freeze({
-  colima: colimaAdapter,
-  orbstack: orbstackAdapter,
-  'docker-desktop': dockerDesktopAdapter,
-  native: nativeAdapter,
-  wsl2: wsl2Adapter
-});
-
-export function getAdapter(engineId) {
-  const adapter = ADAPTERS[engineId];
-  if (!adapter) {
-    throw new Error(`No adapter registered for engine '${engineId}'`);
-  }
-  return adapter;
-}
-
-export function enginesForPlatform(platformName) {
-  return Object.values(ADAPTERS)
-    .filter((adapter) => adapter.supportedPlatforms.includes(platformName))
-    .map((adapter) => adapter.id);
-}