@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/inspectors/herdr/focus.js

@@ -0,0 +1,47 @@
+export function herdrPaneRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return;
+  const record = value;
+  return record.pane && typeof record.pane === "object" && !Array.isArray(record.pane) ? record.pane : record;
+}
+function text(record, ...keys) {
+  for (const key of keys)
+    if (typeof record[key] === "string" && record[key])
+      return record[key];
+  return;
+}
+export function herdrPaneFocusTarget(value) {
+  const pane = herdrPaneRecord(value);
+  if (!pane)
+    return {};
+  return {
+    paneId: text(pane, "pane_id", "paneId", "id"),
+    tabId: text(pane, "tab_id", "tabId"),
+    workspaceId: text(pane, "workspace_id", "workspaceId")
+  };
+}
+export async function focusHerdrPane(client, paneId, signal) {
+  const live = await client.run(["pane", "get", paneId], { timeoutMs: 5000, signal });
+  if (live.ok === false)
+    return live;
+  const target = herdrPaneFocusTarget(live.data);
+  if (!target.paneId) {
+    return { ok: false, error: { code: "INVALID_PANE_RESPONSE", message: `Herdr pane get returned no pane id for '${paneId}'.`, details: live.data } };
+  }
+  if (target.tabId) {
+    const focused = await client.run(["tab", "focus", target.tabId], { timeoutMs: 5000, signal });
+    return focused.ok ? { ok: true, data: { paneId: target.paneId, tabId: target.tabId, ...target.workspaceId ? { workspaceId: target.workspaceId } : {} } } : focused;
+  }
+  if (target.workspaceId) {
+    const focused = await client.run(["workspace", "focus", target.workspaceId], { timeoutMs: 5000, signal });
+    return focused.ok ? { ok: true, data: { paneId: target.paneId, workspaceId: target.workspaceId } } : focused;
+  }
+  return {
+    ok: false,
+    error: {
+      code: "PANE_FOCUS_UNSUPPORTED",
+      message: `Herdr pane '${paneId}' has no tab_id or workspace_id. Select it in Herdr manually, or upgrade Herdr focus support.`,
+      details: live.data
+    }
+  };
+}

package/extensions/dm-subagents/src/inspectors/herdr/inspector-runner.js

@@ -0,0 +1,160 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { fileURLToPath } from "node:url";
+import { parseMissionRecord } from "../../missions/store.js";
+import { requestAsyncSteer, requestAsyncStop } from "../../runs/background/control-channel.js";
+import { formatAsyncRunTranscript } from "../../runs/background/fleet-view.js";
+import { steeringReceipt } from "../../runs/background/steering.js";
+import { readStatus } from "../../shared/utils.js";
+import { decodeSessionRoots } from "./session-roots-codec.js";
+function readMission(filePath) {
+  if (!filePath)
+    return;
+  try {
+    return parseMissionRecord(JSON.parse(fs.readFileSync(filePath, "utf-8")), filePath);
+  } catch {
+    return;
+  }
+}
+export function formatInspectorDashboard(input) {
+  const { status, asyncDir, mission } = input;
+  const lines = [
+    `dm-subagents inspector for ${status.runId}`,
+    "This pane mirrors lifecycle artifacts; closing it does not stop the run.",
+    ""
+  ];
+  if (mission) {
+    lines.push(`Mission: ${mission.title} (${mission.status})`, `Mission id: ${mission.id}`);
+    const open = mission.decisions.filter((decision) => decision.status === "open");
+    if (open.length)
+      lines.push(`Open decisions: ${open.map((decision) => `${decision.id}: ${decision.title}`).join(" | ")}`);
+    lines.push("");
+  }
+  lines.push(formatAsyncRunTranscript(status, asyncDir, { index: input.index, lines: 60, sessionRoots: input.sessionRoots }));
+  const controls = [input.allowSteer === false ? undefined : "steer <message>", input.allowStop === false ? undefined : "stop", "status"].filter(Boolean);
+  lines.push("", `Controls: ${controls.join(" | ")}`, "Supervisor replies remain in the parent DM session (subagent_supervisor/intercom).");
+  return lines.join(`
+`);
+}
+function parseArgs(argv) {
+  const values = new Map;
+  for (let index = 0;index < argv.length; index += 2) {
+    const key = argv[index];
+    const value = argv[index + 1];
+    if (!key?.startsWith("--") || value === undefined)
+      throw new Error(`Invalid inspector argument '${key ?? ""}'.`);
+    values.set(key, value);
+  }
+  const asyncDir = values.get("--async-dir");
+  const runId = values.get("--run-id");
+  if (!asyncDir || !runId)
+    throw new Error("Inspector requires --async-dir and --run-id.");
+  const indexRaw = values.get("--index");
+  const childIndex = indexRaw === undefined ? undefined : Number(indexRaw);
+  if (childIndex !== undefined && (!Number.isInteger(childIndex) || childIndex < 0))
+    throw new Error("--index must be a non-negative integer.");
+  const sessionRootsRaw = values.get("--session-roots");
+  const sessionRoots = sessionRootsRaw === undefined ? [] : decodeSessionRoots(sessionRootsRaw);
+  const refreshRaw = values.get("--refresh-ms");
+  const refreshMs = refreshRaw === undefined ? 1500 : Number(refreshRaw);
+  if (!Number.isInteger(refreshMs) || refreshMs < 250)
+    throw new Error("--refresh-ms must be an integer >= 250.");
+  return {
+    asyncDir: path.resolve(asyncDir),
+    runId,
+    ...childIndex !== undefined ? { index: childIndex } : {},
+    ...values.get("--mission-path") ? { missionPath: path.resolve(values.get("--mission-path")) } : {},
+    sessionRoots,
+    refreshMs,
+    allowSteer: values.get("--allow-steer") !== "false",
+    allowStop: values.get("--allow-stop") !== "false"
+  };
+}
+function isTerminal(status) {
+  return status.state !== "queued" && status.state !== "running";
+}
+export function submitInspectorControl(options, line) {
+  const command = line.trim();
+  if (!command || command === "status")
+    return "Status refreshed.";
+  const status = readStatus(options.asyncDir);
+  if (!status || status.runId !== options.runId)
+    throw new Error(`Lifecycle status for run '${options.runId}' is unavailable.`);
+  if (command === "stop") {
+    if (options.allowStop === false)
+      throw new Error("Authority policy does not allow stop from this inspector.");
+    if (isTerminal(status))
+      throw new Error(`Run '${options.runId}' is ${status.state} and cannot be stopped.`);
+    requestAsyncStop(options.asyncDir, { source: "herdr-inspector" });
+    return `Stop requested for run ${options.runId}.`;
+  }
+  if (command.startsWith("steer ")) {
+    if (options.allowSteer === false)
+      throw new Error("Authority policy does not allow steer from this inspector.");
+    const message = command.slice("steer ".length).trim();
+    if (!message)
+      throw new Error("steer requires a message.");
+    if (isTerminal(status))
+      throw new Error(`Run '${options.runId}' is ${status.state} and cannot be steered.`);
+    const runningIndexes = (status.steps ?? []).map((step, index) => step.status === "running" ? index : undefined).filter((index) => index !== undefined);
+    const targetIndex = options.index ?? (status.mode === "single" ? 0 : undefined);
+    if (targetIndex === undefined && runningIndexes.length === 0)
+      throw new Error("No running child is available to steer. Open a child-specific inspector for a pending child.");
+    requestAsyncSteer(options.asyncDir, {
+      message,
+      ...targetIndex !== undefined ? { targetIndex } : { targetIndexes: runningIndexes },
+      source: "herdr-inspector"
+    });
+    return steeringReceipt(message, `Steering queued for run ${options.runId}.`);
+  }
+  if (command.startsWith("reply "))
+    throw new Error("Supervisor replies are owned by the parent DM session; use subagent_supervisor/intercom there.");
+  throw new Error("Unknown control. Use steer <message>, stop, or status.");
+}
+export function runInspector(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  let notice = "";
+  let timer;
+  const render = () => {
+    const status = readStatus(options.asyncDir);
+    if (!status || status.runId !== options.runId) {
+      process.stdout.write(`\x1B[2J\x1B[Hdm-subagents inspector
+
+Lifecycle status for ${options.runId} is unavailable.
+`);
+      return;
+    }
+    process.stdout.write(`\x1B[2J\x1B[H${formatInspectorDashboard({ status, asyncDir: options.asyncDir, index: options.index, mission: readMission(options.missionPath), allowSteer: options.allowSteer, allowStop: options.allowStop, sessionRoots: options.sessionRoots })}${notice ? `
+
+${notice}` : ""}
+> `);
+    if (isTerminal(status) && timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+  };
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
+  rl.on("line", (line) => {
+    try {
+      notice = submitInspectorControl(options, line);
+    } catch (cause) {
+      notice = `Control error: ${cause instanceof Error ? cause.message : String(cause)}`;
+    }
+    render();
+  });
+  render();
+  if (!isTerminal(readStatus(options.asyncDir) ?? { state: "failed" })) {
+    timer = setInterval(render, options.refreshMs);
+    timer.unref?.();
+  }
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
+  try {
+    runInspector();
+  } catch (cause) {
+    process.stderr.write(`Herdr inspector failed: ${cause instanceof Error ? cause.message : String(cause)}
+`);
+    process.exitCode = 1;
+  }
+}