@duckmind/dm-windows-x64 0.61.4 → 0.61.9

package/extensions/dm-subagents/src/runs/background/inspect-rpc.js

@@ -0,0 +1,373 @@
+import * as fs from "node:fs";
+import { sanitizeDisplayText, truncateDisplayText } from "../../shared/display-text.js";
+import { decodeUtf8Tail } from "../../shared/utf8.js";
+import { DIRS } from "../../shared/types.js";
+import { readStatus } from "../../shared/utils.js";
+import { readSessionMessagesTail } from "./fleet-view.js";
+import { completionReplayPath, readCompletionArchive, readCompletionReplay } from "./completion-replay.js";
+import { resultPayloadPathForSessionRun } from "./result-files.js";
+import { resolveSubagentRunId } from "./run-id-resolver.js";
+import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.js";
+export const INSPECT_REPLY_KIND = "dm-subagents.inspect-reply";
+export const INSPECT_REPLY_VERSION = 1;
+export const INSPECT_WIDGET_KEY = "subagent-inspect";
+export const INSPECT_WIDGET_PREFIX = "DM_SUBAGENT_INSPECT_JSON:";
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+const MAX_ID_LENGTH = 256;
+const MAX_LABEL_LENGTH = 160;
+const MAX_TASK_LENGTH = 2000;
+const MAX_FINAL_OUTPUT_LENGTH = 8000;
+const MAX_MESSAGE_TEXT_LENGTH = 1000;
+const DEFAULT_MESSAGE_LINES = 100;
+const MAX_MESSAGE_LINES = 200;
+const FAILED_OUTPUT_ARTIFACT_PREFIX = `Subagent run failed before producing output.
+
+Error:
+`;
+export const MAX_SERIALIZED_BYTES = 64 * 1024;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function publicText(value, maxLength) {
+  if (typeof value !== "string")
+    return;
+  const normalized = sanitizeDisplayText(value.slice(0, maxLength * 4));
+  return normalized ? truncateDisplayText(normalized, maxLength) : undefined;
+}
+function boundContent(value, maxLength) {
+  const normalized = value.replace(/[\u2028\u2029]/g, `
+`);
+  return truncateDisplayText(normalized, maxLength);
+}
+function errorReply(request, code, message) {
+  return {
+    kind: INSPECT_REPLY_KIND,
+    version: INSPECT_REPLY_VERSION,
+    requestId: typeof request.requestId === "string" && REQUEST_ID_PATTERN.test(request.requestId) ? request.requestId : "invalid",
+    ...typeof request.asyncId === "string" ? { asyncId: truncateDisplayText(request.asyncId, MAX_ID_LENGTH) } : {},
+    ...typeof request.childId === "string" ? { childId: truncateDisplayText(request.childId, MAX_ID_LENGTH) } : {},
+    error: { code, message }
+  };
+}
+export function parseInspectRequest(args) {
+  const tokens = args.trim().split(/\s+/).filter(Boolean);
+  const positional = [];
+  let lines;
+  for (let index = 0;index < tokens.length; index++) {
+    const token = tokens[index];
+    if (token === "--lines") {
+      const value = tokens[++index];
+      const parsed = value === undefined ? NaN : Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed))
+        return { error: "--lines requires an integer value." };
+      lines = parsed;
+      continue;
+    }
+    if (token.startsWith("--"))
+      return { error: `Unknown flag: ${token}. Supported: --lines N.` };
+    positional.push(token);
+  }
+  const [requestId, asyncId, childId, ...extra] = positional;
+  if (!requestId || !REQUEST_ID_PATTERN.test(requestId)) {
+    return { error: "requestId must match [A-Za-z0-9_-]{1,64}." };
+  }
+  if (!asyncId)
+    return { error: "Usage: /subagents-inspect-rpc <requestId> <asyncId> [childId] [--lines N]." };
+  if (asyncId.length > MAX_ID_LENGTH || childId !== undefined && childId.length > MAX_ID_LENGTH) {
+    return { error: "asyncId/childId exceed the maximum length." };
+  }
+  if (extra.length > 0)
+    return { error: "Too many positional arguments. Usage: /subagents-inspect-rpc <requestId> <asyncId> [childId] [--lines N]." };
+  if (lines !== undefined && (lines < 1 || !Number.isSafeInteger(lines)))
+    return { error: "--lines must be a positive integer." };
+  return { request: { requestId, asyncId, childId, lines } };
+}
+function findChildNode(status, asyncDir, childId) {
+  const steps = status.steps ?? [];
+  for (let index = 0;index < steps.length; index++) {
+    const step = steps[index];
+    const ids = [step.workflowKey, step.runId, `step:${index}`];
+    if (ids.includes(childId)) {
+      return { asyncDir, status, stepIndex: index, label: step.label ?? step.agent };
+    }
+  }
+  const findNested = (children) => {
+    for (const child of children ?? []) {
+      if (child.id === childId)
+        return child;
+      const deeper = findNested(child.children);
+      if (deeper)
+        return deeper;
+    }
+    return;
+  };
+  for (const step of steps) {
+    const nested = findNested(step.children);
+    if (nested) {
+      if (!nested.asyncDir)
+        return { error: `Child '${childId}' has no async directory to inspect.` };
+      const childStatus = readStatus(nested.asyncDir);
+      if (!childStatus)
+        return { error: `Child '${childId}' status is unavailable.` };
+      return { asyncDir: nested.asyncDir, status: childStatus, label: nested.agent ?? nested.agents?.join(", ") };
+    }
+  }
+  return { error: `Child '${childId}' was not found under async run '${status.runId}'.` };
+}
+function resultOutput(data, stepIndex) {
+  if (!isRecord(data))
+    throw new Error("Async result payload must be an object.");
+  if (data.results !== undefined && !Array.isArray(data.results))
+    throw new Error("Async result payload results must be an array.");
+  if (data.summary !== undefined && typeof data.summary !== "string")
+    throw new Error("Async result payload summary must be a string.");
+  const results = data.results;
+  if (stepIndex !== undefined && results) {
+    const stepResult = results[stepIndex];
+    if (stepResult === undefined)
+      return {};
+    if (!isRecord(stepResult))
+      throw new Error("Async result payload step result must be an object.");
+    if (stepResult.output !== undefined && typeof stepResult.output !== "string")
+      throw new Error("Async result payload step output must be a string.");
+    if (stepResult.error !== undefined && typeof stepResult.error !== "string")
+      throw new Error("Async result payload step error must be a string.");
+    return {
+      ...typeof stepResult.output === "string" ? { output: stepResult.output } : {},
+      ...typeof stepResult.error === "string" ? { errorText: stepResult.error } : {}
+    };
+  }
+  if (typeof data.summary === "string")
+    return { output: data.summary };
+  if (results?.length === 1) {
+    const result = results[0];
+    if (!isRecord(result))
+      throw new Error("Async result payload result must be an object.");
+    if (result.output !== undefined && typeof result.output !== "string")
+      throw new Error("Async result payload output must be a string.");
+    if (typeof result.output === "string")
+      return { output: result.output };
+  }
+  return {};
+}
+function readOutputArtifact(outputPath) {
+  const file = fs.openSync(outputPath, "r");
+  try {
+    const prefix = Buffer.allocUnsafe(Buffer.byteLength(FAILED_OUTPUT_ARTIFACT_PREFIX, "utf-8"));
+    const prefixBytes = fs.readSync(file, prefix, 0, prefix.length, 0);
+    const failedOutput = prefix.subarray(0, prefixBytes).toString("utf-8") === FAILED_OUTPUT_ARTIFACT_PREFIX;
+    const size = fs.fstatSync(file).size;
+    const length = Math.min(size, MAX_FINAL_OUTPUT_LENGTH * 4);
+    const buffer = Buffer.allocUnsafe(length);
+    const bytesRead = fs.readSync(file, buffer, 0, length, size - length);
+    let text = decodeUtf8Tail(buffer.subarray(0, bytesRead));
+    if (!failedOutput)
+      return { output: text };
+    const metadata = text.lastIndexOf(`
+Metadata: `);
+    if (metadata >= 0 && !text.slice(metadata + 1).includes(`
+`))
+      text = text.slice(0, metadata);
+    const transcript = text.lastIndexOf(`
+
+Transcript: `);
+    if (transcript >= 0 && !text.slice(transcript + 2).includes(`
+`))
+      text = text.slice(0, transcript);
+    return { errorText: text.startsWith(FAILED_OUTPUT_ARTIFACT_PREFIX) ? text.slice(FAILED_OUTPUT_ARTIFACT_PREFIX.length) : text };
+  } finally {
+    fs.closeSync(file);
+  }
+}
+function readSessionBackedOutput(sessionPath, trustedRoots, trustedSessionFileRoot) {
+  if (trustedRoots.length === 0 && !trustedSessionFileRoot)
+    return {};
+  const tail = readSessionMessagesTail(sessionPath, MAX_MESSAGE_LINES, trustedRoots, [sessionPath], trustedSessionFileRoot);
+  const last = tail.messages.findLast((message) => message.role === "assistant" && message.kind === "text");
+  if (!last)
+    return {};
+  const parts = tail.messages.filter((message) => message.recordIndex === last.recordIndex && message.kind === "text");
+  return { output: parts.map((part) => part.text).join(`
+`) };
+}
+function readResultOutput(resultsDir, sessionId, runId, stepIndex, trustedRoots, stepAgent, now, trustedSessionFileRoot) {
+  const resultPath = resultPayloadPathForSessionRun(resultsDir, sessionId, runId);
+  if (resultPath)
+    return resultOutput(JSON.parse(fs.readFileSync(resultPath, "utf-8")), stepIndex);
+  const replayPath = completionReplayPath(resultsDir, runId);
+  let rawReplay;
+  try {
+    rawReplay = JSON.parse(fs.readFileSync(replayPath, "utf-8"));
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  const nowMs = now();
+  const replay = readCompletionReplay(resultsDir, runId, { sessionId, now: nowMs });
+  if (!replay) {
+    if (isRecord(rawReplay) && rawReplay.version === 1 && rawReplay.runId === runId && rawReplay.sessionId === sessionId && typeof rawReplay.expiresAt === "number" && rawReplay.expiresAt > nowMs) {
+      throw new Error("Completion replay record failed validation.");
+    }
+    return {};
+  }
+  const archive = readCompletionArchive(replay.archivePath);
+  const childEntries = archive?.entries.filter((entry) => entry.resultIndex !== undefined || entry.agent !== undefined) ?? [];
+  const singleChild = childEntries.length === 1;
+  const uniqueLegacyAgent = (agent) => agent !== undefined && archive?.entries.filter((entry) => entry.resultIndex === undefined && entry.agent === agent).length === 1;
+  const matches = (entry) => {
+    if (stepIndex !== undefined) {
+      if (entry.resultIndex !== undefined)
+        return entry.resultIndex === stepIndex;
+      return uniqueLegacyAgent(stepAgent) && entry.agent === stepAgent;
+    }
+    if (singleChild)
+      return entry.resultIndex !== undefined || entry.agent !== undefined;
+    return entry.resultIndex === undefined && entry.agent === undefined;
+  };
+  const artifact = archive?.entries.find((entry) => entry.source === "output-artifact" && matches(entry));
+  const artifactPath = artifact?.source === "output-artifact" ? artifact.path : undefined;
+  if (artifactPath)
+    return readOutputArtifact(artifactPath);
+  const sessionEntry = archive?.entries.find((entry) => entry.source === "session" && matches(entry));
+  const sessionPath = sessionEntry?.source === "session" ? sessionEntry.path : undefined;
+  if (sessionPath)
+    return readSessionBackedOutput(sessionPath, trustedRoots, trustedSessionFileRoot);
+  const output = archive?.entries.find((entry) => entry.source === "result-tail" && matches(entry))?.text;
+  return output ? { output } : {};
+}
+function toReplyMessage(message) {
+  return {
+    role: truncateDisplayText(sanitizeDisplayText(message.role), 32),
+    kind: message.kind,
+    text: boundContent(message.text, MAX_MESSAGE_TEXT_LENGTH),
+    ...message.name ? { name: truncateDisplayText(sanitizeDisplayText(message.name), 96) } : {},
+    ...message.isError === true ? { isError: true } : {}
+  };
+}
+function enforceByteBudget(reply) {
+  const truncated = reply.truncated ?? { task: false, messages: 0, finalOutput: false };
+  const sized = () => Buffer.byteLength(JSON.stringify(reply), "utf-8");
+  while (reply.messages && reply.messages.length > 0 && sized() > MAX_SERIALIZED_BYTES) {
+    reply.messages.shift();
+    truncated.messages += 1;
+  }
+  if (sized() > MAX_SERIALIZED_BYTES && reply.finalOutput) {
+    reply.finalOutput = truncateDisplayText(reply.finalOutput, Math.max(0, reply.finalOutput.length - (sized() - MAX_SERIALIZED_BYTES) - 256));
+    truncated.finalOutput = true;
+  }
+  if (sized() > MAX_SERIALIZED_BYTES && reply.task) {
+    reply.task = truncateDisplayText(reply.task, Math.max(0, reply.task.length - (sized() - MAX_SERIALIZED_BYTES) - 256));
+    truncated.task = true;
+  }
+  if (truncated.task || truncated.messages > 0 || truncated.finalOutput)
+    reply.truncated = truncated;
+  return reply;
+}
+export function buildInspectReply(request, deps = {}) {
+  const asyncDirRoot = deps.asyncDirRoot ?? DIRS.async;
+  const resultsDir = deps.resultsDir ?? DIRS.results;
+  const currentSessionId = deps.state?.currentSessionId ?? undefined;
+  if (!currentSessionId) {
+    return errorReply(request, "no_active_session", "Inspection requires an active session; the request could not be attributed to a session.");
+  }
+  let resolved;
+  try {
+    resolved = resolveSubagentRunId(request.asyncId, { asyncDirRoot, resultsDir, state: deps.state });
+  } catch {
+    return errorReply(request, "invalid_request", "The requested async run could not be resolved.");
+  }
+  if (!resolved || resolved.kind === "foreground") {
+    return errorReply(request, "not_found", `Async run '${request.asyncId}' was not found.`);
+  }
+  try {
+    let asyncDir;
+    let status;
+    if (resolved.kind === "nested") {
+      reconcileNestedAsyncDescendants(resolved.match.route, { resultsDir, kill: deps.kill, now: deps.now });
+      asyncDir = resolved.match.run.asyncDir ?? "";
+      status = asyncDir ? readStatus(asyncDir) : null;
+    } else {
+      if (!resolved.location.asyncDir)
+        return errorReply(request, "stale", `Async run '${request.asyncId}' has no remaining artifacts.`);
+      asyncDir = resolved.location.asyncDir;
+      status = reconcileAsyncRun(asyncDir, { resultsDir, kill: deps.kill, now: deps.now }).status ?? readStatus(asyncDir);
+    }
+    if (!status)
+      return errorReply(request, "stale", `Async run '${request.asyncId}' artifacts are no longer available.`);
+    if (status.sessionId !== currentSessionId) {
+      return errorReply(request, "foreign_session", "Inspection is only available for async runs owned by the current session.");
+    }
+    const node = request.childId === undefined ? { asyncDir, status } : findChildNode(status, asyncDir, request.childId);
+    if ("error" in node)
+      return errorReply(request, "not_found", node.error);
+    if (node.asyncDir !== asyncDir) {
+      if (node.status.sessionId !== currentSessionId) {
+        return errorReply(request, "foreign_session", "Inspection is only available for async runs owned by the current session.");
+      }
+      reconcileAsyncRun(node.asyncDir, { resultsDir, kill: deps.kill, now: deps.now });
+      node.status = readStatus(node.asyncDir) ?? node.status;
+    }
+    const step = node.stepIndex !== undefined ? node.status.steps?.[node.stepIndex] : undefined;
+    const lineLimit = Math.max(1, Math.min(MAX_MESSAGE_LINES, Math.trunc(request.lines ?? DEFAULT_MESSAGE_LINES)));
+    const sessionFile = step?.sessionFile ?? node.status.sessionFile;
+    const trustedRoots = [...new Set([
+      ...deps.state?.trustedSessionRoots ?? [],
+      ...node.status.sessionRoot ? [node.status.sessionRoot] : []
+    ])];
+    let messages;
+    let task;
+    if (sessionFile && (trustedRoots.length > 0 || deps.state?.trustedSessionFileRoot)) {
+      const tail = readSessionMessagesTail(sessionFile, lineLimit, trustedRoots, [sessionFile], deps.state?.trustedSessionFileRoot);
+      if (tail.messages.length > 0) {
+        messages = tail.messages.map(toReplyMessage);
+        if (!tail.truncated && node.status.context !== "fork" && step?.context !== "fork") {
+          const firstUser = tail.messages.find((message) => message.role === "user" && message.kind === "text");
+          if (firstUser)
+            task = firstUser.text;
+        }
+      }
+    }
+    const result = readResultOutput(resultsDir, currentSessionId, node.status.runId, node.stepIndex, trustedRoots, step?.agent, deps.now ?? Date.now, deps.state?.trustedSessionFileRoot);
+    const failedText = step?.error ?? node.status.error;
+    if (result.output === undefined && result.errorText === undefined && failedText !== undefined) {
+      return errorReply(request, "internal", "Inspection could not read the async run artifacts.");
+    }
+    const finalOutputRaw = result.output ?? result.errorText;
+    const truncated = { task: false, messages: 0, finalOutput: false };
+    const boundedTask = task !== undefined ? boundContent(task, MAX_TASK_LENGTH) : undefined;
+    if (task !== undefined && boundedTask !== task)
+      truncated.task = true;
+    const boundedFinal = finalOutputRaw !== undefined ? boundContent(finalOutputRaw, MAX_FINAL_OUTPUT_LENGTH) : undefined;
+    if (finalOutputRaw !== undefined && boundedFinal !== finalOutputRaw)
+      truncated.finalOutput = true;
+    const label = publicText(node.label ?? step?.label ?? step?.agent ?? node.status.runId, MAX_LABEL_LENGTH);
+    const reply = {
+      kind: INSPECT_REPLY_KIND,
+      version: INSPECT_REPLY_VERSION,
+      requestId: request.requestId,
+      asyncId: node.status.runId,
+      ...request.childId !== undefined ? { childId: request.childId } : {},
+      status: node.status.state,
+      ...label ? { label } : {},
+      ...boundedTask !== undefined ? { task: boundedTask } : {},
+      ...messages && messages.length > 0 ? { messages } : {},
+      ...boundedFinal !== undefined ? { finalOutput: boundedFinal } : {},
+      ...truncated.task || truncated.finalOutput || truncated.messages > 0 ? { truncated } : {}
+    };
+    return enforceByteBudget(reply);
+  } catch {
+    return errorReply(request, "internal", "Inspection could not read the async run artifacts.");
+  }
+}
+export function encodeInspectReply(reply) {
+  return [`${INSPECT_WIDGET_PREFIX}${JSON.stringify(reply)}`];
+}
+export function handleInspectRpcArgs(args, deps = {}) {
+  const parsed = parseInspectRequest(args);
+  if (parsed.error || !parsed.request) {
+    const firstToken = args.trim().split(/\s+/)[0];
+    const echo = firstToken !== undefined && REQUEST_ID_PATTERN.test(firstToken) ? { requestId: firstToken } : {};
+    return errorReply(echo, "invalid_request", parsed.error ?? "Invalid inspect request.");
+  }
+  return buildInspectReply(parsed.request, deps);
+}