@aliou/pi-processes 0.4.7 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "license": "MIT",
   "type": "module",
   "private": false,
@@ -30,18 +30,20 @@
   "dependencies": {
     "@aliou/pi-utils-settings": "^0.4.0",
     "@aliou/pi-utils-ui": "^0.1.0",
+    "@aliou/sh": "^0.1.0",
     "@sinclair/typebox": "^0.34.41"
   },
   "peerDependencies": {
-    "@mariozechner/pi-coding-agent": ">=0.51.0"
+    "@mariozechner/pi-coding-agent": ">=0.51.0",
+    "@mariozechner/pi-tui": ">=0.51.0"
   },
   "devDependencies": {
+    "@aliou/biome-plugins": "^0.3.2",
     "@aliou/pi-evals": "^0.3.0",
     "@biomejs/biome": "^2.3.13",
     "@changesets/cli": "^2.27.11",
     "@mariozechner/pi-ai": "0.52.7",
     "@mariozechner/pi-coding-agent": "0.52.7",
-    "@mariozechner/pi-tui": "0.52.7",
     "@types/node": "^25.0.10",
     "husky": "^9.1.7",
     "typescript": "^5.9.3",
@@ -50,12 +52,16 @@
   "peerDependenciesMeta": {
     "@mariozechner/pi-coding-agent": {
       "optional": true
+    },
+    "@mariozechner/pi-tui": {
+      "optional": true
     }
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
     "lint": "biome check",
     "format": "biome check --write",
+    "check:lockfile": "pnpm install --frozen-lockfile --ignore-scripts",
     "changeset": "changeset",
     "version": "changeset version",
     "release": "pnpm changeset publish"

package/src/commands/settings-command.ts

@@ -93,6 +93,23 @@ export function registerProcessesSettings(
             },
           ],
         },
+        {
+          label: "Interception",
+          items: [
+            {
+              id: "interception.blockBackgroundCommands",
+              label: "Block background commands",
+              description:
+                "Block bash background commands (&, nohup, disown, setsid) and guide the model to use the process tool",
+              currentValue:
+                (tabConfig?.interception?.blockBackgroundCommands ??
+                resolved.interception.blockBackgroundCommands)
+                  ? "on"
+                  : "off",
+              values: ["on", "off"],
+            },
+          ],
+        },
         {
           label: "Widget",
           items: [
@@ -114,6 +131,11 @@ export function registerProcessesSettings(
     onSettingChange: (id, newValue, config) => {
       const updated = structuredClone(config);
       // Boolean fields.
+      if (id === "interception.blockBackgroundCommands") {
+        if (!updated.interception) updated.interception = {};
+        updated.interception.blockBackgroundCommands = newValue === "on";
+        return updated;
+      }
       if (id === "widget.showStatusWidget") {
         if (!updated.widget) updated.widget = {};
         updated.widget.showStatusWidget = newValue === "on";

package/src/components/process-picker-component.ts

@@ -4,7 +4,12 @@ import {
   renderPanelTitleLine,
 } from "@aliou/pi-utils-ui";
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import { type Component, matchesKey } from "@mariozechner/pi-tui";
+import {
+  type Component,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+} from "@mariozechner/pi-tui";
 import type { ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
 import { statusIcon, statusLabel } from "./status-format";
@@ -111,7 +116,14 @@ export class ProcessPickerComponent implements Component {
     const dim = (s: string) => theme.fg("dim", s);
     const accent = (s: string) => theme.fg("accent", s);
 
-    const padLine = createPanelPadder(width);
+    const innerWidth = width - 2;
+    const basePadLine = createPanelPadder(width);
+    const padLine = (content: string): string =>
+      basePadLine(
+        visibleWidth(content) > innerWidth
+          ? truncateToWidth(content, innerWidth)
+          : content,
+      );
 
     const lines: string[] = [];
     const processes = this.getProcesses();

package/src/components/processes-component.ts

@@ -4,7 +4,12 @@ import {
   renderPanelTitleLine,
 } from "@aliou/pi-utils-ui";
 import type { Theme } from "@mariozechner/pi-coding-agent";
-import { type Component, matchesKey, visibleWidth } from "@mariozechner/pi-tui";
+import {
+  type Component,
+  matchesKey,
+  truncateToWidth,
+  visibleWidth,
+} from "@mariozechner/pi-tui";
 import { configLoader } from "../config";
 import type { ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
@@ -214,7 +219,13 @@ export class ProcessesComponent implements Component {
     const processes = this.manager.list();
     const innerWidth = width - 2;
 
-    const padLine = createPanelPadder(width);
+    const basePadLine = createPanelPadder(width);
+    const padLine = (content: string): string =>
+      basePadLine(
+        visibleWidth(content) > innerWidth
+          ? truncateToWidth(content, innerWidth)
+          : content,
+      );
 
     lines.push(renderPanelTitleLine("Background Processes", width, theme));
 
@@ -225,11 +236,18 @@ export class ProcessesComponent implements Component {
       lines.push(padLine(""));
     } else {
       const prefixWidth = 2;
-      const idWidth = 9;
-      const nameWidth = 15;
-      const statusWidth = 18;
-      const timeWidth = 8;
-      const sizeWidth = 8;
+
+      // Responsive column widths based on available space
+      // Minimum widths: id=6, name=8, cmd=4, status=10, time=4, size=4 = ~40 chars minimum
+      const minTotalWidth = 40;
+      const scaleFactor =
+        innerWidth < minTotalWidth ? innerWidth / minTotalWidth : 1;
+
+      const idWidth = Math.max(6, Math.floor(9 * scaleFactor));
+      const nameWidth = Math.max(8, Math.floor(15 * scaleFactor));
+      const statusWidth = Math.max(10, Math.floor(18 * scaleFactor));
+      const timeWidth = Math.max(4, Math.floor(8 * scaleFactor));
+      const sizeWidth = Math.max(4, Math.floor(8 * scaleFactor));
 
       const hasProcessScroll = processes.length > maxVisibleProcesses;
       const headerSuffixText = hasProcessScroll
@@ -237,18 +255,16 @@ export class ProcessesComponent implements Component {
         : "";
       const headerSuffixLen = hasProcessScroll ? headerSuffixText.length : 0;
 
-      // Reserve space for scroll suffix in the command column
-      const cmdWidth = Math.max(
-        10,
-        innerWidth -
-          prefixWidth -
-          idWidth -
-          nameWidth -
-          statusWidth -
-          timeWidth -
-          sizeWidth -
-          headerSuffixLen,
-      );
+      // Calculate command column width based on remaining space
+      const fixedWidth =
+        prefixWidth +
+        idWidth +
+        nameWidth +
+        statusWidth +
+        timeWidth +
+        sizeWidth +
+        headerSuffixLen;
+      const cmdWidth = Math.max(4, innerWidth - fixedWidth);
 
       lines.push(padLine(""));
       const header =
@@ -409,7 +425,12 @@ export class ProcessesComponent implements Component {
     const footerLeftLen = visibleWidth(footerLeft);
     const footerRightLen = visibleWidth(footerRight);
     const footerGap = Math.max(2, innerWidth - footerLeftLen - footerRightLen);
-    const footer = footerLeft + " ".repeat(footerGap) + footerRight;
+    let footer = footerLeft + " ".repeat(footerGap) + footerRight;
+
+    // Truncate footer if it exceeds inner width (e.g., on very narrow terminals)
+    if (footerLeftLen + footerGap + footerRightLen > innerWidth) {
+      footer = truncateToWidth(footer, innerWidth);
+    }
 
     lines.push(padLine(footer));
     lines.push(renderPanelRule(width, theme));

package/src/config.ts

@@ -28,6 +28,10 @@ export interface ProcessesConfig {
     /** Show the status widget below the editor. */
     showStatusWidget?: boolean;
   };
+  interception?: {
+    /** Block background bash commands (&, nohup, disown, setsid) and guide the model to use the process tool. */
+    blockBackgroundCommands?: boolean;
+  };
 }
 
 export interface ResolvedProcessesConfig {
@@ -45,6 +49,9 @@ export interface ResolvedProcessesConfig {
   widget: {
     showStatusWidget: boolean;
   };
+  interception: {
+    blockBackgroundCommands: boolean;
+  };
 }
 
 const DEFAULT_CONFIG: ResolvedProcessesConfig = {
@@ -60,6 +67,9 @@ const DEFAULT_CONFIG: ResolvedProcessesConfig = {
   widget: {
     showStatusWidget: true,
   },
+  interception: {
+    blockBackgroundCommands: false,
+  },
 };
 
 export const configLoader = new ConfigLoader<

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,14 +1,24 @@
 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";
 
-export function setupProcessesHooks(pi: ExtensionAPI, manager: ProcessManager) {
+export function setupProcessesHooks(
+  pi: ExtensionAPI,
+  manager: ProcessManager,
+  config: ResolvedProcessesConfig,
+) {
   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);
 

package/src/hooks/widget.ts

@@ -2,7 +2,7 @@ import type {
   ExtensionAPI,
   ExtensionContext,
 } from "@mariozechner/pi-coding-agent";
-import { visibleWidth } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import { configLoader } from "../config";
 import type { ProcessInfo } from "../constants";
 import type { ProcessManager } from "../manager";
@@ -75,16 +75,28 @@ function renderWidget(
   for (const proc of allProcs) {
     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 (currentLen + needed > effectiveMax && includedCount > 0) {
+    // 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`;
+      reservedForSuffix = separatorLen + visibleWidth(suffixText);
+    }
+
+    if (
+      currentLen + needed + reservedForSuffix > effectiveMax &&
+      includedCount > 0
+    ) {
       // Show how many are hidden
-      const remaining = allProcs.length - includedCount;
-      if (remaining > 0) {
-        parts.push(theme.fg("dim", `+${remaining} more`));
+      const hiddenCount = allProcs.length - includedCount;
+      if (hiddenCount > 0) {
+        parts.push(theme.fg("dim", `+${hiddenCount} more`));
       }
       break;
     }
@@ -94,11 +106,25 @@ 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);
+  }
+
   if (parts.length === 0) {
     return [];
   }
 
-  return [prefix + parts.join(separator)];
+  const line = prefix + parts.join(separator);
+  return [
+    visibleWidth(line) > effectiveMax
+      ? truncateToWidth(line, effectiveMax)
+      : line,
+  ];
 }
 
 export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {

package/src/index.ts

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

package/src/utils/command-executor.test.ts

@@ -1,9 +1,10 @@
+import type * as nodeFs from "node:fs";
 import { existsSync } from "node:fs";
 import { describe, expect, it, vi } from "vitest";
 import { resolveShellExecutable } from "./command-executor";
 
 vi.mock("node:fs", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("node:fs")>();
+  const actual = await importOriginal<typeof nodeFs>();
   return { ...actual, existsSync: vi.fn() };
 });
 

package/src/utils/shell-utils.ts

@@ -0,0 +1,133 @@
+// Shell AST helpers. Duplicated from pi-toolchain since cross-extension imports are not allowed.
+
+import type {
+  Command,
+  Program,
+  SimpleCommand,
+  Statement,
+  Word,
+  WordPart,
+} from "@aliou/sh";
+
+/**
+ * Resolve a Word node to its literal string value.
+ * Concatenates Literal, SglQuoted, and simple DblQuoted parts.
+ * For parts containing parameter expansions, command substitutions, etc.,
+ * includes the raw text representation (e.g. `$VAR`).
+ */
+export function wordToString(word: Word): string {
+  return word.parts.map(partToString).join("");
+}
+
+function partToString(part: WordPart): string {
+  switch (part.type) {
+    case "Literal":
+      return part.value;
+    case "SglQuoted":
+      return part.value;
+    case "DblQuoted":
+      return part.parts.map(partToString).join("");
+    case "ParamExp":
+      return part.short
+        ? `$${part.param.value}`
+        : `\${${part.param.value}${part.op ?? ""}${part.value ? wordToString(part.value) : ""}}`;
+    case "CmdSubst":
+      return "$(...)";
+    case "ArithExp":
+      return `$((${part.expr}))`;
+    case "ProcSubst":
+      return `${part.op}(...)`;
+  }
+}
+
+/**
+ * Walk the AST and call `callback` for every SimpleCommand found at any
+ * nesting depth. Returns early if callback returns `true`.
+ */
+export function walkCommands(
+  node: Program,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): void {
+  for (const stmt of node.body) {
+    if (walkStatement(stmt, callback)) return;
+  }
+}
+
+function walkStatement(
+  stmt: Statement,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  return walkCommand(stmt.command, callback);
+}
+
+function walkStatements(
+  stmts: Statement[],
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  for (const stmt of stmts) {
+    if (walkStatement(stmt, callback)) return true;
+  }
+  return false;
+}
+
+function walkCommand(
+  cmd: Command,
+  callback: (cmd: SimpleCommand) => boolean | undefined,
+): boolean {
+  switch (cmd.type) {
+    case "SimpleCommand":
+      return callback(cmd) === true;
+
+    case "Pipeline":
+      return walkStatements(cmd.commands, callback);
+
+    case "Logical":
+      return (
+        walkStatement(cmd.left, callback) || walkStatement(cmd.right, callback)
+      );
+
+    case "Subshell":
+    case "Block":
+      return walkStatements(cmd.body, callback);
+
+    case "IfClause":
+      return (
+        walkStatements(cmd.cond, callback) ||
+        walkStatements(cmd.then, callback) ||
+        (cmd.else ? walkStatements(cmd.else, callback) : false)
+      );
+
+    case "ForClause":
+    case "SelectClause":
+    case "WhileClause":
+      return (
+        ("cond" in cmd && cmd.cond
+          ? walkStatements(cmd.cond, callback)
+          : false) || walkStatements(cmd.body, callback)
+      );
+
+    case "CaseClause":
+      for (const item of cmd.items) {
+        if (walkStatements(item.body, callback)) return true;
+      }
+      return false;
+
+    case "FunctionDecl":
+      return walkStatements(cmd.body, callback);
+
+    case "TimeClause":
+      return walkStatement(cmd.command, callback);
+
+    case "CoprocClause":
+      return walkStatement(cmd.body, callback);
+
+    case "CStyleLoop":
+      return walkStatements(cmd.body, callback);
+
+    case "TestClause":
+    case "ArithCmd":
+    case "DeclClause":
+    case "LetClause":
+      return false;
+  }
+}