@fitlab-ai/agent-infra 0.7.5 → 0.7.7

package/dist/lib/task/issue-form.js

@@ -0,0 +1,66 @@
+import { parse } from 'yaml';
+// Field id -> task value mapping (single source of truth, per HD-1).
+// Only ids that map cleanly to title / description / requirements get a value;
+// every other text field gets `N/A`. This deliberately tightens the older
+// "suggested" mapping table (impact / context / alternatives / steps / expected
+// no longer flow into requirements) so the requirements checklist is never
+// pushed into an unrelated field.
+const TITLE_IDS = new Set(['summary', 'title']);
+const DESCRIPTION_IDS = new Set([
+    'description',
+    'problem',
+    'what-happened',
+    'question',
+    'current-content',
+    'issue-description',
+    'detailed-description'
+]);
+const REQUIREMENTS_IDS = new Set(['requirements', 'solution', 'suggested-content']);
+// Only free-text field types carry task content; structural / static fields are skipped.
+const TEXT_FIELD_TYPES = new Set(['input', 'textarea']);
+const PLACEHOLDER = 'N/A';
+function mapFieldValue(id, fields) {
+    if (TITLE_IDS.has(id))
+        return fields.title;
+    if (DESCRIPTION_IDS.has(id))
+        return fields.description;
+    if (REQUIREMENTS_IDS.has(id))
+        return fields.requirements;
+    return '';
+}
+/**
+ * Render the final Issue body for a GitHub Issue Form (scenario A).
+ *
+ * Walks the form's `body[]` in order, skips `markdown` / `dropdown` /
+ * `checkboxes`, and renders each `input` / `textarea` as `### {label}` followed
+ * by the deterministically-mapped task value (or `N/A` when the field has no
+ * reliable source). The template structure is preserved; the whole task.md and
+ * its scaffolding sections are never emitted.
+ *
+ * Throws on unreadable / non-object YAML or a missing `body[]` list so the
+ * caller can fall back to the default body.
+ */
+function renderTemplateBody(formText, fields) {
+    const doc = parse(formText);
+    if (!doc || typeof doc !== 'object' || !Array.isArray(doc.body)) {
+        throw new Error('Issue Form has no body[] list');
+    }
+    const sections = [];
+    for (const raw of doc.body) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const type = typeof raw.type === 'string' ? raw.type : '';
+        if (!TEXT_FIELD_TYPES.has(type))
+            continue;
+        const label = typeof raw.attributes?.label === 'string' ? raw.attributes.label.trim() : '';
+        if (!label)
+            continue;
+        const id = typeof raw.id === 'string' ? raw.id : '';
+        const mapped = mapFieldValue(id, fields);
+        const value = mapped.trim() === '' ? PLACEHOLDER : mapped;
+        sections.push(`### ${label}\n\n${value}`);
+    }
+    return `${sections.join('\n\n')}\n`;
+}
+export { renderTemplateBody, mapFieldValue, PLACEHOLDER };
+//# sourceMappingURL=issue-form.js.map

package/dist/lib/task/sections.js

@@ -0,0 +1,44 @@
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Return the body of the first `## {alias}` section (any alias matches), from
+ * the heading line to the next `## ` heading or EOF. Lines are preserved
+ * verbatim (checkbox text is never normalized); only leading/trailing blank
+ * lines are trimmed. Returns '' when no alias heading is present.
+ */
+function extractSection(content, aliases) {
+    const lines = content.split('\n');
+    let start = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i].trim();
+        if (aliases.some((alias) => new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`).test(line))) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start === -1)
+        return '';
+    let end = lines.length;
+    for (let i = start; i < lines.length; i += 1) {
+        if (/^##\s+/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    return lines.slice(start, end).join('\n').replace(/^\n+/, '').replace(/\n+$/, '');
+}
+/**
+ * Return the heading alias that actually appears as a `## {alias}` line, so a
+ * rendered section can mirror the source language. Falls back to the first
+ * alias when none is present.
+ */
+function findSectionHeading(content, aliases) {
+    for (const alias of aliases) {
+        if (new RegExp(`^##\\s+${escapeRegExp(alias)}\\s*$`, 'm').test(content))
+            return alias;
+    }
+    return aliases[0];
+}
+export { extractSection, findSectionHeading };
+//# sourceMappingURL=sections.js.map

package/lib/sandbox/commands/create.ts

@@ -1084,6 +1084,13 @@ function runEngineTaskCommand(engine: string, cmd: string, args: string[], opts:
   return runTaskCommand(command.cmd, command.args, opts);
 }
 
+// `docker run` args for mounting a tool's containerMount as an in-container
+// tmpfs. containerMount is an in-container path, so it is NOT engine-converted.
+export function buildTmpfsRunArgs(containerMount: string, tmpfs: { size?: string }): string[] {
+  const size = tmpfs.size ?? '512m';
+  return ['--tmpfs', `${containerMount}:rw,size=${size}`];
+}
+
 export function buildImage(
   config: Pick<SandboxCreateConfig, 'project' | 'imageName' | 'repoRoot'> & { engine?: string | null },
   tools: SandboxTool[],
@@ -1397,10 +1404,12 @@ export async function create(args: string[]): Promise<void> {
               // The TUI reads <toolDir>/opencode.json via OPENCODE_CONFIG pinned in tools.js.
               ensureOpenCodeModelInheritance(opencodeEntry.dir, effectiveConfig.home);
             }
-            const toolVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) => [
-              '-v',
-              volumeArg(engine, dir, tool.containerMount)
-            ]);
+            const toolVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) =>
+              tool.tmpfs ? [] : ['-v', volumeArg(engine, dir, tool.containerMount)]
+            );
+            const tmpfsArgs = effectiveResolvedTools.flatMap(({ tool }) =>
+              tool.tmpfs ? buildTmpfsRunArgs(tool.containerMount, tool.tmpfs) : []
+            );
             const workspaceDir = path.join(effectiveConfig.repoRoot, '.agents', 'workspace');
             hostShellConfig = prepareHostShellConfig({
               home: effectiveConfig.home,
@@ -1412,6 +1421,24 @@ export async function create(args: string[]): Promise<void> {
               '-v',
               volumeArg(engine, hostPath, containerPath, ':ro')
             ]);
+            // A tmpfs containerMount starts empty, so the config seeded into the
+            // host dir before launch would be invisible in-container. Bind only
+            // the explicitly declared seed entries (config.toml, model-catalogs)
+            // back over the tmpfs as nested mounts — the same proven mechanism as
+            // hostLiveMounts/auth.json, established at `docker run` time (no
+            // post-start `docker cp`, which can land under a freshly-mounted
+            // tmpfs instead of inside it). The allowlist is deliberate: any
+            // runtime files left in the host dir (e.g. a stale logs_2.sqlite or
+            // sessions/ from a previous bind-mount era) must NOT be re-mounted,
+            // or the high-churn writes would land on the host SSD again.
+            const tmpfsSeedVolumes = effectiveResolvedTools.flatMap(({ tool, dir }) =>
+              (tool.tmpfs?.seed ?? []).flatMap((entry) => {
+                const hostPath = path.join(dir, entry);
+                return fs.existsSync(hostPath)
+                  ? ['-v', volumeArg(engine, hostPath, path.posix.join(tool.containerMount, entry))]
+                  : [];
+              })
+            );
             const liveMountVolumes = effectiveResolvedTools.flatMap(({ tool }) =>
               (tool.hostLiveMounts ?? [])
                 .filter(({ hostPath }) => fs.existsSync(hostPath))
@@ -1466,6 +1493,8 @@ export async function create(args: string[]): Promise<void> {
               volumeArg(engine, hostJoin(effectiveConfig.home, '.ssh'), '/home/devuser/.ssh', ':ro'),
               ...dotfilesMount,
               ...toolVolumes,
+              ...tmpfsArgs,
+              ...tmpfsSeedVolumes,
               ...liveMountVolumes,
               ...shellConfigVolumes,
               ...envFile.dockerArgs,

package/lib/sandbox/commands/ls.ts

@@ -1,11 +1,8 @@
-import fs from 'node:fs';
-import path from 'node:path';
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
 import { loadConfig } from '../config.ts';
 import { sandboxBranchLabel, sandboxLabel } from '../constants.ts';
 import { detectEngine } from '../engine.ts';
-import { resolveTools, toolProjectDirCandidates } from '../tools.ts';
 import { formatTable } from '../../table.ts';
 import { lookupShortIdByBranch } from '../../task/short-id.ts';
 import { fetchSandboxRows } from './list-running.ts';
@@ -20,7 +17,10 @@ id bound to each container's branch (via
 .agents/workspace/active/.short-ids.json), or '-' if no active task is
 bound. Pass the SHORT value to "ai sandbox exec" (e.g. 'ai sandbox exec 11').
 A '-' means no active task is bound to that branch, so the sandbox is free
-to remove with "ai sandbox rm <branch>".`;
+to remove with "ai sandbox rm <branch>".
+
+Use "ai sandbox show <ref>" for a single sandbox's worktree and per-tool
+state paths.`;
 
 const CONTAINER_TABLE_HEADERS = ['#', 'SHORT', 'NAMES', 'STATUS', 'BRANCH'] as const;
 
@@ -40,14 +40,6 @@ export function formatContainerTable(rows: ContainerTableRow[], zebra = false):
   );
 }
 
-function listChildren(dir: string): string[] {
-  if (!fs.existsSync(dir)) {
-    return [];
-  }
-
-  return fs.readdirSync(dir).sort().map((entry) => path.join(dir, entry));
-}
-
 export function ls(args: string[] = []): void {
   if (args.length > 0 && (args[0] === '--help' || args[0] === '-h')) {
     process.stdout.write(`${USAGE}\n`);
@@ -56,7 +48,6 @@ export function ls(args: string[] = []): void {
 
   const config = loadConfig();
   const engine = detectEngine(config);
-  const tools = resolveTools(config);
   const label = sandboxLabel(config);
   const { running, nonRunning } = fetchSandboxRows(engine, label, sandboxBranchLabel(config));
 
@@ -87,27 +78,4 @@ export function ls(args: string[] = []): void {
       );
     }
   }
-
-  p.log.step('Worktrees');
-  const worktrees = listChildren(config.worktreeBase);
-  if (worktrees.length === 0) {
-    p.log.warn('  No sandbox worktrees');
-  } else {
-    for (const worktree of worktrees) {
-      process.stdout.write(`  ${worktree}\n`);
-    }
-  }
-
-  for (const tool of tools) {
-    p.log.step(`${tool.name} state`);
-    const entries = toolProjectDirCandidates(tool, config.project)
-      .flatMap((dir) => listChildren(dir));
-    if (entries.length === 0) {
-      p.log.warn(`  No ${tool.name} sandbox state`);
-      continue;
-    }
-    for (const entry of entries) {
-      process.stdout.write(`  ${entry}\n`);
-    }
-  }
 }

package/lib/sandbox/commands/show.ts

@@ -0,0 +1,80 @@
+import fs from 'node:fs';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import type { SandboxConfig } from '../config.ts';
+import { loadConfig } from '../config.ts';
+import { assertValidBranchName, worktreeDirCandidates } from '../constants.ts';
+import { resolveBranchArg } from './list-running.ts';
+import { resolveTools, toolConfigDirCandidates } from '../tools.ts';
+
+const USAGE = `Usage: ai sandbox show <branch | TASK-id | N | '#N'>
+
+Shows one sandbox's worktree path and per-tool state paths (Claude Code,
+Codex, Gemini CLI, OpenCode). The argument follows the same contract as
+'ai sandbox exec' and 'ai sandbox start': N (bare) is the recommended form
+for task short ids (e.g. 'ai sandbox show 11'); '#N', a TASK-id, or a plain
+branch name are also accepted. Use 'ai sandbox ls' for the container list.`;
+
+export type SandboxDetail = {
+  worktrees: string[];
+  toolStates: { name: string; entries: string[] }[];
+};
+
+function existingDirs(candidates: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const candidate of candidates) {
+    if (!seen.has(candidate) && fs.existsSync(candidate)) {
+      seen.add(candidate);
+      result.push(candidate);
+    }
+  }
+  return result;
+}
+
+export function collectSandboxDetail(config: SandboxConfig, branch: string): SandboxDetail {
+  const worktrees = existingDirs(worktreeDirCandidates(config, branch));
+  const toolStates = resolveTools(config).map((tool) => ({
+    name: tool.name,
+    entries: existingDirs(toolConfigDirCandidates(tool, config.project, branch))
+  }));
+  return { worktrees, toolStates };
+}
+
+export function show(args: string[] = []): void {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(`${USAGE}\n`);
+    if (args.length === 0) {
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  const config = loadConfig();
+  const branch = resolveBranchArg(args[0]!, { repoRoot: config.repoRoot });
+  assertValidBranchName(branch);
+
+  const detail = collectSandboxDetail(config, branch);
+
+  p.intro(pc.cyan(`Sandbox detail for ${config.project} · ${branch}`));
+
+  p.log.step('Worktree');
+  if (detail.worktrees.length === 0) {
+    p.log.warn('  No worktree for this branch');
+  } else {
+    for (const worktree of detail.worktrees) {
+      process.stdout.write(`  ${worktree}\n`);
+    }
+  }
+
+  for (const tool of detail.toolStates) {
+    p.log.step(`${tool.name} state`);
+    if (tool.entries.length === 0) {
+      p.log.warn(`  No ${tool.name} sandbox state`);
+      continue;
+    }
+    for (const entry of tool.entries) {
+      process.stdout.write(`  ${entry}\n`);
+    }
+  }
+}

package/lib/sandbox/index.ts

@@ -9,6 +9,8 @@ Commands:
   ls                           List sandboxes for the current project (the '#'
                                column is a display-only row number; the 'SHORT'
                                column shows the active task short id, '-' if none)
+  show <branch | TASK-id | N | '#N'>
+                               Show one sandbox's worktree and per-tool state paths
   prune [--dry-run]            Remove orphaned per-branch state dirs
   rebuild [--quiet] [--refresh]
                                Rebuild the sandbox image (--refresh pulls base + tools)
@@ -56,6 +58,11 @@ export async function runSandbox(args: string[]): Promise<void> {
       ls(rest);
       break;
     }
+    case 'show': {
+      const { show } = await import('./commands/show.ts');
+      show(rest);
+      break;
+    }
     case 'prune': {
       const { prune } = await import('./commands/prune.ts');
       await prune(rest);

package/lib/sandbox/tools.ts

@@ -19,6 +19,13 @@ export type SandboxTool = {
   pathRewriteFiles?: string[];
   hostLiveMounts?: Array<{ hostPath: string; containerSubpath: string }>;
   postSetupCmds?: string[];
+  // When set, containerMount is mounted as an in-container tmpfs (RAM) instead
+  // of bind-mounting the host config dir, keeping high-churn tool logs off the
+  // host disk. `seed` lists the host-dir entries (relative to the tool's config
+  // dir) to bind back over the tmpfs so seeded config stays visible — it is an
+  // explicit allowlist so runtime files (e.g. logs_2.sqlite, sessions) left in
+  // the host dir are NOT re-mounted, which would defeat the tmpfs.
+  tmpfs?: { size?: string; seed?: string[] };
 };
 
 type ToolsConfig = {
@@ -70,6 +77,12 @@ function createBuiltinTools(home: string, project: string): Record<string, Sandb
       containerMount: '/home/devuser/.codex',
       versionCmd: 'codex --version',
       setupHint: 'Run codex once inside the container and choose Device Code login if needed.',
+      // codex churns ~/.codex/logs_2.sqlite heavily (upstream openai/codex#24275);
+      // a bind-mount would write-amplify onto the host SSD via virtiofs. Mount the
+      // codex home as tmpfs so those logs stay in RAM and die with the container.
+      // Only the seeded config (config.toml, model-catalogs) is bound back over
+      // the tmpfs; runtime files like logs_2.sqlite must stay in RAM.
+      tmpfs: { size: '512m', seed: ['config.toml', 'model-catalogs'] },
       hostLiveMounts: [
         { hostPath: hostJoin(home, '.codex', 'auth.json'), containerSubpath: 'auth.json' }
       ],
@@ -259,6 +272,19 @@ function parseHostLiveMounts(value: unknown, context: string): SandboxTool['host
   });
 }
 
+function parseTmpfs(value: unknown, context: string): SandboxTool['tmpfs'] {
+  if (value === undefined) {
+    return undefined;
+  }
+  if (!isPlainObject(value)) {
+    throw new Error(`${context}: field "tmpfs" must be an object when provided`);
+  }
+  return {
+    size: asOptionalNonEmptyString(value.size, 'tmpfs.size', context),
+    seed: asStringArray(value.seed, 'tmpfs.seed', context)
+  };
+}
+
 export function parseCustomTool(
   entry: unknown,
   index: number,
@@ -294,7 +320,8 @@ export function parseCustomTool(
     hostPreSeedDirs: parseHostPreSeedDirs(entry.hostPreSeedDirs, context),
     pathRewriteFiles: asStringArray(entry.pathRewriteFiles, 'pathRewriteFiles', context),
     hostLiveMounts: parseHostLiveMounts(entry.hostLiveMounts, context),
-    postSetupCmds: asStringArray(entry.postSetupCmds, 'postSetupCmds', context)
+    postSetupCmds: asStringArray(entry.postSetupCmds, 'postSetupCmds', context),
+    tmpfs: parseTmpfs(entry.tmpfs, context)
   };
 
   validateTool(tool);

package/lib/task/commands/issue-body.ts

@@ -0,0 +1,102 @@
+import fs from 'node:fs';
+import { resolveTaskRef } from '../resolve-ref.ts';
+import { extractTitle } from '../frontmatter.ts';
+import { extractSection, findSectionHeading } from '../sections.ts';
+import { renderTemplateBody, PLACEHOLDER } from '../issue-form.ts';
+import type { TaskFields } from '../issue-form.ts';
+
+const USAGE = `Usage: ai task issue-body <N | #N | TASK-id> [--template <path>]
+
+Print a deterministic Issue body extracted from a task's task.md.
+  <ref>               Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  --template <path>   Render the final body for the given GitHub Issue Form (scenario A);
+                      without it, print the default '描述 + 需求' body (scenario B).
+
+Only the task title, '## 描述' and '## 需求' sections are ever emitted; the rest of
+task.md (scaffolding sections, placeholders) is never written to the body.
+`;
+
+const DESCRIPTION_ALIASES = ['描述', 'Description'];
+const REQUIREMENTS_ALIASES = ['需求', 'Requirements'];
+
+/**
+ * Build the scenario B default body, mirroring whichever heading language the
+ * task.md actually uses, with empty sections falling back to `N/A`.
+ */
+function buildDefaultBody(content: string): string {
+  const descHeading = findSectionHeading(content, DESCRIPTION_ALIASES);
+  const reqHeading = findSectionHeading(content, REQUIREMENTS_ALIASES);
+  const description = extractSection(content, DESCRIPTION_ALIASES) || PLACEHOLDER;
+  const requirements = extractSection(content, REQUIREMENTS_ALIASES) || PLACEHOLDER;
+  return `## ${descHeading}\n\n${description}\n\n## ${reqHeading}\n\n${requirements}\n`;
+}
+
+function readTaskFields(content: string): TaskFields {
+  return {
+    title: extractTitle(content),
+    description: extractSection(content, DESCRIPTION_ALIASES),
+    requirements: extractSection(content, REQUIREMENTS_ALIASES)
+  };
+}
+
+function issueBody(args: string[] = []): void {
+  if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
+    process.stdout.write(USAGE);
+    if (args.length === 0) process.exitCode = 1;
+    return;
+  }
+
+  let ref: string | undefined;
+  let templatePath: string | undefined;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i]!;
+    if (arg === '--template') {
+      templatePath = args[i + 1];
+      i += 1;
+    } else if (ref === undefined) {
+      ref = arg;
+    }
+  }
+
+  if (!ref) {
+    process.stderr.write('ai task issue-body: missing task ref\n');
+    process.exitCode = 1;
+    return;
+  }
+  if (templatePath === undefined && args.includes('--template')) {
+    process.stderr.write('ai task issue-body: --template requires a path\n');
+    process.exitCode = 1;
+    return;
+  }
+
+  const resolved = resolveTaskRef(ref);
+  if (!resolved.ok) {
+    process.stderr.write(`ai task issue-body: ${resolved.message}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+
+  if (templatePath !== undefined) {
+    let formText: string;
+    try {
+      formText = fs.readFileSync(templatePath, 'utf8');
+    } catch (e) {
+      process.stderr.write(`ai task issue-body: cannot read template '${templatePath}': ${(e as Error).message}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    try {
+      process.stdout.write(renderTemplateBody(formText, readTaskFields(content)));
+    } catch (e) {
+      process.stderr.write(`ai task issue-body: cannot render template '${templatePath}': ${(e as Error).message}\n`);
+      process.exitCode = 1;
+    }
+    return;
+  }
+
+  process.stdout.write(buildDefaultBody(content));
+}
+
+export { issueBody, buildDefaultBody };