@aliou/pi-processes 0.4.5 → 0.4.7

package/README.md

@@ -20,8 +20,8 @@ pi install git:github.com/aliou/pi-processes
 
 ## Features
 
-- **Tool**: `processes` with actions: `start`, `list`, `output`, `logs`, `kill`, `clear`
-- **Command**: `/processes` - interactive panel to view and manage processes
+- **Tool**: `process` with actions: `start`, `list`, `output`, `logs`, `kill`, `clear`
+- **Commands**: `/process:list` (interactive panel), `/process:stream` (stream logs), `/process:logs` (log paths), `/process:kill` (kill process), `/process:clear` (clear finished)
 - Auto-cleanup on session exit
 - File-based logging (logs written to temp files, not memory)
 - Friendly process names (auto-inferred or custom)
@@ -31,48 +31,55 @@ pi install git:github.com/aliou/pi-processes
 ### Tool (for agent)
 
 ```
-processes start "pnpm dev" name="backend-dev"
-processes start "pnpm build" name="build" notifyOnSuccess=true
-processes start "pnpm test" notifyOnFailure=true
-processes list
-processes output id="backend"
-processes logs id="proc_1"
-processes kill id="backend"
-processes clear
+process start "pnpm dev" name="backend-dev"
+process start "pnpm build" name="build" alertOnSuccess=true
+process start "pnpm test" alertOnFailure=true
+process list
+process output id="backend"
+process logs id="proc_1"
+process kill id="backend"
+process clear
 ```
 
-**Notification parameters** (for `start` action):
-- `notifyOnSuccess` (default: false) - Get notified when process completes successfully. Use for builds/tests where you need confirmation.
-- `notifyOnFailure` (default: true) - Get notified when process crashes/fails. Use to be alerted of unexpected failures.
-- `notifyOnKill` (default: false) - Get notified if killed by external signal. Note: killing via tool never notifies.
+**Alert parameters** (for `start` action):
+- `alertOnSuccess` (default: false) - Get a turn to react when process completes successfully. Use for builds/tests where you need confirmation.
+- `alertOnFailure` (default: true) - Get a turn to react when process fails/crashes. Use to be alerted of unexpected failures.
+- `alertOnKill` (default: false) - Get a turn to react if killed by external signal. Note: killing via tool never triggers a turn.
 
 **Important:** You don't need to poll or wait for processes. Notifications arrive automatically based on your preferences. Start processes and continue with other work - you'll be informed if something requires attention.
 
-Note: User always sees notifications in UI. Notification preferences only control whether the agent is informed.
+Note: User always sees process updates in the UI. The alert flags control whether the agent gets a turn to react (e.g. check results, fix code, restart).
 
-### Command (interactive)
+### Commands (interactive)
 
-Run `/processes` to open the panel:
+Run `/process:list` to open the panel:
 - `j/k` - select process
 - `J/K` - scroll logs
+- `enter` - stream logs for selected process
 - `x` - kill selected process
 - `c` - clear finished processes
 - `q` - quit
 
+Other commands:
+- `/process:stream [id|name]` - stream logs from a running process
+- `/process:logs [id|name]` - show log file paths
+- `/process:kill [id|name]` - kill a running process
+- `/process:clear` - clear finished processes
+
 ## Test Scripts
 
-Test scripts in `test/` directory:
+Test scripts in `src/test/` directory:
 
 ```bash
-./test/test-output.sh          # Continuous output (80 chars/sec)
-./test/test-exit-success.sh 5  # Exits successfully after 5s
-./test/test-exit-failure.sh 5  # Exits with code 1 after 5s
-./test/test-exit-crash.sh 5    # Exits with code 137 after 5s
+./src/test/test-output.sh          # Continuous output (80 chars/sec)
+./src/test/test-exit-success.sh 5  # Exits successfully after 5s
+./src/test/test-exit-failure.sh 5  # Exits with code 1 after 5s
+./src/test/test-exit-crash.sh 5    # Exits with code 137 after 5s
 ```
 
 ## Future Improvements
 
-- [ ] **Expandable log view**: Allow toggling between collapsed (current fixed height) and expanded (full height) log view in the `/processes` panel.
+- [ ] **Expandable log view**: Allow toggling between collapsed (current fixed height) and expanded (full height) log view in the `/process:list` panel.
 
 - [ ] **Copy log file path**: Add keyboard shortcut to copy the stdout/stderr log file path to clipboard for easy access.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -47,6 +47,11 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18"
   },
+  "peerDependenciesMeta": {
+    "@mariozechner/pi-coding-agent": {
+      "optional": true
+    }
+  },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "biome check",

package/src/commands/index.ts

@@ -0,0 +1,334 @@
+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,
+): void {
+  let streamingProcessId: string | null = null;
+
+  // ── /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("/process:list requires interactive mode", "error");
+        return;
+      }
+
+      // If currently streaming, dismiss the stream widget and show the list.
+      if (streamingProcessId) {
+        ctx.ui.setWidget(LOG_STREAM_WIDGET_ID, undefined);
+        streamingProcessId = null;
+      }
+
+      const result = await ctx.ui.custom<string | null>(
+        (tui, theme, _keybindings, done) => {
+          return new ProcessesComponent(
+            tui,
+            theme,
+            (processId?: string) => {
+              if (processId) {
+                done(processId);
+              } else {
+                done(null);
+              }
+            },
+            manager,
+          );
+        },
+      );
+
+      // RPC fallback.
+      if (result === undefined) {
+        ctx.ui.notify("/process:list requires interactive mode", "info");
+        return;
+      }
+
+      // User dismissed with Escape/q.
+      if (result === null) {
+        return;
+      }
+
+      // User selected a process — start streaming its logs.
+      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/src/commands/settings-command.ts

@@ -0,0 +1,157 @@
+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: "Execution",
+          items: [
+            {
+              id: "execution.shellPath",
+              label: "Shell path",
+              description:
+                "Absolute shell path override used to execute commands",
+              currentValue:
+                tabConfig?.execution?.shellPath ??
+                resolved.execution.shellPath ??
+                "auto",
+              values: [
+                "auto",
+                "/run/current-system/sw/bin/bash",
+                "/bin/bash",
+                "/usr/bin/bash",
+                "/usr/local/bin/bash",
+              ],
+            },
+          ],
+        },
+        {
+          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;
+      }
+      if (id === "execution.shellPath") {
+        if (!updated.execution) updated.execution = {};
+        updated.execution.shellPath =
+          newValue === "auto" ? undefined : newValue;
+        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,
+  });
+}