@aliou/pi-processes 0.6.4 → 0.7.0

package/src/tools/actions/debug.ts

@@ -0,0 +1,148 @@
+import { ToolCallHeader } from "@aliou/pi-utils-ui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
+import type { ExecuteResult, ProcessInfo } from "../../constants";
+
+interface DebugParams {
+  preview?: "start" | "list" | "output" | "logs" | "error";
+}
+
+export function renderDebugCall(
+  args: DebugParams,
+  theme: Theme,
+): ToolCallHeader {
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "debug_preview",
+      mainArg: args.preview,
+    },
+    theme,
+  );
+}
+
+function mockProcess(overrides?: Partial<ProcessInfo>): ProcessInfo {
+  const now = Date.now();
+  return {
+    id: "proc_42",
+    name: "demo-server",
+    pid: 4242,
+    command: "pnpm dev --port 3000",
+    cwd: "/tmp/demo",
+    startTime: now - 12_000,
+    endTime: null,
+    status: "running",
+    exitCode: null,
+    success: null,
+    stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
+    stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
+    alertOnSuccess: false,
+    alertOnFailure: true,
+    alertOnKill: false,
+    ...overrides,
+  };
+}
+
+/**
+ * Temporary no-side-effect previews for process tool renderers.
+ * Remove before release.
+ */
+export function executeDebugPreview(params: DebugParams): ExecuteResult {
+  const preview = params.preview ?? "start";
+
+  if (preview === "start") {
+    const process = mockProcess();
+    const message = [
+      `Started "${process.name}" (${process.id}, PID: ${process.pid})`,
+      "Log files:",
+      `  stdout: ${process.stdoutFile}`,
+      `  stderr: ${process.stderrFile}`,
+    ].join("\n");
+    return {
+      content: [{ type: "text", text: message }],
+      details: {
+        action: "start",
+        success: true,
+        message,
+        process,
+      },
+    };
+  }
+
+  if (preview === "list") {
+    const processes = [
+      mockProcess(),
+      mockProcess({
+        id: "proc_11",
+        name: "builder",
+        pid: 1011,
+        command: "pnpm build --watch",
+      }),
+      mockProcess({
+        id: "proc_10",
+        name: "tests",
+        pid: 1010,
+        command: "pnpm test",
+        status: "exited",
+        success: false,
+        endTime: Date.now() - 3_000,
+        exitCode: 1,
+      }),
+    ];
+
+    return {
+      content: [{ type: "text", text: "Debug preview: list" }],
+      details: {
+        action: "list",
+        success: true,
+        message: "Debug preview: list",
+        processes,
+      },
+    };
+  }
+
+  if (preview === "output") {
+    return {
+      content: [{ type: "text", text: "Debug preview: output" }],
+      details: {
+        action: "output",
+        success: true,
+        message:
+          '"demo-server" (proc_42) [running]: 4 stdout lines, 2 stderr lines',
+        output: {
+          status: "running",
+          stdout: [
+            "starting...",
+            "loading config",
+            "ready on http://localhost:3000",
+            "watching for changes",
+          ],
+          stderr: [
+            "warn: deprecated option in config",
+            "error: simulated stack trace line",
+          ],
+        },
+        logFiles: {
+          stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
+          stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
+        },
+      },
+    };
+  }
+
+  if (preview === "logs") {
+    return {
+      content: [{ type: "text", text: "Debug preview: logs" }],
+      details: {
+        action: "logs",
+        success: true,
+        message: "Debug preview: logs",
+        logFiles: {
+          stdoutFile: "/tmp/pi-processes-demo/proc_42-stdout.log",
+          stderrFile: "/tmp/pi-processes-demo/proc_42-stderr.log",
+        },
+      },
+    };
+  }
+
+  throw new Error("Invalid logWatches[0].pattern: Unterminated group");
+}

package/src/tools/actions/index.ts

@@ -1,16 +1,30 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { ExecuteResult } from "../../constants";
+import { ToolBody, ToolCallHeader } from "@aliou/pi-utils-ui";
+import type {
+  AgentToolResult,
+  ExtensionContext,
+  Theme,
+  ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import type { Component } from "@mariozechner/pi-tui";
+import type {
+  ExecuteResult,
+  ProcessAction,
+  ProcessesDetails,
+} from "../../constants";
 import type { ProcessManager } from "../../manager";
 import { executeClear } from "./clear";
-import { executeKill } from "./kill";
-import { executeList } from "./list";
-import { executeLogs } from "./logs";
-import { executeOutput } from "./output";
-import { executeStart } from "./start";
-import { executeWrite } from "./write";
+import { executeDebugPreview, renderDebugCall } from "./debug";
+import { executeKill, renderKillCall } from "./kill";
+import { executeList, renderListResult } from "./list";
+import { executeLogs, renderLogsCall, renderLogsResult } from "./logs";
+import { executeOutput, renderOutputCall, renderOutputResult } from "./output";
+import { executeStart, renderStartCall, renderStartResult } from "./start";
+import { executeWrite, renderWriteCall } from "./write";
+
+const DEBUG_PREVIEW_ENABLED = process.env.PI_PROCESSES_DEBUG_PREVIEW === "1";
 
 interface ActionParams {
-  action: string;
+  action: ProcessAction | string;
   command?: string;
   name?: string;
   id?: string;
@@ -19,6 +33,12 @@ interface ActionParams {
   alertOnSuccess?: boolean;
   alertOnFailure?: boolean;
   alertOnKill?: boolean;
+  logWatches?: Array<{
+    pattern: string;
+    stream?: "stdout" | "stderr" | "both";
+    repeat?: boolean;
+  }>;
+  preview?: "start" | "list" | "output" | "logs" | "error";
 }
 
 export async function executeAction(
@@ -41,14 +61,89 @@ export async function executeAction(
       return executeClear(manager);
     case "write":
       return executeWrite(params, manager);
+    case "debug_preview":
+      if (!DEBUG_PREVIEW_ENABLED) {
+        throw new Error(
+          "Action 'debug_preview' is disabled. Set PI_PROCESSES_DEBUG_PREVIEW=1 to enable.",
+        );
+      }
+      return executeDebugPreview(params);
     default:
       return {
         content: [{ type: "text", text: `Unknown action: ${params.action}` }],
         details: {
-          action: params.action,
+          action: params.action as ProcessAction,
           success: false,
           message: `Unknown action: ${params.action}`,
         },
       };
   }
 }
+
+export function renderActionCall(
+  args: ActionParams,
+  theme: Theme,
+): Component | undefined {
+  switch (args.action) {
+    case "start":
+      return renderStartCall(args, theme);
+    case "output":
+      return renderOutputCall(args, theme);
+    case "logs":
+      return renderLogsCall(args, theme);
+    case "kill":
+      return renderKillCall(args, theme);
+    case "write":
+      return renderWriteCall(args, theme);
+    case "debug_preview":
+      return renderDebugCall(args, theme);
+    default:
+      return new ToolCallHeader(
+        { toolName: "Process", action: args.action },
+        theme,
+      );
+  }
+}
+
+export function renderActionResult(
+  result: AgentToolResult<ProcessesDetails>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): Component | undefined {
+  const { details } = result;
+
+  if (!details) {
+    return undefined;
+  }
+
+  switch (details.action) {
+    case "start":
+      return renderStartResult(result, options, theme);
+    case "list":
+      return renderListResult(result, options, theme);
+    case "output":
+      return renderOutputResult(result, options, theme);
+    case "logs":
+      return renderLogsResult(result, options, theme);
+    case "kill":
+    case "write":
+    case "clear":
+    case "debug_preview":
+      // Default rendering for these actions
+      return new ToolBody(
+        {
+          fields: [
+            {
+              label: "Result",
+              value: details.message,
+              showCollapsed: true,
+            },
+          ],
+        },
+        options,
+        theme,
+      );
+    default:
+      return undefined;
+  }
+}

package/src/tools/actions/kill.ts

@@ -1,3 +1,5 @@
+import { ToolCallHeader } from "@aliou/pi-utils-ui";
+import type { Theme } from "@mariozechner/pi-coding-agent";
 import type { ExecuteResult } from "../../constants";
 import type { ProcessManager } from "../../manager";
 
@@ -5,6 +7,17 @@ interface KillParams {
   id?: string;
 }
 
+export function renderKillCall(args: KillParams, theme: Theme): ToolCallHeader {
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "kill",
+      mainArg: args.id,
+    },
+    theme,
+  );
+}
+
 export async function executeKill(
   params: KillParams,
   manager: ProcessManager,
@@ -20,7 +33,7 @@ export async function executeKill(
     };
   }
 
-  const proc = manager.find(params.id);
+  const proc = manager.get(params.id);
   if (!proc) {
     const message = `Process not found: ${params.id}`;
     return {

package/src/tools/actions/list.ts

@@ -1,6 +1,19 @@
-import type { ExecuteResult } from "../../constants";
+import { ToolBody, ToolFooter } from "@aliou/pi-utils-ui";
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import type { ExecuteResult, ProcessesDetails } from "../../constants";
 import type { ProcessManager } from "../../manager";
-import { formatRuntime, formatStatus, truncateCmd } from "../../utils";
+import {
+  formatRuntime,
+  formatStatus,
+  formatStatusTag,
+  formatTimestamp,
+  truncateCmd,
+} from "../../utils";
 
 export function executeList(manager: ProcessManager): ExecuteResult {
   const processes = manager.list();
@@ -35,3 +48,141 @@ export function executeList(manager: ProcessManager): ExecuteResult {
     },
   };
 }
+
+export function renderListResult(
+  result: AgentToolResult<ProcessesDetails>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): ToolBody {
+  const { details } = result;
+
+  if (!details.processes || details.processes.length === 0) {
+    return new ToolBody(
+      {
+        fields: [
+          {
+            label: "Processes",
+            value: "No background processes running",
+            showCollapsed: true,
+          },
+        ],
+      },
+      options,
+      theme,
+    );
+  }
+
+  const processes = [...details.processes];
+
+  const statusRank = (status: string): number => {
+    switch (status) {
+      case "running":
+        return 0;
+      case "terminating":
+        return 1;
+      case "terminate_timeout":
+        return 2;
+      case "killed":
+        return 3;
+      case "exited":
+        return 4;
+      default:
+        return 5;
+    }
+  };
+
+  processes.sort((a, b) => {
+    const rankDiff = statusRank(a.status) - statusRank(b.status);
+    if (rankDiff !== 0) return rankDiff;
+    return b.startTime - a.startTime;
+  });
+
+  const runningCount = processes.filter(
+    (p) => p.status === "running" || p.status === "terminating",
+  ).length;
+
+  const lines: string[] = [
+    theme.fg(
+      "success",
+      `${processes.length} process(es), ${runningCount} running/terminating`,
+    ),
+  ];
+
+  for (const process of processes) {
+    const status = formatStatusTag(process, theme);
+    lines.push(
+      [
+        `- ${theme.fg("accent", process.name)} ${theme.fg("muted", `(${process.id})`)}`,
+        `  pid: ${process.pid}   status: ${status}`,
+        `  started: ${theme.fg("muted", formatTimestamp(process.startTime))}`,
+        `  ended:   ${theme.fg("muted", formatTimestamp(process.endTime))}`,
+        `  runtime: ${theme.fg("muted", formatRuntime(process.startTime, process.endTime))}`,
+      ].join("\n"),
+    );
+  }
+
+  const fields: Array<
+    { label: string; value: string; showCollapsed?: boolean } | Text
+  > = [new Text(lines.join("\n"), 0, 0)];
+
+  const running = details.processes.filter(
+    (p) => p.status === "running" || p.status === "terminating",
+  );
+  const finishedOk = details.processes.filter(
+    (p) => p.status === "exited" && p.success,
+  ).length;
+  const failed = details.processes.filter(
+    (p) => p.status === "exited" && !p.success,
+  ).length;
+  const killed = details.processes.filter((p) => p.status === "killed").length;
+
+  const runningSummary =
+    running.length > 0
+      ? running
+          .slice(0, 3)
+          .map(
+            (p) =>
+              `${theme.fg("accent", `"${p.name}"`)} [${formatStatusTag(p, theme)}]`,
+          )
+          .join(", ")
+      : theme.fg("muted", "no running process");
+
+  const restParts: string[] = [];
+  if (finishedOk > 0) restParts.push(`${finishedOk} finished`);
+  if (failed > 0) restParts.push(`${failed} failed`);
+  if (killed > 0) restParts.push(`${killed} killed`);
+  const restSummary =
+    restParts.length > 0 ? theme.fg("muted", ` + ${restParts.join(", ")}`) : "";
+
+  fields.push({
+    label: "Processes",
+    value: runningSummary + restSummary,
+    showCollapsed: true,
+  });
+
+  const footerItems: Array<{
+    label: string;
+    value: string;
+  }> = [];
+  if (runningCount > 0) {
+    footerItems.push({ label: "running", value: String(runningCount) });
+  }
+  if (failed > 0) {
+    footerItems.push({ label: "failed", value: String(failed) });
+  }
+  if (killed > 0) {
+    footerItems.push({ label: "killed", value: String(killed) });
+  }
+
+  return new ToolBody(
+    {
+      fields,
+      footer:
+        footerItems.length > 0
+          ? new ToolFooter(theme, { items: footerItems, separator: " | " })
+          : undefined,
+    },
+    options,
+    theme,
+  );
+}

package/src/tools/actions/logs.ts

@@ -1,10 +1,68 @@
-import type { ExecuteResult } from "../../constants";
+import { ToolBody, ToolCallHeader } from "@aliou/pi-utils-ui";
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import type { ExecuteResult, ProcessesDetails } from "../../constants";
 import type { ProcessManager } from "../../manager";
 
 interface LogsParams {
   id?: string;
 }
 
+export function renderLogsCall(args: LogsParams, theme: Theme): ToolCallHeader {
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "logs",
+      mainArg: args.id,
+    },
+    theme,
+  );
+}
+
+export function renderLogsResult(
+  result: AgentToolResult<ProcessesDetails>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): ToolBody {
+  const { details } = result;
+
+  if (!details.logFiles) {
+    return new ToolBody(
+      {
+        fields: [
+          {
+            label: "Error",
+            value: "Missing log file details",
+            showCollapsed: true,
+          },
+        ],
+      },
+      options,
+      theme,
+    );
+  }
+
+  const fields: Array<
+    { label: string; value: string; showCollapsed?: boolean } | Text
+  > = [
+    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,
+    ),
+  ];
+
+  return new ToolBody({ fields }, options, theme);
+}
+
 export function executeLogs(
   params: LogsParams,
   manager: ProcessManager,
@@ -20,7 +78,7 @@ export function executeLogs(
     };
   }
 
-  const proc = manager.find(params.id);
+  const proc = manager.get(params.id);
   if (!proc) {
     const message = `Process not found: ${params.id}`;
     return {
@@ -35,7 +93,7 @@ export function executeLogs(
 
   const logFiles = manager.getLogFiles(proc.id);
   if (!logFiles) {
-    const message = `Could not get log files for: ${proc.id}`;
+    const message = `Could not get log files for "${proc.name}" (${proc.id})`;
     return {
       content: [{ type: "text", text: message }],
       details: {