@aliou/pi-processes 0.5.0 → 0.6.0

package/src/hooks/process-end.ts

@@ -1,7 +1,4 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { MESSAGE_TYPE_PROCESS_UPDATE, type ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
 import { formatRuntime } from "../utils";
@@ -17,21 +14,6 @@ interface ProcessUpdateDetails {
 }
 
 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;
 
@@ -47,27 +29,18 @@ export function setupProcessEndHook(pi: ExtensionAPI, manager: ProcessManager) {
 
     const runtime = formatRuntime(info.startTime, info.endTime);
 
-    // Build notification message
+    // Build 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.
+    // Send the message to the conversation - displayed via custom renderer in UI
     // Only trigger an agent turn when the notification preferences say so.
     const details: ProcessUpdateDetails = {
       processId: info.id,

package/src/hooks/widget/index.ts

@@ -0,0 +1,2 @@
+export { setupProcessWidget } from "./setup";
+export type { DockActions } from "./types";

package/src/hooks/widget/setup.ts

@@ -0,0 +1,168 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@mariozechner/pi-coding-agent";
+import { LogDockComponent } from "../../components/log-dock-component";
+import { configLoader, type ResolvedProcessesConfig } from "../../config";
+import { LIVE_STATUSES } from "../../constants";
+import type { ProcessManager } from "../../manager";
+import { renderStatusWidget } from "./status-widget";
+import {
+  type DockActions,
+  type DockState,
+  LOG_DOCK_WIDGET_ID,
+  STATUS_WIDGET_ID,
+} from "./types";
+
+export function setupProcessWidget(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+  config: ResolvedProcessesConfig,
+) {
+  let latestContext: ExtensionContext | null = null;
+  let logDockComponent: LogDockComponent | null = null;
+  let logDockComponentTui: { requestRender(): void } | null = null;
+
+  const dockState: DockState = {
+    visibility: "hidden",
+    followEnabled: config.follow.enabledByDefault,
+    focusedProcessId: null,
+  };
+
+  function updateWidget() {
+    if (!latestContext?.hasUI) return;
+
+    if (!configLoader.getConfig().widget.showStatusWidget) {
+      latestContext.ui.setWidget(STATUS_WIDGET_ID, undefined);
+    } else {
+      const processes = manager.list();
+      const maxWidth = process.stdout.columns || 120;
+      const lines = renderStatusWidget(
+        processes,
+        latestContext.ui.theme,
+        maxWidth,
+      );
+
+      if (lines.length === 0) {
+        latestContext.ui.setWidget(STATUS_WIDGET_ID, undefined);
+      } else {
+        latestContext.ui.setWidget(STATUS_WIDGET_ID, lines, {
+          placement: "belowEditor",
+        });
+      }
+    }
+
+    if (dockState.visibility === "hidden") {
+      latestContext.ui.setWidget(LOG_DOCK_WIDGET_ID, undefined);
+      if (logDockComponent) {
+        logDockComponent.dispose();
+        logDockComponent = null;
+        logDockComponentTui = null;
+      }
+      return;
+    }
+
+    const mode = dockState.visibility as "collapsed" | "open";
+    const height = mode === "collapsed" ? 3 : config.widget.dockHeight;
+
+    if (logDockComponent && logDockComponentTui) {
+      logDockComponent.update({
+        mode,
+        focusedProcessId: dockState.focusedProcessId,
+        dockHeight: height,
+      });
+    } else {
+      const ctx = latestContext;
+      ctx.ui.setWidget(
+        LOG_DOCK_WIDGET_ID,
+        (tui: { requestRender(): void }, theme: typeof ctx.ui.theme) => {
+          logDockComponent = new LogDockComponent({
+            manager,
+            tui,
+            theme,
+            mode,
+            focusedProcessId: dockState.focusedProcessId,
+            dockHeight: height,
+          });
+          logDockComponentTui = tui;
+          return logDockComponent;
+        },
+        { placement: "aboveEditor" },
+      );
+    }
+  }
+
+  const dockActions: DockActions = {
+    getFocusedProcessId: () => dockState.focusedProcessId,
+    isFollowEnabled: () => dockState.followEnabled,
+    setFocus(id) {
+      dockState.focusedProcessId = id;
+      if (id && dockState.visibility === "hidden")
+        dockState.visibility = "open";
+      updateWidget();
+    },
+    expand() {
+      dockState.visibility = "open";
+      updateWidget();
+    },
+    collapse() {
+      dockState.visibility = "collapsed";
+      updateWidget();
+    },
+    hide() {
+      dockState.visibility = "hidden";
+      updateWidget();
+    },
+    toggle() {
+      if (dockState.visibility === "hidden") dockState.visibility = "collapsed";
+      else if (dockState.visibility === "collapsed")
+        dockState.visibility = "open";
+      else dockState.visibility = "collapsed";
+      updateWidget();
+    },
+    toggleFollow() {
+      dockState.followEnabled = !dockState.followEnabled;
+      updateWidget();
+    },
+  };
+
+  manager.onEvent((event) => {
+    if (event.type === "process_started") {
+      if (dockState.followEnabled && dockState.visibility === "hidden") {
+        dockState.visibility = "collapsed";
+      }
+    }
+
+    if (event.type === "process_ended") {
+      if (dockState.focusedProcessId === event.info.id) {
+        dockState.focusedProcessId = null;
+      }
+      const running = manager.list().filter((p) => LIVE_STATUSES.has(p.status));
+      if (
+        running.length === 0 &&
+        config.follow.autoHideOnFinish &&
+        dockState.followEnabled
+      ) {
+        dockState.visibility = "hidden";
+      }
+    }
+
+    updateWidget();
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    latestContext = ctx;
+  });
+
+  pi.on("session_switch", async (_event, ctx) => {
+    if (logDockComponent) {
+      logDockComponent.dispose();
+      logDockComponent = null;
+      logDockComponentTui = null;
+    }
+    latestContext = ctx;
+    updateWidget();
+  });
+
+  return { update: updateWidget, dockActions };
+}

package/src/hooks/{widget.ts → widget/status-widget.ts}

@@ -1,13 +1,6 @@
-import type {
-  ExtensionAPI,
-  ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
-import { configLoader } from "../config";
-import type { ProcessInfo } from "../constants";
-import type { ProcessManager } from "../manager";
-
-const WIDGET_ID = "processes-status";
+import type { ProcessInfo } from "../../constants";
 
 function formatProcessStatus(
   proc: ProcessInfo,
@@ -35,14 +28,12 @@ function formatProcessStatus(
   }
 }
 
-function renderWidget(
+export function renderStatusWidget(
   processes: ProcessInfo[],
   theme: ExtensionContext["ui"]["theme"],
   maxWidth?: number,
 ): string[] {
-  if (processes.length === 0) {
-    return [];
-  }
+  if (processes.length === 0) return [];
 
   const aliveish = processes.filter(
     (p) =>
@@ -76,13 +67,9 @@ function renderWidget(
     const formatted = formatProcessStatus(proc, theme);
     const formattedLen = visibleWidth(formatted);
     const remaining = allProcs.length - includedCount - 1;
-
-    // Check if adding this part would exceed the width
     const needed =
       includedCount > 0 ? separatorLen + formattedLen : formattedLen;
 
-    // If there are more processes after this one, reserve space for the
-    // overflow suffix (separator + "+N more") so the final line fits.
     let reservedForSuffix = 0;
     if (remaining > 0) {
       const suffixText = `+${remaining} more`;
@@ -93,11 +80,8 @@ function renderWidget(
       currentLen + needed + reservedForSuffix > effectiveMax &&
       includedCount > 0
     ) {
-      // Show how many are hidden
       const hiddenCount = allProcs.length - includedCount;
-      if (hiddenCount > 0) {
-        parts.push(theme.fg("dim", `+${hiddenCount} more`));
-      }
+      if (hiddenCount > 0) parts.push(theme.fg("dim", `+${hiddenCount} more`));
       break;
     }
 
@@ -106,18 +90,11 @@ function renderWidget(
     includedCount++;
   }
 
-  // Edge case: the very first element was too wide and the loop's overflow
-  // check was skipped (it only fires when includedCount > 0). The suffix
-  // reservation already shrinks the budget, but a single process that fills
-  // the whole line still slips through. Show it truncated rather than nothing.
   if (includedCount === 0 && allProcs.length > 0) {
-    const formatted = formatProcessStatus(allProcs[0], theme);
-    parts.push(formatted);
+    parts.push(formatProcessStatus(allProcs[0], theme));
   }
 
-  if (parts.length === 0) {
-    return [];
-  }
+  if (parts.length === 0) return [];
 
   const line = prefix + parts.join(separator);
   return [
@@ -126,47 +103,3 @@ function renderWidget(
       : line,
   ];
 }
-
-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/hooks/widget/types.ts

@@ -0,0 +1,21 @@
+export type DockVisibility = "hidden" | "collapsed" | "open";
+
+export interface DockState {
+  visibility: DockVisibility;
+  followEnabled: boolean;
+  focusedProcessId: string | null;
+}
+
+export interface DockActions {
+  getFocusedProcessId(): string | null;
+  isFollowEnabled(): boolean;
+  setFocus(id: string | null): void;
+  expand(): void;
+  collapse(): void;
+  hide(): void;
+  toggle(): void;
+  toggleFollow(): void;
+}
+
+export const STATUS_WIDGET_ID = "processes-status";
+export const LOG_DOCK_WIDGET_ID = "processes-dock";

package/src/index.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { setupProcessesCommands } from "./commands";
-import { registerProcessesSettings } from "./commands/settings-command";
+import { registerProcessesSettings } from "./commands/settings";
 import { configLoader } from "./config";
 import { setupProcessesHooks } from "./hooks";
 import { ProcessManager } from "./manager";
@@ -21,8 +21,13 @@ export default async function (pi: ExtensionAPI) {
   });
 
   const config = configLoader.getConfig();
-  const { update: updateWidget } = setupProcessesHooks(pi, manager, config);
-  setupProcessesCommands(pi, manager);
+
+  const { update: updateWidget, dockActions } = setupProcessesHooks(
+    pi,
+    manager,
+    config,
+  );
+  setupProcessesCommands(pi, manager, dockActions);
   setupProcessesTools(pi, manager);
   registerProcessesSettings(pi, () => {
     updateWidget();

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}`,
+    },
+  };
+}