@aliou/pi-processes 0.3.4 → 0.4.2

package/constants/index.ts

@@ -0,0 +1,11 @@
+export type {
+  ExecuteResult,
+  KillResult,
+  ManagerEvent,
+  ProcessesDetails,
+  ProcessInfo,
+  ProcessStatus,
+  StartOptions,
+} from "./types";
+
+export { LIVE_STATUSES, MESSAGE_TYPE_PROCESS_UPDATE } from "./types";

package/constants/types.ts

@@ -0,0 +1,65 @@
+// Custom message type for process update notifications
+export const MESSAGE_TYPE_PROCESS_UPDATE = "ad-process:update";
+
+export type ProcessStatus =
+  | "running"
+  | "terminating"
+  | "terminate_timeout"
+  | "exited"
+  | "killed";
+
+export const LIVE_STATUSES: ReadonlySet<ProcessStatus> = new Set([
+  "running",
+  "terminating",
+  "terminate_timeout",
+]);
+
+export interface ProcessInfo {
+  id: string;
+  name: string;
+  pid: number; // On Unix, this is also the PGID (process group leader)
+  command: string;
+  cwd: string;
+  startTime: number;
+  endTime: number | null;
+  status: ProcessStatus;
+  exitCode: number | null;
+  success: boolean | null; // null if running, true if exit code 0, false otherwise
+  stdoutFile: string;
+  stderrFile: string;
+  alertOnSuccess: boolean;
+  alertOnFailure: boolean;
+  alertOnKill: boolean;
+}
+
+export type ManagerEvent =
+  | { type: "process_started"; info: ProcessInfo }
+  | { type: "process_status_changed"; info: ProcessInfo; prev: ProcessStatus }
+  | { type: "process_ended"; info: ProcessInfo }
+  | { type: "processes_changed" };
+
+export type KillResult =
+  | { ok: true; info: ProcessInfo }
+  | { ok: false; info: ProcessInfo; reason: "not_found" | "timeout" | "error" };
+
+export interface StartOptions {
+  alertOnSuccess?: boolean;
+  alertOnFailure?: boolean;
+  alertOnKill?: boolean;
+}
+
+export interface ProcessesDetails {
+  action: string;
+  success: boolean;
+  message: string;
+  process?: ProcessInfo;
+  processes?: ProcessInfo[];
+  output?: { stdout: string[]; stderr: string[]; status: string };
+  logFiles?: { stdoutFile: string; stderrFile: string };
+  cleared?: number;
+}
+
+export interface ExecuteResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: ProcessesDetails;
+}

package/hooks/index.ts

@@ -10,7 +10,9 @@ export function setupProcessesHooks(pi: ExtensionAPI, manager: ProcessManager) {
   setupProcessEndHook(pi, manager);
 
   // Set up widget AFTER process-end so it chains onto the existing callback
-  setupProcessWidget(pi, manager);
+  const widget = setupProcessWidget(pi, manager);
 
   setupMessageRenderer(pi);
+
+  return widget;
 }

package/hooks/widget.ts

@@ -3,6 +3,7 @@ import type {
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
 import { visibleWidth } from "@mariozechner/pi-tui";
+import { configLoader } from "../config";
 import type { ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
 
@@ -106,6 +107,11 @@ export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
   function updateWidget() {
     if (!latestContext?.hasUI) return;
 
+    if (!configLoader.getConfig().widget.showStatusWidget) {
+      latestContext.ui.setWidget(WIDGET_ID, undefined);
+      return;
+    }
+
     const processes = manager.list();
     const maxWidth = process.stdout.columns || 120;
     const lines = renderWidget(processes, latestContext.ui.theme, maxWidth);

package/index.ts

@@ -1,10 +1,12 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { setupProcessesCommands } from "./commands";
+import { registerProcessesSettings } from "./commands/settings-command";
+import { configLoader } from "./config";
 import { setupProcessesHooks } from "./hooks";
 import { ProcessManager } from "./manager";
 import { setupProcessesTools } from "./tools";
 
-export default function (pi: ExtensionAPI) {
+export default async function (pi: ExtensionAPI) {
   if (process.platform === "win32") {
     pi.on("session_start", async (_event, ctx) => {
       if (!ctx.hasUI) return;
@@ -13,9 +15,13 @@ export default function (pi: ExtensionAPI) {
     return;
   }
 
+  await configLoader.load();
   const manager = new ProcessManager();
 
-  setupProcessesHooks(pi, manager);
-  setupProcessesTools(pi, manager);
+  const { update: updateWidget } = setupProcessesHooks(pi, manager);
   setupProcessesCommands(pi, manager);
+  setupProcessesTools(pi, manager);
+  registerProcessesSettings(pi, () => {
+    updateWidget();
+  });
 }

package/manager.ts

@@ -23,6 +23,7 @@ import { isProcessGroupAlive, killProcessGroup } from "./utils";
 interface ManagedProcess extends ProcessInfo {
   process: ChildProcess;
   lastSignalSent: NodeJS.Signals | null;
+  combinedFile: string;
 }
 
 export class ProcessManager {
@@ -122,9 +123,11 @@ export class ProcessManager {
     const id = `proc_${++this.counter}`;
     const stdoutFile = join(this.logDir, `${id}-stdout.log`);
     const stderrFile = join(this.logDir, `${id}-stderr.log`);
+    const combinedFile = join(this.logDir, `${id}-combined.log`);
 
     appendFileSync(stdoutFile, "");
     appendFileSync(stderrFile, "");
+    appendFileSync(combinedFile, "");
 
     const child = spawn("/bin/bash", ["-lc", command], {
       cwd,
@@ -148,6 +151,7 @@ export class ProcessManager {
       success: null,
       stdoutFile,
       stderrFile,
+      combinedFile,
       alertOnSuccess: options?.alertOnSuccess ?? false,
       alertOnFailure: options?.alertOnFailure ?? true,
       alertOnKill: options?.alertOnKill ?? false,
@@ -173,6 +177,15 @@ export class ProcessManager {
     child.stdout?.on("data", (data: Buffer) => {
       try {
         appendFileSync(stdoutFile, data);
+        const lines = data.toString().split("\n");
+        // The last element after split is either empty (if data ended with \n)
+        // or a partial line. We write all parts with the prefix and newline.
+        const tagged = lines
+          .map((line, i) =>
+            i < lines.length - 1 ? `1:${line}\n` : line ? `1:${line}\n` : "",
+          )
+          .join("");
+        if (tagged) appendFileSync(combinedFile, tagged);
       } catch {
         // Ignore
       }
@@ -181,6 +194,13 @@ export class ProcessManager {
     child.stderr?.on("data", (data: Buffer) => {
       try {
         appendFileSync(stderrFile, data);
+        const lines = data.toString().split("\n");
+        const tagged = lines
+          .map((line, i) =>
+            i < lines.length - 1 ? `2:${line}\n` : line ? `2:${line}\n` : "",
+          )
+          .join("");
+        if (tagged) appendFileSync(combinedFile, tagged);
       } catch {
         // Ignore
       }
@@ -262,6 +282,26 @@ export class ProcessManager {
     };
   }
 
+  getCombinedOutput(
+    id: string,
+    tailLines = 100,
+  ): { type: "stdout" | "stderr"; text: string }[] | null {
+    const managed = this.processes.get(id);
+    if (!managed) return null;
+
+    const rawLines = this.readTailLines(managed.combinedFile, tailLines);
+    return rawLines.map((line) => {
+      if (line.startsWith("2:")) {
+        return { type: "stderr", text: line.slice(2) };
+      }
+      // Default to stdout (handles "1:" prefix and any malformed lines).
+      return {
+        type: "stdout",
+        text: line.startsWith("1:") ? line.slice(2) : line,
+      };
+    });
+  }
+
   getFullOutput(id: string): { stdout: string; stderr: string } | null {
     const managed = this.processes.get(id);
     if (!managed) return null;
@@ -374,6 +414,7 @@ export class ProcessManager {
       try {
         rmSync(managed.stdoutFile, { force: true });
         rmSync(managed.stderrFile, { force: true });
+        rmSync(managed.combinedFile, { force: true });
       } catch {
         // Ignore
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.3.4",
+  "version": "0.4.2",
   "type": "module",
   "private": false,
   "keywords": [
@@ -25,12 +25,17 @@
   "files": [
     "*.ts",
     "commands",
+    "components",
+    "constants",
     "hooks",
     "tools",
+    "utils",
     "README.md"
   ],
   "dependencies": {
-    "@sinclair/typebox": "^0.34.41"
+    "@sinclair/typebox": "^0.34.41",
+    "@aliou/pi-utils-settings": "0.3.0",
+    "@aliou/pi-utils-ui": "^0.1.0"
   },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.51.0"

package/tools/actions/kill.ts

@@ -53,7 +53,7 @@ export async function executeKill(
   if (result.reason === "timeout") {
     const message =
       `SIGTERM timed out for "${proc.name}" (${proc.id}). ` +
-      "Run /processes and press x on terminate_timeout to force kill (SIGKILL).";
+      "Run /process:list and press x on terminate_timeout to force kill (SIGKILL).";
     return {
       content: [{ type: "text", text: message }],
       details: {

package/tools/actions/output.ts

@@ -1,8 +1,8 @@
+import { configLoader } from "../../config";
 import type { ExecuteResult } from "../../constants";
 import type { ProcessManager } from "../../manager";
 import { formatStatus, stripAnsi } from "../../utils";
 
-const MAX_LINES = 200;
 const MAX_BYTES = 50 * 1024; // 50KB
 
 interface OutputParams {
@@ -37,7 +37,8 @@ export function executeOutput(
     };
   }
 
-  const output = manager.getOutput(proc.id);
+  const { defaultTailLines } = configLoader.getConfig().output;
+  const output = manager.getOutput(proc.id, defaultTailLines);
   if (!output) {
     const message = `Could not read output for: ${proc.id}`;
     return {
@@ -68,7 +69,8 @@ export function executeOutput(
   }
 
   const fullText = outputParts.join("\n");
-  const contentText = truncateTail(fullText, logFiles);
+  const { maxOutputLines } = configLoader.getConfig().output;
+  const contentText = truncateTail(fullText, logFiles, maxOutputLines);
 
   return {
     content: [{ type: "text", text: contentText }],
@@ -89,12 +91,13 @@ export function executeOutput(
 function truncateTail(
   text: string,
   logFiles: { stdoutFile: string; stderrFile: string } | null,
+  maxLines: number,
 ): string {
   const totalBytes = Buffer.byteLength(text, "utf-8");
   const lines = text.split("\n");
   const totalLines = lines.length;
 
-  if (totalLines <= MAX_LINES && totalBytes <= MAX_BYTES) {
+  if (totalLines <= maxLines && totalBytes <= MAX_BYTES) {
     return text;
   }
 
@@ -103,7 +106,7 @@ function truncateTail(
   let keptBytes = 0;
   let hitBytes = false;
 
-  for (let i = lines.length - 1; i >= 0 && kept.length < MAX_LINES; i--) {
+  for (let i = lines.length - 1; i >= 0 && kept.length < maxLines; i--) {
     const line = lines[i] ?? "";
     const lineBytes =
       Buffer.byteLength(line, "utf-8") + (kept.length > 0 ? 1 : 0);

package/tools/index.ts

@@ -1,3 +1,4 @@
+import { ToolBody, ToolCallHeader, ToolFooter } from "@aliou/pi-utils-ui";
 import { StringEnum } from "@mariozechner/pi-ai";
 import type {
   AgentToolResult,
@@ -59,8 +60,8 @@ type ProcessesParamsType = Static<typeof ProcessesParams>;
 
 export function setupProcessesTools(pi: ExtensionAPI, manager: ProcessManager) {
   pi.registerTool<typeof ProcessesParams, ProcessesDetails>({
-    name: "processes",
-    label: "Processes",
+    name: "process",
+    label: "Process",
     description: `Manage background processes. Actions:
 - start: Run command in background (requires 'name' and 'command')
   - alertOnSuccess (default: false): Get a turn to react when process completes successfully
@@ -82,36 +83,53 @@ Note: User always sees process updates in the UI. The notify flags control wheth
       return executeAction(params, manager, ctx);
     },
 
-    renderCall(args: ProcessesParamsType, theme: Theme): Text {
-      let text = theme.fg("toolTitle", theme.bold("processes "));
-      text += theme.fg("accent", args.action);
+    renderCall(args: ProcessesParamsType, theme: Theme) {
+      const longArgs: Array<{ label?: string; value: string }> = [];
+      const optionArgs: Array<{ label: string; value: string }> = [];
+      let mainArg: string | undefined;
 
-      switch (args.action) {
-        case "start":
-          if (args.name) {
-            text += ` ${theme.fg("accent", `"${args.name}"`)}`;
-          }
-          if (args.command) {
-            text += ` ${theme.fg("muted", args.command.slice(0, 40))}`;
-          }
-          break;
-        case "output":
-        case "kill":
-        case "logs":
-          if (args.id) {
-            text += ` ${theme.fg("muted", args.id)}`;
+      if (args.action === "start") {
+        if (args.name) {
+          mainArg = `"${args.name}"`;
+        }
+
+        if (args.command) {
+          if (!mainArg && args.command.length <= 60) {
+            mainArg = args.command;
+          } else if (args.command.length <= 60) {
+            optionArgs.push({ label: "command", value: args.command });
+          } else {
+            longArgs.push({ label: "command", value: args.command });
           }
-          break;
+        }
+      }
+
+      if (
+        (args.action === "output" ||
+          args.action === "kill" ||
+          args.action === "logs") &&
+        args.id
+      ) {
+        mainArg = args.id;
       }
 
-      return new Text(text, 0, 0);
+      return new ToolCallHeader(
+        {
+          toolName: "Process",
+          action: args.action,
+          mainArg,
+          optionArgs,
+          longArgs,
+        },
+        theme,
+      );
     },
 
     renderResult(
       result: AgentToolResult<ProcessesDetails>,
-      _options: ToolRenderResultOptions,
+      options: ToolRenderResultOptions,
       theme: Theme,
-    ): Text {
+    ) {
       const { details } = result;
 
       if (!details) {
@@ -123,34 +141,32 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         );
       }
 
-      if (!details.success) {
-        return new Text(theme.fg("error", details.message), 0, 0);
-      }
-
-      // For start action
-      if (details.action === "start" && details.process) {
-        const p = details.process;
-        return new Text(
-          theme.fg("success", "\u2713 Started ") +
-            theme.fg("accent", `"${p.name}"`) +
-            ` (${p.id}, PID: ${p.pid})`,
-          0,
-          0,
-        );
-      }
-
-      // For output action
-      if (details.action === "output" && details.output) {
-        const lines: string[] = [];
-        lines.push(theme.fg("muted", details.message));
+      const fields: Array<
+        { label: string; value: string; showCollapsed?: boolean } | Text
+      > = [];
 
+      if (!details.success) {
+        fields.push({
+          label: "Error",
+          value: theme.fg("error", details.message),
+          showCollapsed: true,
+        });
+      } else if (details.action === "start" && details.process) {
+        const process = details.process;
+        fields.push({
+          label: "Status",
+          value:
+            theme.fg("success", "Started") +
+            ` ${theme.fg("accent", `"${process.name}"`)} (${process.id}, PID: ${process.pid})`,
+          showCollapsed: true,
+        });
+      } else if (details.action === "output" && details.output) {
+        const lines: string[] = [theme.fg("muted", details.message)];
         let hadAnsi = false;
 
         if (details.output.stdout.length > 0) {
-          lines.push("");
-          lines.push(theme.fg("accent", "stdout:"));
-          const stdoutLines = details.output.stdout.slice(-20);
-          for (const line of stdoutLines) {
+          lines.push("", theme.fg("accent", "stdout:"));
+          for (const line of details.output.stdout.slice(-20)) {
             if (!hadAnsi && hasAnsi(line)) hadAnsi = true;
             lines.push(stripAnsi(line));
           }
@@ -165,10 +181,8 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         }
 
         if (details.output.stderr.length > 0) {
-          lines.push("");
-          lines.push(theme.fg("warning", "stderr:"));
-          const stderrLines = details.output.stderr.slice(-10);
-          for (const line of stderrLines) {
+          lines.push("", theme.fg("warning", "stderr:"));
+          for (const line of details.output.stderr.slice(-10)) {
             if (!hadAnsi && hasAnsi(line)) hadAnsi = true;
             lines.push(theme.fg("warning", stripAnsi(line)));
           }
@@ -183,28 +197,25 @@ Note: User always sees process updates in the UI. The notify flags control wheth
         }
 
         if (hadAnsi) {
-          lines.push("");
           lines.push(
+            "",
             theme.fg("muted", "ANSI escape codes were stripped from output"),
           );
         }
 
-        return new Text(lines.join("\n"), 0, 0);
-      }
-
-      // For list action
-      if (
+        fields.push(new Text(lines.join("\n"), 0, 0));
+      } else if (
         details.action === "list" &&
         details.processes &&
         details.processes.length > 0
       ) {
-        const lines: string[] = [];
-        lines.push(
+        const lines: string[] = [
           theme.fg("success", `${details.processes.length} process(es):`),
-        );
-        for (const p of details.processes) {
+        ];
+
+        for (const process of details.processes) {
           let status: string;
-          switch (p.status) {
+          switch (process.status) {
             case "running":
               status = theme.fg("accent", "running");
               break;
@@ -218,43 +229,52 @@ Note: User always sees process updates in the UI. The notify flags control wheth
               status = theme.fg("warning", "killed");
               break;
             case "exited":
-              status = p.success
+              status = process.success
                 ? theme.fg("success", "exit(0)")
-                : theme.fg("error", `exit(${p.exitCode ?? "?"})`);
+                : theme.fg("error", `exit(${process.exitCode ?? "?"})`);
               break;
             default:
-              status = theme.fg("muted", p.status);
+              status = theme.fg("muted", process.status);
           }
+
           lines.push(
-            `  ${p.id} ${theme.fg("accent", `"${p.name}"`)}: ${truncateCmd(p.command)} [${status}] ${formatRuntime(p.startTime, p.endTime)}`,
+            `  ${process.id} ${theme.fg("accent", `"${process.name}"`)}: ${truncateCmd(process.command)} [${status}] ${formatRuntime(process.startTime, process.endTime)}`,
           );
         }
-        return new Text(lines.join("\n"), 0, 0);
-      }
 
-      // For logs action
-      if (details.action === "logs" && details.logFiles) {
-        const lines: string[] = [];
-        lines.push(theme.fg("success", "Log files:"));
-        lines.push(
-          `  stdout: ${theme.fg("accent", details.logFiles.stdoutFile)}`,
+        fields.push(new Text(lines.join("\n"), 0, 0));
+      } else if (details.action === "logs" && details.logFiles) {
+        fields.push(
+          new Text(
+            [
+              theme.fg("success", "Log files:"),
+              `  stdout: ${theme.fg("accent", details.logFiles.stdoutFile)}`,
+              `  stderr: ${theme.fg("accent", details.logFiles.stderrFile)}`,
+            ].join("\n"),
+            0,
+            0,
+          ),
         );
-        lines.push(
-          `  stderr: ${theme.fg("accent", details.logFiles.stderrFile)}`,
-        );
-        return new Text(lines.join("\n"), 0, 0);
+      } else {
+        fields.push({
+          label: "Result",
+          value: details.message,
+          showCollapsed: true,
+        });
       }
 
-      // For clear action
-      if (details.action === "clear") {
-        return new Text(
-          theme.fg("success", "\u2713 ") + theme.fg("muted", details.message),
-          0,
-          0,
-        );
-      }
+      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",
+          },
+        ],
+      });
 
-      return new Text(details.message, 0, 0);
+      return new ToolBody({ fields, footer }, options, theme);
     },
   });
 }

package/utils/ansi.ts

@@ -0,0 +1,36 @@
+/**
+ * Strip ANSI escape codes from a string.
+ *
+ * Removes:
+ * - All CSI sequences (\x1b[...X) - SGR, cursor movement, erase, scroll, etc.
+ * - OSC 8 hyperlinks (\x1b]8;;URL\x07)
+ * - APC sequences (\x1b_...\x07 or \x1b_...\x1b\\)
+ */
+/**
+ * Check if a string contains ANSI escape codes.
+ */
+export function hasAnsi(str: string): boolean {
+  return str.includes(String.fromCodePoint(0x001b));
+}
+
+export function stripAnsi(str: string): string {
+  // ESC = \u001b, BEL = \u0007
+  const ESC = String.fromCodePoint(0x001b);
+  const BEL = String.fromCodePoint(0x0007);
+
+  if (!str.includes(ESC)) {
+    return str;
+  }
+
+  // Strip all CSI sequences (ESC[...X where X is any letter)
+  let clean = str.replace(new RegExp(`${ESC}\\[[0-9;]*[A-Za-z]`, "gu"), "");
+  // Strip OSC 8 hyperlinks: ESC]8;;URL<BEL> and ESC]8;;<BEL>
+  clean = clean.replace(new RegExp(`${ESC}\\]8;;[^${BEL}]*${BEL}`, "gu"), "");
+  // Strip APC sequences: ESC_...<BEL> or ESC_...<ESC>\\ (used for cursor marker)
+  clean = clean.replace(
+    new RegExp(`${ESC}_[^${BEL}${ESC}]*(?:${BEL}|${ESC}\\\\)`, "gu"),
+    "",
+  );
+
+  return clean;
+}

package/utils/format.ts

@@ -0,0 +1,42 @@
+import type { ProcessInfo } from "../constants";
+
+export function formatRuntime(
+  startTime: number,
+  endTime: number | null,
+): string {
+  const end = endTime ?? Date.now();
+  const ms = end - startTime;
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+export function formatStatus(proc: ProcessInfo): string {
+  switch (proc.status) {
+    case "running":
+      return "running";
+    case "terminating":
+      return "terminating";
+    case "terminate_timeout":
+      return "terminate_timeout";
+    case "killed":
+      return "killed";
+    case "exited":
+      return proc.success ? "exit(0)" : `exit(${proc.exitCode ?? "?"})`;
+    default:
+      return proc.status;
+  }
+}
+
+export function truncateCmd(cmd: string, max = 40): string {
+  if (cmd.length <= max) return cmd;
+  return `${cmd.slice(0, max - 3)}...`;
+}