@aliou/pi-processes 0.6.3 → 0.7.0

package/src/components/processes-component.ts

@@ -48,6 +48,19 @@ function truncate(str: string, maxLen: number): string {
   return `${str.slice(0, maxLen - 3)}...`;
 }
 
+function fitCell(
+  value: string,
+  width: number,
+  align: "left" | "right" = "left",
+): string {
+  const truncated = truncateToWidth(value, Math.max(0, width));
+  const pad = Math.max(0, width - visibleWidth(truncated));
+  if (align === "right") {
+    return " ".repeat(pad) + truncated;
+  }
+  return truncated + " ".repeat(pad);
+}
+
 export class ProcessesComponent implements Component {
   private tui: { requestRender: () => void };
   private theme: Theme;
@@ -243,8 +256,7 @@ export class ProcessesComponent implements Component {
       const scaleFactor =
         innerWidth < minTotalWidth ? innerWidth / minTotalWidth : 1;
 
-      const idWidth = Math.max(6, Math.floor(9 * scaleFactor));
-      const nameWidth = Math.max(8, Math.floor(15 * scaleFactor));
+      const processWidth = Math.max(14, Math.floor(24 * scaleFactor));
       const statusWidth = Math.max(10, Math.floor(18 * scaleFactor));
       const timeWidth = Math.max(4, Math.floor(8 * scaleFactor));
       const sizeWidth = Math.max(4, Math.floor(8 * scaleFactor));
@@ -258,8 +270,7 @@ export class ProcessesComponent implements Component {
       // Calculate command column width based on remaining space
       const fixedWidth =
         prefixWidth +
-        idWidth +
-        nameWidth +
+        processWidth +
         statusWidth +
         timeWidth +
         sizeWidth +
@@ -269,8 +280,7 @@ export class ProcessesComponent implements Component {
       lines.push(padLine(""));
       const header =
         "  " +
-        dim("ID".padEnd(idWidth)) +
-        dim("Name".padEnd(nameWidth)) +
+        dim("Process".padEnd(processWidth)) +
         dim("Command".padEnd(cmdWidth)) +
         dim("Status".padEnd(statusWidth)) +
         dim("Time".padEnd(timeWidth)) +
@@ -294,18 +304,24 @@ export class ProcessesComponent implements Component {
         const totalSize = sizes ? sizes.stdout + sizes.stderr : 0;
 
         const statusText = this.formatStatus(proc);
-        const statusPadding =
-          statusWidth + (statusText.length - visibleWidth(statusText));
+
+        // Keep process cell bounded even with large IDs.
+        const idPlain = `(${proc.id})`;
+        const maxNameLen = Math.max(
+          1,
+          processWidth - visibleWidth(idPlain) - 1,
+        );
+        const tName = truncate(proc.name, maxNameLen);
+        const processCell = isSelected
+          ? `${accent(tName)} ${dim(` ${idPlain}`)}`
+          : `${tName}${dim(` ${idPlain}`)}`;
 
         const row =
-          (isSelected
-            ? accent(proc.id.padEnd(idWidth))
-            : proc.id.padEnd(idWidth)) +
-          truncate(proc.name, nameWidth - 1).padEnd(nameWidth) +
-          truncate(proc.command, cmdWidth - 1).padEnd(cmdWidth) +
-          statusText.padEnd(statusPadding) +
-          formatRuntime(proc.startTime, proc.endTime).padEnd(timeWidth) +
-          formatBytes(totalSize).padStart(sizeWidth);
+          fitCell(processCell, processWidth) +
+          fitCell(truncate(proc.command, cmdWidth - 1), cmdWidth) +
+          fitCell(statusText, statusWidth) +
+          fitCell(formatRuntime(proc.startTime, proc.endTime), timeWidth) +
+          fitCell(formatBytes(totalSize), sizeWidth, "right");
 
         if (isSelected) {
           lines.push(padLine(`${accent(">")} ${row}`));

package/src/config.ts

@@ -1,8 +1,8 @@
 /**
  * Configuration for the processes extension.
  *
- * Global: ~/.pi/agent/extensions/processes.json
- * Memory: ephemeral overrides via /process:settings
+ * Global: ~/.pi/agent/extensions/process.json
+ * Memory: ephemeral overrides via /ps:settings
  */
 
 import { ConfigLoader } from "@aliou/pi-utils-settings";
@@ -11,7 +11,7 @@ import { DEFAULT_KEYBINDINGS } from "./utils/keybindings";
 
 export interface ProcessesConfig {
   processList?: {
-    /** Max visible processes in the /process:list TUI list. */
+    /** Max visible processes in the /ps TUI list. */
     maxVisibleProcesses?: number;
     /** Max log preview lines shown below the selected process. */
     maxPreviewLines?: number;

package/src/constants/index.ts

@@ -1,7 +1,11 @@
 export type {
   ExecuteResult,
   KillResult,
+  LogWatch,
+  LogWatchMatchEvent,
+  LogWatchStream,
   ManagerEvent,
+  ProcessAction,
   ProcessesDetails,
   ProcessInfo,
   ProcessStatus,

package/src/constants/types.ts

@@ -1,6 +1,16 @@
 // Custom message type for process update notifications
 export const MESSAGE_TYPE_PROCESS_UPDATE = "ad-process:update";
 
+export type ProcessAction =
+  | "start"
+  | "list"
+  | "output"
+  | "logs"
+  | "kill"
+  | "clear"
+  | "write"
+  | "debug_preview";
+
 export type ProcessStatus =
   | "running"
   | "terminating"
@@ -14,6 +24,14 @@ export const LIVE_STATUSES: ReadonlySet<ProcessStatus> = new Set([
   "terminate_timeout",
 ]);
 
+export type LogWatchStream = "stdout" | "stderr" | "both";
+
+export interface LogWatch {
+  pattern: string;
+  stream?: LogWatchStream;
+  repeat?: boolean;
+}
+
 export interface ProcessInfo {
   id: string;
   name: string;
@@ -32,9 +50,25 @@ export interface ProcessInfo {
   alertOnKill: boolean;
 }
 
+export interface LogWatchMatchEvent {
+  processId: string;
+  processName: string;
+  processCommand: string;
+  source: "stdout" | "stderr";
+  line: string;
+  watch: {
+    index: number;
+    pattern: string;
+    stream: LogWatchStream;
+    repeat: boolean;
+  };
+}
+
 export type ManagerEvent =
   | { type: "process_started"; info: ProcessInfo }
   | { type: "process_ended"; info: ProcessInfo }
+  | { type: "process_output_changed"; id: string }
+  | { type: "process_watch_matched"; match: LogWatchMatchEvent }
   | { type: "processes_changed" };
 
 export type KillResult =
@@ -52,10 +86,11 @@ export interface StartOptions {
   alertOnSuccess?: boolean;
   alertOnFailure?: boolean;
   alertOnKill?: boolean;
+  logWatches?: LogWatch[];
 }
 
 export interface ProcessesDetails {
-  action: string;
+  action: ProcessAction;
   success: boolean;
   message: string;
   process?: ProcessInfo;

package/src/hooks/index.ts

@@ -5,6 +5,7 @@ import { setupBackgroundBlocker } from "./background-blocker";
 import { setupCleanupHook } from "./cleanup";
 import { setupMessageRenderer } from "./message-renderer";
 import { setupProcessEndHook } from "./process-end";
+import { setupProcessWatchHook } from "./process-watch";
 import { type DockActions, setupProcessWidget } from "./widget";
 
 export type { DockActions };
@@ -16,6 +17,7 @@ export function setupProcessesHooks(
 ): { update: () => void; dockActions: DockActions } {
   setupCleanupHook(pi, manager);
   setupProcessEndHook(pi, manager);
+  setupProcessWatchHook(pi, manager);
 
   if (config.interception.blockBackgroundCommands) {
     setupBackgroundBlocker(pi);

package/src/hooks/message-renderer.ts

@@ -6,7 +6,8 @@ import type {
 import { Text } from "@mariozechner/pi-tui";
 import { MESSAGE_TYPE_PROCESS_UPDATE } from "../constants";
 
-interface ProcessUpdateDetails {
+interface ProcessLifecycleDetails {
+  kind?: "lifecycle";
   processId: string;
   processName: string;
   command: string;
@@ -16,10 +17,25 @@ interface ProcessUpdateDetails {
   runtime: string;
 }
 
+interface ProcessWatchMatchDetails {
+  kind: "watch_matched";
+  processId: string;
+  processName: string;
+  command: string;
+  source: "stdout" | "stderr";
+  line: string;
+  watch: {
+    index: number;
+    pattern: string;
+    stream: "stdout" | "stderr" | "both";
+    repeat: boolean;
+  };
+}
+
 interface ProcessUpdateMessage {
   customType: string;
   content: string | Array<{ type: string; text?: string }>;
-  details?: ProcessUpdateDetails;
+  details?: ProcessLifecycleDetails | ProcessWatchMatchDetails;
 }
 
 function getContentText(
@@ -35,7 +51,9 @@ function getContentText(
 }
 
 export function setupMessageRenderer(pi: ExtensionAPI) {
-  pi.registerMessageRenderer<ProcessUpdateDetails>(
+  pi.registerMessageRenderer<
+    ProcessLifecycleDetails | ProcessWatchMatchDetails
+  >(
     MESSAGE_TYPE_PROCESS_UPDATE,
     (
       message: ProcessUpdateMessage,
@@ -48,6 +66,20 @@ export function setupMessageRenderer(pi: ExtensionAPI) {
         return new Text(getContentText(message.content), 0, 0);
       }
 
+      if (details.kind === "watch_matched") {
+        const streamColor = details.source === "stderr" ? "warning" : "accent";
+        const text =
+          theme.fg("success", "* ") +
+          theme.fg("accent", `"${details.processName}"`) +
+          theme.fg("muted", ` (${details.processId}) `) +
+          theme.fg("success", "watch matched ") +
+          theme.fg("muted", `/${details.watch.pattern}/ `) +
+          theme.fg(streamColor, `[${details.source}]`) +
+          theme.fg("muted", ` ${details.line}`);
+
+        return new Text(text, 0, 0);
+      }
+
       let icon: string;
       let color: "success" | "error" | "warning";
 

package/src/hooks/process-end.ts

@@ -4,6 +4,7 @@ import type { ProcessManager } from "../manager";
 import { formatRuntime } from "../utils";
 
 interface ProcessUpdateDetails {
+  kind: "lifecycle";
   processId: string;
   processName: string;
   command: string;
@@ -43,6 +44,7 @@ export function setupProcessEndHook(pi: ExtensionAPI, manager: ProcessManager) {
     // Send the message to the conversation - displayed via custom renderer in UI
     // Only trigger an agent turn when the notification preferences say so.
     const details: ProcessUpdateDetails = {
+      kind: "lifecycle",
       processId: info.id,
       processName: info.name,
       command: info.command,

package/src/hooks/process-watch.ts

@@ -0,0 +1,83 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { MESSAGE_TYPE_PROCESS_UPDATE } from "../constants";
+import type { ProcessManager } from "../manager";
+
+interface ProcessWatchUpdateDetails {
+  kind: "watch_matched";
+  processId: string;
+  processName: string;
+  command: string;
+  source: "stdout" | "stderr";
+  line: string;
+  watch: {
+    index: number;
+    pattern: string;
+    stream: "stdout" | "stderr" | "both";
+    repeat: boolean;
+  };
+}
+
+const REPEAT_WATCH_TURN_COOLDOWN_MS = 5000;
+
+export function setupProcessWatchHook(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+) {
+  const lastRepeatTurnAt = new Map<string, number>();
+
+  manager.onEvent((event) => {
+    if (event.type === "process_ended") {
+      // Cleanup cooldown state for this process.
+      const prefix = `${event.info.id}:`;
+      for (const key of lastRepeatTurnAt.keys()) {
+        if (key.startsWith(prefix)) {
+          lastRepeatTurnAt.delete(key);
+        }
+      }
+      return;
+    }
+
+    if (event.type !== "process_watch_matched") return;
+
+    const match = event.match;
+    const message =
+      `Watch matched for '${match.processName}' (${match.processId}) ` +
+      `[${match.source}] /${match.watch.pattern}/`;
+
+    const details: ProcessWatchUpdateDetails = {
+      kind: "watch_matched",
+      processId: match.processId,
+      processName: match.processName,
+      command: match.processCommand,
+      source: match.source,
+      line: match.line,
+      watch: {
+        index: match.watch.index,
+        pattern: match.watch.pattern,
+        stream: match.watch.stream,
+        repeat: match.watch.repeat,
+      },
+    };
+
+    let triggerTurn = true;
+    if (match.watch.repeat) {
+      const watchKey = `${match.processId}:${match.watch.index}`;
+      const now = Date.now();
+      const last = lastRepeatTurnAt.get(watchKey) ?? 0;
+      triggerTurn = now - last >= REPEAT_WATCH_TURN_COOLDOWN_MS;
+      if (triggerTurn) {
+        lastRepeatTurnAt.set(watchKey, now);
+      }
+    }
+
+    pi.sendMessage(
+      {
+        customType: MESSAGE_TYPE_PROCESS_UPDATE,
+        content: message,
+        display: true,
+        details,
+      },
+      { triggerTurn },
+    );
+  });
+}

package/src/manager.test.ts

@@ -0,0 +1,331 @@
+import { afterEach, describe, expect, it } from "vitest";
+import type { ManagerEvent } from "./constants";
+import { ProcessManager } from "./manager";
+
+function waitForEnd(manager: ProcessManager, id: string): Promise<void> {
+  return new Promise((resolve) => {
+    const unsub = manager.onEvent((e) => {
+      if (e.type === "process_ended" && e.info.id === id) {
+        unsub();
+        resolve();
+      }
+    });
+  });
+}
+
+function collectEvents(manager: ProcessManager): ManagerEvent[] {
+  const events: ManagerEvent[] = [];
+  // Unsubscribe not stored; manager.cleanup() in afterEach clears all listeners.
+  manager.onEvent((e) => events.push(e));
+  return events;
+}
+
+describe("process_output_changed", () => {
+  let manager: ProcessManager;
+
+  afterEach(() => {
+    manager.cleanup();
+  });
+
+  it("emits process_output_changed on stdout", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "echo hello", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    expect(outputEvents.length).toBeGreaterThanOrEqual(1);
+    expect(outputEvents[0]).toEqual({
+      type: "process_output_changed",
+      id: info.id,
+    });
+  });
+
+  it("emits process_output_changed on stderr", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "echo err >&2", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    expect(outputEvents.length).toBeGreaterThanOrEqual(1);
+    expect(outputEvents[0]).toEqual({
+      type: "process_output_changed",
+      id: info.id,
+    });
+  });
+
+  it("throttles rapid output", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "seq 1 200", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    // Should be significantly fewer than 200 due to throttling
+    expect(outputEvents.length).toBeGreaterThanOrEqual(1);
+    expect(outputEvents.length).toBeLessThan(50);
+  });
+
+  it("stdout and stderr share one throttle bucket", async () => {
+    manager = new ProcessManager();
+
+    // Dual-stream burst: writes to both stdout and stderr rapidly
+    const events2 = collectEvents(manager);
+    const info2 = manager.start(
+      "dual",
+      "bash -c 'for i in $(seq 1 50); do echo out$i; echo err$i >&2; done'",
+      "/tmp",
+    );
+    await waitForEnd(manager, info2.id);
+    const dualCount = events2.filter(
+      (e) => e.type === "process_output_changed",
+    ).length;
+
+    // Both streams share one throttle bucket, so total events should be low
+    expect(dualCount).toBeLessThan(30);
+  });
+
+  it("trailing emit fires after burst ends", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "seq 1 100", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    // There should be at least one output event, and a process_ended event
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    const endEvents = events.filter((e) => e.type === "process_ended");
+    expect(outputEvents.length).toBeGreaterThanOrEqual(1);
+    expect(endEvents.length).toBe(1);
+  });
+
+  it("final output event before process_ended", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "echo hello", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    let lastOutputIdx = -1;
+    for (let i = events.length - 1; i >= 0; i--) {
+      if (events[i].type === "process_output_changed") {
+        lastOutputIdx = i;
+        break;
+      }
+    }
+    const endIdx = events.findIndex((e) => e.type === "process_ended");
+
+    expect(lastOutputIdx).toBeGreaterThanOrEqual(0);
+    expect(endIdx).toBeGreaterThanOrEqual(0);
+    expect(lastOutputIdx).toBeLessThan(endIdx);
+  });
+
+  it("no output events for silent process", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+    const info = manager.start("test", "true", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    // Wait a bit for any stale trailing emits
+    await new Promise((r) => setTimeout(r, 200));
+
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    expect(outputEvents.length).toBe(0);
+  });
+
+  it("no stale events after clearFinished", async () => {
+    manager = new ProcessManager();
+    const info = manager.start("test", "seq 1 50", "/tmp");
+    await waitForEnd(manager, info.id);
+
+    manager.clearFinished();
+
+    const lateEvents: ManagerEvent[] = [];
+    manager.onEvent((e) => lateEvents.push(e));
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const staleOutput = lateEvents.filter(
+      (e) => e.type === "process_output_changed",
+    );
+    expect(staleOutput.length).toBe(0);
+  });
+
+  it("events carry correct process id with multiple processes", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info1 = manager.start("proc1", "echo one", "/tmp");
+    const info2 = manager.start("proc2", "echo two", "/tmp");
+
+    await Promise.all([
+      waitForEnd(manager, info1.id),
+      waitForEnd(manager, info2.id),
+    ]);
+
+    const outputEvents = events.filter(
+      (e) => e.type === "process_output_changed",
+    );
+
+    for (const e of outputEvents) {
+      if (e.type === "process_output_changed") {
+        expect([info1.id, info2.id]).toContain(e.id);
+      }
+    }
+
+    // Both processes should have at least one output event
+    const ids = new Set(
+      outputEvents
+        .filter(
+          (e): e is Extract<ManagerEvent, { type: "process_output_changed" }> =>
+            e.type === "process_output_changed",
+        )
+        .map((e) => e.id),
+    );
+    expect(ids.has(info1.id)).toBe(true);
+    expect(ids.has(info2.id)).toBe(true);
+  });
+});
+
+describe("process_watch_matched", () => {
+  let manager: ProcessManager;
+
+  afterEach(() => {
+    manager.cleanup();
+  });
+
+  it("fires once by default on first matching line", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info = manager.start(
+      "watch-once",
+      "bash -c 'echo ready; echo ready; echo ready'",
+      "/tmp",
+      {
+        logWatches: [{ pattern: "ready" }],
+      },
+    );
+
+    await waitForEnd(manager, info.id);
+
+    const matches = events.filter((e) => e.type === "process_watch_matched");
+    expect(matches).toHaveLength(1);
+
+    const first = matches[0];
+    if (first.type === "process_watch_matched") {
+      expect(first.match.processId).toBe(info.id);
+      expect(first.match.source).toBe("stdout");
+      expect(first.match.watch.repeat).toBe(false);
+      expect(first.match.line).toBe("ready");
+    }
+  });
+
+  it("supports repeat watches", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info = manager.start(
+      "watch-repeat",
+      "bash -c 'echo done; echo done; echo done'",
+      "/tmp",
+      {
+        logWatches: [{ pattern: "done", repeat: true }],
+      },
+    );
+
+    await waitForEnd(manager, info.id);
+
+    const matches = events.filter((e) => e.type === "process_watch_matched");
+    expect(matches).toHaveLength(3);
+  });
+
+  it("respects stream scoping", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info = manager.start(
+      "watch-stream",
+      "bash -c 'echo out; echo err >&2'",
+      "/tmp",
+      {
+        logWatches: [{ pattern: "err", stream: "stderr" }],
+      },
+    );
+
+    await waitForEnd(manager, info.id);
+
+    const matches = events.filter((e) => e.type === "process_watch_matched");
+    expect(matches).toHaveLength(1);
+
+    const match = matches[0];
+    if (match.type === "process_watch_matched") {
+      expect(match.match.source).toBe("stderr");
+      expect(match.match.line).toBe("err");
+    }
+  });
+
+  it("stream both matches stdout and stderr", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info = manager.start(
+      "watch-both",
+      "bash -c 'echo marker; echo marker >&2'",
+      "/tmp",
+      {
+        logWatches: [{ pattern: "marker", stream: "both", repeat: true }],
+      },
+    );
+
+    await waitForEnd(manager, info.id);
+
+    const matches = events.filter((e) => e.type === "process_watch_matched");
+    expect(matches).toHaveLength(2);
+
+    const sources = new Set(
+      matches
+        .filter(
+          (e): e is Extract<ManagerEvent, { type: "process_watch_matched" }> =>
+            e.type === "process_watch_matched",
+        )
+        .map((e) => e.match.source),
+    );
+
+    expect(sources.has("stdout")).toBe(true);
+    expect(sources.has("stderr")).toBe(true);
+  });
+
+  it("matches trailing partial line at process end", async () => {
+    manager = new ProcessManager();
+    const events = collectEvents(manager);
+
+    const info = manager.start("watch-trailing", "printf ready", "/tmp", {
+      logWatches: [{ pattern: "ready" }],
+    });
+
+    await waitForEnd(manager, info.id);
+
+    const matches = events.filter((e) => e.type === "process_watch_matched");
+    expect(matches).toHaveLength(1);
+  });
+
+  it("throws for invalid watch regex", () => {
+    manager = new ProcessManager();
+
+    expect(() =>
+      manager.start("bad-watch", "echo ok", "/tmp", {
+        logWatches: [{ pattern: "(" }],
+      }),
+    ).toThrowError(/Invalid log watch pattern/);
+  });
+});