@aliou/pi-processes 0.4.5 → 0.4.6

package/src/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/src/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/src/hooks/cleanup.ts

@@ -0,0 +1,10 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProcessManager } from "../manager";
+
+export function setupCleanupHook(pi: ExtensionAPI, manager: ProcessManager) {
+  pi.on("session_shutdown", () => {
+    manager.stopWatcher();
+    manager.shutdownKillAll();
+    manager.cleanup();
+  });
+}

package/src/hooks/index.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ProcessManager } from "../manager";
+import { setupCleanupHook } from "./cleanup";
+import { setupMessageRenderer } from "./message-renderer";
+import { setupProcessEndHook } from "./process-end";
+import { setupProcessWidget } from "./widget";
+
+export function setupProcessesHooks(pi: ExtensionAPI, manager: ProcessManager) {
+  setupCleanupHook(pi, manager);
+  setupProcessEndHook(pi, manager);
+
+  // Set up widget AFTER process-end so it chains onto the existing callback
+  const widget = setupProcessWidget(pi, manager);
+
+  setupMessageRenderer(pi);
+
+  return widget;
+}

package/src/hooks/message-renderer.ts

@@ -0,0 +1,83 @@
+import type {
+  ExtensionAPI,
+  MessageRenderOptions,
+  Theme,
+} from "@mariozechner/pi-coding-agent";
+import { Text } from "@mariozechner/pi-tui";
+import { MESSAGE_TYPE_PROCESS_UPDATE } from "../constants";
+
+interface ProcessUpdateDetails {
+  processId: string;
+  processName: string;
+  command: string;
+  status: "exited" | "killed";
+  exitCode: number | null;
+  success: boolean;
+  runtime: string;
+}
+
+interface ProcessUpdateMessage {
+  customType: string;
+  content: string | Array<{ type: string; text?: string }>;
+  details?: ProcessUpdateDetails;
+}
+
+function getContentText(
+  content: string | Array<{ type: string; text?: string }>,
+): string {
+  if (typeof content === "string") {
+    return content;
+  }
+  return content
+    .filter((c) => c.type === "text" && c.text)
+    .map((c) => c.text as string)
+    .join("");
+}
+
+export function setupMessageRenderer(pi: ExtensionAPI) {
+  pi.registerMessageRenderer<ProcessUpdateDetails>(
+    MESSAGE_TYPE_PROCESS_UPDATE,
+    (
+      message: ProcessUpdateMessage,
+      _options: MessageRenderOptions,
+      theme: Theme,
+    ) => {
+      const details = message.details;
+
+      if (!details) {
+        return new Text(getContentText(message.content), 0, 0);
+      }
+
+      let icon: string;
+      let color: "success" | "error" | "warning";
+
+      if (details.status === "killed") {
+        icon = "\u2717"; // x mark
+        color = "warning";
+      } else if (details.success) {
+        icon = "\u2713"; // check mark
+        color = "success";
+      } else {
+        icon = "\u2717"; // x mark
+        color = "error";
+      }
+
+      const statusText =
+        details.status === "killed"
+          ? "terminated"
+          : details.success
+            ? "completed"
+            : `exited(${details.exitCode ?? "?"})`;
+
+      const text =
+        theme.fg(color, `${icon} `) +
+        theme.fg("accent", `"${details.processName}"`) +
+        theme.fg("muted", ` (${details.processId})`) +
+        " " +
+        theme.fg(color, statusText) +
+        theme.fg("muted", ` ${details.runtime}`);
+
+      return new Text(text, 0, 0);
+    },
+  );
+}

package/src/hooks/process-end.ts

@@ -0,0 +1,92 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { MESSAGE_TYPE_PROCESS_UPDATE, type ProcessInfo } from "../constants";
+import type { ProcessManager } from "../manager";
+import { formatRuntime } from "../utils";
+
+interface ProcessUpdateDetails {
+  processId: string;
+  processName: string;
+  command: string;
+  status: "exited" | "killed";
+  exitCode: number | null;
+  success: boolean;
+  runtime: string;
+}
+
+export function setupProcessEndHook(pi: ExtensionAPI, manager: ProcessManager) {
+  let latestContext: ExtensionContext | null = null;
+
+  // Capture context from session events
+  pi.on("session_start", async (_event, ctx) => {
+    latestContext = ctx;
+  });
+
+  pi.on("turn_start", async (_event, ctx) => {
+    latestContext = ctx;
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    latestContext = ctx;
+  });
+
+  manager.onEvent((event) => {
+    if (event.type !== "process_ended") return;
+
+    const info: ProcessInfo = event.info;
+
+    // Determine if the agent should get a turn to react to this process ending.
+    // When true, the agent receives the message in its context and can respond
+    // (e.g. check results, fix code, restart the process).
+    const triggerAgentTurn =
+      (info.status === "killed" && info.alertOnKill) ||
+      (info.status === "exited" && info.success && info.alertOnSuccess) ||
+      (info.status === "exited" && !info.success && info.alertOnFailure);
+
+    const runtime = formatRuntime(info.startTime, info.endTime);
+
+    // Build notification message
+    let message: string;
+    let level: "info" | "error" | "warning";
+
+    if (info.status === "killed") {
+      message = `Process '${info.name}' was terminated (${runtime})`;
+      level = "warning";
+    } else if (info.success) {
+      message = `Process '${info.name}' completed successfully (${runtime})`;
+      level = "info";
+    } else {
+      message = `Process '${info.name}' crashed with exit code ${info.exitCode ?? "?"} (${runtime})`;
+      level = "error";
+    }
+
+    // Always notify user via UI
+    if (latestContext?.hasUI) {
+      latestContext.ui.notify(message, level);
+    }
+
+    // Always send the message so it appears in the conversation history.
+    // Only trigger an agent turn when the notification preferences say so.
+    const details: ProcessUpdateDetails = {
+      processId: info.id,
+      processName: info.name,
+      command: info.command,
+      status: info.status as "exited" | "killed",
+      exitCode: info.exitCode,
+      success: info.success ?? false,
+      runtime,
+    };
+
+    pi.sendMessage(
+      {
+        customType: MESSAGE_TYPE_PROCESS_UPDATE,
+        content: message,
+        display: true,
+        details,
+      },
+      { triggerTurn: triggerAgentTurn },
+    );
+  });
+}

package/src/hooks/widget.ts

@@ -0,0 +1,146 @@
+import type {
+  ExtensionAPI,
+  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";
+
+const WIDGET_ID = "processes-status";
+
+function formatProcessStatus(
+  proc: ProcessInfo,
+  theme: ExtensionContext["ui"]["theme"],
+): string {
+  const name =
+    proc.name.length > 20 ? `${proc.name.slice(0, 17)}...` : proc.name;
+
+  switch (proc.status) {
+    case "running":
+      return `${theme.fg("accent", name)} ${theme.fg("dim", "running")}`;
+    case "terminating":
+      return `${theme.fg("warning", name)} ${theme.fg("dim", "terminating")}`;
+    case "terminate_timeout":
+      return `${theme.fg("error", name)} ${theme.fg("error", "terminate_timeout")}`;
+    case "killed":
+      return `${theme.fg("warning", name)} ${theme.fg("dim", "killed")}`;
+    case "exited":
+      if (proc.success) {
+        return `${theme.fg("dim", name)} ${theme.fg("success", "done")}`;
+      }
+      return `${theme.fg("error", name)} ${theme.fg("error", `exit(${proc.exitCode ?? "?"})`)}`;
+    default:
+      return `${theme.fg("dim", name)} ${theme.fg("dim", proc.status)}`;
+  }
+}
+
+function renderWidget(
+  processes: ProcessInfo[],
+  theme: ExtensionContext["ui"]["theme"],
+  maxWidth?: number,
+): string[] {
+  if (processes.length === 0) {
+    return [];
+  }
+
+  const aliveish = processes.filter(
+    (p) =>
+      p.status === "running" ||
+      p.status === "terminating" ||
+      p.status === "terminate_timeout",
+  );
+  const finished = processes.filter(
+    (p) =>
+      p.status !== "running" &&
+      p.status !== "terminating" &&
+      p.status !== "terminate_timeout",
+  );
+
+  const allProcs: ProcessInfo[] = [
+    ...aliveish,
+    ...finished.sort((a, b) => (b.endTime ?? 0) - (a.endTime ?? 0)),
+  ];
+
+  const prefix = theme.fg("dim", "processes: ");
+  const prefixLen = visibleWidth(prefix);
+  const separator = theme.fg("dim", " | ");
+  const separatorLen = visibleWidth(separator);
+  const effectiveMax = maxWidth ?? 200;
+
+  const parts: string[] = [];
+  let currentLen = prefixLen;
+  let includedCount = 0;
+
+  for (const proc of allProcs) {
+    const formatted = formatProcessStatus(proc, theme);
+    const formattedLen = visibleWidth(formatted);
+
+    // Check if adding this part would exceed the width
+    const needed =
+      includedCount > 0 ? separatorLen + formattedLen : formattedLen;
+
+    if (currentLen + needed > effectiveMax && includedCount > 0) {
+      // Show how many are hidden
+      const remaining = allProcs.length - includedCount;
+      if (remaining > 0) {
+        parts.push(theme.fg("dim", `+${remaining} more`));
+      }
+      break;
+    }
+
+    parts.push(formatted);
+    currentLen += needed;
+    includedCount++;
+  }
+
+  if (parts.length === 0) {
+    return [];
+  }
+
+  return [prefix + parts.join(separator)];
+}
+
+export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
+  let latestContext: ExtensionContext | null = null;
+
+  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);
+
+    if (lines.length === 0) {
+      latestContext.ui.setWidget(WIDGET_ID, undefined);
+    } else {
+      latestContext.ui.setWidget(WIDGET_ID, lines, {
+        placement: "belowEditor",
+      });
+    }
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    // Startup defer: capture context only. First render happens on process
+    // manager events or explicit settings updates.
+    latestContext = ctx;
+  });
+
+  pi.on("session_switch", async (_event, ctx) => {
+    latestContext = ctx;
+    updateWidget();
+  });
+
+  manager.onEvent(() => {
+    updateWidget();
+  });
+
+  return {
+    update: updateWidget,
+  };
+}

package/src/index.ts

@@ -1,27 +1,29 @@
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-
-const MARKER_DIR = join(homedir(), ".pi", "agent", "extensions", "migrations");
-const MARKER_FILE = join(MARKER_DIR, "processes-moved");
+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 async function (pi: ExtensionAPI) {
-  if (existsSync(MARKER_FILE)) return;
-
-  pi.on("session_start", async (_event, ctx) => {
-    if (existsSync(MARKER_FILE)) return;
+  if (process.platform === "win32") {
+    pi.on("session_start", async (_event, ctx) => {
+      if (!ctx.hasUI) return;
+      ctx.ui.notify("processes extension not available on Windows", "warning");
+    });
+    return;
+  }
 
-    if (ctx.hasUI) {
-      ctx.ui.notify(
-        "@aliou/pi-processes has moved to its own repo. " +
-          "Run: pi install npm:@aliou/pi-processes -- " +
-          "then remove it from the pi-extensions package config.",
-        "warning",
-      );
-    }
+  await configLoader.load();
+  const manager = new ProcessManager({
+    getConfiguredShellPath: () => configLoader.getConfig().execution.shellPath,
+  });
 
-    mkdirSync(MARKER_DIR, { recursive: true });
-    writeFileSync(MARKER_FILE, new Date().toISOString());
+  const { update: updateWidget } = setupProcessesHooks(pi, manager);
+  setupProcessesCommands(pi, manager);
+  setupProcessesTools(pi, manager);
+  registerProcessesSettings(pi, () => {
+    updateWidget();
   });
 }