@haemmid/pi-processes 0.9.0

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,53 @@
+import type { ProcessInfo } from "../constants";
+
+export function formatTimestamp(timestamp: number): string {
+  const date = new Date(timestamp);
+  const datePart = `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+  const timePart = `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`;
+  return `${datePart} ${timePart}`;
+}
+
+function pad2(value: number): string {
+  return value.toString().padStart(2, "0");
+}
+
+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,8 @@
+export { hasAnsi, sanitizeLine, stripAnsi } from "./ansi";
+export {
+  formatRuntime,
+  formatStatus,
+  formatTimestamp,
+  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);
+}

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