@aliou/pi-processes 0.6.4 → 0.7.1

package/src/tools/actions/output.ts

@@ -1,7 +1,14 @@
+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 { configLoader } from "../../config";
-import type { ExecuteResult } from "../../constants";
+import type { ExecuteResult, ProcessesDetails } from "../../constants";
 import type { ProcessManager } from "../../manager";
-import { formatStatus, stripAnsi } from "../../utils";
+import { formatStatus, hasAnsi, stripAnsi } from "../../utils";
 
 const MAX_BYTES = 50 * 1024; // 50KB
 
@@ -9,6 +16,118 @@ interface OutputParams {
   id?: string;
 }
 
+export function renderOutputCall(
+  args: OutputParams,
+  theme: Theme,
+): ToolCallHeader {
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "output",
+      mainArg: args.id,
+    },
+    theme,
+  );
+}
+
+export function renderOutputResult(
+  result: AgentToolResult<ProcessesDetails>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): ToolBody {
+  const { details } = result;
+
+  if (!details.output) {
+    return new ToolBody(
+      {
+        fields: [
+          {
+            label: "Error",
+            value: "Missing output details",
+            showCollapsed: true,
+          },
+        ],
+      },
+      options,
+      theme,
+    );
+  }
+
+  const lines: string[] = [theme.fg("muted", details.message)];
+  let hadAnsi = false;
+
+  if (details.output.stdout.length > 0) {
+    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));
+    }
+    if (details.output.stdout.length > 20) {
+      lines.push(
+        theme.fg(
+          "muted",
+          `... (${details.output.stdout.length - 20} more lines)`,
+        ),
+      );
+    }
+  }
+
+  if (details.output.stderr.length > 0) {
+    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)));
+    }
+    if (details.output.stderr.length > 10) {
+      lines.push(
+        theme.fg(
+          "muted",
+          `... (${details.output.stderr.length - 10} more lines)`,
+        ),
+      );
+    }
+  }
+
+  if (details.logFiles) {
+    lines.push(
+      "",
+      theme.fg("success", "Log files:"),
+      `  stdout: ${theme.fg("accent", details.logFiles.stdoutFile)}`,
+      `  stderr: ${theme.fg("accent", details.logFiles.stderrFile)}`,
+    );
+  }
+
+  if (hadAnsi) {
+    lines.push(
+      "",
+      theme.fg("muted", "ANSI escape codes were stripped from output"),
+    );
+  }
+
+  const fields: Array<
+    { label: string; value: string; showCollapsed?: boolean } | Text
+  > = [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,
+  });
+
+  return new ToolBody({ fields }, options, theme);
+}
+
 export function executeOutput(
   params: OutputParams,
   manager: ProcessManager,
@@ -24,7 +143,7 @@ export function executeOutput(
     };
   }
 
-  const proc = manager.find(params.id);
+  const proc = manager.get(params.id);
   if (!proc) {
     const message = `Process not found: ${params.id}`;
     return {
@@ -40,7 +159,7 @@ export function executeOutput(
   const { defaultTailLines } = configLoader.getConfig().output;
   const output = manager.getOutput(proc.id, defaultTailLines);
   if (!output) {
-    const message = `Could not read output for: ${proc.id}`;
+    const message = `Could not read output for "${proc.name}" (${proc.id})`;
     return {
       content: [{ type: "text", text: message }],
       details: {
@@ -79,6 +198,12 @@ export function executeOutput(
       success: true,
       message,
       output,
+      logFiles: logFiles
+        ? {
+            stdoutFile: logFiles.stdoutFile,
+            stderrFile: logFiles.stderrFile,
+          }
+        : undefined,
     },
   };
 }

package/src/tools/actions/start.ts

@@ -1,13 +1,123 @@
-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 { Text } from "@mariozechner/pi-tui";
+import type { ExecuteResult, ProcessesDetails } from "../../constants";
 import type { ProcessManager } from "../../manager";
 
+type WatchStream = "stdout" | "stderr" | "both";
+
+interface StartLogWatch {
+  pattern: string;
+  stream?: WatchStream;
+  repeat?: boolean;
+}
+
 interface StartParams {
   name?: string;
   command?: string;
   alertOnSuccess?: boolean;
   alertOnFailure?: boolean;
   alertOnKill?: boolean;
+  logWatches?: StartLogWatch[];
+}
+
+export function renderStartCall(
+  args: StartParams,
+  theme: Theme,
+): ToolCallHeader {
+  const longArgs: Array<{ label?: string; value: string }> = [];
+  const optionArgs: Array<{ label: string; value: string }> = [];
+  let mainArg: string | undefined;
+
+  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 });
+    }
+  }
+
+  if (args.logWatches && args.logWatches.length > 0) {
+    optionArgs.push({
+      label: "watches",
+      value: String(args.logWatches.length),
+    });
+  }
+
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "start",
+      mainArg,
+      optionArgs,
+      longArgs,
+    },
+    theme,
+  );
+}
+
+export function renderStartResult(
+  result: AgentToolResult<ProcessesDetails>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): ToolBody {
+  const { details } = result;
+  const process = details.process;
+
+  if (!process) {
+    return new ToolBody(
+      {
+        fields: [
+          {
+            label: "Error",
+            value: "Missing process details",
+            showCollapsed: true,
+          },
+        ],
+      },
+      options,
+      theme,
+    );
+  }
+
+  const fields: Array<
+    { label: string; value: string; showCollapsed?: boolean } | Text
+  > = [
+    new Text(
+      [
+        theme.fg("success", "Started process"),
+        `  name: ${theme.fg("accent", process.name)}`,
+        `  command: ${process.command}`,
+        `  id: ${theme.fg("accent", process.id)}`,
+        `  pid: ${String(process.pid)}`,
+        "  Log files:",
+        `    - stdout: ${theme.fg("accent", process.stdoutFile)}`,
+        `    - stderr: ${theme.fg("accent", process.stderrFile)}`,
+      ].join("\n"),
+      0,
+      0,
+    ),
+    {
+      label: "Status",
+      value:
+        theme.fg("success", "Started") +
+        ` ${theme.fg("accent", `"${process.name}"`)} (${process.id}, PID: ${process.pid})`,
+      showCollapsed: true,
+    },
+  ];
+
+  return new ToolBody({ fields }, options, theme);
 }
 
 export function executeStart(
@@ -36,13 +146,47 @@ export function executeStart(
     };
   }
 
-  const proc = manager.start(params.name, params.command, ctx.cwd, {
-    alertOnSuccess: params.alertOnSuccess,
-    alertOnFailure: params.alertOnFailure,
-    alertOnKill: params.alertOnKill,
-  });
+  const watchValidationError = validateLogWatches(params.logWatches);
+  if (watchValidationError) {
+    return {
+      content: [{ type: "text", text: watchValidationError }],
+      details: {
+        action: "start",
+        success: false,
+        message: watchValidationError,
+      },
+    };
+  }
+
+  let proc: ReturnType<ProcessManager["start"]>;
+  try {
+    proc = manager.start(params.name, params.command, ctx.cwd, {
+      alertOnSuccess: params.alertOnSuccess,
+      alertOnFailure: params.alertOnFailure,
+      alertOnKill: params.alertOnKill,
+      logWatches: params.logWatches,
+    });
+  } catch (error) {
+    const message =
+      error instanceof Error
+        ? `Invalid start options: ${error.message}`
+        : "Invalid start options";
+    return {
+      content: [{ type: "text", text: message }],
+      details: {
+        action: "start",
+        success: false,
+        message,
+      },
+    };
+  }
 
-  const message = `Started "${proc.name}" (${proc.id}, PID: ${proc.pid})\nLogs: ${proc.stdoutFile}`;
+  const message = [
+    `Started "${proc.name}" (${proc.id}, PID: ${proc.pid})`,
+    "Log files:",
+    `  stdout: ${proc.stdoutFile}`,
+    `  stderr: ${proc.stderrFile}`,
+  ].join("\n");
   return {
     content: [{ type: "text", text: message }],
     details: {
@@ -53,3 +197,48 @@ export function executeStart(
     },
   };
 }
+
+function validateLogWatches(watches?: StartLogWatch[]): string | null {
+  if (!watches) return null;
+
+  if (!Array.isArray(watches)) {
+    return "Invalid parameter: logWatches must be an array";
+  }
+
+  for (const [index, watch] of watches.entries()) {
+    if (!watch || typeof watch !== "object") {
+      return `Invalid logWatches[${index}]: expected an object`;
+    }
+
+    if (
+      typeof watch.pattern !== "string" ||
+      watch.pattern.trim().length === 0
+    ) {
+      return `Invalid logWatches[${index}].pattern: expected non-empty string`;
+    }
+
+    try {
+      // Validate regex syntax at process start for fast feedback.
+      new RegExp(watch.pattern);
+    } catch (error) {
+      const message =
+        error instanceof Error ? error.message : "invalid regular expression";
+      return `Invalid logWatches[${index}].pattern: ${message}`;
+    }
+
+    if (
+      watch.stream !== undefined &&
+      watch.stream !== "stdout" &&
+      watch.stream !== "stderr" &&
+      watch.stream !== "both"
+    ) {
+      return `Invalid logWatches[${index}].stream: expected stdout, stderr, or both`;
+    }
+
+    if (watch.repeat !== undefined && typeof watch.repeat !== "boolean") {
+      return `Invalid logWatches[${index}].repeat: expected boolean`;
+    }
+  }
+
+  return null;
+}

package/src/tools/actions/write.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";
 
@@ -7,6 +9,30 @@ interface WriteParams {
   end?: boolean;
 }
 
+export function renderWriteCall(
+  args: WriteParams,
+  theme: Theme,
+): ToolCallHeader {
+  const optionArgs: Array<{ label: string; value: string }> = [];
+
+  if (args.input) {
+    optionArgs.push({ label: "input", value: args.input });
+    if (args.end) {
+      optionArgs.push({ label: "end", value: "true" });
+    }
+  }
+
+  return new ToolCallHeader(
+    {
+      toolName: "Process",
+      action: "write",
+      mainArg: args.id,
+      optionArgs,
+    },
+    theme,
+  );
+}
+
 export function executeWrite(
   params: WriteParams,
   manager: ProcessManager,
@@ -35,7 +61,7 @@ export function executeWrite(
     };
   }
 
-  const process = manager.find(id);
+  const process = manager.get(id);
   if (!process) {
     return {
       content: [{ type: "text", text: `Process not found: ${id}` }],
@@ -75,7 +101,7 @@ export function executeWrite(
     content: [
       {
         type: "text",
-        text: `Wrote ${input.length} bytes to ${process.id}${suffix}`,
+        text: `Wrote ${input.length} bytes to "${process.name}" (${process.id})${suffix}`,
       },
     ],
     details: {