@aliou/pi-processes 0.9.4 → 0.10.0

package/src/hooks/widget/setup.ts

@@ -1,167 +0,0 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@earendil-works/pi-coding-agent";
-import { LogDockComponent } from "../../components/log-dock-component";
-import { configLoader, type ResolvedProcessesConfig } from "../../config";
-import { LIVE_STATUSES } from "../../constants";
-import type { ProcessManager } from "../../manager";
-import { renderStatusWidget } from "./status-widget";
-import {
-  type DockActions,
-  type DockState,
-  LOG_DOCK_WIDGET_ID,
-  STATUS_WIDGET_ID,
-} from "./types";
-
-export function setupProcessWidget(
-  pi: ExtensionAPI,
-  manager: ProcessManager,
-  config: ResolvedProcessesConfig,
-) {
-  let activeCtx: ExtensionContext | null = null;
-  let logDockComponent: LogDockComponent | null = null;
-  let logDockComponentTui: { requestRender(): void } | null = null;
-
-  const dockState: DockState = {
-    visibility: "hidden",
-    followEnabled: config.follow.enabledByDefault,
-    focusedProcessId: null,
-  };
-
-  function updateWidget() {
-    if (!activeCtx?.hasUI) return;
-
-    if (!configLoader.getConfig().widget.showStatusWidget) {
-      activeCtx.ui.setWidget(STATUS_WIDGET_ID, undefined);
-    } else {
-      const processes = manager.list();
-      const maxWidth = process.stdout.columns || 120;
-      const lines = renderStatusWidget(processes, activeCtx.ui.theme, maxWidth);
-
-      if (lines.length === 0) {
-        activeCtx.ui.setWidget(STATUS_WIDGET_ID, undefined);
-      } else {
-        activeCtx.ui.setWidget(STATUS_WIDGET_ID, lines, {
-          placement: "belowEditor",
-        });
-      }
-    }
-
-    if (dockState.visibility === "hidden") {
-      activeCtx.ui.setWidget(LOG_DOCK_WIDGET_ID, undefined);
-      if (logDockComponent) {
-        logDockComponent.dispose();
-        logDockComponent = null;
-        logDockComponentTui = null;
-      }
-      return;
-    }
-
-    const mode = dockState.visibility as "collapsed" | "open";
-    const height = mode === "collapsed" ? 3 : config.widget.dockHeight;
-
-    if (logDockComponent && logDockComponentTui) {
-      logDockComponent.update({
-        mode,
-        focusedProcessId: dockState.focusedProcessId,
-        dockHeight: height,
-      });
-    } else {
-      const ctx = activeCtx;
-      ctx.ui.setWidget(
-        LOG_DOCK_WIDGET_ID,
-        (tui: { requestRender(): void }, theme: typeof ctx.ui.theme) => {
-          logDockComponent = new LogDockComponent({
-            manager,
-            tui,
-            theme,
-            mode,
-            focusedProcessId: dockState.focusedProcessId,
-            dockHeight: height,
-          });
-          logDockComponentTui = tui;
-          return logDockComponent;
-        },
-        { placement: "aboveEditor" },
-      );
-    }
-  }
-
-  const dockActions: DockActions = {
-    getFocusedProcessId: () => dockState.focusedProcessId,
-    isFollowEnabled: () => dockState.followEnabled,
-    setFocus(id) {
-      dockState.focusedProcessId = id;
-      if (id && dockState.visibility === "hidden")
-        dockState.visibility = "open";
-      updateWidget();
-    },
-    expand() {
-      dockState.visibility = "open";
-      updateWidget();
-    },
-    collapse() {
-      dockState.visibility = "collapsed";
-      updateWidget();
-    },
-    hide() {
-      dockState.visibility = "hidden";
-      updateWidget();
-    },
-    toggle() {
-      if (dockState.visibility === "hidden") dockState.visibility = "collapsed";
-      else if (dockState.visibility === "collapsed")
-        dockState.visibility = "open";
-      else dockState.visibility = "collapsed";
-      updateWidget();
-    },
-  };
-
-  manager.onEvent((event) => {
-    if (event.type === "process_started") {
-      if (dockState.followEnabled && dockState.visibility === "hidden") {
-        dockState.visibility = "collapsed";
-      }
-    }
-
-    if (event.type === "process_ended") {
-      if (dockState.focusedProcessId === event.info.id) {
-        dockState.focusedProcessId = null;
-      }
-      const running = manager.list().filter((p) => LIVE_STATUSES.has(p.status));
-      if (
-        running.length === 0 &&
-        config.follow.autoHideOnFinish &&
-        dockState.followEnabled
-      ) {
-        dockState.visibility = "hidden";
-      }
-    }
-
-    updateWidget();
-  });
-
-  pi.on("session_start", async (_event, ctx) => {
-    if (logDockComponent) {
-      logDockComponent.dispose();
-      logDockComponent = null;
-      logDockComponentTui = null;
-    }
-    activeCtx = ctx;
-    updateWidget();
-  });
-
-  pi.on("session_shutdown", async (_event, ctx) => {
-    activeCtx = null;
-    if (logDockComponent) {
-      logDockComponent.dispose();
-      logDockComponent = null;
-      logDockComponentTui = null;
-    }
-    ctx.ui.setWidget(STATUS_WIDGET_ID, undefined);
-    ctx.ui.setWidget(LOG_DOCK_WIDGET_ID, undefined);
-  });
-
-  return { update: updateWidget, dockActions };
-}

package/src/hooks/widget/status-widget.ts

@@ -1,105 +0,0 @@
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
-import type { ProcessInfo } from "../../constants";
-
-function formatProcessStatus(
-  proc: ProcessInfo,
-  theme: ExtensionContext["ui"]["theme"],
-): string {
-  const name =
-    proc.name.length > 20 ? `${proc.name.slice(0, 17)}...` : proc.name;
-
-  switch (proc.status) {
-    case "running":
-      return `${theme.fg("accent", name)} ${theme.fg("dim", "running")}`;
-    case "terminating":
-      return `${theme.fg("warning", name)} ${theme.fg("dim", "terminating")}`;
-    case "terminate_timeout":
-      return `${theme.fg("error", name)} ${theme.fg("error", "terminate_timeout")}`;
-    case "killed":
-      return `${theme.fg("warning", name)} ${theme.fg("dim", "killed")}`;
-    case "exited":
-      if (proc.success) {
-        return `${theme.fg("dim", name)} ${theme.fg("success", "done")}`;
-      }
-      return `${theme.fg("error", name)} ${theme.fg("error", `exit(${proc.exitCode ?? "?"})`)}`;
-    default:
-      return `${theme.fg("dim", name)} ${theme.fg("dim", proc.status)}`;
-  }
-}
-
-export function renderStatusWidget(
-  processes: ProcessInfo[],
-  theme: ExtensionContext["ui"]["theme"],
-  maxWidth?: number,
-): string[] {
-  if (processes.length === 0) return [];
-
-  const aliveish = processes.filter(
-    (p) =>
-      p.status === "running" ||
-      p.status === "terminating" ||
-      p.status === "terminate_timeout",
-  );
-  const finished = processes.filter(
-    (p) =>
-      p.status !== "running" &&
-      p.status !== "terminating" &&
-      p.status !== "terminate_timeout",
-  );
-
-  const allProcs: ProcessInfo[] = [
-    ...aliveish,
-    ...finished.sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0)),
-  ];
-
-  const prefix = theme.fg("dim", "processes: ");
-  const prefixLen = visibleWidth(prefix);
-  const separator = theme.fg("dim", " | ");
-  const separatorLen = visibleWidth(separator);
-  const effectiveMax = maxWidth ?? 200;
-
-  const parts: string[] = [];
-  let currentLen = prefixLen;
-  let includedCount = 0;
-
-  for (const proc of allProcs) {
-    const formatted = formatProcessStatus(proc, theme);
-    const formattedLen = visibleWidth(formatted);
-    const remaining = allProcs.length - includedCount - 1;
-    const needed =
-      includedCount > 0 ? separatorLen + formattedLen : formattedLen;
-
-    let reservedForSuffix = 0;
-    if (remaining > 0) {
-      const suffixText = `+${remaining} more`;
-      reservedForSuffix = separatorLen + visibleWidth(suffixText);
-    }
-
-    if (
-      currentLen + needed + reservedForSuffix > effectiveMax &&
-      includedCount > 0
-    ) {
-      const hiddenCount = allProcs.length - includedCount;
-      if (hiddenCount > 0) parts.push(theme.fg("dim", `+${hiddenCount} more`));
-      break;
-    }
-
-    parts.push(formatted);
-    currentLen += needed;
-    includedCount++;
-  }
-
-  if (includedCount === 0 && allProcs.length > 0) {
-    parts.push(formatProcessStatus(allProcs[0], theme));
-  }
-
-  if (parts.length === 0) return [];
-
-  const line = prefix + parts.join(separator);
-  return [
-    visibleWidth(line) > effectiveMax
-      ? truncateToWidth(line, effectiveMax)
-      : line,
-  ];
-}

package/src/hooks/widget/types.ts

@@ -1,20 +0,0 @@
-export type DockVisibility = "hidden" | "collapsed" | "open";
-
-export interface DockState {
-  visibility: DockVisibility;
-  followEnabled: boolean;
-  focusedProcessId: string | null;
-}
-
-export interface DockActions {
-  getFocusedProcessId(): string | null;
-  isFollowEnabled(): boolean;
-  setFocus(id: string | null): void;
-  expand(): void;
-  collapse(): void;
-  hide(): void;
-  toggle(): void;
-}
-
-export const STATUS_WIDGET_ID = "processes-status";
-export const LOG_DOCK_WIDGET_ID = "processes-dock";

package/src/index.ts

@@ -1,35 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { setupProcessesCommands } from "./commands";
-import { registerProcessesSettings } from "./commands/settings";
-import { configLoader } from "./config";
-import { setupProcessesHooks } from "./hooks";
-import { ProcessManager } from "./manager";
-import { setupProcessesTools } from "./tools";
-
-export default async function (pi: ExtensionAPI) {
-  if (process.platform === "win32") {
-    pi.on("session_start", async (_event, ctx) => {
-      if (!ctx.hasUI) return;
-      ctx.ui.notify("processes extension not available on Windows", "warning");
-    });
-    return;
-  }
-
-  await configLoader.load();
-  const manager = new ProcessManager({
-    getConfiguredShellPath: () => configLoader.getConfig().execution.shellPath,
-  });
-
-  const config = configLoader.getConfig();
-
-  const { update: updateWidget, dockActions } = setupProcessesHooks(
-    pi,
-    manager,
-    config,
-  );
-  setupProcessesCommands(pi, manager, dockActions);
-  setupProcessesTools(pi, manager);
-  registerProcessesSettings(pi, () => {
-    updateWidget();
-  });
-}

package/src/manager.test.ts

@@ -1,331 +0,0 @@
-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/);
-  });
-});