@aliou/pi-processes 0.3.4 → 0.4.2

package/commands/index.ts

@@ -1,29 +1,73 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
 import { LogStreamComponent } from "../components/log-stream-component";
+import { ProcessPickerComponent } from "../components/process-picker-component";
 import { ProcessesComponent } from "../components/processes-component";
+import { LIVE_STATUSES, type ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
 
 const LOG_STREAM_WIDGET_ID = "processes-log-stream";
 
+function runningProcessCompletions(manager: ProcessManager) {
+  return (prefix: string) => {
+    const processes = manager.list();
+    const lower = prefix.toLowerCase();
+    return processes
+      .filter(
+        (p) =>
+          LIVE_STATUSES.has(p.status) &&
+          (p.id.toLowerCase().startsWith(lower) ||
+            p.name.toLowerCase().startsWith(lower)),
+      )
+      .map((p) => ({
+        value: p.id,
+        label: p.id,
+        description: p.name,
+      }));
+  };
+}
+
+function allProcessCompletions(manager: ProcessManager) {
+  return (prefix: string) => {
+    const processes = manager.list();
+    const lower = prefix.toLowerCase();
+    return processes
+      .filter(
+        (p) =>
+          p.id.toLowerCase().startsWith(lower) ||
+          p.name.toLowerCase().startsWith(lower),
+      )
+      .map((p) => ({
+        value: p.id,
+        label: p.id,
+        description: p.name,
+      }));
+  };
+}
+
 export function setupProcessesCommands(
   pi: ExtensionAPI,
   manager: ProcessManager,
-) {
-  // Track whether we're currently streaming logs.
-  let isStreaming = false;
+): void {
+  let streamingProcessId: string | null = null;
 
-  pi.registerCommand("processes", {
+  // ── /process:list ──────────────────────────────────────────────────
+  // Registered first so it appears first in autocomplete.
+  pi.registerCommand("process:list", {
     description: "View and manage background processes",
     handler: async (_args, ctx) => {
       if (!ctx.hasUI) {
-        ctx.ui.notify("/processes requires interactive mode", "error");
+        ctx.ui.notify("/process:list requires interactive mode", "error");
         return;
       }
 
       // If currently streaming, dismiss the stream widget and show the list.
-      if (isStreaming) {
+      if (streamingProcessId) {
         ctx.ui.setWidget(LOG_STREAM_WIDGET_ID, undefined);
-        isStreaming = false;
+        streamingProcessId = null;
       }
 
       const result = await ctx.ui.custom<string | null>(
@@ -45,7 +89,7 @@ export function setupProcessesCommands(
 
       // RPC fallback.
       if (result === undefined) {
-        ctx.ui.notify("/processes requires interactive mode", "info");
+        ctx.ui.notify("/process:list requires interactive mode", "info");
         return;
       }
 
@@ -55,14 +99,236 @@ export function setupProcessesCommands(
       }
 
       // User selected a process — start streaming its logs.
-      isStreaming = true;
-      ctx.ui.setWidget(
-        LOG_STREAM_WIDGET_ID,
-        (tui, theme) => {
-          return new LogStreamComponent(tui, theme, manager, result);
-        },
-        { placement: "aboveEditor" },
+      startStreaming(ctx.ui, manager, result);
+    },
+  });
+
+  // ── /process:stream [id|name] ──────────────────────────────────────
+  pi.registerCommand("process:stream", {
+    description: "Stream logs from a running process",
+    getArgumentCompletions: runningProcessCompletions(manager),
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+
+      // Explicit argument: stream that process.
+      if (arg) {
+        const proc = manager.find(arg);
+        if (!proc) {
+          ctx.ui.notify(`Process not found: ${arg}`, "error");
+          return;
+        }
+        if (!LIVE_STATUSES.has(proc.status)) {
+          ctx.ui.notify(
+            `${proc.name} (${proc.id}) is not running (${proc.status})`,
+            "info",
+          );
+          return;
+        }
+        startStreaming(ctx.ui, manager, proc.id);
+        return;
+      }
+
+      // No argument + currently streaming: dismiss.
+      if (streamingProcessId) {
+        ctx.ui.setWidget(LOG_STREAM_WIDGET_ID, undefined);
+        streamingProcessId = null;
+        return;
+      }
+
+      // No argument + not streaming: pick from running processes.
+      const running = manager.list().filter((p) => LIVE_STATUSES.has(p.status));
+
+      // No running processes.
+      if (running.length === 0) {
+        ctx.ui.notify("No running processes", "info");
+        return;
+      }
+
+      // Single running process: auto-select.
+      if (running.length === 1 && running[0]) {
+        startStreaming(ctx.ui, manager, running[0].id);
+        return;
+      }
+
+      // Multiple running processes: show picker.
+      const processId = await pickProcess(
+        ctx,
+        manager,
+        "Select process to stream",
+        (p) => LIVE_STATUSES.has(p.status),
+      );
+      if (!processId) return;
+      startStreaming(ctx.ui, manager, processId);
+    },
+  });
+
+  // ── /process:logs [id|name] ────────────────────────────────────────
+  pi.registerCommand("process:logs", {
+    description: "Show log file paths for a process",
+    getArgumentCompletions: allProcessCompletions(manager),
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+
+      let processId: string | undefined;
+
+      if (arg) {
+        const proc = manager.find(arg);
+        if (!proc) {
+          ctx.ui.notify(`Process not found: ${arg}`, "error");
+          return;
+        }
+        processId = proc.id;
+      } else {
+        // No argument: show picker.
+        processId = await pickProcess(ctx, manager, "Select process for logs");
+        if (!processId) return;
+      }
+
+      const logFiles = manager.getLogFiles(processId);
+      const proc = manager.get(processId);
+      if (!logFiles || !proc) {
+        ctx.ui.notify(`Process not found: ${processId}`, "error");
+        return;
+      }
+
+      ctx.ui.notify(
+        `${proc.name} (${proc.id})\nstdout: ${logFiles.stdoutFile}\nstderr: ${logFiles.stderrFile}`,
+        "info",
       );
     },
   });
+
+  // ── /process:kill [id|name] ────────────────────────────────────────
+  pi.registerCommand("process:kill", {
+    description: "Kill a running background process",
+    getArgumentCompletions: runningProcessCompletions(manager),
+    handler: async (args, ctx) => {
+      const arg = args.trim();
+
+      let processId: string | undefined;
+
+      if (arg) {
+        const proc = manager.find(arg);
+        if (!proc) {
+          ctx.ui.notify(`Process not found: ${arg}`, "error");
+          return;
+        }
+        if (!LIVE_STATUSES.has(proc.status)) {
+          ctx.ui.notify(
+            `${proc.name} (${proc.id}) is not running (${proc.status})`,
+            "info",
+          );
+          return;
+        }
+        processId = proc.id;
+      } else {
+        // No argument: show picker (only running processes).
+        const running = manager
+          .list()
+          .filter((p) => LIVE_STATUSES.has(p.status));
+
+        if (running.length === 0) {
+          ctx.ui.notify("No running processes to kill", "info");
+          return;
+        }
+
+        if (running.length === 1 && running[0]) {
+          processId = running[0].id;
+        } else {
+          processId = await pickProcess(
+            ctx,
+            manager,
+            "Select process to kill",
+            (p) => LIVE_STATUSES.has(p.status),
+          );
+          if (!processId) return;
+        }
+      }
+
+      const proc = manager.get(processId);
+      if (!proc) {
+        ctx.ui.notify(`Process not found: ${processId}`, "error");
+        return;
+      }
+
+      const signal =
+        proc.status === "terminate_timeout" ? "SIGKILL" : "SIGTERM";
+      const timeoutMs = signal === "SIGKILL" ? 200 : 3000;
+      const result = await manager.kill(processId, { signal, timeoutMs });
+
+      if (result.ok) {
+        ctx.ui.notify(`Killed ${proc.name} (${proc.id})`, "info");
+      } else {
+        ctx.ui.notify(
+          `Failed to kill ${proc.name} (${proc.id}): ${result.reason}`,
+          "error",
+        );
+      }
+    },
+  });
+
+  // ── /process:clear ─────────────────────────────────────────────────
+  pi.registerCommand("process:clear", {
+    description: "Clear finished processes",
+    handler: async (_args, ctx) => {
+      const cleared = manager.clearFinished();
+      if (cleared > 0) {
+        ctx.ui.notify(
+          `Cleared ${cleared} finished process${cleared > 1 ? "es" : ""}`,
+          "info",
+        );
+      } else {
+        ctx.ui.notify("No finished processes to clear", "info");
+      }
+    },
+  });
+
+  // ── Helpers ────────────────────────────────────────────────────────
+
+  function startStreaming(
+    ui: ExtensionCommandContext["ui"],
+    mgr: ProcessManager,
+    processId: string,
+  ) {
+    streamingProcessId = processId;
+    ui.setWidget(
+      LOG_STREAM_WIDGET_ID,
+      (tui: { requestRender: () => void }, theme: Theme) => {
+        return new LogStreamComponent(tui, theme, mgr, processId);
+      },
+      { placement: "aboveEditor" },
+    );
+  }
+}
+
+async function pickProcess(
+  ctx: ExtensionCommandContext,
+  manager: ProcessManager,
+  title: string,
+  filter?: (proc: ProcessInfo) => boolean,
+): Promise<string | undefined> {
+  if (!ctx.hasUI) {
+    ctx.ui.notify("Interactive mode required", "error");
+    return undefined;
+  }
+
+  const result = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+    return new ProcessPickerComponent(
+      tui,
+      theme,
+      (processId?: string) => {
+        done(processId ?? null);
+      },
+      manager,
+      title,
+      filter,
+    );
+  });
+
+  // RPC fallback or user cancelled.
+  if (result === undefined || result === null) {
+    return undefined;
+  }
+
+  return result;
 }

package/commands/settings-command.ts

@@ -0,0 +1,128 @@
+import {
+  registerSettingsCommand,
+  type SettingsSection,
+} from "@aliou/pi-utils-settings";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProcessesConfig, ResolvedProcessesConfig } from "../config";
+import { configLoader } from "../config";
+
+export function registerProcessesSettings(
+  pi: ExtensionAPI,
+  onSave?: () => void,
+): void {
+  registerSettingsCommand<ProcessesConfig, ResolvedProcessesConfig>(pi, {
+    commandName: "process:settings",
+    title: "Processes Settings",
+    configStore: configLoader,
+    buildSections: (
+      tabConfig: ProcessesConfig | null,
+      resolved: ResolvedProcessesConfig,
+    ): SettingsSection[] => {
+      return [
+        {
+          label: "Process List",
+          items: [
+            {
+              id: "processList.maxVisibleProcesses",
+              label: "Max visible processes",
+              description:
+                "Maximum processes shown in the /processes list before scrolling",
+              currentValue: String(
+                tabConfig?.processList?.maxVisibleProcesses ??
+                  resolved.processList.maxVisibleProcesses,
+              ),
+              values: ["4", "6", "8", "12", "16"],
+            },
+            {
+              id: "processList.maxPreviewLines",
+              label: "Max preview lines",
+              description: "Log preview lines shown below the selected process",
+              currentValue: String(
+                tabConfig?.processList?.maxPreviewLines ??
+                  resolved.processList.maxPreviewLines,
+              ),
+              values: ["6", "8", "12", "16", "24"],
+            },
+          ],
+        },
+        {
+          label: "Output Limits",
+          items: [
+            {
+              id: "output.defaultTailLines",
+              label: "Default tail lines",
+              description:
+                "Number of tail lines returned to the agent by default",
+              currentValue: String(
+                tabConfig?.output?.defaultTailLines ??
+                  resolved.output.defaultTailLines,
+              ),
+              values: ["50", "100", "200", "500"],
+            },
+            {
+              id: "output.maxOutputLines",
+              label: "Max output lines",
+              description: "Hard cap on output lines returned to the agent",
+              currentValue: String(
+                tabConfig?.output?.maxOutputLines ??
+                  resolved.output.maxOutputLines,
+              ),
+              values: ["100", "200", "500", "1000"],
+            },
+          ],
+        },
+        {
+          label: "Widget",
+          items: [
+            {
+              id: "widget.showStatusWidget",
+              label: "Show status widget",
+              description: "Show process status widget below the editor",
+              currentValue:
+                (tabConfig?.widget?.showStatusWidget ??
+                resolved.widget.showStatusWidget)
+                  ? "on"
+                  : "off",
+              values: ["on", "off"],
+            },
+          ],
+        },
+      ];
+    },
+    onSettingChange: (id, newValue, config) => {
+      const updated = structuredClone(config);
+      // Boolean fields.
+      if (id === "widget.showStatusWidget") {
+        if (!updated.widget) updated.widget = {};
+        updated.widget.showStatusWidget = newValue === "on";
+        return updated;
+      }
+      // Numeric fields.
+      const num = Number.parseInt(newValue, 10);
+      if (Number.isNaN(num)) return null;
+
+      switch (id) {
+        case "processList.maxVisibleProcesses":
+          if (!updated.processList) updated.processList = {};
+          updated.processList.maxVisibleProcesses = num;
+          break;
+        case "processList.maxPreviewLines":
+          if (!updated.processList) updated.processList = {};
+          updated.processList.maxPreviewLines = num;
+          break;
+        case "output.defaultTailLines":
+          if (!updated.output) updated.output = {};
+          updated.output.defaultTailLines = num;
+          break;
+        case "output.maxOutputLines":
+          if (!updated.output) updated.output = {};
+          updated.output.maxOutputLines = num;
+          break;
+        default:
+          return null;
+      }
+      return updated;
+    },
+    onSave,
+  });
+}

package/components/log-stream-component.ts

@@ -0,0 +1,149 @@
+import {
+  createPanelPadder,
+  renderPanelRule,
+  renderPanelTitleLine,
+} from "@aliou/pi-utils-ui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import {
+  type Component,
+  truncateToWidth,
+  visibleWidth,
+} from "@mariozechner/pi-tui";
+import type { ProcessManager } from "../manager";
+import { stripAnsi } from "../utils";
+import { statusIcon, statusLabel } from "./status-format";
+
+const MAX_LOG_LINES = 16;
+const POLL_INTERVAL_MS = 500;
+
+export class LogStreamComponent implements Component {
+  private tui: { requestRender: () => void };
+  private theme: Theme;
+  private manager: ProcessManager;
+  private processId: string;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private unsubscribe: (() => void) | null = null;
+  private cachedLines: string[] = [];
+  private cachedWidth = 0;
+
+  constructor(
+    tui: { requestRender: () => void },
+    theme: Theme,
+    manager: ProcessManager,
+    processId: string,
+  ) {
+    this.tui = tui;
+    this.theme = theme;
+    this.manager = manager;
+    this.processId = processId;
+
+    // Poll log file for new output.
+    this.timer = setInterval(() => {
+      this.invalidate();
+      this.tui.requestRender();
+    }, POLL_INTERVAL_MS);
+
+    // Also re-render on process events (status changes, etc.).
+    this.unsubscribe = this.manager.onEvent(() => {
+      this.invalidate();
+      this.tui.requestRender();
+    });
+  }
+
+  handleInput(_data: string): boolean {
+    // Widget doesn't handle input — the editor is still active.
+    return false;
+  }
+
+  invalidate(): void {
+    this.cachedWidth = 0;
+    this.cachedLines = [];
+  }
+
+  render(width: number): string[] {
+    if (width === this.cachedWidth && this.cachedLines.length > 0) {
+      return this.cachedLines;
+    }
+
+    const theme = this.theme;
+    const dim = (s: string) => theme.fg("dim", s);
+    const warning = (s: string) => theme.fg("warning", s);
+    const innerWidth = width - 2;
+
+    const basePadLine = createPanelPadder(width);
+    const padLine = (content: string): string => {
+      const contentWidth = visibleWidth(content);
+      return basePadLine(
+        contentWidth > innerWidth
+          ? truncateToWidth(content, innerWidth)
+          : content,
+      );
+    };
+
+    const lines: string[] = [];
+    const proc = this.manager.get(this.processId);
+
+    if (!proc) {
+      lines.push(renderPanelRule(width, theme));
+      lines.push(padLine(warning("Process not found")));
+      lines.push(renderPanelRule(width, theme));
+      this.cachedLines = lines;
+      this.cachedWidth = width;
+      return this.cachedLines;
+    }
+
+    // Header
+    const icon = statusIcon(proc.status, proc.success);
+    const label = statusLabel(proc);
+    lines.push(
+      renderPanelTitleLine(
+        `Process: ${proc.name} (${proc.id}) ${icon} ${label}`,
+        width,
+        theme,
+      ),
+    );
+
+    // Log lines (interleaved stdout + stderr in temporal order).
+    const logLines = this.manager.getCombinedOutput(
+      this.processId,
+      MAX_LOG_LINES,
+    );
+    if (logLines && logLines.length > 0) {
+      for (const line of logLines) {
+        const cleaned = stripAnsi(line.text);
+        const display = truncateToWidth(cleaned, innerWidth - 2);
+        if (line.type === "stderr") {
+          lines.push(padLine(warning(display)));
+        } else {
+          lines.push(padLine(display));
+        }
+      }
+    } else {
+      lines.push(padLine(dim("(no output yet)")));
+    }
+
+    // Pad to MAX_LOG_LINES for stable height.
+    const renderedLogLines = lines.length - 1; // minus header
+    for (let i = renderedLogLines; i < MAX_LOG_LINES; i++) {
+      lines.push(padLine(""));
+    }
+
+    // Footer hint
+    lines.push(renderPanelRule(width, theme));
+    lines.push(padLine(dim("Run /process:stream to dismiss")));
+    lines.push(renderPanelRule(width, theme));
+
+    this.cachedLines = lines;
+    this.cachedWidth = width;
+    return this.cachedLines;
+  }
+
+  dispose(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+  }
+}