@aliou/pi-processes 0.4.7 → 0.6.0

package/src/manager.ts

@@ -9,6 +9,7 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { Writable } from "node:stream";
 
 import {
   type KillResult,
@@ -17,12 +18,15 @@ import {
   type ProcessInfo,
   type ProcessStatus,
   type StartOptions,
+  type WriteResult,
 } from "./constants";
 import { isProcessGroupAlive, killProcessGroup } from "./utils";
 import { spawnCommand } from "./utils/command-executor";
 
 interface ManagedProcess extends ProcessInfo {
   process: ChildProcess;
+  stdin: Writable | null;
+  stdinClosed: boolean;
   lastSignalSent: NodeJS.Signals | null;
   combinedFile: string;
 }
@@ -57,15 +61,8 @@ export class ProcessManager {
 
   private transition(managed: ManagedProcess, next: ProcessStatus): void {
     if (managed.status === next) return;
-    const prev = managed.status;
     managed.status = next;
 
-    this.emit({
-      type: "process_status_changed",
-      info: this.toProcessInfo(managed),
-      prev,
-    });
-
     if (next === "exited" || next === "killed") {
       this.emit({ type: "process_ended", info: this.toProcessInfo(managed) });
     }
@@ -159,6 +156,8 @@ export class ProcessManager {
       alertOnFailure: options?.alertOnFailure ?? true,
       alertOnKill: options?.alertOnKill ?? false,
       process: child,
+      stdin: child.stdin,
+      stdinClosed: false,
       lastSignalSent: null,
     };
 
@@ -319,12 +318,15 @@ export class ProcessManager {
     }
   }
 
-  getLogFiles(id: string): { stdoutFile: string; stderrFile: string } | null {
+  getLogFiles(
+    id: string,
+  ): { stdoutFile: string; stderrFile: string; combinedFile: string } | null {
     const managed = this.processes.get(id);
     if (!managed) return null;
     return {
       stdoutFile: managed.stdoutFile,
       stderrFile: managed.stderrFile,
+      combinedFile: managed.combinedFile,
     };
   }
 
@@ -407,6 +409,50 @@ export class ProcessManager {
     return { ok: true, info: this.toProcessInfo(managed) };
   }
 
+  writeToStdin(
+    id: string,
+    data: string,
+    opts?: { end?: boolean },
+  ): WriteResult {
+    const managed = this.processes.get(id);
+    if (!managed) {
+      return {
+        ok: false,
+        reason: "not_found",
+      };
+    }
+
+    if (!LIVE_STATUSES.has(managed.status)) {
+      return {
+        ok: false,
+        reason: "process_exited",
+      };
+    }
+
+    if (managed.stdinClosed || !managed.stdin) {
+      return {
+        ok: false,
+        reason: "stdin_closed",
+      };
+    }
+
+    try {
+      managed.stdin.write(data);
+
+      if (opts?.end) {
+        managed.stdin.end();
+        managed.stdinClosed = true;
+      }
+
+      return { ok: true };
+    } catch {
+      return {
+        ok: false,
+        reason: "write_error",
+      };
+    }
+  }
+
   clearFinished(): number {
     let cleared = 0;
     for (const [id, managed] of this.processes) {
@@ -519,4 +565,10 @@ export class ProcessManager {
   }
 }
 
-export type { ProcessInfo, ProcessStatus, ManagerEvent, KillResult };
+export type {
+  ProcessInfo,
+  ProcessStatus,
+  ManagerEvent,
+  KillResult,
+  WriteResult,
+};

package/src/tools/actions/index.ts

@@ -7,12 +7,15 @@ import { executeList } from "./list";
 import { executeLogs } from "./logs";
 import { executeOutput } from "./output";
 import { executeStart } from "./start";
+import { executeWrite } from "./write";
 
 interface ActionParams {
   action: string;
   command?: string;
   name?: string;
   id?: string;
+  input?: string;
+  end?: boolean;
   alertOnSuccess?: boolean;
   alertOnFailure?: boolean;
   alertOnKill?: boolean;
@@ -36,6 +39,8 @@ export async function executeAction(
       return executeKill(params, manager);
     case "clear":
       return executeClear(manager);
+    case "write":
+      return executeWrite(params, manager);
     default:
       return {
         content: [{ type: "text", text: `Unknown action: ${params.action}` }],

package/src/tools/actions/write.ts

@@ -0,0 +1,87 @@
+import type { ExecuteResult } from "../../constants";
+import type { ProcessManager } from "../../manager";
+
+interface WriteParams {
+  id?: string;
+  input?: string;
+  end?: boolean;
+}
+
+export function executeWrite(
+  params: WriteParams,
+  manager: ProcessManager,
+): ExecuteResult {
+  const { id, input, end } = params;
+
+  if (!id) {
+    return {
+      content: [{ type: "text", text: "Missing required parameter: id" }],
+      details: {
+        action: "write",
+        success: false,
+        message: "Missing required parameter: id",
+      },
+    };
+  }
+
+  if (input === undefined) {
+    return {
+      content: [{ type: "text", text: "Missing required parameter: input" }],
+      details: {
+        action: "write",
+        success: false,
+        message: "Missing required parameter: input",
+      },
+    };
+  }
+
+  const process = manager.find(id);
+  if (!process) {
+    return {
+      content: [{ type: "text", text: `Process not found: ${id}` }],
+      details: {
+        action: "write",
+        success: false,
+        message: `Process not found: ${id}`,
+      },
+    };
+  }
+
+  const result = manager.writeToStdin(process.id, input, { end });
+
+  if (!result.ok) {
+    const messages: Record<string, string> = {
+      not_found: `Process not found: ${process.id}`,
+      process_exited: `Process has already exited: ${process.id}`,
+      stdin_closed: `Stdin already closed for process: ${process.id}`,
+      write_error: `Failed to write to stdin for process: ${process.id}`,
+    };
+
+    const message =
+      messages[result.reason] || `Unknown error: ${result.reason}`;
+
+    return {
+      content: [{ type: "text", text: message }],
+      details: {
+        action: "write",
+        success: false,
+        message,
+      },
+    };
+  }
+
+  const suffix = end ? " (stdin closed)" : "";
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Wrote ${input.length} bytes to ${process.id}${suffix}`,
+      },
+    ],
+    details: {
+      action: "write",
+      success: true,
+      message: `Wrote ${input.length} bytes to process stdin${suffix}`,
+    },
+  };
+}

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.test.ts

@@ -1,9 +1,10 @@
+import type * as nodeFs from "node:fs";
 import { existsSync } from "node:fs";
 import { describe, expect, it, vi } from "vitest";
 import { resolveShellExecutable } from "./command-executor";
 
 vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs")>();
+  const actual = await importOriginal<typeof nodeFs>();
   return { ...actual, existsSync: vi.fn() };
 });
 

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/utils/shell-utils.ts

@@ -0,0 +1,133 @@
+// Shell AST helpers. Duplicated from pi-toolchain since cross-extension imports are not allowed.
+
+import type {
+  Command,
+  Program,
+  SimpleCommand,
+  Statement,
+  Word,
+  WordPart,
+} from "@aliou/sh";
+
+/**
+ * Resolve a Word node to its literal string value.
+ * Concatenates Literal, SglQuoted, and simple DblQuoted parts.
+ * For parts containing parameter expansions, command substitutions, etc.,
+ * includes the raw text representation (e.g. `$VAR`).
+ */
+export function wordToString(word: Word): string {
+  return word.parts.map(partToString).join("");
+}
+
+function partToString(part: WordPart): string {
+  switch (part.type) {
+    case "Literal":
+      return part.value;
+    case "SglQuoted":
+      return part.value;
+    case "DblQuoted":
+      return part.parts.map(partToString).join("");
+    case "ParamExp":
+      return part.short
+        ? `$${part.param.value}`
+        : `\${${part.param.value}${part.op ?? ""}${part.value ? wordToString(part.value) : ""}}`;
+    case "CmdSubst":
+      return "$(...)";
+    case "ArithExp":
+      return `$((${part.expr}))`;
+    case "ProcSubst":
+      return `${part.op}(...)`;
+  }
+}
+
+/**
+ * Walk the AST and call `callback` for every SimpleCommand found at any
+ * nesting depth. Returns early if callback returns `true`.
+ */
+export function walkCommands(
+  node: Program,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): void {
+  for (const stmt of node.body) {
+    if (walkStatement(stmt, callback)) return;
+  }
+}
+
+function walkStatement(
+  stmt: Statement,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  return walkCommand(stmt.command, callback);
+}
+
+function walkStatements(
+  stmts: Statement[],
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  for (const stmt of stmts) {
+    if (walkStatement(stmt, callback)) return true;
+  }
+  return false;
+}
+
+function walkCommand(
+  cmd: Command,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  switch (cmd.type) {
+    case "SimpleCommand":
+      return callback(cmd) === true;
+
+    case "Pipeline":
+      return walkStatements(cmd.commands, callback);
+
+    case "Logical":
+      return (
+        walkStatement(cmd.left, callback) || walkStatement(cmd.right, callback)
+      );
+
+    case "Subshell":
+    case "Block":
+      return walkStatements(cmd.body, callback);
+
+    case "IfClause":
+      return (
+        walkStatements(cmd.cond, callback) ||
+        walkStatements(cmd.then, callback) ||
+        (cmd.else ? walkStatements(cmd.else, callback) : false)
+      );
+
+    case "ForClause":
+    case "SelectClause":
+    case "WhileClause":
+      return (
+        ("cond" in cmd && cmd.cond
+          ? walkStatements(cmd.cond, callback)
+          : false) || walkStatements(cmd.body, callback)
+      );
+
+    case "CaseClause":
+      for (const item of cmd.items) {
+        if (walkStatements(item.body, callback)) return true;
+      }
+      return false;
+
+    case "FunctionDecl":
+      return walkStatements(cmd.body, callback);
+
+    case "TimeClause":
+      return walkStatement(cmd.command, callback);
+
+    case "CoprocClause":
+      return walkStatement(cmd.body, callback);
+
+    case "CStyleLoop":
+      return walkStatements(cmd.body, callback);
+
+    case "TestClause":
+    case "ArithCmd":
+    case "DeclClause":
+    case "LetClause":
+      return false;
+  }
+}