@pify/swarm 0.7.2 → 0.7.4

package/extensions/swarm.ts

@@ -25,6 +25,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 
 import { BUILTIN_AGENTS } from "../src/builtin.ts";
+import { withUiLock } from "../src/ui-lock.ts";
 import {
   consentQuestion,
   decideConsent,
@@ -542,9 +543,11 @@ export default function swarm(pi: ExtensionAPI) {
     });
     if (verdict !== "ask") return verdict === "allow";
 
-    const approved = await ctx.ui.confirm(
-      "Load this project's agent definitions?",
-      consentQuestion("its own agent definitions, which override the builtins of the same name", dir),
+    const approved = await withUiLock(() =>
+      ctx.ui.confirm(
+        "Load this project's agent definitions?",
+        consentQuestion("its own agent definitions, which override the builtins of the same name", dir),
+      ),
     );
     try {
       writeFileSync(file, `${JSON.stringify(writeConsent(store, ctx.cwd, "agents", approved), null, 2)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pify/swarm",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Coordinate multiple pi agents in parallel: swarm_run fan-out with per-item auto-routing, concurrency queue, aggregated reports",
   "keywords": [
     "pi-package",

package/src/ui-lock.ts

@@ -0,0 +1,52 @@
+/**
+ * One dialog at a time, across every @pify extension in the process.
+ *
+ * pi's interactive host has no queue for extension dialogs: opening a second
+ * `ui.select`/`ui.confirm`/`ui.input` while one is already up displaces the
+ * first component without ever calling its cancel callback, so the first
+ * dialog's promise never settles — the turn hangs (measured in pi's
+ * interactive-mode source: showExtensionSelector clears and replaces the
+ * active selector, and only hideExtensionSelector disposes it). This is a
+ * real collision in this suite: ask-question opens a questionnaire while a
+ * consent prompt (memory/swarm/workflow/subagent) or a yolo confirm can fire
+ * in the same turn, and parallel tool calls make that ordinary.
+ *
+ * The fix is to never let a second dialog open until the first has closed.
+ * A timeout would not help — releasing the lock while the dialog is still on
+ * screen just re-creates the collision — so this is a plain FIFO mutex with
+ * no deadline. It is deliberately keyed on a cross-realm `Symbol.for`, so all
+ * eighteen packages share ONE queue even though each ships its own copy of
+ * this file: the state lives on `globalThis`, not in any one module.
+ *
+ * Vendored per package, like consent.ts, so the suite keeps zero runtime
+ * dependencies.
+ */
+
+const LOCK_KEY = Symbol.for("pify.ui-lock.tail");
+
+interface LockGlobal {
+  [LOCK_KEY]?: Promise<unknown>;
+}
+
+/**
+ * Run `fn` only once every dialog queued before it has finished, and hold the
+ * queue until `fn` settles. A rejection in an earlier holder never wedges the
+ * chain — the next waiter proceeds regardless.
+ */
+export async function withUiLock<T>(fn: () => Promise<T>): Promise<T> {
+  const g = globalThis as unknown as LockGlobal;
+  const prev = g[LOCK_KEY] ?? Promise.resolve();
+
+  let release!: () => void;
+  const mine = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  g[LOCK_KEY] = prev.then(() => mine);
+
+  await prev.catch(() => {});
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}

package/src/widget-clamp.ts

@@ -0,0 +1,35 @@
+/**
+ * Keep a widget from overrunning the screen.
+ *
+ * pi caps string-array widgets at ten lines, but a Text-factory widget — the
+ * pattern every @pify widget uses because it caches and renders efficiently —
+ * bypasses that guard entirely (measured in pi's interactive-mode source). So
+ * the bound is ours to keep: an unbounded row count pushes the editor off
+ * screen, and a single line wider than the terminal can crash the renderer.
+ *
+ * Two rules, applied before any colour escape is added (slicing a coloured
+ * string would cut through an escape sequence):
+ *  - `clampWidth` truncates one segment's *visible* text.
+ *  - `clampRows` caps the row list and, per the suite's no-silent-caps rule,
+ *    replaces the overflow with a visible "+N more" line rather than dropping
+ *    it in silence.
+ */
+
+/** A widget line's variable segment never exceeds this many characters. */
+export const MAX_SEGMENT = 44;
+/** A widget never shows more than this many item rows. */
+export const MAX_WIDGET_ROWS = 8;
+
+export function clampWidth(text: string, max = MAX_SEGMENT): string {
+  const t = text.replace(/[\r\n]+/g, " ");
+  return t.length > max ? `${t.slice(0, max - 1)}…` : t;
+}
+
+/**
+ * Return at most `max` rows; when more were supplied, `more(hidden)` renders
+ * the summary line that stands in for the rest.
+ */
+export function clampRows(rows: string[], max: number, more: (hidden: number) => string): string[] {
+  if (rows.length <= max) return rows;
+  return [...rows.slice(0, max), more(rows.length - max)];
+}

package/src/widget.ts

@@ -1,3 +1,4 @@
+import { clampRows, clampWidth, MAX_WIDGET_ROWS } from "./widget-clamp.ts";
 import type { SwarmRun, ThemeLike } from "./types.ts";
 
 const WIDTH = 54;
@@ -29,7 +30,9 @@ export function buildWidgetLines(run: SwarmRun | null, theme: ThemeLike, now: nu
   const pad = Math.max(1, WIDTH - title.length - hint.length);
   lines.push(dim(`╭${title}${"─".repeat(pad)}${hint}╮`));
 
-  for (const item of run.items) {
+  // Cap the rows: a large swarm would otherwise push the editor off screen,
+  // since a Text-factory widget bypasses pi's ten-line guard.
+  const rows = run.items.map((item) => {
     const paint =
       item.status === "running"
         ? (s: string) => theme.fg("warning", s)
@@ -38,8 +41,10 @@ export function buildWidgetLines(run: SwarmRun | null, theme: ThemeLike, now: nu
           : item.status === "queued"
             ? dim
             : (s: string) => theme.fg("error", s);
-    const text = item.item.length > 32 ? `${item.item.slice(0, 32)}…` : item.item;
-    lines.push(`${dim("│ ")}${paint(`${icon(item.status)} ${item.agent}`)}${dim(` ${text}`)}`);
+    return `${dim("│ ")}${paint(`${icon(item.status)} ${clampWidth(item.agent, 24)}`)}${dim(` ${clampWidth(item.item, 32)}`)}`;
+  });
+  for (const row of clampRows(rows, MAX_WIDGET_ROWS, (hidden) => dim(`│ … +${hidden} more`))) {
+    lines.push(row);
   }
 
   lines.push(dim(`╰${"─".repeat(WIDTH)}╯`));