@mutmutco/cli 2.54.1 → 2.55.0

package/dist/overlord-controller.cjs

@@ -0,0 +1,322 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/overlord-controller.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/overlord.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
+
+// src/atomic-write.ts
+var import_node_fs = require("node:fs");
+function atomicWriteFileSync(path, content) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(tmp, content, "utf8");
+  (0, import_node_fs.renameSync)(tmp, path);
+}
+
+// src/overlord.ts
+function isoNow(now = () => /* @__PURE__ */ new Date()) {
+  return now().toISOString();
+}
+function buildCodexFuguLaunch(slot, options) {
+  const args = [];
+  if (slot.role === "ultra") args.push("--model", "fugu-ultra");
+  args.push("--no-alt-screen");
+  if (options.profile === "full-trust-repair") {
+    args.push("-a", "never", "-s", "danger-full-access");
+    if (options.cwd) args.push("-C", options.cwd);
+    return { command: "codex-fugu", args };
+  }
+  const sandbox = options.profile === "implementation" ? "workspace-write" : "read-only";
+  if (options.profile === "implementation" && !options.cwd) {
+    throw new Error("implementation servant launch requires an owned worktree cwd");
+  }
+  args.push(
+    "-a",
+    "never",
+    "-s",
+    sandbox,
+    "-c",
+    'sandbox_permissions=["disk-full-read-access"]'
+  );
+  if (options.cwd) args.push("-C", options.cwd);
+  return { command: "codex-fugu", args };
+}
+function readOverlordRegistry(statePath2) {
+  if (!(0, import_node_fs2.existsSync)(statePath2)) return { runs: {} };
+  try {
+    const parsed = JSON.parse((0, import_node_fs2.readFileSync)(statePath2, "utf8"));
+    return { activeRunId: parsed.activeRunId, runs: parsed.runs ?? {} };
+  } catch {
+    return { runs: {} };
+  }
+}
+function writeOverlordRegistry(statePath2, registry) {
+  (0, import_node_fs2.mkdirSync)((0, import_node_path.dirname)(statePath2), { recursive: true });
+  atomicWriteFileSync(statePath2, `${JSON.stringify(registry, null, 2)}
+`);
+}
+function recordOverlordHeartbeat(run, options) {
+  const timestamp = isoNow(options.now);
+  const controllerResource = {
+    kind: "process",
+    pid: options.controllerPid,
+    commandName: "mmi-cli overlord controller",
+    runId: run.runId,
+    runToken: run.runToken,
+    fingerprint: options.fingerprint
+  };
+  const others = run.ownedResources.filter((resource) => resource.commandName !== "mmi-cli overlord controller");
+  return {
+    ...run,
+    state: run.state === "starting" ? "active" : run.state,
+    updatedAt: timestamp,
+    controllerPid: options.controllerPid,
+    controllerFingerprint: options.fingerprint,
+    lastControllerHeartbeatAt: timestamp,
+    ownedResources: [controllerResource, ...others]
+  };
+}
+function recordOverlordControllerHeartbeat(runId2, statePath2, fingerprint2, controllerPid, now = () => /* @__PURE__ */ new Date()) {
+  const registry = readOverlordRegistry(statePath2);
+  const run = registry.runs[runId2];
+  if (!run || run.state === "stopped" || run.state === "failed") return false;
+  const next = recordOverlordHeartbeat(run, { controllerPid, fingerprint: fingerprint2, now });
+  writeOverlordRegistry(statePath2, {
+    ...registry,
+    activeRunId: registry.activeRunId ?? runId2,
+    runs: { ...registry.runs, [runId2]: next }
+  });
+  return true;
+}
+
+// src/overlord-controller.ts
+var [runId, statePath, fingerprint] = process.argv.slice(2);
+if (!runId || !statePath || !fingerprint) {
+  console.error("mmi-cli overlord controller: missing run id, state path, or fingerprint");
+  process.exit(2);
+}
+var intervalMs = Number(process.env.MMI_OVERLORD_HEARTBEAT_MS ?? 1e4);
+var servants = /* @__PURE__ */ new Map();
+function heartbeat() {
+  const alive = recordOverlordControllerHeartbeat(runId, statePath, fingerprint, process.pid);
+  if (!alive) process.exit(0);
+}
+function servantPrompt(servant, run) {
+  const roleLine = servant.role === "ultra" ? "You are the single Ultra Fugu: take the hardest, highest-uncertainty questions and report calibrated judgment." : "You are a normal Fugu servant: take one bounded mission at a time and report concise evidence.";
+  return [
+    `You are ${servant.name} in Overlord run ${run.runId}.`,
+    roleLine,
+    "First respond with exactly: ACK " + servant.name + " ready",
+    "After the ACK, wait for the Overlord to assign bounded work.",
+    "Do not start dev servers, browsers, Playwright, PRs, merges, releases, or worktree changes unless the Overlord explicitly assigns that scope.",
+    "When assigned work, gather evidence before editing, verify before claiming done, and escalate blockers instead of looping."
+  ].join("\n");
+}
+function quoteCmdArg(arg) {
+  const normalized = arg.replace(/\r?\n/g, " ");
+  return `"${normalized.replace(/"/g, '\\"')}"`;
+}
+function ptyLaunchCommand(command, args) {
+  if (process.platform !== "win32") return { file: command, args };
+  return {
+    file: "cmd.exe",
+    args: `/d /s /c ${command} ${args.map(quoteCmdArg).join(" ")}`
+  };
+}
+function servantFingerprint(run, servant) {
+  return `mmi-overlord-servant:${run.runId}:${servant.slotId}`;
+}
+function writeJournal(servant, text) {
+  try {
+    (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(servant.journalPath), { recursive: true });
+    (0, import_node_fs3.appendFileSync)(servant.journalPath, text, "utf8");
+  } catch {
+  }
+}
+function upsertOwnedResource(resources, resource) {
+  return [
+    resource,
+    ...resources.filter(
+      (existing) => !(existing.kind === resource.kind && existing.pid === resource.pid && existing.fingerprint === resource.fingerprint)
+    )
+  ];
+}
+function updateServant(slotId, mutate) {
+  const registry = readOverlordRegistry(statePath);
+  const run = registry.runs[runId];
+  if (!run) return;
+  const nextServants = run.servants.map((servant) => servant.slotId === slotId ? mutate(run, servant) : servant);
+  writeOverlordRegistry(statePath, {
+    ...registry,
+    runs: {
+      ...registry.runs,
+      [runId]: {
+        ...run,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        servants: nextServants
+      }
+    }
+  });
+}
+function recordServantStart(run, servant, pid, servantFp) {
+  const registry = readOverlordRegistry(statePath);
+  const current = registry.runs[run.runId] ?? run;
+  const resource = {
+    kind: "process",
+    pid,
+    commandName: "codex-fugu",
+    runId: run.runId,
+    runToken: run.runToken,
+    fingerprint: servantFp
+  };
+  writeOverlordRegistry(statePath, {
+    ...registry,
+    activeRunId: registry.activeRunId ?? run.runId,
+    runs: {
+      ...registry.runs,
+      [run.runId]: {
+        ...current,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        servants: current.servants.map((item) => item.slotId === servant.slotId ? {
+          ...item,
+          state: "starting",
+          pid,
+          fingerprint: servantFp,
+          composerSubmitMode: "crlf",
+          lastLivenessCheckAt: (/* @__PURE__ */ new Date()).toISOString()
+        } : item),
+        ownedResources: upsertOwnedResource(current.ownedResources, resource)
+      }
+    }
+  });
+}
+function markServantExit(slotId) {
+  updateServant(slotId, (_run, servant) => ({
+    ...servant,
+    state: servant.state === "stopped" ? "stopped" : "lost",
+    lastLivenessCheckAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
+function markServantAck(slotId) {
+  updateServant(slotId, (_run, servant) => ({
+    ...servant,
+    state: "ready",
+    lastAckAt: (/* @__PURE__ */ new Date()).toISOString(),
+    lastUsefulSignalAt: (/* @__PURE__ */ new Date()).toISOString()
+  }));
+}
+function messageTargets(run, target) {
+  if (target === "all") return run.servants;
+  return run.servants.filter((servant) => servant.slotId === target || servant.name.toLowerCase().replace(/\s+/g, "-") === target);
+}
+function deliverPendingMessages() {
+  const registry = readOverlordRegistry(statePath);
+  const run = registry.runs[runId];
+  if (!run?.messages?.length) return;
+  let changed = false;
+  const nextMessages = run.messages.map((message) => {
+    if (message.deliveredAt) return message;
+    const targets = messageTargets(run, message.target);
+    if (!targets.length) return message;
+    const liveTargets = targets.map((servant) => servants.get(servant.slotId));
+    if (liveTargets.some((servant) => !servant)) return message;
+    for (const child of liveTargets) child?.write(`${message.text}\r
+`);
+    changed = true;
+    return { ...message, deliveredAt: (/* @__PURE__ */ new Date()).toISOString() };
+  });
+  if (!changed) return;
+  writeOverlordRegistry(statePath, {
+    ...registry,
+    runs: {
+      ...registry.runs,
+      [runId]: {
+        ...run,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        messages: nextMessages
+      }
+    }
+  });
+}
+async function launchServants() {
+  const registry = readOverlordRegistry(statePath);
+  const run = registry.runs[runId];
+  if (!run || run.state === "stopped" || run.state === "failed") return;
+  const pty = await import("@homebridge/node-pty-prebuilt-multiarch");
+  (0, import_node_fs3.mkdirSync)(run.journalDir, { recursive: true });
+  for (const servant of run.servants) {
+    if (servants.has(servant.slotId) || servant.state === "ready" || servant.state === "starting") continue;
+    const launch = buildCodexFuguLaunch(servant, { profile: servant.profile, cwd: run.worktree });
+    const command = ptyLaunchCommand(launch.command, [...launch.args, servantPrompt(servant, run)]);
+    const child = pty.spawn(command.file, command.args, {
+      name: "xterm-256color",
+      cols: 120,
+      rows: 40,
+      cwd: run.worktree,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        CODEX_FUGU_NO_NOTICE: "1",
+        CODEX_FUGU_NO_UPDATE: "1"
+      }
+    });
+    servants.set(servant.slotId, child);
+    const servantFp = servantFingerprint(run, servant);
+    writeJournal(servant, `
+[overlord] launched ${launch.command} ${launch.args.join(" ")}
+`);
+    recordServantStart(run, servant, child.pid, servantFp);
+    child.onData((data) => {
+      writeJournal(servant, data);
+      if (/ACK\s+.+\s+ready/i.test(data)) markServantAck(servant.slotId);
+    });
+    child.onExit(() => {
+      servants.delete(servant.slotId);
+      markServantExit(servant.slotId);
+    });
+  }
+}
+function shutdown() {
+  for (const child of servants.values()) {
+    try {
+      child.kill();
+    } catch {
+    }
+  }
+  process.exit(0);
+}
+process.on("SIGTERM", shutdown);
+process.on("SIGINT", shutdown);
+heartbeat();
+if (process.env.MMI_OVERLORD_SKIP_SERVANT_LAUNCH !== "1") {
+  void launchServants().then(deliverPendingMessages).catch(() => void 0);
+}
+setInterval(() => {
+  heartbeat();
+  deliverPendingMessages();
+}, Number.isFinite(intervalMs) && intervalMs > 0 ? intervalMs : 1e4);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mutmutco/cli",
-  "version": "2.54.1",
+  "version": "2.55.0",
   "description": "MMI Future CLI — delivers the org rules (whole-file), plus saga and KB access. The cross-IDE engine the plugin's SessionStart hook drives.",
   "type": "module",
   "license": "UNLICENSED",
@@ -35,6 +35,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@homebridge/node-pty-prebuilt-multiarch": "^0.13.1",
     "commander": "^15.0.0"
   },
   "devDependencies": {