@fitchmultz/pi-subagents 0.44.7 → 0.45.0

package/src/extension/message-renderers.ts

@@ -0,0 +1,334 @@
+import {
+  keyText,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type MessageRenderOptions,
+} from "@earendil-works/pi-coding-agent";
+import {
+  Box,
+  Container,
+  Spacer,
+  Text,
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+  type Component,
+} from "@earendil-works/pi-tui";
+import { renderSubagentResult } from "../tui/render.ts";
+import { withMouseExpansion } from "../tui/action-hints.ts";
+import {
+  getSlashRenderableSnapshot,
+  resolveSlashMessageDetails,
+  type SlashMessageDetails,
+} from "../slash/slash-live-state.ts";
+import type { SubagentNotifyDetails } from "../runs/background/notify.ts";
+import { formatDuration, shortenPath } from "../shared/formatters.ts";
+import { SLASH_RESULT_TYPE, type SubagentExecutionResult } from "../shared/types.ts";
+import type { ReadonlyInput } from "../shared/types/inputs.ts";
+import {
+  formatSubagentControlNotice,
+  SUBAGENT_CONTROL_MESSAGE_TYPE,
+  type SubagentControlMessageDetails,
+} from "./control-notices.ts";
+import { parseControlNotice } from "./control-notice-schema.ts";
+
+type Theme = ExtensionContext["ui"]["theme"];
+type RenderOptions = Readonly<MessageRenderOptions>;
+
+function compactView(options: RenderOptions): boolean {
+  return "compactView" in options && options.compactView === true && !options.expanded;
+}
+
+function resultBackground(
+  result: ReadonlyInput<SubagentExecutionResult>,
+): "toolPendingBg" | "toolErrorBg" | "toolSuccessBg" {
+  if (
+    result.details.progress?.some((entry) => entry.status === "running") === true ||
+    result.details.results.some((entry) => entry.progress?.status === "running")
+  ) {
+    return "toolPendingBg";
+  }
+  return result.details.results.some(
+    (entry) => entry.exitCode !== 0 && entry.progress?.status !== "running",
+  )
+    ? "toolErrorBg"
+    : "toolSuccessBg";
+}
+
+function rebuildSlashResult(
+  container: Container,
+  result: ReadonlyInput<SubagentExecutionResult>,
+  options: RenderOptions,
+  theme: Theme,
+): void {
+  container.clear();
+  if (compactView(options)) {
+    container.addChild(renderSubagentResult(result, options, theme));
+    return;
+  }
+  container.addChild(new Spacer(1));
+  const background = resultBackground(result);
+  const box = new Box(1, 1, (text: string) => theme.bg(background, text));
+  box.addChild(renderSubagentResult(result, options, theme));
+  container.addChild(box);
+}
+
+function compactLine(text: string, width: number, options: RenderOptions, theme: Theme): string {
+  const key = keyText("app.tools.expand");
+  const hint = key.length > 0 ? theme.fg("dim", ` · ${key}`) : "";
+  const line = `${" ".repeat(options.outputPad)}${text.replace(/\s+/g, " ").trim()}`;
+  return truncateToWidth(truncateToWidth(line, width - visibleWidth(hint)) + hint, width);
+}
+
+function createSlashResult(
+  details: ReadonlyInput<SlashMessageDetails>,
+  options: RenderOptions,
+  theme: Theme,
+): Container {
+  const container = new Container();
+  let lastVersion = -1;
+  container.render = (width: number): string[] => {
+    const snapshot = getSlashRenderableSnapshot(details);
+    if (snapshot.version !== lastVersion) {
+      lastVersion = snapshot.version;
+      rebuildSlashResult(container, snapshot.result, options, theme);
+    }
+    if (compactView(options)) {
+      const key = keyText("app.tools.expand");
+      const hint = key.length > 0 ? theme.fg("dim", ` · ${key}`) : "";
+      const [heading = ""] = Container.prototype.render.call(
+        container,
+        Math.max(1, width - options.outputPad - visibleWidth(hint)),
+      );
+      return [
+        truncateToWidth(
+          `${" ".repeat(options.outputPad)}${heading.replace(/\s+/g, " ").trimEnd()}${hint}`,
+          width,
+        ),
+      ];
+    }
+    return Container.prototype.render.call(container, width);
+  };
+  return container;
+}
+
+function isNotifyStatus(status: string | undefined): status is SubagentNotifyDetails["status"] {
+  return (
+    status === "completed" || status === "failed" || status === "blocked" || status === "paused"
+  );
+}
+
+function parseNotifyContent(content: string): SubagentNotifyDetails | undefined {
+  const lines = content.split("\n");
+  const match = (lines.at(0) ?? "").match(
+    /^Background task (completed|failed|blocked|paused): \*\*(.+?)\*\*(?:\s+(\([^)]*\)))?$/,
+  );
+  if (!match) {
+    return undefined;
+  }
+  const status = match.at(1);
+  const agent = match.at(2);
+  if (agent === undefined || !isNotifyStatus(status)) {
+    return undefined;
+  }
+  const body = lines.slice(2);
+  const sessionIndex = sessionLineIndex(body);
+  const sessionLine = sessionIndex >= 0 ? body.at(sessionIndex) : undefined;
+  const preview = (sessionIndex >= 0 ? body.slice(0, sessionIndex) : body).join("\n").trim();
+  const taskInfo = match.at(3);
+  return {
+    agent,
+    status,
+    ...(taskInfo !== undefined && taskInfo.length > 0 ? { taskInfo } : {}),
+    resultPreview: preview.length > 0 ? preview : "(no output)",
+    ...sessionFields(sessionLine),
+  };
+}
+
+function sessionLineIndex(lines: readonly string[]): number {
+  for (let index = lines.length - 1; index >= 1; index--) {
+    const previous = lines.at(index - 1);
+    const line = lines.at(index);
+    if (
+      previous?.trim() === "" &&
+      line !== undefined &&
+      /^(Session|Session file|Session share error):\s+/.test(line)
+    ) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+function sessionFields(
+  line: string | undefined,
+): Pick<SubagentNotifyDetails, "sessionLabel" | "sessionValue"> {
+  if (line === undefined || line.length === 0) {
+    return {};
+  }
+  const separator = line.indexOf(":");
+  const sessionLabel = line.slice(0, separator).toLowerCase();
+  const sessionValue = line.slice(separator + 1).trim();
+  return sessionLabel.length > 0 && sessionValue.length > 0 ? { sessionLabel, sessionValue } : {};
+}
+
+function notifyHeading(details: ReadonlyInput<SubagentNotifyDetails>, theme: Theme): string {
+  let icon = theme.fg("error", "✗");
+  if (details.status === "completed") {
+    icon = theme.fg("success", "✓");
+  } else if (details.status === "paused" || details.status === "blocked") {
+    icon = theme.fg("warning", "■");
+  }
+  const parts: string[] = [];
+  if (details.taskInfo !== undefined && details.taskInfo.length > 0) {
+    parts.push(details.taskInfo);
+  }
+  if (details.durationMs !== undefined) {
+    parts.push(formatDuration(details.durationMs));
+  }
+  const title = `${icon} ${theme.bold(details.agent)} ${theme.fg("dim", details.status)}`;
+  return parts.length > 0
+    ? `${title} ${theme.fg("dim", "·")} ${parts.map((part) => theme.fg("dim", part)).join(` ${theme.fg("dim", "·")} `)}`
+    : title;
+}
+
+function compactPreview(text: string, options: RenderOptions, theme: Theme): Component {
+  return {
+    render: (width) => [compactLine(text, width, options, theme)],
+    invalidate() {
+      /* Render calculates the current layout on every call. */
+    },
+  };
+}
+
+function notifyBody(
+  details: ReadonlyInput<SubagentNotifyDetails>,
+  options: RenderOptions,
+  theme: Theme,
+): string {
+  let text = notifyHeading(details, theme);
+  const trimmed = details.resultPreview.trim();
+  const previewLines = options.expanded
+    ? trimmed.split("\n").filter((line) => line.trim().length > 0)
+    : trimmed.split("\n", 1).filter((line) => line.trim().length > 0);
+  for (const line of previewLines.length > 0 ? previewLines : ["(no output)"]) {
+    text += `\n  ${theme.fg("dim", `⎿  ${line}`)}`;
+  }
+  const key = keyText("app.tools.expand");
+  if (!options.expanded && key.length > 0) {
+    text += `\n  ${theme.fg("dim", `${key} full notification`)}`;
+  }
+  if (
+    details.sessionLabel !== undefined &&
+    details.sessionLabel.length > 0 &&
+    details.sessionValue !== undefined &&
+    details.sessionValue.length > 0
+  ) {
+    text += `\n  ${theme.fg("muted", `${details.sessionLabel}: ${shortenPath(details.sessionValue)}`)}`;
+  }
+  return text;
+}
+
+function renderNotify(
+  content: string,
+  details: ReadonlyInput<SubagentNotifyDetails> | undefined,
+  options: RenderOptions,
+  theme: Theme,
+): Component {
+  if (!details) {
+    const preview = content.split("\n").find((line) => line.trim().length > 0) ?? "(no output)";
+    return compactView(options) ? compactPreview(preview, options, theme) : new Text(content, 0, 0);
+  }
+  if (compactView(options)) {
+    const preview = details.resultPreview.trim().split("\n", 1).at(0) ?? "";
+    return compactPreview(
+      `${notifyHeading(details, theme)} · ${theme.fg("dim", preview.length > 0 ? preview : "(no output)")}`,
+      options,
+      theme,
+    );
+  }
+  const text = notifyBody(details, options, theme);
+  return options.expanded
+    ? new Text(text, 0, 0)
+    : {
+        render: (width) => text.split("\n").map((line) => truncateToWidth(line, width)),
+        invalidate() {
+          /* Width-dependent rendering has no cached layout. */
+        },
+      };
+}
+
+class ControlNoticeComponent implements Component {
+  private readonly details: ReadonlyInput<SubagentControlMessageDetails>;
+  private readonly theme: Theme;
+
+  constructor(details: ReadonlyInput<SubagentControlMessageDetails>, theme: Theme) {
+    this.details = details;
+    this.theme = theme;
+  }
+
+  invalidate(): void {
+    /* Rendering is computed from immutable notice data. */
+  }
+
+  render(width: number): string[] {
+    const eventLabel = this.details.event.type.replaceAll("_", " ");
+    if (width < 3) {
+      return [truncateToWidth(`Subagent ${eventLabel}`, width)];
+    }
+    const bodyWidth = Math.max(1, width - 2);
+    const header = truncateToWidth(
+      ` ⚠ Subagent ${eventLabel}: ${this.details.event.agent} `,
+      bodyWidth,
+      "",
+    );
+    const lines = [
+      this.theme.fg(
+        "accent",
+        `╭${header}${"─".repeat(Math.max(0, bodyWidth - visibleWidth(header)))}╮`,
+      ),
+    ];
+    for (const line of wrapTextWithAnsi(formatSubagentControlNotice(this.details), bodyWidth)) {
+      const text = truncateToWidth(line, bodyWidth, "");
+      lines.push(
+        this.theme.fg(
+          "accent",
+          `│${text}${" ".repeat(Math.max(0, bodyWidth - visibleWidth(text)))}│`,
+        ),
+      );
+    }
+    lines.push(this.theme.fg("accent", `╰${"─".repeat(bodyWidth)}╯`));
+    return lines;
+  }
+}
+
+export function registerMessageRenderers(pi: ExtensionAPI): void {
+  pi.registerMessageRenderer<SlashMessageDetails>(
+    SLASH_RESULT_TYPE,
+    withMouseExpansion((message, options, theme) => {
+      const details = resolveSlashMessageDetails(message.details);
+      if (details) {
+        return createSlashResult(details, options, theme);
+      }
+      return;
+    }),
+  );
+  pi.registerMessageRenderer<SubagentNotifyDetails | undefined>(
+    "subagent-notify",
+    withMouseExpansion((message, options, theme) => {
+      const content = typeof message.content === "string" ? message.content : "";
+      return renderNotify(content, message.details ?? parseNotifyContent(content), options, theme);
+    }),
+  );
+  pi.registerMessageRenderer(SUBAGENT_CONTROL_MESSAGE_TYPE, (message, _options, theme) => {
+    const notice = parseControlNotice(message.details);
+    if (!notice) {
+      return;
+    }
+    const content = typeof message.content === "string" ? message.content : undefined;
+    return new ControlNoticeComponent(
+      { ...notice, noticeText: formatSubagentControlNotice(notice, content) },
+      theme,
+    );
+  });
+}

package/src/extension/nested-control-inbox.ts

@@ -0,0 +1,196 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import {
+  readNestedControlRequests,
+  writeNestedControlResult,
+  type NestedControlRequestRecord,
+  type NestedRoute,
+} from "../runs/shared/nested-events.ts";
+import { errorMessage, hasErrorCode } from "../shared/unknown.ts";
+import type { ReadonlyInput } from "../shared/types/inputs.ts";
+
+type Request = ReadonlyInput<NestedControlRequestRecord & { filePath: string }>;
+type Result = ReadonlyInput<Parameters<typeof writeNestedControlResult>[1]>;
+interface InboxOptions {
+  readonly route: ReadonlyInput<NestedRoute>;
+  readonly childIndex?: number;
+  readonly restoring: () => boolean;
+  readonly owns: (runId: string) => boolean;
+  readonly execute: (
+    request: Request,
+  ) => Promise<{ readonly ok: boolean; readonly message: string }>;
+}
+
+/** Owns claim-before-execute and durable-result-before-delete ordering. */
+export class NestedControlInbox {
+  private readonly seen = new Set<string>();
+  private readonly seenFiles = new Set<string>();
+  private readonly inFlight = new Map<string, Promise<void>>();
+  private readonly pendingResults = new Map<string, Result>();
+  private readonly timer: NodeJS.Timeout;
+
+  private readonly options: InboxOptions;
+
+  constructor(options: InboxOptions) {
+    this.options = options;
+    this.timer = setInterval(() => this.poll(), 200);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    clearInterval(this.timer);
+  }
+
+  async stopAndJoin(): Promise<void> {
+    this.stop();
+    await Promise.all(this.inFlight.values());
+  }
+
+  private eligible(request: Request): boolean {
+    if (this.seen.has(request.requestId) || this.inFlight.has(request.requestId)) {
+      return false;
+    }
+    if (
+      request.targetChildIndex !== undefined &&
+      request.targetChildIndex !== this.options.childIndex
+    ) {
+      return false;
+    }
+    return (
+      this.options.owns(request.targetRunId) ||
+      (request.targetChildIndex === undefined && Date.now() - request.ts >= 400)
+    );
+  }
+
+  private poll(): void {
+    if (this.options.restoring()) {
+      return;
+    }
+    try {
+      for (const request of readNestedControlRequests(this.options.route, this.seenFiles)) {
+        if (this.eligible(request)) {
+          this.receive(request);
+        }
+      }
+    } catch (error) {
+      console.error(
+        `Failed to poll nested control inbox '${this.options.route.controlInbox}' for root '${this.options.route.rootRunId}':`,
+        error,
+      );
+    }
+  }
+
+  private receive(request: Request): void {
+    // Reserve synchronously: filesystem-only controls can finish before the first await.
+    const operation = Promise.resolve().then(() => this.process(request));
+    const owned = operation
+      .catch((error: unknown) => {
+        console.error(`Failed to handle nested control request '${request.requestId}':`, error);
+      })
+      .finally(() => {
+        this.inFlight.delete(request.requestId);
+      });
+    this.inFlight.set(request.requestId, owned);
+  }
+
+  private failure(request: Request, message: string): Result {
+    return {
+      ts: Date.now(),
+      requestId: request.requestId,
+      targetRunId: request.targetRunId,
+      ok: false,
+      message,
+    };
+  }
+
+  private claim(request: Request): Result | undefined {
+    if (this.pendingResults.size >= 100) {
+      return this.failure(
+        request,
+        "Nested control result queue is full; retry after pending results are delivered.",
+      );
+    }
+    try {
+      const fd = fs.openSync(`${request.filePath}.claimed`, "wx", 0o600);
+      try {
+        fs.writeFileSync(fd, `${request.requestId}\n`, "utf-8");
+      } finally {
+        fs.closeSync(fd);
+      }
+    } catch (error) {
+      return this.failure(
+        request,
+        hasErrorCode(error, "EEXIST")
+          ? "Nested control request was already claimed; refusing to execute it again because the original outcome is unavailable."
+          : `Failed to claim nested control request safely: ${errorMessage(error)}`,
+      );
+    }
+    return undefined;
+  }
+
+  private async execute(request: Request): Promise<Result> {
+    try {
+      const outcome = await this.options.execute(request);
+      return {
+        ts: Date.now(),
+        requestId: request.requestId,
+        targetRunId: request.targetRunId,
+        ...outcome,
+      };
+    } catch (error) {
+      return this.failure(request, errorMessage(error));
+    }
+  }
+
+  private async process(request: Request): Promise<void> {
+    const result =
+      this.pendingResults.get(request.requestId) ??
+      this.claim(request) ??
+      (await this.execute(request));
+    try {
+      writeNestedControlResult(this.options.route, result);
+    } catch (error) {
+      if (this.pendingResults.size < 100 || this.pendingResults.has(request.requestId)) {
+        this.pendingResults.set(request.requestId, result);
+      }
+      console.error(
+        `Failed to write nested control result for request '${request.requestId}' targeting '${request.targetRunId}' via inbox '${this.options.route.controlInbox}'; keeping request for retry:`,
+        error,
+      );
+      return;
+    }
+    this.pendingResults.delete(request.requestId);
+    this.remember(request);
+    this.remove(request);
+  }
+
+  private remember(request: Request): void {
+    for (const [set, value] of [
+      [this.seen, request.requestId],
+      [this.seenFiles, path.basename(request.filePath)],
+    ] as const) {
+      set.add(value);
+      if (set.size > 1000) {
+        const oldest = set.values().next().value;
+        if (oldest !== undefined) {
+          set.delete(oldest);
+        }
+      }
+    }
+  }
+
+  private remove(request: Request): void {
+    try {
+      fs.unlinkSync(request.filePath);
+    } catch (error) {
+      if (!hasErrorCode(error, "ENOENT")) {
+        return;
+      }
+    }
+    try {
+      fs.unlinkSync(`${request.filePath}.claimed`);
+    } catch {
+      // A leftover claim prevents replay; the durable receipt is already published.
+    }
+  }
+}