@aliou/pi-processes 0.4.2 → 0.4.4

package/commands/settings-command.ts

@@ -71,6 +71,28 @@ export function registerProcessesSettings(
             },
           ],
         },
+        {
+          label: "Execution",
+          items: [
+            {
+              id: "execution.shellPath",
+              label: "Shell path",
+              description:
+                "Absolute shell path override used to execute commands",
+              currentValue:
+                tabConfig?.execution?.shellPath ??
+                resolved.execution.shellPath ??
+                "auto",
+              values: [
+                "auto",
+                "/run/current-system/sw/bin/bash",
+                "/bin/bash",
+                "/usr/bin/bash",
+                "/usr/local/bin/bash",
+              ],
+            },
+          ],
+        },
         {
           label: "Widget",
           items: [
@@ -97,6 +119,13 @@ export function registerProcessesSettings(
         updated.widget.showStatusWidget = newValue === "on";
         return updated;
       }
+      if (id === "execution.shellPath") {
+        if (!updated.execution) updated.execution = {};
+        updated.execution.shellPath =
+          newValue === "auto" ? undefined : newValue;
+        return updated;
+      }
+
       // Numeric fields.
       const num = Number.parseInt(newValue, 10);
       if (Number.isNaN(num)) return null;

package/config.ts

@@ -20,6 +20,10 @@ export interface ProcessesConfig {
     /** Hard cap on output lines returned to the agent. */
     maxOutputLines?: number;
   };
+  execution?: {
+    /** Absolute shell path override. Leave unset to auto-resolve. */
+    shellPath?: string;
+  };
   widget?: {
     /** Show the status widget below the editor. */
     showStatusWidget?: boolean;
@@ -35,6 +39,9 @@ export interface ResolvedProcessesConfig {
     defaultTailLines: number;
     maxOutputLines: number;
   };
+  execution: {
+    shellPath?: string;
+  };
   widget: {
     showStatusWidget: boolean;
   };
@@ -49,6 +56,7 @@ const DEFAULT_CONFIG: ResolvedProcessesConfig = {
     defaultTailLines: 100,
     maxOutputLines: 200,
   },
+  execution: {},
   widget: {
     showStatusWidget: true,
   },

package/hooks/widget.ts

@@ -126,8 +126,9 @@ export function setupProcessWidget(pi: ExtensionAPI, manager: ProcessManager) {
   }
 
   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;
-    updateWidget();
   });
 
   pi.on("session_switch", async (_event, ctx) => {

package/index.ts

@@ -16,7 +16,9 @@ export default async function (pi: ExtensionAPI) {
   }
 
   await configLoader.load();
-  const manager = new ProcessManager();
+  const manager = new ProcessManager({
+    getConfiguredShellPath: () => configLoader.getConfig().execution.shellPath,
+  });
 
   const { update: updateWidget } = setupProcessesHooks(pi, manager);
   setupProcessesCommands(pi, manager);

package/manager.ts

@@ -1,4 +1,4 @@
-import { type ChildProcess, spawn } from "node:child_process";
+import type { ChildProcess } from "node:child_process";
 import { EventEmitter } from "node:events";
 import {
   appendFileSync,
@@ -19,6 +19,7 @@ import {
   type StartOptions,
 } from "./constants";
 import { isProcessGroupAlive, killProcessGroup } from "./utils";
+import { spawnCommand } from "./utils/command-executor";
 
 interface ManagedProcess extends ProcessInfo {
   process: ChildProcess;
@@ -26,16 +27,23 @@ interface ManagedProcess extends ProcessInfo {
   combinedFile: string;
 }
 
+interface ProcessManagerOptions {
+  getConfiguredShellPath?: () => string | undefined;
+}
+
 export class ProcessManager {
   private processes: Map<string, ManagedProcess> = new Map();
   private counter = 0;
   private logDir: string;
   private events = new EventEmitter();
   private watcher: ReturnType<typeof setInterval> | null = null;
+  private getConfiguredShellPath: () => string | undefined;
 
-  constructor() {
+  constructor(options?: ProcessManagerOptions) {
     this.logDir = join(tmpdir(), `pi-processes-${Date.now()}`);
     mkdirSync(this.logDir, { recursive: true });
+    this.getConfiguredShellPath =
+      options?.getConfiguredShellPath ?? (() => undefined);
   }
 
   onEvent(listener: (event: ManagerEvent) => void): () => void {
@@ -129,12 +137,7 @@ export class ProcessManager {
     appendFileSync(stderrFile, "");
     appendFileSync(combinedFile, "");
 
-    const child = spawn("/bin/bash", ["-lc", command], {
-      cwd,
-      env: process.env,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-    });
+    const child = spawnCommand(command, cwd, this.getConfiguredShellPath());
 
     child.unref();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aliou/pi-processes",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "type": "module",
   "private": false,
   "keywords": [
@@ -34,7 +34,7 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.41",
-    "@aliou/pi-utils-settings": "0.3.0",
+    "@aliou/pi-utils-settings": "0.4.0",
     "@aliou/pi-utils-ui": "^0.1.0"
   },
   "peerDependencies": {

package/utils/command-executor.test.ts

@@ -0,0 +1,47 @@
+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")>();
+  return { ...actual, existsSync: vi.fn() };
+});
+
+const existsSyncMock = vi.mocked(existsSync);
+
+describe("resolveShellExecutable", () => {
+  it("prefers shell configured in settings when it is an existing absolute path", () => {
+    existsSyncMock.mockImplementation(
+      (path) => path === "/nix/store/abc-bash-5.3/bin/bash",
+    );
+
+    const resolved = resolveShellExecutable({
+      configuredShell: "/nix/store/abc-bash-5.3/bin/bash",
+      knownPaths: ["/bin/bash", "/usr/bin/bash"],
+    });
+
+    expect(resolved).toBe("/nix/store/abc-bash-5.3/bin/bash");
+  });
+
+  it("falls back to first existing known shell path", () => {
+    existsSyncMock.mockImplementation((path) => path === "/usr/bin/bash");
+
+    const resolved = resolveShellExecutable({
+      configuredShell: undefined,
+      knownPaths: ["/bin/bash", "/usr/bin/bash", "/usr/local/bin/bash"],
+    });
+
+    expect(resolved).toBe("/usr/bin/bash");
+  });
+
+  it("throws when no configured/known shell path exists", () => {
+    existsSyncMock.mockReturnValue(false);
+
+    expect(() =>
+      resolveShellExecutable({
+        configuredShell: undefined,
+        knownPaths: ["/bin/bash", "/usr/bin/bash"],
+      }),
+    ).toThrow(/shell/i);
+  });
+});

package/utils/command-executor.ts

@@ -0,0 +1,56 @@
+import { type ChildProcess, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+
+interface ResolveShellExecutableOptions {
+  configuredShell?: string;
+  knownPaths: string[];
+}
+
+const DEFAULT_KNOWN_SHELL_PATHS = [
+  "/run/current-system/sw/bin/bash",
+  "/bin/bash",
+  "/usr/bin/bash",
+  "/usr/local/bin/bash",
+];
+
+function isExistingAbsolutePath(shell: string | undefined): shell is string {
+  return typeof shell === "string" && isAbsolute(shell) && existsSync(shell);
+}
+
+export function resolveShellExecutable({
+  configuredShell,
+  knownPaths,
+}: ResolveShellExecutableOptions): string {
+  if (isExistingAbsolutePath(configuredShell)) {
+    return configuredShell;
+  }
+
+  for (const path of knownPaths) {
+    if (isExistingAbsolutePath(path)) {
+      return path;
+    }
+  }
+
+  throw new Error(
+    "Unable to resolve shell executable. Checked configured shell and known shell paths.",
+  );
+}
+
+export function spawnCommand(
+  command: string,
+  cwd: string,
+  configuredShell?: string,
+): ChildProcess {
+  const shellExecutable = resolveShellExecutable({
+    configuredShell,
+    knownPaths: DEFAULT_KNOWN_SHELL_PATHS,
+  });
+
+  return spawn(shellExecutable, ["-lc", command], {
+    cwd,
+    env: process.env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true,
+  });
+}