@aliou/pi-processes 0.4.7 → 0.6.0

package/src/config.ts

@@ -6,6 +6,8 @@
  */
 
 import { ConfigLoader } from "@aliou/pi-utils-settings";
+import type { ProcessesKeybindings } from "./utils/keybindings";
+import { DEFAULT_KEYBINDINGS } from "./utils/keybindings";
 
 export interface ProcessesConfig {
   processList?: {
@@ -27,6 +29,21 @@ export interface ProcessesConfig {
   widget?: {
     /** Show the status widget below the editor. */
     showStatusWidget?: boolean;
+    /** Default dock state when follow mode is enabled. */
+    dockDefaultState?: "hidden" | "collapsed";
+    /** Height of the dock in lines when open. */
+    dockHeight?: number;
+  };
+  follow?: {
+    /** Enable follow mode by default when starting processes. */
+    enabledByDefault?: boolean;
+    /** Auto-hide dock when all processes finish. */
+    autoHideOnFinish?: boolean;
+  };
+  keybindings?: Partial<ProcessesKeybindings>;
+  interception?: {
+    /** Block background bash commands (&, nohup, disown, setsid) and guide the model to use the process tool. */
+    blockBackgroundCommands?: boolean;
   };
 }
 
@@ -44,6 +61,16 @@ export interface ResolvedProcessesConfig {
   };
   widget: {
     showStatusWidget: boolean;
+    dockDefaultState: "hidden" | "collapsed";
+    dockHeight: number;
+  };
+  follow: {
+    enabledByDefault: boolean;
+    autoHideOnFinish: boolean;
+  };
+  keybindings: ProcessesKeybindings;
+  interception: {
+    blockBackgroundCommands: boolean;
   };
 }
 
@@ -58,7 +85,17 @@ const DEFAULT_CONFIG: ResolvedProcessesConfig = {
   },
   execution: {},
   widget: {
-    showStatusWidget: true,
+    showStatusWidget: false,
+    dockDefaultState: "collapsed",
+    dockHeight: 12,
+  },
+  follow: {
+    enabledByDefault: true,
+    autoHideOnFinish: true,
+  },
+  keybindings: DEFAULT_KEYBINDINGS,
+  interception: {
+    blockBackgroundCommands: false,
   },
 };
 

package/src/constants/index.ts

@@ -6,6 +6,7 @@ export type {
   ProcessInfo,
   ProcessStatus,
   StartOptions,
+  WriteResult,
 } from "./types";
 
 export { LIVE_STATUSES, MESSAGE_TYPE_PROCESS_UPDATE } from "./types";

package/src/constants/types.ts

@@ -34,7 +34,6 @@ export interface ProcessInfo {
 
 export type ManagerEvent =
   | { type: "process_started"; info: ProcessInfo }
-  | { type: "process_status_changed"; info: ProcessInfo; prev: ProcessStatus }
   | { type: "process_ended"; info: ProcessInfo }
   | { type: "processes_changed" };
 
@@ -42,6 +41,13 @@ export type KillResult =
   | { ok: true; info: ProcessInfo }
   | { ok: false; info: ProcessInfo; reason: "not_found" | "timeout" | "error" };
 
+export type WriteResult =
+  | { ok: true }
+  | {
+      ok: false;
+      reason: "not_found" | "process_exited" | "stdin_closed" | "write_error";
+    };
+
 export interface StartOptions {
   alertOnSuccess?: boolean;
   alertOnFailure?: boolean;

package/src/hooks/background-blocker.ts

@@ -0,0 +1,66 @@
+/**
+ * Blocks background bash commands (e.g. `cmd &`, `nohup cmd`) and guides
+ * the model to use the process tool instead.
+ *
+ * Opt-in via config: `interception.blockBackgroundCommands`.
+ */
+
+import { parse } from "@aliou/sh";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { walkCommands, wordToString } from "../utils/shell-utils";
+
+const BACKGROUND_CMD_NAMES = new Set(["nohup", "disown", "setsid"]);
+const BACKGROUND_PATTERN = /&\s*$/;
+
+export function setupBackgroundBlocker(pi: ExtensionAPI): void {
+  pi.on("tool_call", async (event, ctx) => {
+    if (event.toolName !== "bash") return;
+
+    const command = String(event.input.command ?? "");
+
+    let hasBackground = false;
+    try {
+      const { ast } = parse(command);
+
+      // Check statement-level background flag (cmd &)
+      for (const stmt of ast.body) {
+        if (stmt.background) {
+          hasBackground = true;
+          break;
+        }
+      }
+
+      // Check for nohup/disown/setsid as command names
+      if (!hasBackground) {
+        walkCommands(ast, (cmd) => {
+          const name = cmd.words?.[0] ? wordToString(cmd.words[0]) : undefined;
+          if (name && BACKGROUND_CMD_NAMES.has(name)) {
+            hasBackground = true;
+            return true;
+          }
+          return false;
+        });
+      }
+    } catch {
+      // Fallback to regex on parse failure
+      hasBackground = BACKGROUND_PATTERN.test(command);
+    }
+
+    if (hasBackground) {
+      ctx.ui?.notify(
+        "Blocked background command. Use the process tool instead.",
+        "warning",
+      );
+
+      return {
+        block: true,
+        reason:
+          "Background commands (&, nohup, disown, setsid) are not supported in bash. " +
+          'Use the "process" tool with action "start" to run commands in the background. ' +
+          'Example: process({ action: "start", name: "my-server", command: "npm run dev" })',
+      };
+    }
+
+    return;
+  });
+}

package/src/hooks/index.ts

@@ -1,16 +1,28 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ResolvedProcessesConfig } from "../config";
 import type { ProcessManager } from "../manager";
+import { setupBackgroundBlocker } from "./background-blocker";
 import { setupCleanupHook } from "./cleanup";
 import { setupMessageRenderer } from "./message-renderer";
 import { setupProcessEndHook } from "./process-end";
-import { setupProcessWidget } from "./widget";
+import { type DockActions, setupProcessWidget } from "./widget";
 
-export function setupProcessesHooks(pi: ExtensionAPI, manager: ProcessManager) {
+export type { DockActions };
+
+export function setupProcessesHooks(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+  config: ResolvedProcessesConfig,
+): { update: () => void; dockActions: DockActions } {
   setupCleanupHook(pi, manager);
   setupProcessEndHook(pi, manager);
 
+  if (config.interception.blockBackgroundCommands) {
+    setupBackgroundBlocker(pi);
+  }
+
   // Set up widget AFTER process-end so it chains onto the existing callback
-  const widget = setupProcessWidget(pi, manager);
+  const widget = setupProcessWidget(pi, manager, config);
 
   setupMessageRenderer(pi);
 

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 { 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 { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+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) =>
@@ -75,17 +66,22 @@ function renderWidget(
   for (const proc of allProcs) {
     const formatted = formatProcessStatus(proc, theme);
     const formattedLen = visibleWidth(formatted);
-
-    // Check if adding this part would exceed the width
+    const remaining = allProcs.length - includedCount - 1;
     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`));
-      }
+    let reservedForSuffix = 0;
+    if (remaining > 0) {
+      const suffixText = `+${remaining} more`;
+      reservedForSuffix = separatorLen + visibleWidth(suffixText);
+    }
+
+    if (
+      currentLen + needed + reservedForSuffix > effectiveMax &&
+      includedCount > 0
+    ) {
+      const hiddenCount = allProcs.length - includedCount;
+      if (hiddenCount > 0) parts.push(theme.fg("dim", `+${hiddenCount} more`));
       break;
     }
 
@@ -94,53 +90,16 @@ function renderWidget(
     includedCount++;
   }
 
-  if (parts.length === 0) {
-    return [];
+  if (includedCount === 0 && allProcs.length > 0) {
+    parts.push(formatProcessStatus(allProcs[0], theme));
   }
 
-  return [prefix + parts.join(separator)];
-}
-
-export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
-  let latestContext: ExtensionContext | null = null;
+  if (parts.length === 0) return [];
 
-  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,
-  };
+  const line = prefix + parts.join(separator);
+  return [
+    visibleWidth(line) > effectiveMax
+      ? truncateToWidth(line, effectiveMax)
+      : line,
+  ];
 }

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";
@@ -20,8 +20,14 @@ export default async function (pi: ExtensionAPI) {
     getConfiguredShellPath: () => configLoader.getConfig().execution.shellPath,
   });
 
-  const { update: updateWidget } = setupProcessesHooks(pi, manager);
-  setupProcessesCommands(pi, manager);
+  const config = configLoader.getConfig();
+
+  const { update: updateWidget, dockActions } = setupProcessesHooks(
+    pi,
+    manager,
+    config,
+  );
+  setupProcessesCommands(pi, manager, dockActions);
   setupProcessesTools(pi, manager);
   registerProcessesSettings(pi, () => {
     updateWidget();