@f-o-h/cli 0.1.16 → 0.1.18

package/README.md

@@ -4,7 +4,7 @@ AI-operator provisioning CLI for Front Of House.
 
 Public mirror: https://github.com/iiko38/front-of-house-cli
 
-Current published baseline: `@f-o-h/cli@0.1.16`
+Current published baseline: `@f-o-h/cli@0.1.18`
 
 This mirror is a generated release artifact. The private product monorepo is not
 published here, and no open-source license is granted unless stated separately.
@@ -144,30 +144,30 @@ After dry-run review, one controlled Codex run can be launched explicitly with
 `run.json` even on timeout or non-zero exit:
 
 ```bash
-foh eval external-agent execute \
-  --runner codex \
-  --batch test-results/external-agent-runs/<one-model-batch>/batch.json \
-  --timeout-minutes 30 \
-  --live \
-  --json
-```
-
-For Linux eval hosts where Codex's default Bubblewrap sandbox cannot configure
-loopback networking, keep sandboxing enabled and select the legacy Landlock
-backend explicitly:
-
-```bash
-foh eval external-agent execute \
-  --runner codex \
-  --batch test-results/external-agent-runs/<one-model-batch>/batch.json \
-  --codex-sandbox-backend legacy-landlock \
-  --codex-network-access \
-  --timeout-minutes 30 \
-  --live \
-  --json
-```
-
-## Local Scenario Suites
+foh eval external-agent execute \
+  --runner codex \
+  --batch test-results/external-agent-runs/<one-model-batch>/batch.json \
+  --timeout-minutes 30 \
+  --live \
+  --json
+```
+
+For Linux eval hosts where Codex's default Bubblewrap sandbox cannot configure
+loopback networking, keep sandboxing enabled and select the legacy Landlock
+backend explicitly:
+
+```bash
+foh eval external-agent execute \
+  --runner codex \
+  --batch test-results/external-agent-runs/<one-model-batch>/batch.json \
+  --codex-sandbox-backend legacy-landlock \
+  --codex-network-access \
+  --timeout-minutes 30 \
+  --live \
+  --json
+```
+
+## Local Scenario Suites
 
 `foh test run --suite <file>` runs deterministic widget-runtime checks for a
 specific agent. The suite format supports reply text checks plus structured

package/dist/foh.js

@@ -14637,9 +14637,9 @@ function registerAgent(program3) {
       process.stdout.write(yaml);
       return;
     }
-    const { writeFileSync: writeFileSync9 } = await import("fs");
+    const { writeFileSync: writeFileSync10 } = await import("fs");
     const outputPath = opts.output ?? "tenant.yaml";
-    writeFileSync9(
+    writeFileSync10(
       outputPath,
       `# tenant.yaml - Front Of House agent manifest
 # Edit this file and run: foh plan tenant.yaml
@@ -16074,11 +16074,11 @@ function registerVoice(program3) {
     }
     const outputPath = String(opts.out || `foh-voice-preview-${provider}-${voiceId}.mp3`).trim();
     const audio = Buffer.from(await res.arrayBuffer());
-    const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync9 } = await import("fs");
+    const { mkdirSync: mkdirSync7, writeFileSync: writeFileSync10 } = await import("fs");
     const { dirname: dirname6, resolve: resolve12 } = await import("path");
     const absolutePath = resolve12(outputPath);
     mkdirSync7(dirname6(absolutePath), { recursive: true });
-    writeFileSync9(absolutePath, audio);
+    writeFileSync10(absolutePath, audio);
     format({
       status: "ok",
       provider,
@@ -32681,7 +32681,7 @@ var StdioServerTransport = class {
 };
 
 // src/lib/cli-version.ts
-var CLI_VERSION = "0.1.16";
+var CLI_VERSION = "0.1.18";
 
 // src/commands/mcp-serve.ts
 var DEFAULT_TIMEOUT_MS = 12e4;
@@ -34816,8 +34816,8 @@ function registerSetup(program3) {
         }
         try {
           const manifest = await agentExport(resolvedAgentId, { apiUrlOverride: opts.apiUrl });
-          const { writeFileSync: writeFileSync9 } = await import("fs");
-          writeFileSync9(
+          const { writeFileSync: writeFileSync10 } = await import("fs");
+          writeFileSync10(
             "tenant.yaml",
             `# tenant.yaml - Front Of House agent manifest
 # Edit this file and run: foh plan tenant.yaml
@@ -34985,8 +34985,8 @@ function registerSim(program3) {
       }
       const cert = response.certificate;
       if (opts.out) {
-        const { writeFileSync: writeFileSync9 } = await import("fs");
-        writeFileSync9(opts.out, JSON.stringify(cert, null, 2) + "\n", "utf-8");
+        const { writeFileSync: writeFileSync10 } = await import("fs");
+        writeFileSync10(opts.out, JSON.stringify(cert, null, 2) + "\n", "utf-8");
         process.stderr.write(`  Certificate written to ${opts.out}
 `);
       }
@@ -35036,8 +35036,8 @@ function registerSim(program3) {
         });
       }
       if (opts.out) {
-        const { writeFileSync: writeFileSync9 } = await import("fs");
-        writeFileSync9(opts.out, JSON.stringify(response.certificate, null, 2) + "\n", "utf-8");
+        const { writeFileSync: writeFileSync10 } = await import("fs");
+        writeFileSync10(opts.out, JSON.stringify(response.certificate, null, 2) + "\n", "utf-8");
         process.stderr.write(`  Final certificate written to ${opts.out}
 `);
       }
@@ -38376,7 +38376,8 @@ function artifactFiles(runDir) {
   if (!(0, import_fs12.existsSync)(runDir)) return [];
   return (0, import_fs12.readdirSync)(runDir).map((name) => (0, import_path10.join)(runDir, name)).filter((path2) => {
     const stat = (0, import_fs12.statSync)(path2);
-    return stat.isFile() && TEXT_ARTIFACT_NAMES.has(path2.split(/[\\/]/).pop() || "");
+    const name = path2.split(/[\\/]/).pop() || "";
+    return stat.isFile() && (TEXT_ARTIFACT_NAMES.has(name) || name.startsWith("command-output-cmd_"));
   }).sort();
 }
 function finding(kind, file2, count) {
@@ -38465,30 +38466,154 @@ function getExternalAgentRunDir() {
   if (!raw || !raw.trim()) return null;
   return (0, import_path11.resolve)(raw);
 }
+function commandIdFor(input) {
+  const seed = `${input.startedAt}:${input.argv.join("\0")}:${process.pid}`;
+  let hash2 = 2166136261;
+  for (let i = 0; i < seed.length; i += 1) {
+    hash2 ^= seed.charCodeAt(i);
+    hash2 = Math.imul(hash2, 16777619);
+  }
+  return `cmd_${(hash2 >>> 0).toString(16).padStart(8, "0")}`;
+}
+function outputArtifactName(commandId) {
+  return `command-output-${commandId}.txt`;
+}
+function parseEnvelope(text) {
+  const candidates = [
+    ...text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{") && line.endsWith("}")).reverse()
+  ];
+  const firstObject = text.indexOf("{");
+  const lastObject = text.lastIndexOf("}");
+  if (firstObject >= 0 && lastObject > firstObject) candidates.push(text.slice(firstObject, lastObject + 1));
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      const status = typeof parsed.status === "string" ? parsed.status : parsed.ok === true ? "pass" : parsed.ok === false ? "fail" : null;
+      const reasonCode = typeof parsed.reason_code === "string" ? parsed.reason_code : typeof parsed.code === "string" ? parsed.code : null;
+      if (status || reasonCode) return { status, reasonCode };
+    } catch {
+    }
+  }
+  return { status: null, reasonCode: null };
+}
 function recordExternalAgentCliInvocation(input) {
   const runDir = getExternalAgentRunDir();
-  if (!runDir) return;
+  if (!runDir) return null;
   try {
     (0, import_fs13.mkdirSync)(runDir, { recursive: true });
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const args = input.argv.slice(2).map((arg) => redactText(String(arg)));
+    const commandId = commandIdFor({ startedAt, argv: args });
+    const promptVersion = process.env[EXTERNAL_AGENT_PROMPT_VERSION_ENV] || null;
+    const cwd = redactPath(process.cwd());
     const record2 = {
-      schema_version: "external_agent_cli_command.v1",
-      recorded_at: (/* @__PURE__ */ new Date()).toISOString(),
+      schema_version: "external_agent_cli_command.v2",
+      command_id: commandId,
+      phase: "started",
+      recorded_at: startedAt,
       cli_version: input.cliVersion,
-      cwd: redactPath(process.cwd()),
+      cwd,
       argv: args,
       command: args.join(" "),
       json_requested: args.includes("--json"),
-      prompt_version: process.env[EXTERNAL_AGENT_PROMPT_VERSION_ENV] || null
+      prompt_version: promptVersion,
+      started_at: startedAt
     };
     (0, import_fs13.appendFileSync)((0, import_path11.join)(runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
+    return {
+      commandId,
+      runDir,
+      startedAt,
+      cliVersion: input.cliVersion,
+      cwd,
+      argv: args,
+      command: args.join(" "),
+      jsonRequested: args.includes("--json"),
+      promptVersion
+    };
   } catch {
+    return null;
+  }
+}
+function installExternalAgentCliCompletionRecorder(capture) {
+  if (!capture) return;
+  const chunks = [];
+  const maxChars = 256 * 1024;
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  function captureChunk(chunk) {
+    if (typeof chunk === "string") {
+      if (chunks.join("").length < maxChars) chunks.push(chunk.slice(0, maxChars));
+      return;
+    }
+    if (Buffer.isBuffer(chunk)) {
+      if (chunks.join("").length < maxChars) chunks.push(chunk.toString("utf8").slice(0, maxChars));
+    }
   }
+  process.stdout.write = ((chunk, ...args) => {
+    captureChunk(chunk);
+    return originalStdoutWrite(chunk, ...args);
+  });
+  process.stderr.write = ((chunk, ...args) => {
+    captureChunk(chunk);
+    return originalStderrWrite(chunk, ...args);
+  });
+  process.once("exit", (code) => {
+    try {
+      process.stdout.write = originalStdoutWrite;
+      process.stderr.write = originalStderrWrite;
+      const output = redactPath(chunks.join("").slice(0, maxChars));
+      completeExternalAgentCliInvocation(capture, {
+        output,
+        exitCode: Number.isInteger(code) ? code : process.exitCode && Number.isInteger(process.exitCode) ? Number(process.exitCode) : null
+      });
+    } catch {
+    }
+  });
+}
+function completeExternalAgentCliInvocation(capture, input) {
+  const completedAt = input.completedAt || (/* @__PURE__ */ new Date()).toISOString();
+  const output = redactPath(String(input.output || "").slice(0, 256 * 1024));
+  const parsed = parseEnvelope(output);
+  let artifact = null;
+  if (output.trim()) {
+    artifact = outputArtifactName(capture.commandId);
+    (0, import_fs13.writeFileSync)((0, import_path11.join)(capture.runDir, artifact), output, "utf8");
+  }
+  const record2 = {
+    schema_version: "external_agent_cli_command.v2",
+    command_id: capture.commandId,
+    phase: "completed",
+    recorded_at: completedAt,
+    cli_version: capture.cliVersion,
+    cwd: capture.cwd,
+    argv: capture.argv,
+    command: capture.command,
+    json_requested: capture.jsonRequested,
+    prompt_version: capture.promptVersion,
+    started_at: capture.startedAt,
+    completed_at: completedAt,
+    duration_ms: Math.max(0, Date.parse(completedAt) - Date.parse(capture.startedAt)),
+    exit_code: Number.isInteger(input.exitCode) ? Number(input.exitCode) : null,
+    status: parsed.status,
+    reason_code: parsed.reasonCode,
+    output_artifact: artifact,
+    output_bytes: Buffer.byteLength(output, "utf8")
+  };
+  (0, import_fs13.appendFileSync)((0, import_path11.join)(capture.runDir, "commands.ndjson"), safeJsonLine(record2), "utf8");
 }
 function readCommandRecords(runDir) {
   const commandLogPath = (0, import_path11.join)(runDir, "commands.ndjson");
   if (!(0, import_fs13.existsSync)(commandLogPath)) return [];
-  return (0, import_fs13.readFileSync)(commandLogPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  const records = (0, import_fs13.readFileSync)(commandLogPath, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => JSON.parse(line));
+  const byId = /* @__PURE__ */ new Map();
+  const ordered = [];
+  for (const record2 of records) {
+    const id = record2.command_id || `${record2.recorded_at}:${record2.command}`;
+    if (!byId.has(id)) ordered.push(record2);
+    byId.set(id, record2.phase === "completed" ? record2 : byId.get(id) ?? record2);
+  }
+  return ordered.map((record2) => byId.get(record2.command_id || `${record2.recorded_at}:${record2.command}`) || record2);
 }
 
 // src/lib/external-agent-executor.ts
@@ -39501,7 +39626,7 @@ function installSoftExitTrap() {
 
 // src/index.ts
 installSoftExitTrap();
-recordExternalAgentCliInvocation({ argv: process.argv, cliVersion: CLI_VERSION });
+installExternalAgentCliCompletionRecorder(recordExternalAgentCliInvocation({ argv: process.argv, cliVersion: CLI_VERSION }));
 var program2 = new Command();
 var BUG_REPORT_URL = process.env.FOH_BUG_REPORT_URL ?? "https://github.com/iiko38/front-of-house/issues";
 function shouldRenderBanner2(argv) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@f-o-h/cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "FOH CLI - AI-operator provisioning tool for Front Of House",
   "license": "UNLICENSED",
   "bin": {