@dadado/agent-kit-cli 5.16.0 → 5.18.0

package/dashboard/README.md

@@ -10,7 +10,7 @@ directly, and `packages/cli/dashboard/` is a generated copy (gitignored, produce
 | `start.mjs` / `start-broadcast.mjs` | loopback and LAN entry points, per-workspace port allocation |
 | `dashboard-data.mjs` | snapshot builder for the panel |
 | `dashboard.html`, `open.html` | panel and share shell |
-| `lib/*.mjs` | guards, semantic model, live refresh, browser open, terminal snapshot |
+| `lib/*.mjs` | guards, semantic model, live refresh, browser open, terminal snapshot, headless run feed (`run-logs.mjs`) |
 | `lib/guards.d.mts` | hand-written types consumed by the CLI package (parity is pinned by a test) |
 
 ## Where the tests live
@@ -24,6 +24,15 @@ before it fans out to the workspace packages).
 `dashboard.html` is outside Biome's scope; CSS/HTML-only changes are covered by
 `packages/cli/src/dashboard/plugin-ux-validation.test.ts` instead.
 
+## Embedding (action seam, CSP readiness)
+
+A host page can replace the copy-to-clipboard default by defining
+`window.__MISSION_CONTROL_ACTIONS__ = { perform(action) }` before the panel's script runs;
+every action is one `{ kind: "copy", text, subject, destination, toastMessage }` record. The web
+dashboard keeps the copy-only default. Contract, CSP readiness counts and the innerHTML sink
+audit: `docs/mission-control-embedding.md`. The snapshot shape is versioned by `dashboardDataVersion`
+and published as `docs/contracts/mission-control-snapshot.schema.json`.
+
 ## Git tab and DevOps tab
 
 The Git tab (`#git`) keeps the pre-rendered `git log --graph` markdown block and adds a

package/dashboard/dashboard-data.mjs

@@ -17,6 +17,7 @@ import {
 import { projectSlugFromRoot } from "./lib/live-refresh.mjs";
 import { PIPELINE_CACHE_ENV, readCachedPipeline } from "./lib/pipeline-cache.mjs";
 import { selectWorkspaceProcesses } from "./lib/processes.mjs";
+import { collectRunLogs } from "./lib/run-logs.mjs";
 import {
   EXTERNAL_REPORT_FILE_RE,
   FIELD_REPORT_CADENCE_LEDGER_REL,
@@ -131,7 +132,7 @@ function redactTerminalOutput(text) {
 
 const SNAPSHOT = {
   _schema: {
-    version: "1.3.0",
+    version: "1.5.0",
     description: "Mission Control dashboard data model",
     fields: {
       generatedAt: "ISO-8601 timestamp of snapshot generation",
@@ -148,6 +149,8 @@ const SNAPSHOT = {
         "Best-effort DevOps signal: pipeline ({available, runs[], reason?} recent gh run list rows; reason is 'budget' when the shared snapshot budget ran out before gh was attempted, or 'call-failed' when gh was attempted and missing/unauthenticated/timed out/errored; reason is only present when available is false; fetchedAt is the ISO time gh was last attempted, reused from serve.mjs for up to 60s) and deploy ({tags[], changelog} v* git tags + latest CHANGELOG release entry as a 'what shipped recently' proxy, not a live infra poll)",
       terminals:
         "Active Cursor terminal sessions with metadata, output line count, and capped lastOutput",
+      runLogs:
+        "Newest headless agent-kit run / tick logs from <state root>/loop-logs (AGENT_KIT_STATE_ROOT: .cursor by default, or .agent-kit; no ~/.cursor dependency): format, session id, capped last agent text, result, LOOP_TICK_RESULT line, HITL gate ids and reply stamps (1.5.0)",
       processes:
         "Running process snapshots (node, serve.mjs, git operations) with elapsed time and a generated narration per process",
       skills: "Available skills discovered in .cursor/skills/",
@@ -156,7 +159,7 @@ const SNAPSHOT = {
     },
   },
   generatedAt: new Date().toISOString(),
-  dashboardDataVersion: "1.4.0",
+  dashboardDataVersion: "1.5.0",
   plans: [],
   system: {
     repoRoot: ROOT,
@@ -167,6 +170,7 @@ const SNAPSHOT = {
   memory: {},
   git: {},
   terminals: [],
+  runLogs: [],
   processes: [],
   skills: [],
   health: { status: "ok", checks: [] },
@@ -769,6 +773,12 @@ if (existsSync(terminalProjectPath)) {
   }
 }
 
+// 7b. Headless run feed (<state root>/loop-logs, AGENT_KIT_STATE_ROOT): the kit's own transcript source,
+// independent of ~/.cursor/projects (embeddable contract, 1.5.0).
+if (withinSnapshotBudget(200)) {
+  SNAPSHOT.runLogs = collectRunLogs(ROOT, { redact: redactTerminalOutput });
+}
+
 // 8. Config
 const configPath = join(ROOT, ".cursor", "context", "config.json");
 if (existsSync(configPath)) {

package/dashboard/dashboard.html

@@ -4874,6 +4874,8 @@ function copyActionTitle(subject, destination, text) {
 function copyForPaste(text, subject, destination) {
   return copyToClipboard(text, {
     toastMessage: copyToastMessage(subject || text, destination, text),
+    subject: subject || '',
+    destination: destination || '',
   });
 }
 
@@ -5185,6 +5187,8 @@ async function copyRepoPath(relPath) {
   if (!relPath) return;
   await copyToClipboard(relPath, {
     toastMessage: pathCopyToastMessage(relPath),
+    subject: `path ${relPath}`,
+    destination: 'filePicker',
   });
 }
 
@@ -5683,6 +5687,42 @@ function renderGitHygieneHint(git) {
   `;
 }
 
+// ===== Action seam (contract: docs/mission-control-embedding.md) =====
+/**
+ * One action interface, two implementations. Every dashboard action is a typed
+ * `{ kind: 'copy', text, subject, destination, toastMessage }` record. The open
+ * web dashboard keeps the default implementation: copy to the clipboard and
+ * name the paste destination (copy-only, ADR 2026-07-25). A host page (an
+ * embedding app) may define `window.__MISSION_CONTROL_ACTIONS__ = { perform(action) }`
+ * before this script runs; it then receives the frozen record instead and
+ * validates it host-side against its own allowlist. The dashboard never names
+ * a command for a host to run and adds no other action kind.
+ * Contract: docs/mission-control-embedding.md.
+ */
+const MISSION_CONTROL_ACTION_KINDS = Object.freeze(['copy']);
+
+/** Host action implementation injected by an embedding page, or null (web default). */
+function missionControlActionHost() {
+  const host = typeof window !== 'undefined' ? window.__MISSION_CONTROL_ACTIONS__ : null;
+  return host && typeof host.perform === 'function' ? host : null;
+}
+
+/**
+ * Hand one action record to the injected host. The host's `{ message }` (or
+ * the copy-vocabulary label) is confirmed in the toast; a rejection is shown
+ * as an error and never retried here.
+ */
+async function performHostAction(host, action, opts) {
+  try {
+    const result = await host.perform(Object.freeze({ ...action }));
+    const message = result && typeof result.message === 'string' ? result.message : action.toastMessage;
+    if (!opts.silent) showToast(message, !!(result && result.ok === false));
+  } catch (err) {
+    const reason = err && err.message ? err.message : String(err);
+    showToast(`Action failed: ${reason}`, true);
+  }
+}
+
 // ===== Copy to clipboard + toast (Phase 1) =====
 /** Fallback confirmation. Callers should pass a destination-aware message. */
 function copyToastLabel(text) {
@@ -5692,6 +5732,20 @@ function copyToastLabel(text) {
 async function copyToClipboard(text, options) {
   const opts = options || {};
   const label = opts.toastMessage || copyToastLabel(text);
+  const host = missionControlActionHost();
+  if (host) {
+    return performHostAction(
+      host,
+      {
+        kind: MISSION_CONTROL_ACTION_KINDS[0],
+        text: String(text ?? ''),
+        subject: String(opts.subject || ''),
+        destination: String(opts.destination || ''),
+        toastMessage: label,
+      },
+      opts,
+    );
+  }
   try {
     if (navigator.clipboard && navigator.clipboard.writeText) {
       await navigator.clipboard.writeText(text);
@@ -5999,6 +6053,8 @@ function copyConfigSnippet(group) {
   for (const key of keys) snippet[key] = payload[key];
   void copyToClipboard(JSON.stringify(snippet, null, 2), {
     toastMessage: 'Copied config snippet - paste into .cursor/context/config.json',
+    subject: 'config snippet',
+    destination: '.cursor/context/config.json',
   });
   return false;
 }
@@ -6014,6 +6070,8 @@ function copyStaticConfigSnippet(id) {
   if (!snippet) return false;
   void copyToClipboard(JSON.stringify(snippet, null, 2), {
     toastMessage: 'Copied config snippet - paste into .cursor/context/config.json (not writable via tab)',
+    subject: 'config snippet',
+    destination: '.cursor/context/config.json',
   });
   return false;
 }

package/dashboard/lib/run-logs.d.mts

@@ -0,0 +1,34 @@
+/** Ambient types for dashboard/lib/run-logs.mjs (consumed by CLI TypeScript). */
+
+export const MAX_RUN_LOGS: 10;
+export const MAX_RUN_LOG_BYTES: number;
+export const MAX_RUN_LOG_TEXT: 600;
+
+export interface RunLogSummary {
+  format: "stream-json" | "codex" | "acp" | null;
+  sessionId: string | null;
+  events: number;
+  lastText: string;
+  result: { isError: boolean; subtype: string | null; text: string } | null;
+  sentinel: string | null;
+  gates: string[];
+  replies: string[];
+}
+
+export interface RunLogRow extends RunLogSummary {
+  id: string;
+  kind: "tick" | "run";
+  path: string;
+  updatedAt: string;
+  bytes: number;
+  source: "loop-logs";
+}
+
+export function resolveRunnerStateDir(
+  env?: Record<string, string | undefined>,
+): ".cursor" | ".agent-kit";
+export function summarizeRunLog(text: string, redact?: (s: string) => string): RunLogSummary;
+export function collectRunLogs(
+  root: string,
+  opts?: { stateDir?: string; redact?: (s: string) => string; max?: number },
+): RunLogRow[];

package/dashboard/lib/run-logs.mjs

@@ -0,0 +1,218 @@
+/**
+ * Headless run feed for Mission Control: the kit's own `.cursor/loop-logs/`
+ * (`tick-*.log` from `agent-kit run-plan`, `run-*.log` from `agent-kit run`),
+ * so the panel and an embedding host can show agent output, gates and tick
+ * results without reading `~/.cursor/projects` (ADR 2026-10-08
+ * mission-control-embeddable-contract).
+ *
+ * The logs are already redacted when the CLI writes them; a caller-supplied
+ * `redact` runs again over every string this module returns. Read-only and
+ * bounded: newest MAX_RUN_LOGS files, the last MAX_RUN_LOG_BYTES of each.
+ * Understands the three shapes the backends write: claude / cursor-agent
+ * stream-json, codex `exec --json`, and the cursor-acp JSON-RPC transcript.
+ */
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+export const MAX_RUN_LOGS = 10;
+export const MAX_RUN_LOG_BYTES = 256 * 1024;
+export const MAX_RUN_LOG_TEXT = 600;
+const MAX_LIST = 10;
+
+const LOG_NAME_RE = /^(tick|run)-[0-9-]+\.log$/;
+const GATE_RE = /^HITL_GATE:\s*([a-z0-9-]+)\s*\|/m;
+const SENTINEL_RE = /LOOP_TICK_RESULT:\s*(continue|stop(?:\s*[—-].*)?)/i;
+const REPLY_RE = /HITL_REPLY:\s*[a-z0-9-]+\s*\|[^\n]*/;
+
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+
+function cap(text, max = MAX_RUN_LOG_TEXT) {
+  const s = String(text ?? "").trim();
+  return s.length > max ? `${s.slice(0, max - 1)}…` : s;
+}
+
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .map((part) => (isRecord(part) && typeof part.text === "string" ? part.text : ""))
+    .join("");
+}
+
+/**
+ * Summary of one log's text: backend shape, session id, last agent text,
+ * the final result, the `LOOP_TICK_RESULT` line, gate ids and reply stamps.
+ * Never throws; unknown lines are skipped.
+ */
+export function summarizeRunLog(text, redact = (s) => s) {
+  const out = {
+    format: null,
+    sessionId: null,
+    events: 0,
+    lastText: "",
+    result: null,
+    sentinel: null,
+    gates: [],
+    replies: [],
+  };
+  let acpTurn = "";
+  const noteText = (t) => {
+    if (!t) return;
+    out.lastText = t;
+    const gate = GATE_RE.exec(t);
+    if (gate?.[1] && out.gates.length < MAX_LIST) out.gates.push(gate[1]);
+  };
+  const noteReply = (t) => {
+    const m = REPLY_RE.exec(t);
+    if (m && out.replies.length < MAX_LIST) out.replies.push(m[0].trim());
+  };
+  for (const raw of String(text ?? "").split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith("{")) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isRecord(ev)) continue;
+    out.events += 1;
+    // cursor-acp: JSON-RPC 2.0 transcript (both directions).
+    if (ev.jsonrpc === "2.0") {
+      out.format ??= "acp";
+      const params = isRecord(ev.params) ? ev.params : null;
+      if (ev.method === "session/update" && isRecord(params?.update)) {
+        const u = params.update;
+        if (u.sessionUpdate === "agent_message_chunk" && isRecord(u.content)) {
+          acpTurn += typeof u.content.text === "string" ? u.content.text : "";
+        }
+      } else if (ev.method === "session/prompt" && params) {
+        noteReply(textOf(params.prompt));
+      } else if (isRecord(ev.result) && typeof ev.result.sessionId === "string") {
+        out.sessionId = ev.result.sessionId;
+      } else if (isRecord(ev.result) && typeof ev.result.stopReason === "string") {
+        noteText(acpTurn);
+        out.result = { isError: false, subtype: ev.result.stopReason, text: cap(acpTurn) };
+        acpTurn = "";
+      } else if (isRecord(ev.error) && ev.id !== undefined && !ev.method) {
+        const message = typeof ev.error.message === "string" ? ev.error.message : "error";
+        out.result = { isError: true, subtype: "error", text: cap(message) };
+      }
+      continue;
+    }
+    const type = ev.type;
+    // codex exec --json
+    if (type === "thread.started" || type === "turn.completed" || type === "turn.failed") {
+      out.format ??= "codex";
+    }
+    if (type === "thread.started" && typeof ev.thread_id === "string") out.sessionId = ev.thread_id;
+    else if (type === "item.completed" && isRecord(ev.item)) {
+      const kind = ev.item.type ?? ev.item.item_type;
+      if (
+        (kind === "agent_message" || kind === "assistant_message") &&
+        typeof ev.item.text === "string"
+      ) {
+        noteText(ev.item.text);
+      }
+    } else if (type === "turn.completed") {
+      out.result = { isError: false, subtype: "success", text: cap(out.lastText) };
+    } else if (type === "turn.failed") {
+      const message =
+        isRecord(ev.error) && typeof ev.error.message === "string" ? ev.error.message : "failed";
+      out.result = { isError: true, subtype: "error", text: cap(message) };
+    }
+    // claude / cursor-agent stream-json
+    else if (type === "system" && ev.subtype === "init") {
+      out.format ??= "stream-json";
+      if (typeof ev.session_id === "string") out.sessionId = ev.session_id;
+    } else if (type === "assistant" && isRecord(ev.message)) {
+      noteText(textOf(ev.message.content));
+    } else if (type === "user" && ev.isReplay === true && isRecord(ev.message)) {
+      noteReply(textOf(ev.message.content));
+    } else if (type === "result") {
+      out.format ??= "stream-json";
+      const resultText = typeof ev.result === "string" ? ev.result : "";
+      if (resultText) noteText(resultText);
+      out.result = {
+        isError: ev.is_error === true,
+        subtype: typeof ev.subtype === "string" ? ev.subtype : null,
+        text: cap(resultText),
+      };
+    }
+  }
+  const sentinel = SENTINEL_RE.exec(out.result?.text || out.lastText);
+  out.sentinel = sentinel ? `LOOP_TICK_RESULT: ${sentinel[1].trim()}` : null;
+  out.lastText = cap(out.lastText);
+  out.gates = [...new Set(out.gates)];
+  out.lastText = redact(out.lastText);
+  if (out.result) out.result.text = redact(out.result.text);
+  out.replies = out.replies.map((r) => redact(r));
+  return out;
+}
+
+/**
+ * Runner state dir for the loop logs: mirrors `resolveStateDir` in
+ * packages/cli/src/utils/kit-paths.ts (`AGENT_KIT_STATE_ROOT`, `.cursor` or
+ * `.agent-kit`, anything else falls back to `.cursor`). HTML/ESM cannot import
+ * the TS module; a parity test keeps the two in step.
+ */
+export function resolveRunnerStateDir(env = process.env) {
+  const raw = String(env?.AGENT_KIT_STATE_ROOT ?? "")
+    .trim()
+    .replace(/\/+$/, "");
+  return raw === ".agent-kit" ? ".agent-kit" : ".cursor";
+}
+
+/** Read the tail of a file (the newest events matter; the head may be a long prompt echo). */
+function readTail(file, size) {
+  const text = readFileSync(file, "utf8");
+  if (size <= MAX_RUN_LOG_BYTES) return text;
+  const tail = text.slice(-MAX_RUN_LOG_BYTES);
+  const cut = tail.indexOf("\n");
+  return cut === -1 ? tail : tail.slice(cut + 1);
+}
+
+/**
+ * Rows for the newest headless logs under `<root>/<stateDir>/loop-logs/`.
+ * A missing directory or unreadable file yields fewer rows, never an error.
+ */
+export function collectRunLogs(root, opts = {}) {
+  const stateDir = opts.stateDir ?? resolveRunnerStateDir();
+  const redact = typeof opts.redact === "function" ? opts.redact : (s) => s;
+  const max = opts.max ?? MAX_RUN_LOGS;
+  const dir = join(root, stateDir, "loop-logs");
+  let names;
+  try {
+    names = readdirSync(dir).filter((f) => LOG_NAME_RE.test(f));
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const name of names) {
+    try {
+      const st = statSync(join(dir, name));
+      if (st.isFile()) files.push({ name, mtimeMs: st.mtimeMs, size: st.size });
+    } catch {
+      // vanished between readdir and stat
+    }
+  }
+  files.sort((a, b) => b.mtimeMs - a.mtimeMs || (a.name < b.name ? 1 : -1));
+  const rows = [];
+  for (const f of files.slice(0, max)) {
+    try {
+      const summary = summarizeRunLog(readTail(join(dir, f.name), f.size), redact);
+      rows.push({
+        id: f.name,
+        kind: f.name.startsWith("tick-") ? "tick" : "run",
+        path: `${stateDir}/loop-logs/${f.name}`,
+        updatedAt: new Date(f.mtimeMs).toISOString(),
+        bytes: f.size,
+        source: "loop-logs",
+        ...summary,
+      });
+    } catch {
+      // unreadable log: skipped
+    }
+  }
+  return rows;
+}

package/dist/{add-7UMSGVWC.js → add-KQJE3ZTG.js}

@@ -5,7 +5,7 @@ import {
 import {
   REGISTRY_CLI_ARGS,
   resolveRegistryFromCli
-} from "./chunk-XWPO3VYQ.js";
+} from "./chunk-ZDCEAGD4.js";
 import {
   logger
 } from "./chunk-ZB43YMHW.js";
@@ -22,11 +22,11 @@ import {
   resolveProtectedGlobs,
   saveManifest,
   upsertIdList
-} from "./chunk-VS2JD2XC.js";
-import "./chunk-5VCOWTTP.js";
+} from "./chunk-WSJ77EHO.js";
 import {
   KIT_VERSION
 } from "./chunk-7HDQEK6T.js";
+import "./chunk-C26I6HTO.js";
 import "./chunk-77V75A7O.js";
 
 // src/commands/add.ts

package/dist/{chunk-KD2MYBB6.js → chunk-3J3I2W22.js}

@@ -1,6 +1,6 @@
 import {
   HANDOFF_REL
-} from "./chunk-5VCOWTTP.js";
+} from "./chunk-C26I6HTO.js";
 import {
   ensureDir
 } from "./chunk-77V75A7O.js";

package/dist/{chunk-YGBBHKBE.js → chunk-6FXQINND.js}

@@ -1,11 +1,11 @@
 import {
   managedPairs
-} from "./chunk-6QV2BFGA.js";
+} from "./chunk-GSCXFJB7.js";
 import {
   isProtectedPath,
   resolveContained,
   resolveProtectedGlobs
-} from "./chunk-VS2JD2XC.js";
+} from "./chunk-WSJ77EHO.js";
 
 // src/lifecycle/diff.ts
 import { readFile } from "fs/promises";