pidnap 0.0.0-dev.0 → 0.0.0-dev.2

package/src/manager.ts

@@ -12,6 +12,7 @@ import {
   type RestartingProcessOptions,
 } from "./restarting-process.ts";
 import { EnvManager } from "./env-manager.ts";
+import { killProcessOnPort } from "./port-utils.ts";
 
 // Valibot schemas
 
@@ -46,6 +47,7 @@ export const RestartingProcessEntrySchema = v.object({
   options: v.optional(RestartingProcessOptionsSchema),
   envFile: v.optional(v.string()),
   envReloadDelay: v.optional(EnvReloadDelaySchema), // Default 5000ms
+  port: v.optional(v.number()), // Kill any process on this port before spawning
 });
 
 export type RestartingProcessEntry = v.InferOutput<typeof RestartingProcessEntrySchema>;
@@ -108,6 +110,9 @@ export class Manager {
   private envReloadTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
   private envChangeUnsubscribe: (() => void) | null = null;
 
+  // Port tracking for processes
+  private processPortConfig: Map<string, number> = new Map();
+
   // Shutdown handling
   private signalHandlers: Map<NodeJS.Signals, () => void> = new Map();
   private shutdownPromise: Promise<void> | null = null;
@@ -182,6 +187,19 @@ export class Manager {
     return join(this.logDir, "cron", `${name}.log`);
   }
 
+  /**
+   * Kill any process running on the configured port for a process
+   */
+  private async killPortForProcess(processName: string): Promise<void> {
+    const port = this.processPortConfig.get(processName);
+    if (port === undefined) return;
+
+    const killed = await killProcessOnPort(port);
+    if (killed) {
+      this.logger.info(`Killed process on port ${port} before starting "${processName}"`);
+    }
+  }
+
   private ensureLogDirs(): void {
     mkdirSync(this.logDir, { recursive: true });
     mkdirSync(join(this.logDir, "process"), { recursive: true });
@@ -389,11 +407,13 @@ export class Manager {
   /**
    * Start a restarting process by target
    */
-  startProcessByTarget(target: string | number): RestartingProcess {
+  async startProcessByTarget(target: string | number): Promise<RestartingProcess> {
     const proc = this.getProcessByTarget(target);
     if (!proc) {
       throw new Error(`Process not found: ${target}`);
     }
+    // Kill any process on the configured port before starting
+    await this.killPortForProcess(proc.name);
     proc.start();
     return proc;
   }
@@ -421,6 +441,8 @@ export class Manager {
     if (!proc) {
       throw new Error(`Process not found: ${target}`);
     }
+    // Kill any process on the configured port before restarting
+    await this.killPortForProcess(proc.name);
     await proc.restart(force);
     return proc;
   }
@@ -527,12 +549,13 @@ export class Manager {
   /**
    * Add a restarting process at runtime
    */
-  addProcess(
+  async addProcess(
     name: string,
     definition: ProcessDefinition,
     options?: RestartingProcessOptions,
     envReloadDelay?: EnvReloadDelay,
-  ): RestartingProcess {
+    port?: number,
+  ): Promise<RestartingProcess> {
     if (this.restartingProcesses.has(name)) {
       throw new Error(`Process "${name}" already exists`);
     }
@@ -545,6 +568,13 @@ export class Manager {
       processLogger,
     );
     this.restartingProcesses.set(name, restartingProcess);
+
+    // Track port config and kill any process on that port before starting
+    if (port !== undefined) {
+      this.processPortConfig.set(name, port);
+      await this.killPortForProcess(name);
+    }
+
     restartingProcess.start();
 
     // Track env reload config for this process
@@ -662,6 +692,13 @@ export class Manager {
           processLogger,
         );
         this.restartingProcesses.set(entry.name, restartingProcess);
+
+        // Track port config and kill any process on that port before starting
+        if (entry.port !== undefined) {
+          this.processPortConfig.set(entry.name, entry.port);
+          await this.killPortForProcess(entry.name);
+        }
+
         restartingProcess.start();
 
         // Track env reload config for this process

package/src/port-utils.ts

@@ -0,0 +1,39 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { treeKill } from "./tree-kill.ts";
+
+const execAsync = promisify(exec);
+
+/**
+ * Kill any process listening on the specified port, including all descendants.
+ */
+export async function killProcessOnPort(port: number): Promise<boolean> {
+  try {
+    // Use lsof to find the process ID listening on the port
+    const { stdout } = await execAsync(`lsof -ti tcp:${port}`);
+    const pids = stdout
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((p) => parseInt(p, 10))
+      .filter((p) => !isNaN(p));
+
+    if (pids.length === 0) {
+      return false; // No process found on port
+    }
+
+    // Tree kill all processes found on the port (kills children/grandchildren too)
+    for (const pid of pids) {
+      try {
+        await treeKill(pid, "SIGKILL");
+      } catch {
+        // Process may have already exited
+      }
+    }
+
+    return true;
+  } catch {
+    // Command failed (e.g., no process on port)
+    return false;
+  }
+}

package/src/tree-kill.ts

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+
+type ProcessTree = Record<number, number[]>;
+
+/**
+ * Kill a process and all its descendants (children, grandchildren, etc.)
+ * @param pid - The process ID to kill
+ * @param signal - The signal to send (default: SIGTERM)
+ * @returns Promise that resolves when all processes have been signaled
+ */
+export async function treeKill(pid: number, signal: NodeJS.Signals = "SIGTERM"): Promise<void> {
+  if (Number.isNaN(pid)) {
+    throw new Error("pid must be a number");
+  }
+
+  const tree: ProcessTree = { [pid]: [] };
+  const pidsToProcess = new Set<number>([pid]);
+
+  // Build the process tree
+  await buildProcessTree(pid, tree, pidsToProcess);
+
+  // Kill all processes in the tree (children first, then parents)
+  killAll(tree, signal);
+}
+
+/**
+ * Build a tree of all child processes recursively
+ */
+async function buildProcessTree(
+  parentPid: number,
+  tree: ProcessTree,
+  pidsToProcess: Set<number>,
+): Promise<void> {
+  return new Promise((resolve) => {
+    const ps = spawn("ps", ["-o", "pid", "--no-headers", "--ppid", String(parentPid)]);
+
+    let allData = "";
+
+    ps.stdout.on("data", (data: Buffer) => {
+      allData += data.toString("ascii");
+    });
+
+    ps.on("close", async (code) => {
+      pidsToProcess.delete(parentPid);
+
+      if (code !== 0) {
+        // No child processes found for this parent
+        if (pidsToProcess.size === 0) {
+          resolve();
+        }
+        return;
+      }
+
+      const childPids = allData.match(/\d+/g);
+      if (!childPids) {
+        if (pidsToProcess.size === 0) {
+          resolve();
+        }
+        return;
+      }
+
+      // Process all child PIDs concurrently
+      const promises: Promise<void>[] = [];
+
+      for (const pidStr of childPids) {
+        const childPid = parseInt(pidStr, 10);
+        tree[parentPid].push(childPid);
+        tree[childPid] = [];
+        pidsToProcess.add(childPid);
+        promises.push(buildProcessTree(childPid, tree, pidsToProcess));
+      }
+
+      await Promise.all(promises);
+
+      if (pidsToProcess.size === 0) {
+        resolve();
+      }
+    });
+
+    ps.on("error", () => {
+      pidsToProcess.delete(parentPid);
+      if (pidsToProcess.size === 0) {
+        resolve();
+      }
+    });
+  });
+}
+
+/**
+ * Kill all processes in the tree
+ * Kills children before parents to ensure clean shutdown
+ */
+function killAll(tree: ProcessTree, signal: NodeJS.Signals): void {
+  const killed = new Set<number>();
+
+  // Get all PIDs and sort by depth (deepest first)
+  const allPids = Object.keys(tree).map(Number);
+
+  // Kill children first, then parents
+  for (const pid of allPids) {
+    // Kill all children of this pid
+    for (const childPid of tree[pid]) {
+      if (!killed.has(childPid)) {
+        killPid(childPid, signal);
+        killed.add(childPid);
+      }
+    }
+  }
+
+  // Kill all parent pids
+  for (const pid of allPids) {
+    if (!killed.has(pid)) {
+      killPid(pid, signal);
+      killed.add(pid);
+    }
+  }
+}
+
+/**
+ * Kill a single process, ignoring ESRCH errors (process already dead)
+ */
+function killPid(pid: number, signal: NodeJS.Signals): void {
+  try {
+    process.kill(pid, signal);
+  } catch (err) {
+    // ESRCH = No such process (already dead) - ignore this
+    if ((err as NodeJS.ErrnoException).code !== "ESRCH") {
+      throw err;
+    }
+  }
+}