@dadado/agent-kit-cli 5.15.1 → 5.16.0

package/dist/chunk-HFUH3HVS.js

@@ -0,0 +1,282 @@
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/commands/dashboard.ts
+import { execFileSync, spawn as spawn2 } from "child_process";
+import { existsSync, readFileSync as readFileSync2, realpathSync } from "fs";
+import { access } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+import { defineCommand } from "citty";
+
+// ../../dashboard/lib/guards.mjs
+import { randomBytes, timingSafeEqual } from "crypto";
+import { networkInterfaces } from "os";
+import { resolve } from "path";
+var REPO_ROOT_ENV = "MISSION_CONTROL_REPO_ROOT";
+var KIT_ROOT_ENV_KEYS = Object.freeze(["MISSION_CONTROL_KIT_ROOT", "AGENT_KIT_HOME"]);
+var CONTEXT_CONFIG_REL = ".cursor/context/config.json";
+var CONFIG_PERSONA_IDS = Object.freeze(["autopilot", "night-shift", "ghost-runner"]);
+var CONFIG_PERSONA_MODES = Object.freeze(["continue-plan", "run-plan", "cli-run-plan"]);
+var CONFIG_REVIEW_BACKENDS = Object.freeze(["auto", "claude", "cursor"]);
+var CONFIG_REVIEW_MODES = Object.freeze(["paste", "autonomous"]);
+var CONFIG_REVIEW_PREFLIGHT = Object.freeze(["off", "warn", "block"]);
+function resolveContextConfigPath(repoRoot, fsHooks = {}) {
+  const exists = fsHooks.existsSync;
+  const realpath = fsHooks.realpathSync;
+  const mkdir = fsHooks.mkdirSync;
+  if (typeof repoRoot !== "string" || !repoRoot) {
+    return { ok: false, error: "invalid repo root" };
+  }
+  const abs = resolve(repoRoot, CONTEXT_CONFIG_REL);
+  const contextDir = resolve(repoRoot, ".cursor", "context");
+  const absNorm = abs.replace(/\\/g, "/");
+  if (!absNorm.endsWith("/.cursor/context/config.json")) {
+    return { ok: false, error: "path escape" };
+  }
+  try {
+    if (typeof mkdir === "function" && typeof exists === "function" && !exists(contextDir)) {
+      mkdir(contextDir, { recursive: true });
+    }
+    if (typeof realpath === "function" && typeof exists === "function" && exists(abs)) {
+      const fileReal = String(realpath(abs)).replace(/\\/g, "/");
+      const rootReal = String(realpath(repoRoot)).replace(/\\/g, "/");
+      if (!fileReal.startsWith(`${rootReal}/`)) {
+        return { ok: false, error: "path escape" };
+      }
+      if (!fileReal.endsWith("/.cursor/context/config.json")) {
+        return { ok: false, error: "path escape" };
+      }
+      return { ok: true, path: realpath(abs) };
+    }
+  } catch {
+    return { ok: false, error: "path escape" };
+  }
+  return { ok: true, path: abs };
+}
+
+// ../../dashboard/lib/open-browser.mjs
+import { spawn, spawnSync } from "child_process";
+import { readFileSync } from "fs";
+import { platform as osPlatform } from "os";
+var OS_DEFAULT_TOKENS = /* @__PURE__ */ new Set(["", "default", "os", "ask"]);
+function isSafePreferredBrowser(value) {
+  if (typeof value !== "string") return false;
+  const s = value.trim();
+  if (!s) return false;
+  if (/[/\\]/.test(s)) return false;
+  if (/[\0-\x1f\x7f]/.test(s)) return false;
+  if (/[$`;&|<>(){}[\]!*?#~"'%^=,+]/.test(s)) return false;
+  if (s.includes(":")) return false;
+  if (/^-/.test(s)) return false;
+  return true;
+}
+function normalizePreferredBrowser(value) {
+  if (value == null) return null;
+  const s = String(value).trim();
+  if (!s || OS_DEFAULT_TOKENS.has(s.toLowerCase())) return null;
+  if (!isSafePreferredBrowser(s)) return null;
+  return s;
+}
+function readPreferredBrowserFromConfig(configPath, fsHooks = {}) {
+  const read = fsHooks.readFileSync ?? readFileSync;
+  try {
+    const raw = read(configPath, "utf8");
+    const data = JSON.parse(raw);
+    if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+    const mc = data.missionControl;
+    if (!mc || typeof mc !== "object" || Array.isArray(mc)) return null;
+    return mc.preferredBrowser ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/dashboard.ts
+function readPreferredBrowserFromWorkspace(cwd, readFile = readFileSync2) {
+  const resolved = resolveContextConfigPath(path.resolve(cwd), {
+    existsSync,
+    realpathSync
+  });
+  if (!resolved.ok) return null;
+  const value = readPreferredBrowserFromConfig(resolved.path, { readFileSync: readFile });
+  return normalizePreferredBrowser(value);
+}
+function applyDashboardOpenEnv(env, opts) {
+  const next = { ...env };
+  if (opts.noOpen) next.MISSION_CONTROL_NO_OPEN = "1";
+  const flag = opts.browser?.trim();
+  if (flag) {
+    const safe = normalizePreferredBrowser(flag);
+    if (safe) next.MISSION_CONTROL_PREFERRED_BROWSER = safe;
+  } else if (!next.MISSION_CONTROL_PREFERRED_BROWSER && opts.cwd) {
+    const fromConfig = readPreferredBrowserFromWorkspace(opts.cwd);
+    if (fromConfig) next.MISSION_CONTROL_PREFERRED_BROWSER = fromConfig;
+  }
+  return next;
+}
+function dashboardSpawnEnv(env, snapshotRoot, opts) {
+  const root = path.resolve(snapshotRoot);
+  return applyDashboardOpenEnv({ ...env, MISSION_CONTROL_REPO_ROOT: root }, { ...opts, cwd: root });
+}
+function dashboardProcessTitle(snapshotRoot) {
+  const base = path.basename(path.resolve(snapshotRoot)) || "workspace";
+  return `Mission Control \xB7 ${base}`;
+}
+function bundledDashboardCandidates(filename, moduleUrl = import.meta.url) {
+  const here = path.dirname(fileURLToPath(moduleUrl));
+  return [
+    // Published / built: <pkg>/dist/index.js -> <pkg>/dashboard/
+    path.join(here, "..", "dashboard", filename),
+    // Dev source: packages/cli/src/commands/*.ts -> packages/cli/dashboard/ (sync copy)
+    path.join(here, "..", "..", "dashboard", filename),
+    // From src/commands: packages/dashboard/ (unused layout); from dist: two levels above package
+    path.join(here, "..", "..", "..", "dashboard", filename)
+  ];
+}
+async function firstExisting(candidates) {
+  for (const candidate of candidates) {
+    try {
+      await access(candidate);
+      return path.resolve(candidate);
+    } catch {
+    }
+  }
+  return null;
+}
+async function findDashboardStart(cwd, env = process.env, options = {}) {
+  let dir = path.resolve(cwd);
+  for (; ; ) {
+    const candidate = path.join(dir, "dashboard", "start.mjs");
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  for (const key of ["MISSION_CONTROL_KIT_ROOT", "AGENT_KIT_HOME"]) {
+    const base = env[key];
+    if (!base || typeof base !== "string" || !base.trim()) continue;
+    const candidate = path.join(path.resolve(base.trim()), "dashboard", "start.mjs");
+    try {
+      await access(candidate);
+      return candidate;
+    } catch {
+    }
+  }
+  const sibling = path.join(path.resolve(cwd), "..", "agent-kit", "dashboard", "start.mjs");
+  try {
+    await access(sibling);
+    return path.resolve(sibling);
+  } catch {
+  }
+  return firstExisting(
+    bundledDashboardCandidates("start.mjs", options.moduleUrl ?? import.meta.url)
+  );
+}
+function resolveDashboardSnapshotRoot(cwd) {
+  const abs = path.resolve(cwd);
+  let dir = abs;
+  for (; ; ) {
+    if (existsSync(path.join(dir, ".cursor", "agent-kit.json"))) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  try {
+    const top = execFileSync("git", ["-C", abs, "rev-parse", "--show-toplevel"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    if (top) return path.resolve(top);
+  } catch {
+  }
+  return abs;
+}
+function runStartScript(startPath, env) {
+  return new Promise((resolve2, reject) => {
+    const child = spawn2(process.execPath, [startPath], {
+      cwd: path.dirname(path.dirname(startPath)),
+      env,
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve2(code ?? 1));
+  });
+}
+var dashboardCommand = defineCommand({
+  meta: {
+    name: "dashboard",
+    description: "Start Mission Control for this workspace (loopback; opens panel URL)."
+  },
+  args: {
+    cwd: {
+      type: "string",
+      default: process.cwd(),
+      description: "Workspace to snapshot (nearest .cursor/agent-kit.json, else git root); also searched upward for dashboard/start.mjs"
+    },
+    "no-open": {
+      type: "boolean",
+      default: false,
+      description: "Do not open a browser; only ensure the server is up and print the URL"
+    },
+    browser: {
+      type: "string",
+      description: "Preferred browser app/binary for this launch (overrides config missionControl.preferredBrowser)"
+    }
+  },
+  async run({ args }) {
+    const snapshotRoot = resolveDashboardSnapshotRoot(args.cwd);
+    const startPath = await findDashboardStart(args.cwd);
+    if (!startPath) {
+      logger.error("No dashboard/start.mjs found.");
+      console.error(
+        [
+          "",
+          "The dashboard runtime is not available in this workspace.",
+          "L0 install provides the /dashboard command text but not the panel itself.",
+          "",
+          "Recovery (pick one):",
+          "  1. Upgrade the CLI: npx @dadado/agent-kit-cli@latest dashboard",
+          "     (Path C ships dashboard/ from 4.8.2 onward)",
+          "  2. Set an env var pointing to an agent-kit checkout:",
+          "     export MISSION_CONTROL_KIT_ROOT=/path/to/agent-kit",
+          "     agent-kit dashboard",
+          "  3. Place an agent-kit sibling: ../agent-kit/dashboard/start.mjs",
+          "  4. Run directly from a kit tree: node dashboard/start.mjs",
+          "",
+          "Works in Cursor, VS Code, and any Node.js terminal.",
+          ""
+        ].join("\n")
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const env = dashboardSpawnEnv({ ...process.env }, snapshotRoot, {
+      noOpen: Boolean(args["no-open"]),
+      browser: args.browser
+    });
+    process.title = dashboardProcessTitle(snapshotRoot);
+    const code = await runStartScript(startPath, env);
+    if (code !== 0) process.exitCode = code;
+  }
+});
+
+export {
+  REPO_ROOT_ENV,
+  readPreferredBrowserFromWorkspace,
+  applyDashboardOpenEnv,
+  dashboardSpawnEnv,
+  dashboardProcessTitle,
+  bundledDashboardCandidates,
+  findDashboardStart,
+  resolveDashboardSnapshotRoot,
+  dashboardCommand
+};

package/dist/chunk-HS7LVVLO.js

@@ -0,0 +1,74 @@
+import {
+  logger
+} from "./chunk-ZB43YMHW.js";
+
+// src/lifecycle/report.ts
+function logApplyStats(stats) {
+  if (stats.written.length > 0) {
+    logger.success(`Wrote ${stats.written.length} file(s)`);
+    for (const p of stats.written) logger.info(`  + ${p}`);
+  }
+  if (stats.unchanged.length > 0) {
+    logger.info(`Unchanged: ${stats.unchanged.length}`);
+  }
+  if (stats.removed.length > 0) {
+    logger.info(`Removed managed legacy files: ${stats.removed.length}`);
+    for (const p of stats.removed) logger.info(`  - ${p}`);
+  }
+  if (stats.collisions.length > 0) {
+    logger.warn("Slash collision preserved because the legacy command is customized:");
+    for (const p of stats.collisions) logger.info(`  ! ${p}`);
+  }
+  if (stats.preservedCustomized.length > 0) {
+    logger.warn(
+      `Preserved customized overlay (agents/skills/commands/hooks/scripts); local body kept, kit body not applied: ${stats.preservedCustomized.length}`
+    );
+    for (const p of stats.preservedCustomized) logger.info(`  ! ${p}`);
+    logger.info(
+      "  Run `agent-kit diff` to see the kit body; send the change upstream (`agent-kit contribute` for agents/skills/commands/hooks, a factory PR for scripts); or add the path to `protected` in .cursor/agent-kit.json to keep it pinned on purpose."
+    );
+  }
+  if (stats.skippedProtected.length > 0) {
+    logger.warn(`Skipped protected (L3): ${stats.skippedProtected.length}`);
+    for (const p of stats.skippedProtected) logger.info(`  ~ ${p}`);
+  }
+  if (stats.skippedSymlink.length > 0) {
+    logger.warn(
+      `Skipped symlinked path (resolves outside the registry/project root, or is a symlink): ${stats.skippedSymlink.length}`
+    );
+    for (const p of stats.skippedSymlink) logger.info(`  ~ ${p}`);
+  }
+  if (stats.missing.length > 0) {
+    logger.warn(`Missing in registry: ${stats.missing.length}`);
+    for (const p of stats.missing) logger.info(`  ? ${p}`);
+  }
+}
+function listSkippedPaths(paths) {
+  const shown = paths.slice(0, 5).join(", ");
+  const more = paths.length > 5 ? ` (+${paths.length - 5} more)` : "";
+  return `${shown}${more}`;
+}
+function formatSkippedSymlinks(paths) {
+  return `${paths.length} kit path(s) were not written because they resolve outside the project (symlink): ${listSkippedPaths(paths)}. Manifest version left unchanged; replace the symlinked directory with a real one inside the project and re-run.`;
+}
+function formatPersonalizationSkippedSymlinks(paths, notRecorded) {
+  const ids = notRecorded.length > 0 ? notRecorded.join(", ") : "none";
+  return `${paths.length} personalization path(s) were not written because they resolve outside the project (symlink): ${listSkippedPaths(paths)}. Manifest saved without: ${ids}; replace the symlinked directory with a real one inside the project and re-run.`;
+}
+var SkippedSymlinkError = class extends Error {
+  constructor(stats, message = formatSkippedSymlinks(stats.skippedSymlink), claudeSessionStartInstructions) {
+    super(message);
+    this.stats = stats;
+    this.claudeSessionStartInstructions = claudeSessionStartInstructions;
+    this.name = "SkippedSymlinkError";
+  }
+  stats;
+  claudeSessionStartInstructions;
+};
+
+export {
+  logApplyStats,
+  formatSkippedSymlinks,
+  formatPersonalizationSkippedSymlinks,
+  SkippedSymlinkError
+};

package/dist/chunk-IHROBTNM.js

@@ -0,0 +1,135 @@
+// src/invariants/handoff-prune.ts
+var HANDOFF_MACHINE_FIELD_LABELS = [
+  "Plan",
+  "Last updated",
+  "Mode",
+  "Phase completed",
+  "Next phase",
+  "Completed to-dos",
+  "Next to-dos",
+  "Parked plans",
+  "Backlog plans",
+  "Run queue",
+  "Queue cursor",
+  "Queue status",
+  "Queue outcomes",
+  "Gaps",
+  "Instruction for the next agent"
+];
+var HANDOFF_FIXED_SECTION_HEADING_PREFIXES = [
+  "## Work Status",
+  "## Session Context",
+  "## Files Touched",
+  "## Decisions Made",
+  "## Issues Found",
+  "## Run queue (multi-plan only)"
+];
+var HANDOFF_MAX_LINES = 200;
+var HANDOFF_MAX_LINE_LENGTH = 2e3;
+var MACHINE_FIELD_RE = new RegExp(
+  `^- \\*\\*(${HANDOFF_MACHINE_FIELD_LABELS.map((l) => l.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")}):\\*\\*`
+);
+function isChunkStart(line) {
+  return /^- \*\*/.test(line) || /^## /.test(line);
+}
+function isFixedSectionHeading(line) {
+  return HANDOFF_FIXED_SECTION_HEADING_PREFIXES.some((p) => line.startsWith(p));
+}
+function splitIntoChunks(lines) {
+  const firstStart = lines.findIndex(isChunkStart);
+  if (firstStart === -1) return { preamble: lines, chunks: [] };
+  const preamble = lines.slice(0, firstStart);
+  const chunks = [];
+  let current = [lines[firstStart]];
+  for (const line of lines.slice(firstStart + 1)) {
+    if (isChunkStart(line)) {
+      chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+      current = [line];
+    } else {
+      current.push(line);
+    }
+  }
+  chunks.push({ lines: current, isMachineField: MACHINE_FIELD_RE.test(current[0] ?? "") });
+  return { preamble, chunks };
+}
+function pruneHandoffText(text, keep) {
+  if (!text.trim()) {
+    return { ok: false, reason: "empty file" };
+  }
+  const lines = text.split("\n");
+  const titleIdx = lines.findIndex((l) => /^# /.test(l));
+  if (titleIdx === -1) {
+    return { ok: false, reason: "no H1 title line found" };
+  }
+  let fixedStartIdx = lines.findIndex((l) => isFixedSectionHeading(l));
+  if (fixedStartIdx === -1) fixedStartIdx = lines.length;
+  const head = lines.slice(0, titleIdx + 1);
+  const narrativeLines = lines.slice(titleIdx + 1, fixedStartIdx);
+  const trailingLines = lines.slice(fixedStartIdx);
+  const { preamble, chunks } = splitIntoChunks(narrativeLines);
+  const machineFieldCount = chunks.filter((c) => c.isMachineField).length;
+  if (machineFieldCount === 0) {
+    return { ok: false, reason: "no machine-field bullets found; refusing to prune" };
+  }
+  if (fixedStartIdx === lines.length) {
+    return { ok: false, reason: "no recognized fixed-section heading found; refusing to prune" };
+  }
+  const narrativeChunks = chunks.filter((c) => !c.isMachineField);
+  if (narrativeChunks.length <= keep) {
+    return { ok: true, text, archived: [], keptCount: narrativeChunks.length };
+  }
+  const keptNarrativeIdx = /* @__PURE__ */ new Set();
+  let seen = 0;
+  const chunkIsNarrative = chunks.map((c) => !c.isMachineField);
+  for (let i = 0; i < chunks.length; i++) {
+    if (chunkIsNarrative[i]) {
+      if (seen < keep) keptNarrativeIdx.add(i);
+      seen++;
+    }
+  }
+  const keptChunks = [];
+  const archivedChunks = [];
+  chunks.forEach((c, i) => {
+    if (c.isMachineField || keptNarrativeIdx.has(i)) keptChunks.push(c);
+    else archivedChunks.push(c);
+  });
+  const newNarrativeLines = [...preamble, ...keptChunks.flatMap((c) => c.lines)];
+  const newLines = [...head, ...newNarrativeLines, ...trailingLines];
+  return {
+    ok: true,
+    text: newLines.join("\n"),
+    archived: archivedChunks.map((c) => c.lines.join("\n")),
+    keptCount: keptNarrativeIdx.size
+  };
+}
+function checkHandoffGrowth(text) {
+  if (!text.trim()) return [];
+  const lines = text.split("\n");
+  const warnings = [];
+  if (lines.length > HANDOFF_MAX_LINES) {
+    warnings.push({
+      code: "file-over-limit",
+      message: `HANDOFF.md is ${lines.length} lines, over the ${HANDOFF_MAX_LINES}-line growth-contract limit. Run \`agent-kit handoff --prune\` to archive older narrative entries.`
+    });
+  }
+  let firstOffendingLine = -1;
+  let overCount = 0;
+  lines.forEach((l, i) => {
+    if (l.length > HANDOFF_MAX_LINE_LENGTH) {
+      overCount++;
+      if (firstOffendingLine === -1) firstOffendingLine = i + 1;
+    }
+  });
+  if (overCount > 0) {
+    warnings.push({
+      code: "line-over-limit",
+      message: `HANDOFF.md has ${overCount} line(s) over the ${HANDOFF_MAX_LINE_LENGTH}-char growth-contract limit (first at line ${firstOffendingLine}). Wrap long paragraphs; do not widen the limit.`
+    });
+  }
+  return warnings;
+}
+
+export {
+  pruneHandoffText,
+  checkHandoffGrowth
+};