@aliou/pi-processes 0.4.5 → 0.4.6

package/src/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/src/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,
+  });
+}

package/src/utils/format.ts

@@ -0,0 +1,42 @@
+import type { ProcessInfo } from "../constants";
+
+export function formatRuntime(
+  startTime: number,
+  endTime: number | null,
+): string {
+  const end = endTime ?? Date.now();
+  const ms = end - startTime;
+  const seconds = Math.floor(ms / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+
+  if (hours > 0) {
+    return `${hours}h ${minutes % 60}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds % 60}s`;
+  }
+  return `${seconds}s`;
+}
+
+export function formatStatus(proc: ProcessInfo): string {
+  switch (proc.status) {
+    case "running":
+      return "running";
+    case "terminating":
+      return "terminating";
+    case "terminate_timeout":
+      return "terminate_timeout";
+    case "killed":
+      return "killed";
+    case "exited":
+      return proc.success ? "exit(0)" : `exit(${proc.exitCode ?? "?"})`;
+    default:
+      return proc.status;
+  }
+}
+
+export function truncateCmd(cmd: string, max = 40): string {
+  if (cmd.length <= max) return cmd;
+  return `${cmd.slice(0, max - 3)}...`;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export { hasAnsi, stripAnsi } from "./ansi";
+export { formatRuntime, formatStatus, truncateCmd } from "./format";
+export { isProcessGroupAlive, killProcessGroup } from "./process-group";

package/src/utils/process-group.ts

@@ -0,0 +1,22 @@
+/**
+ * Check if a process group is still alive.
+ * Uses signal 0 to test existence without actually sending a signal.
+ */
+export function isProcessGroupAlive(pgid: number): boolean {
+  try {
+    process.kill(-pgid, 0);
+    return true;
+  } catch (error) {
+    const err = error as NodeJS.ErrnoException;
+    // EPERM: exists, but we can't signal it
+    return err.code === "EPERM";
+  }
+}
+
+/**
+ * Send a signal to an entire process group.
+ * Negative PID targets the process group.
+ */
+export function killProcessGroup(pgid: number, signal: NodeJS.Signals): void {
+  process.kill(-pgid, signal);
+}