@fitlab-ai/agent-infra 0.7.7 → 0.8.1

package/dist/lib/server/protocol.js

@@ -0,0 +1,69 @@
+import { VERSION } from "../version.js";
+import { getSkillRunSpec } from "../run/skills.js";
+const TASK_READ = new Set(['ls', 'list', 'status', 'show', 'log', 'decisions']);
+const SANDBOX_READ = new Set(['ls', 'list', 'show']);
+const SANDBOX_WRITE = new Set(['create', 'start']);
+function splitWords(text) {
+    return text.trim().split(/\s+/).filter(Boolean);
+}
+function taskSubcommand(subcommand) {
+    return subcommand === 'list' ? 'ls' : subcommand;
+}
+export function commandHelp() {
+    return [
+        `agent-infra ${VERSION}`,
+        'Built-ins: /help, /ping, /version',
+        'Read: /sandbox ls|show|vm status, /task decisions|log|ls|show|status',
+        'Write: /sandbox create|start',
+        'Exec: /decide <task-ref> <HD-id> <decision>, /run create-task <description>, /run <skill> <task-ref> ...'
+    ].join('\n');
+}
+export function parseCommand(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('/'))
+        return { kind: 'ignore' };
+    const words = splitWords(trimmed);
+    const [command = '', subcommand = '', ...rest] = words;
+    if (command === '/help')
+        return { kind: 'builtin', name: 'help', role: 'read', args: rest };
+    if (command === '/ping')
+        return { kind: 'builtin', name: 'ping', role: 'read', args: rest };
+    if (command === '/version')
+        return { kind: 'builtin', name: 'version', role: 'read', args: rest };
+    if (command === '/decide') {
+        return { kind: 'ai', role: 'exec', argv: ['decide', subcommand, ...rest] };
+    }
+    if (command === '/task') {
+        if (!TASK_READ.has(subcommand))
+            return { kind: 'error', message: 'Unknown /task command' };
+        return { kind: 'ai', role: 'read', argv: ['task', taskSubcommand(subcommand), ...rest] };
+    }
+    if (command === '/sandbox') {
+        if (subcommand === 'vm') {
+            if (rest[0] !== 'status')
+                return { kind: 'error', message: 'Only /sandbox vm status is allowed' };
+            return { kind: 'ai', role: 'read', argv: ['sandbox', 'vm', 'status'] };
+        }
+        if (SANDBOX_READ.has(subcommand)) {
+            return { kind: 'ai', role: 'read', argv: ['sandbox', taskSubcommand(subcommand), ...rest] };
+        }
+        if (SANDBOX_WRITE.has(subcommand)) {
+            return { kind: 'ai', role: 'write', argv: ['sandbox', subcommand, ...rest] };
+        }
+        if (subcommand === 'rm') {
+            return {
+                kind: 'error',
+                message: '/sandbox rm is not available from IM because it requires interactive confirmation'
+            };
+        }
+        return { kind: 'error', message: 'Unknown /sandbox command' };
+    }
+    if (command === '/run') {
+        const spec = getSkillRunSpec(subcommand);
+        if (!spec)
+            return { kind: 'error', message: `Unknown skill: ${subcommand}` };
+        return { kind: 'ai', role: spec.role, argv: ['run', subcommand, ...rest] };
+    }
+    return { kind: 'error', message: `Unknown command: ${command}` };
+}
+//# sourceMappingURL=protocol.js.map

package/dist/lib/server/redact.js

@@ -0,0 +1,12 @@
+const SECRET_PATTERNS = [
+    /\b(token|secret|password|passwd|api[_-]?key)=([^\s]+)/gi,
+    /\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/g
+];
+export function redactSecrets(text) {
+    let out = text;
+    for (const pattern of SECRET_PATTERNS) {
+        out = out.replace(pattern, (_match, prefix) => `${prefix}=<redacted>`);
+    }
+    return out;
+}
+//# sourceMappingURL=redact.js.map

package/dist/lib/server/runner.js

@@ -0,0 +1,75 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+function resolveCommand(file) {
+    if (process.platform !== 'win32' || path.extname(file)) {
+        return file;
+    }
+    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 lowerCandidate = path.join(dir, `${file}${extension.toLowerCase()}`);
+            if (fs.existsSync(lowerCandidate))
+                return lowerCandidate;
+            const upperCandidate = path.join(dir, `${file}${extension.toUpperCase()}`);
+            if (fs.existsSync(upperCandidate))
+                return upperCandidate;
+        }
+    }
+    return file;
+}
+function needsShell(file) {
+    return process.platform === 'win32' && /\.(?:bat|cmd)$/i.test(file);
+}
+function spawnCapture(file, args, onChunk) {
+    return new Promise((resolve, reject) => {
+        const resolvedFile = resolveCommand(file);
+        const child = spawn(resolvedFile, args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+            shell: needsShell(resolvedFile)
+        });
+        let stdout = '';
+        let stderr = '';
+        let settled = false;
+        let pendingChunks = Promise.resolve();
+        const rejectOnce = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(error);
+        };
+        const resolveOnce = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            resolve(result);
+        };
+        const enqueueChunk = (chunk) => {
+            if (!onChunk)
+                return;
+            pendingChunks = pendingChunks.then(() => onChunk(chunk));
+            pendingChunks.catch(rejectOnce);
+        };
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+            enqueueChunk(chunk);
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk;
+            enqueueChunk(chunk);
+        });
+        child.on('error', rejectOnce);
+        child.on('close', (exitCode, signal) => {
+            pendingChunks
+                .then(() => resolveOnce({ exitCode, signal, stdout, stderr }))
+                .catch(rejectOnce);
+        });
+    });
+}
+export async function runAi(args, options = {}) {
+    return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+}
+//# sourceMappingURL=runner.js.map

package/dist/lib/server/streamer.js

@@ -0,0 +1,44 @@
+import { redactSecrets } from "./redact.js";
+function chunks(text, size) {
+    if (text.length === 0)
+        return [];
+    const out = [];
+    for (let i = 0; i < text.length; i += size) {
+        out.push(text.slice(i, i + size));
+    }
+    return out;
+}
+export async function streamCommand(options, run, send) {
+    await send(`started ${options.title}`);
+    const size = options.chunkChars ?? 4000;
+    const throttleMs = options.throttleMs ?? 0;
+    let streamed = false;
+    let buffer = '';
+    let lastFlush = 0;
+    const flush = async () => {
+        if (!buffer)
+            return;
+        const text = redactSecrets(buffer);
+        buffer = '';
+        lastFlush = Date.now();
+        for (const chunk of chunks(text, size)) {
+            await send(chunk);
+        }
+    };
+    const emit = async (chunk) => {
+        streamed = true;
+        buffer += chunk;
+        const due = throttleMs === 0 || Date.now() - lastFlush >= throttleMs;
+        if (buffer.length >= size || due) {
+            await flush();
+        }
+    };
+    const result = await run(emit);
+    if (!streamed) {
+        buffer += [result.stdout, result.stderr].filter(Boolean).join('\n');
+    }
+    await flush();
+    await send(`finished ${options.title} exitCode=${result.exitCode} signal=${result.signal ?? 'null'}`);
+    return result;
+}
+//# sourceMappingURL=streamer.js.map

package/dist/lib/task/commands/decisions.js

@@ -0,0 +1,258 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { formatTable } from "../../table.js";
+import { resolveTaskRef } from "../resolve-ref.js";
+import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
+import { extractSubSection } from "../sections.js";
+const USAGE = `Usage: ai task decisions <N | #N | TASK-id> [selector] [options]
+
+Lists the human-decision (HD-) items recorded in a task's review disagreement
+ledger, or prints the full detail block for a single item. Read-only.
+
+  <ref>          Bare numeric / '#N' short id, or a full TASK-YYYYMMDD-HHMMSS id.
+  [selector]     Ordinal (1-based) or HD id (e.g. 'HD-3') to show one item's detail.
+
+Options:
+  --all              Include already-decided (human-decided) items, not just pending.
+  --stage <s>        Filter to one stage: analysis | plan | code.
+  --format <fmt>     Output format: text (default) | markdown.
+  -h, --help         Show this help.
+
+Aliased as 'ai task d'.
+`;
+const STAGES = new Set(['analysis', 'plan', 'code']);
+const FORMATS = new Set(['text', 'markdown']);
+const HD_ID_RE = /^HD-\d+$/;
+function fail(message) {
+    process.stderr.write(`ai task decisions: ${message}\n`);
+    process.exitCode = 1;
+}
+// Returns null and sets the exit code when an option is malformed.
+function parseArgs(args) {
+    const out = { positionals: [], all: false, format: 'text' };
+    for (let i = 0; i < args.length; i += 1) {
+        const a = args[i];
+        if (a === '--all') {
+            out.all = true;
+        }
+        else if (a === '--stage') {
+            const v = args[i + 1];
+            if (v === undefined) {
+                fail('--stage requires a value (analysis|plan|code)');
+                return null;
+            }
+            out.stage = v;
+            i += 1;
+        }
+        else if (a.startsWith('--stage=')) {
+            out.stage = a.slice('--stage='.length);
+        }
+        else if (a === '--format') {
+            const v = args[i + 1];
+            if (v === undefined) {
+                fail('--format requires a value (text|markdown)');
+                return null;
+            }
+            out.format = v;
+            i += 1;
+        }
+        else if (a.startsWith('--format=')) {
+            out.format = a.slice('--format='.length);
+        }
+        else if (a.startsWith('-')) {
+            fail(`unknown option '${a}'`);
+            return null;
+        }
+        else {
+            out.positionals.push(a);
+        }
+    }
+    return out;
+}
+// Parse `<file>.md#anchor` evidence into its filename, when present.
+function evidenceFile(evidence) {
+    const m = /([\w.-]+\.md)#/.exec(evidence);
+    return m ? m[1] : null;
+}
+function roundOf(file) {
+    const m = /-r(\d+)\.md$/.exec(file);
+    return m ? Number.parseInt(m[1], 10) : 1;
+}
+// Locate the `### HD-N` detail block for a row. Prefer the artifact named by the
+// row's evidence anchor; otherwise scan analysis/plan/code artifacts and return
+// the block from the highest-round file that contains it. Returns '' when none
+// is found (caller degrades gracefully — plan B3).
+function findDetailBlock(row, taskDir) {
+    const hinted = evidenceFile(row.evidence);
+    if (hinted) {
+        const p = path.join(taskDir, hinted);
+        if (fs.existsSync(p)) {
+            const block = extractSubSection(fs.readFileSync(p, 'utf8'), row.id);
+            if (block)
+                return block;
+        }
+    }
+    let best = '';
+    let bestRound = -1;
+    let entries;
+    try {
+        entries = fs.readdirSync(taskDir);
+    }
+    catch {
+        return '';
+    }
+    for (const file of entries) {
+        if (!/^(analysis|plan|code)(-r\d+)?\.md$/.test(file))
+            continue;
+        const block = extractSubSection(fs.readFileSync(path.join(taskDir, file), 'utf8'), row.id);
+        if (block && roundOf(file) > bestRound) {
+            best = block;
+            bestRound = roundOf(file);
+        }
+    }
+    return best;
+}
+// Pull the `## 人工裁决` record lines that mention this HD id, so a decided item
+// shows the human's recorded ruling alongside its detail block.
+function findDecisionRecord(id, content) {
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length && !/^##\s+(人工裁决|Human Decisions?)\s*$/.test(lines[i]))
+        i += 1;
+    if (i >= lines.length)
+        return [];
+    const idRe = new RegExp(`(^|[^\\w-])${id}(?![\\w-])`);
+    const out = [];
+    for (let j = i + 1; j < lines.length; j += 1) {
+        if (/^##\s/.test(lines[j]))
+            break;
+        if (lines[j].trim().startsWith('-') && idRe.test(lines[j]))
+            out.push(lines[j]);
+    }
+    return out;
+}
+function titleOf(row, taskDir) {
+    const block = findDetailBlock(row, taskDir);
+    if (block) {
+        return block
+            .split('\n')[0]
+            .replace(/^###\s+/, '')
+            .replace(/\s*\[needs-human-decision\]\s*$/, '')
+            .trim();
+    }
+    return row.evidence || '(无详情)';
+}
+function renderList(rows, format, taskDir) {
+    if (rows.length === 0) {
+        process.stdout.write('无待裁决项。\n');
+        return;
+    }
+    const headers = ['#', 'ID', 'STAGE', 'SEVERITY', 'STATUS', 'EVIDENCE', 'TITLE'];
+    const data = rows.map((r, i) => [
+        String(i + 1),
+        r.id,
+        r.stage,
+        r.severity,
+        r.status,
+        r.evidence,
+        titleOf(r, taskDir)
+    ]);
+    if (format === 'markdown') {
+        const sep = headers.map(() => '---');
+        const md = [
+            `| ${headers.join(' | ')} |`,
+            `| ${sep.join(' | ')} |`,
+            ...data.map((row) => `| ${row.join(' | ')} |`)
+        ];
+        process.stdout.write(`${md.join('\n')}\n`);
+        return;
+    }
+    process.stdout.write(`${formatTable(headers, data).join('\n')}\n`);
+}
+function renderDetail(rows, selector, format, taskDir, content) {
+    let row;
+    if (/^\d+$/.test(selector)) {
+        const idx = Number.parseInt(selector, 10) - 1;
+        if (idx < 0 || idx >= rows.length) {
+            fail(`ordinal '${selector}' out of range (1..${rows.length})`);
+            return;
+        }
+        row = rows[idx];
+    }
+    else {
+        const want = selector.toUpperCase();
+        const matches = rows.filter((r) => r.id.toUpperCase() === want);
+        if (matches.length === 0) {
+            fail(`no decision item matches '${selector}'`);
+            return;
+        }
+        if (matches.length > 1) {
+            fail(`duplicate id '${selector}' in ledger; select by ordinal instead`);
+            return;
+        }
+        row = matches[0];
+    }
+    const r = row;
+    const block = findDetailBlock(r, taskDir);
+    const lines = [];
+    if (format === 'markdown') {
+        lines.push(`**${r.id}** (${r.stage}/${r.severity}) · status=\`${r.status}\` · evidence: \`${r.evidence}\``, '');
+    }
+    else {
+        lines.push(`${r.id} (${r.stage}/${r.severity}) status=${r.status}`, `evidence: ${r.evidence}`, '');
+    }
+    if (block) {
+        lines.push(block);
+    }
+    else {
+        lines.push(`（详情块未找到：未在任务产物中定位到 \`### ${r.id}\` 锚点，可能为历史产物或尚未写入；evidence 指向 ${r.evidence}）`);
+    }
+    if (r.status === 'human-decided') {
+        const record = findDecisionRecord(r.id, content);
+        if (record.length) {
+            lines.push('', '人工裁定：', ...record);
+        }
+    }
+    process.stdout.write(`${lines.join('\n')}\n`);
+}
+function decisions(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const parsed = parseArgs(args);
+    if (!parsed)
+        return;
+    if (parsed.positionals.length === 0) {
+        process.stdout.write(USAGE);
+        process.exitCode = 1;
+        return;
+    }
+    if (parsed.stage !== undefined && !STAGES.has(parsed.stage)) {
+        fail(`invalid --stage '${parsed.stage}' (expected analysis|plan|code)`);
+        return;
+    }
+    if (!FORMATS.has(parsed.format)) {
+        fail(`invalid --format '${parsed.format}' (expected text|markdown)`);
+        return;
+    }
+    const resolved = resolveTaskRef(parsed.positionals[0]);
+    if (!resolved.ok) {
+        fail(resolved.message);
+        return;
+    }
+    const content = fs.readFileSync(resolved.taskMdPath, 'utf8');
+    let rows = parseLedger(content).filter((r) => HD_ID_RE.test(r.id));
+    rows = rows.filter((r) => parsed.all ? HUMAN_DECISION_STATUSES.has(r.status) : r.status === 'needs-human-decision');
+    if (parsed.stage !== undefined)
+        rows = rows.filter((r) => r.stage === parsed.stage);
+    const selector = parsed.positionals[1];
+    if (selector === undefined) {
+        renderList(rows, parsed.format, resolved.taskDir);
+    }
+    else {
+        renderDetail(rows, selector, parsed.format, resolved.taskDir, content);
+    }
+}
+export { decisions };
+//# sourceMappingURL=decisions.js.map

package/dist/lib/task/commands/log.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { formatTable } from "../../table.js";
 import { resolveTaskRef } from "../resolve-ref.js";
+import { parseLedger, HUMAN_DECISION_STATUSES } from "../ledger.js";
 const USAGE = `Usage: ai task log <N | #N | TASK-id>
 
 Renders a task's activity log as a per-step status table. A step's start and
@@ -11,13 +12,12 @@ completion time (or '(in progress)' while still running).
 Columns: # (row) / STEP / AGENT / STARTED / DONE / NOTE
   A human-executed step shows AGENT as 'human' and, when it has no start marker,
   a '-' STARTED placeholder. Review-step NOTE also carries two human counts in
-  the verdict list, right after blockers/major/minor: manual-verify (env-blocked)
+  the verdict list, right after blockers/major/minor: manual-validation
   and human-decision (current ledger stage total).
 `;
 const TABLE_HEADERS = ['#', 'STEP', 'AGENT', 'STARTED', 'DONE', 'NOTE'];
 // The activity-log H2 heading is language-dependent (zh template / en template).
 const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
-const LEDGER_HEADING_RE = /^##\s+(审查分歧账本|Review Disagreement Ledger)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 // `- {time} — **{step}** by {agent} — {note}` ; the separator is an em-dash
 // (U+2014). STEP/AGENT are non-greedy so a note that itself contains ' — ' or
@@ -33,11 +33,6 @@ const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
 // note these differ from the `.airc.json` long names claude-code/gemini-cli).
 // Any other executor token (a human name, possibly CJK) is treated as human.
 const KNOWN_AI_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode', 'cursor']);
-const HUMAN_DECISION_STATUSES = new Set(['needs-human-decision', 'human-decided']);
-const ENV_BLOCKED_RE = /\(\+\s*(\d+)\s+env-blocked\)/i;
-// Same match plus any leading whitespace, so folding the count into the verdict
-// text drops the redundant `(+ n env-blocked)` fragment without leaving a gap.
-const ENV_BLOCKED_STRIP_RE = /\s*\(\+\s*\d+\s+env-blocked\)/i;
 const REVIEW_STAGE_PREFIXES = [
     { prefix: 'Review Analysis', stage: 'analysis' },
     { prefix: 'Review Plan', stage: 'plan' },
@@ -102,30 +97,6 @@ function pairEntries(entries) {
     }
     return rows;
 }
-function parseReviewLedger(content) {
-    const lines = content.split('\n');
-    let i = 0;
-    while (i < lines.length && !LEDGER_HEADING_RE.test(lines[i]))
-        i += 1;
-    if (i >= lines.length)
-        return [];
-    const rows = [];
-    for (let j = i + 1; j < lines.length; j += 1) {
-        if (NEXT_H2_RE.test(lines[j]))
-            break;
-        const line = lines[j].trim();
-        if (!line.startsWith('|'))
-            continue;
-        const cells = line
-            .split('|')
-            .slice(1, -1)
-            .map((cell) => cell.trim());
-        if (cells.length < 6 || cells[0] === 'id' || /^-+$/.test(cells[0] ?? ''))
-            continue;
-        rows.push({ stage: cells[1], status: cells[4] });
-    }
-    return rows;
-}
 function countHumanDecisionsByStage(rows) {
     const counts = new Map();
     for (const row of rows) {
@@ -141,9 +112,31 @@ function isReviewStage(stage) {
 function reviewStageForStep(step) {
     return REVIEW_STAGE_PREFIXES.find(({ prefix }) => step.startsWith(prefix))?.stage;
 }
+function splitArtifactSuffix(note) {
+    const arrow = note.indexOf(' → ');
+    return arrow === -1 ? { verdict: note, suffix: '' } : { verdict: note.slice(0, arrow), suffix: note.slice(arrow) };
+}
+function fieldNumber(field, label) {
+    const trimmed = field.trim();
+    const colon = trimmed.indexOf(':');
+    if (colon === -1)
+        return undefined;
+    if (trimmed.slice(0, colon).trim().toLowerCase() !== label)
+        return undefined;
+    const value = Number(trimmed.slice(colon + 1).trim());
+    return Number.isInteger(value) && value >= 0 ? value : undefined;
+}
 function humanValidationCount(note) {
-    const match = ENV_BLOCKED_RE.exec(note);
-    return match ? Number(match[1]) : 0;
+    const { verdict } = splitArtifactSuffix(note);
+    for (const field of verdict.split(',')) {
+        const value = fieldNumber(field, 'manual-validation');
+        if (value !== undefined)
+            return value;
+    }
+    return 0;
+}
+function isHumanCountField(field) {
+    return fieldNumber(field, 'manual-validation') !== undefined || fieldNumber(field, 'human-decision') !== undefined;
 }
 // A step is human-executed when its agent token is not a known AI token. Take
 // the first whitespace-delimited token and drop any trailing parenthetical
@@ -154,13 +147,17 @@ function isHumanAgent(agent) {
 }
 // Fold the two human counts into a review row's verdict NOTE: comma-joined, right
 // after the blockers/major/minor list and before the ` → artifact` link, mirroring
-// the review count line. The raw `(+ n env-blocked)` fragment is dropped so the
-// env-blocked number is not shown twice (it becomes the manual-verify count).
-function foldHumanCounts(note, decisions, envBlocked) {
-    const base = note.replace(ENV_BLOCKED_STRIP_RE, '');
-    const group = `Manual-verify: ${envBlocked}, Human-decision: ${decisions}`;
-    const arrow = base.indexOf(' → ');
-    return arrow === -1 ? `${base}, ${group}` : `${base.slice(0, arrow)}, ${group}${base.slice(arrow)}`;
+// the review count line. Review done notes already carry `Manual-validation` as a
+// source field, so build the final verdict field list once instead of cleaning a
+// previously rendered string.
+function foldHumanCounts(note, decisions, manualValidation) {
+    const { verdict, suffix } = splitArtifactSuffix(note);
+    const fields = verdict
+        .split(',')
+        .map((field) => field.trim())
+        .filter((field) => field !== '' && !isHumanCountField(field));
+    const group = `Manual-validation: ${manualValidation}, Human-decision: ${decisions}`;
+    return `${[...fields, group].join(', ')}${suffix}`;
 }
 function log(args = []) {
     if (args.length === 0 || args[0] === '--help' || args[0] === '-h') {
@@ -188,7 +185,7 @@ function log(args = []) {
         return;
     }
     const steps = pairEntries(entries);
-    const humanDecisionCounts = countHumanDecisionsByStage(parseReviewLedger(content));
+    const humanDecisionCounts = countHumanDecisionsByStage(parseLedger(content));
     const rows = steps.map((s, idx) => {
         const stage = reviewStageForStep(s.step);
         const note = stage