@cydm/pie 2.2.0 → 2.4.0

package/dist/builtin/extensions/herdr-agent-state/index.js

@@ -0,0 +1,272 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import "../../../chunks/chunk-LZQXQOPJ.js";
+
+// builtin/extensions/herdr-agent-state/index.ts
+import { spawn } from "node:child_process";
+var AGENT_LABEL = "pie";
+var SOURCE_ID = "pie";
+var BLOCKING_TOOL_NAME = "ask_user_multi";
+var REPORT_TIMEOUT_MS = 3e3;
+var MAX_RESUME_ARGS = 64;
+var MAX_RESUME_TOTAL_CHARS = 8192;
+var RESUME_ARG_PATTERN = /^[A-Za-z0-9._:/=@,%+-]+$/;
+var MESSAGE_MAX_CHARS = 120;
+function readHerdrEnvironment(env = process.env) {
+  if (env.HERDR_ENV !== "1") return void 0;
+  const paneId = env.HERDR_PANE_ID;
+  const binPath = env.HERDR_BIN_PATH;
+  if (typeof paneId !== "string" || !paneId) return void 0;
+  if (typeof binPath !== "string" || !binPath) return void 0;
+  return { paneId, binPath };
+}
+function createReportSequencer(now = Date.now) {
+  let seq = now() * 1e3;
+  return () => {
+    seq += 1;
+    return seq;
+  };
+}
+function summarizeAskUserQuestion(args) {
+  if (!args || typeof args !== "object") return void 0;
+  const record = args;
+  let text = record.question;
+  if (typeof text !== "string" || !text.trim()) {
+    const questions = record.questions;
+    if (Array.isArray(questions) && questions.length > 0) {
+      const first = questions[0];
+      if (first && typeof first === "object") {
+        text = first.question;
+      }
+    }
+  }
+  if (typeof text !== "string") return void 0;
+  const cleaned = text.replace(/\s+/g, " ").trim();
+  if (!cleaned) return void 0;
+  return cleaned.length > MESSAGE_MAX_CHARS ? `${cleaned.slice(0, MESSAGE_MAX_CHARS - 3)}...` : cleaned;
+}
+function buildResumeArgv(sessionId) {
+  const argv = ["pie", "chat", "--session-id", sessionId];
+  if (argv.length > MAX_RESUME_ARGS) return void 0;
+  if (argv.join(" ").length > MAX_RESUME_TOTAL_CHARS) return void 0;
+  for (const arg of argv) {
+    if (!RESUME_ARG_PATTERN.test(arg)) return void 0;
+  }
+  return argv;
+}
+function buildStateReportArgs(params) {
+  const args = [
+    "pane",
+    "report-agent",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--state",
+    params.state,
+    "--seq",
+    String(params.seq)
+  ];
+  if (params.message) {
+    args.push("--message", params.message);
+  }
+  if (params.agentSessionId) {
+    args.push("--agent-session-id", params.agentSessionId);
+  }
+  if (params.resumeArgv && params.resumeArgv.length > 0) {
+    args.push("--", ...params.resumeArgv);
+  }
+  return args;
+}
+function buildSessionReportArgs(params) {
+  const args = [
+    "pane",
+    "report-agent-session",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--seq",
+    String(params.seq),
+    "--agent-session-id",
+    params.agentSessionId
+  ];
+  if (params.resumeArgv?.length) args.push("--", ...params.resumeArgv);
+  return args;
+}
+function buildReleaseReportArgs(params) {
+  return [
+    "pane",
+    "release-agent",
+    params.paneId,
+    "--source",
+    params.source,
+    "--agent",
+    params.agent,
+    "--seq",
+    String(params.seq)
+  ];
+}
+function spawnHerdrReport(binPath, args, timeoutMs = REPORT_TIMEOUT_MS) {
+  try {
+    const child = spawn(binPath, args, { detached: true, stdio: "ignore" });
+    let killTimer;
+    const clearTimers = () => {
+      clearTimeout(timer);
+      if (killTimer) clearTimeout(killTimer);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+        killTimer = setTimeout(() => {
+          try {
+            if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+          } catch {
+          }
+        }, 1e3);
+        killTimer.unref?.();
+      } catch {
+      }
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", clearTimers);
+    child.on("exit", clearTimers);
+    child.unref();
+  } catch {
+  }
+}
+function attachHerdrReporter(host, herdr, transport = (args) => spawnHerdrReport(herdr.binPath, args), sequencer = createReportSequencer()) {
+  const nextSeq = sequencer;
+  let agentActive = false;
+  const blockingToolCalls = /* @__PURE__ */ new Map();
+  let blockedMessage;
+  let heldPane = false;
+  let lastSessionId;
+  let lastState;
+  let lastMessage;
+  function report(args) {
+    transport(args);
+  }
+  function publishState(options) {
+    const next = desiredState();
+    const unchanged = next.state === lastState && next.message === lastMessage && !options?.force && !options?.resumeArgv;
+    if (unchanged) return;
+    lastState = next.state;
+    lastMessage = next.message;
+    heldPane = true;
+    report(
+      buildStateReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        state: next.state,
+        seq: nextSeq(),
+        message: next.message,
+        agentSessionId: lastSessionId,
+        resumeArgv: options?.resumeArgv
+      })
+    );
+  }
+  function publishSession(sessionId) {
+    const resumeArgv = buildResumeArgv(sessionId);
+    if (!heldPane) {
+      return;
+    }
+    report(
+      buildSessionReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        seq: nextSeq(),
+        agentSessionId: sessionId,
+        resumeArgv
+      })
+    );
+  }
+  function desiredState() {
+    if (blockingToolCalls.size > 0) {
+      return { state: "blocked", message: blockedMessage };
+    }
+    if (agentActive) {
+      return { state: "working" };
+    }
+    return { state: "idle" };
+  }
+  host.on("session:changed", (event) => {
+    const sessionId = typeof event.sessionId === "string" && event.sessionId ? event.sessionId : void 0;
+    const sessionIdChanged = sessionId !== lastSessionId;
+    lastSessionId = sessionId;
+    if (!heldPane) {
+      publishState({
+        force: true,
+        resumeArgv: sessionId ? buildResumeArgv(sessionId) : void 0
+      });
+      return;
+    }
+    if (sessionIdChanged && sessionId) {
+      publishSession(sessionId);
+    }
+  });
+  host.on("turn:start", () => {
+    agentActive = true;
+    publishState();
+  });
+  host.on("agent:end", () => {
+    agentActive = false;
+    blockingToolCalls.clear();
+    blockedMessage = void 0;
+    publishState();
+  });
+  host.on("tool:execution:start", (event) => {
+    if (event.toolName !== BLOCKING_TOOL_NAME) return;
+    const message = summarizeAskUserQuestion(event.args);
+    blockingToolCalls.set(event.toolCallId, message);
+    if (message) {
+      blockedMessage = message;
+    } else if (!blockedMessage) {
+      blockedMessage = "waiting for your answer";
+    }
+    publishState();
+  });
+  host.on("tool:execution:end", (event) => {
+    if (event.toolName !== BLOCKING_TOOL_NAME) return;
+    blockingToolCalls.delete(event.toolCallId);
+    blockedMessage = void 0;
+    for (const message of blockingToolCalls.values()) {
+      if (message) blockedMessage = message;
+    }
+    publishState();
+  });
+  host.registerCleanup?.((reason) => {
+    if (reason !== "shutdown") return;
+    if (!heldPane) return;
+    report(
+      buildReleaseReportArgs({
+        paneId: herdr.paneId,
+        source: SOURCE_ID,
+        agent: AGENT_LABEL,
+        seq: nextSeq()
+      })
+    );
+  });
+}
+function herdrAgentStateExtension(ctx) {
+  const herdr = readHerdrEnvironment();
+  if (!herdr) return;
+  if (!ctx.hasUI) return;
+  ctx.log("herdr agent-state reporter enabled");
+  attachHerdrReporter(ctx, herdr);
+}
+export {
+  attachHerdrReporter,
+  buildReleaseReportArgs,
+  buildResumeArgv,
+  buildSessionReportArgs,
+  buildStateReportArgs,
+  createReportSequencer,
+  herdrAgentStateExtension as default,
+  readHerdrEnvironment,
+  spawnHerdrReport,
+  summarizeAskUserQuestion
+};

package/dist/builtin/extensions/herdr-agent-state/package.json

@@ -0,0 +1,11 @@
+{
+	"name": "herdr-agent-state-extension",
+	"version": "1.0.0",
+	"description": "Report Pie interactive agent lifecycle state (working/idle/blocked), session identity, and resume command to the Herdr terminal workspace manager.",
+	"main": "index.js",
+	"type": "module",
+	"pie": {
+		"name": "herdr-agent-state",
+		"main": "index.js"
+	}
+}