@aliou/pi-processes 0.5.0 → 0.6.0

package/src/tools/index.ts

@@ -15,10 +15,10 @@ import { executeAction } from "./actions";
 
 const ProcessesParams = Type.Object({
   action: StringEnum(
-    ["start", "list", "output", "logs", "kill", "clear"] as const,
+    ["start", "list", "output", "logs", "kill", "clear", "write"] as const,
     {
       description:
-        "Action: start (run command), list (show all), output (get recent output), logs (get log file paths), kill (terminate), clear (remove finished)",
+        "Action: start (run command), list (show all), output (get recent output), logs (get log file paths), kill (terminate), clear (remove finished), write (write to stdin)",
     },
   ),
   command: Type.Optional(
@@ -33,7 +33,18 @@ const ProcessesParams = Type.Object({
   id: Type.Optional(
     Type.String({
       description:
-        "Process ID or name to match (required for output/kill/logs). Can be proc_N or friendly name.",
+        "Process ID or name to match (required for output/kill/logs/write). Can be proc_N or friendly name.",
+    }),
+  ),
+  input: Type.Optional(
+    Type.String({
+      description: "Data to write to process stdin (required for write action)",
+    }),
+  ),
+  end: Type.Optional(
+    Type.Boolean({
+      description:
+        "Close stdin after writing (optional for write action, use for programs reading until EOF)",
     }),
   ),
   alertOnSuccess: Type.Optional(
@@ -72,6 +83,7 @@ export function setupProcessesTools(pi: ExtensionAPI, manager: ProcessManager) {
 - logs: Get log file paths to inspect with read tool (requires 'id')
 - kill: Terminate a process (requires 'id' - can be proc_N or name match like "backend")
 - clear: Remove all finished processes from the list
+- write: Write to process stdin (requires 'id' and 'input', optional 'end' to close stdin)
 
 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.
 
@@ -107,12 +119,20 @@ Note: User always sees process updates in the UI. The notify flags control wheth
       if (
         (args.action === "output" ||
           args.action === "kill" ||
-          args.action === "logs") &&
+          args.action === "logs" ||
+          args.action === "write") &&
         args.id
       ) {
         mainArg = args.id;
       }
 
+      if (args.action === "write" && args.input) {
+        optionArgs.push({ label: "input", value: args.input });
+        if (args.end) {
+          optionArgs.push({ label: "end", value: "true" });
+        }
+      }
+
       return new ToolCallHeader(
         {
           toolName: "Process",
@@ -204,6 +224,23 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         }
 
         fields.push(new Text(lines.join("\n"), 0, 0));
+
+        // Collapsed summary
+        const previewSource =
+          details.output.stdout.length > 0
+            ? details.output.stdout
+            : details.output.stderr;
+        const preview = previewSource
+          .slice(-2)
+          .map((l) => stripAnsi(l))
+          .join("\n");
+        fields.push({
+          label: "Output",
+          value: preview
+            ? `${theme.fg("muted", preview)}`
+            : theme.fg("muted", "(empty)"),
+          showCollapsed: true,
+        });
       } else if (
         details.action === "list" &&
         details.processes &&
@@ -243,6 +280,31 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         }
 
         fields.push(new Text(lines.join("\n"), 0, 0));
+
+        // Collapsed summary: first 3 processes
+        const summary = details.processes
+          .slice(0, 3)
+          .map((p) => {
+            const s =
+              p.status === "running"
+                ? theme.fg("accent", "running")
+                : p.status === "exited" && p.success
+                  ? theme.fg("success", "exit(0)")
+                  : p.status === "exited"
+                    ? theme.fg("error", `exit(${p.exitCode ?? "?"})`)
+                    : theme.fg("muted", p.status);
+            return `${theme.fg("accent", `"${p.name}"`)} [${s}]`;
+          })
+          .join(", ");
+        const more =
+          details.processes.length > 3
+            ? theme.fg("muted", ` +${details.processes.length - 3} more`)
+            : "";
+        fields.push({
+          label: "Processes",
+          value: summary + more,
+          showCollapsed: true,
+        });
       } else if (details.action === "logs" && details.logFiles) {
         fields.push(
           new Text(
@@ -263,16 +325,22 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         });
       }
 
-      const footer = new ToolFooter(theme, {
-        items: [
-          { label: "action", value: details.action, tone: "accent" },
-          {
-            label: "status",
-            value: details.success ? "ok" : "error",
-            tone: details.success ? "success" : "error",
-          },
-        ],
-      });
+      const footerItems: Array<{
+        label: string;
+        value: string;
+        tone: "accent" | "success" | "error" | "warning" | "muted";
+      }> = [];
+      if (!details.success) {
+        footerItems.push({
+          label: "status",
+          value: "error",
+          tone: "error",
+        });
+      }
+      const footer =
+        footerItems.length > 0
+          ? new ToolFooter(theme, { items: footerItems })
+          : undefined;
 
       return new ToolBody({ fields, footer }, options, theme);
     },

package/src/utils/command-executor.ts

@@ -50,7 +50,7 @@ export function spawnCommand(
   return spawn(shellExecutable, ["-lc", command], {
     cwd,
     env: process.env,
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: ["pipe", "pipe", "pipe"],
     detached: true,
   });
 }

package/src/utils/keybindings.ts

@@ -0,0 +1,76 @@
+/**
+ * Keyboard shortcuts configuration for the Process Dock.
+ */
+
+export interface ProcessesKeybindings {
+  /** Toggle dock visibility (global) */
+  toggleDock: string;
+  /** Scroll logs up */
+  scrollUp: string;
+  /** Scroll logs down */
+  scrollDown: string;
+  /** Focus previous process */
+  prevProcess: string;
+  /** Focus next process */
+  nextProcess: string;
+  /** Toggle focus mode */
+  toggleFocus: string;
+  /** Toggle follow mode */
+  toggleFollow: string;
+  /** Kill focused process */
+  killProcess: string;
+  /** Clear finished processes */
+  clearFinished: string;
+  /** Collapse/close dock */
+  closeDock: string;
+}
+
+export const DEFAULT_KEYBINDINGS: ProcessesKeybindings = {
+  toggleDock: "", // Disabled - conflicts with editor shortcuts
+  scrollUp: "k",
+  scrollDown: "j",
+  prevProcess: "h",
+  nextProcess: "l",
+  toggleFocus: "f",
+  toggleFollow: "Shift+F",
+  killProcess: "x",
+  clearFinished: "c",
+  closeDock: "q",
+};
+
+/**
+ * Interface for config that may contain keybindings overrides
+ */
+export interface ProcessesConfigKeybindings {
+  toggleDock?: string;
+  scrollUp?: string;
+  scrollDown?: string;
+  prevProcess?: string;
+  nextProcess?: string;
+  toggleFocus?: string;
+  toggleFollow?: string;
+  killProcess?: string;
+  clearFinished?: string;
+  closeDock?: string;
+}
+
+/**
+ * Load keybindings from config, falling back to defaults.
+ */
+export function loadKeybindings(config: {
+  keybindings?: ProcessesConfigKeybindings;
+}): ProcessesKeybindings {
+  const user = config.keybindings ?? {};
+  return {
+    toggleDock: user.toggleDock ?? DEFAULT_KEYBINDINGS.toggleDock,
+    scrollUp: user.scrollUp ?? DEFAULT_KEYBINDINGS.scrollUp,
+    scrollDown: user.scrollDown ?? DEFAULT_KEYBINDINGS.scrollDown,
+    prevProcess: user.prevProcess ?? DEFAULT_KEYBINDINGS.prevProcess,
+    nextProcess: user.nextProcess ?? DEFAULT_KEYBINDINGS.nextProcess,
+    toggleFocus: user.toggleFocus ?? DEFAULT_KEYBINDINGS.toggleFocus,
+    toggleFollow: user.toggleFollow ?? DEFAULT_KEYBINDINGS.toggleFollow,
+    killProcess: user.killProcess ?? DEFAULT_KEYBINDINGS.killProcess,
+    clearFinished: user.clearFinished ?? DEFAULT_KEYBINDINGS.clearFinished,
+    closeDock: user.closeDock ?? DEFAULT_KEYBINDINGS.closeDock,
+  };
+}

package/src/commands/settings-command.ts

@@ -1,179 +0,0 @@
-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: "Interception",
-          items: [
-            {
-              id: "interception.blockBackgroundCommands",
-              label: "Block background commands",
-              description:
-                "Block bash background commands (&, nohup, disown, setsid) and guide the model to use the process tool",
-              currentValue:
-                (tabConfig?.interception?.blockBackgroundCommands ??
-                resolved.interception.blockBackgroundCommands)
-                  ? "on"
-                  : "off",
-              values: ["on", "off"],
-            },
-          ],
-        },
-        {
-          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 === "interception.blockBackgroundCommands") {
-        if (!updated.interception) updated.interception = {};
-        updated.interception.blockBackgroundCommands = newValue === "on";
-        return updated;
-      }
-      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,
-  });
-}

package/src/components/log-stream-component.ts

@@ -1,149 +0,0 @@
-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;
-  }
-}

package/src/test/test-exit-crash.sh

@@ -1,19 +0,0 @@
-#!/bin/bash
-# Test script that simulates a crash (exit code 137 - like SIGKILL)
-# Usage: ./test-exit-crash.sh [seconds]
-
-WAIT_SECONDS=${1:-17}
-
-echo "Starting unstable task..."
-echo "Will crash in ${WAIT_SECONDS} seconds"
-
-for i in $(seq 1 $WAIT_SECONDS); do
-  echo "[$(date '+%H:%M:%S')] Running... ($i/$WAIT_SECONDS)"
-  if [ $i -eq $((WAIT_SECONDS - 1)) ]; then
-    echo "[WARN] Memory pressure detected" >&2
-  fi
-  sleep 1
-done
-
-echo "FATAL: Segmentation fault (core dumped)" >&2
-exit 137

package/src/test/test-exit-failure.sh

@@ -1,17 +0,0 @@
-#!/bin/bash
-# Test script that exits with failure (exit code 1)
-# Usage: ./test-exit-failure.sh [seconds]
-
-WAIT_SECONDS=${1:-15}
-
-echo "Starting failing task..."
-echo "Will fail in ${WAIT_SECONDS} seconds"
-
-for i in $(seq 1 $WAIT_SECONDS); do
-  echo "[$(date '+%H:%M:%S')] Processing... ($i/$WAIT_SECONDS)"
-  sleep 1
-done
-
-echo "ERROR: Task failed!" >&2
-echo "Something went wrong!" >&2
-exit 1

package/src/test/test-exit-success.sh

@@ -1,16 +0,0 @@
-#!/bin/bash
-# Test script that exits successfully (exit code 0)
-# Usage: ./test-exit-success.sh [seconds]
-
-WAIT_SECONDS=${1:-13}
-
-echo "Starting successful task..."
-echo "Will complete in ${WAIT_SECONDS} seconds"
-
-for i in $(seq 1 $WAIT_SECONDS); do
-  echo "[$(date '+%H:%M:%S')] Working... ($i/$WAIT_SECONDS)"
-  sleep 1
-done
-
-echo "Task completed successfully!"
-exit 0

package/src/test/test-output.sh

@@ -1,28 +0,0 @@
-#!/bin/bash
-# Test script for processes extension
-# Writes 80 characters every second, empty line every 10 seconds
-
-counter=0
-while true; do
-  counter=$((counter + 1))
-  
-  # Generate 80 characters: timestamp + padding
-  timestamp=$(date '+%H:%M:%S')
-  line=$(printf "[%s] Line %05d: " "$timestamp" "$counter")
-  # Pad to 80 chars with random chars
-  padding_len=$((80 - ${#line}))
-  padding=$(head -c $padding_len /dev/urandom | LC_ALL=C tr -dc 'a-zA-Z0-9' 2>/dev/null || printf '%*s' "$padding_len" '' | tr ' ' 'x')
-  echo "${line}${padding}"
-  
-  # Every 10 seconds, print an empty line
-  if [ $((counter % 10)) -eq 0 ]; then
-    echo ""
-  fi
-  
-  # Every 5 lines, write something to stderr
-  if [ $((counter % 5)) -eq 0 ]; then
-    echo "[WARN] Counter reached $counter" >&2
-  fi
-  
-  sleep 1
-done