pidnap 0.0.0-dev.4 → 0.0.0-dev.5

package/src/env-manager.ts

@@ -1,85 +1,94 @@
 import { parse } from "dotenv";
-import { existsSync, globSync, watch, readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { resolve, join, basename } from "node:path";
+import { existsSync, globSync, readFileSync } from "node:fs";
+import { resolve, basename, isAbsolute } from "node:path";
+import { watch } from "chokidar";
 
-export type EnvChangeCallback = (changedKeys: string[]) => void;
-
-export interface EnvManagerConfig {
-  /**
-   * Directory to search for .env files
-   * Defaults to process.cwd()
-   */
-  cwd?: string;
+export type EnvChangeEvent =
+  | {
+      type: "global";
+    }
+  | {
+      type: "process";
+      key: string;
+    };
 
-  /**
-   * Explicit env file paths to load
-   * Key is the identifier (e.g., "global", "app1")
-   * Value is the file path relative to cwd or absolute
-   */
-  files?: Record<string, string>;
+export type EnvChangeCallback = (event: EnvChangeEvent) => void;
 
-  /**
-   * Enable file watching for env files
-   * Defaults to false
-   */
-  watch?: boolean;
+export interface EnvManagerConfig {
+  cwd: string;
+  globalEnvFile?: string;
+  customEnvFiles?: Record<string, string>;
 }
 
 export class EnvManager {
+  private globalEnv: Record<string, string> = {};
+  private globalEnvPath: string;
   private env: Map<string, Record<string, string>> = new Map();
-  private cwd: string;
-  private watchEnabled: boolean;
   private watchers: Map<string, ReturnType<typeof watch>> = new Map();
-  private fileToKeys: Map<string, Set<string>> = new Map();
+  private fileToKey: Map<string, string> = new Map();
   private changeCallbacks: Set<EnvChangeCallback> = new Set();
-  private reloadDebounceTimers: Map<string, ReturnType<typeof setTimeout>> = new Map();
-
-  constructor(config: EnvManagerConfig = {}) {
-    this.cwd = config.cwd ?? process.cwd();
-    this.watchEnabled = config.watch ?? false;
-
-    // Load .env and .env.* files from cwd
+  private cwdWatcher: ReturnType<typeof watch> | null = null;
+  private customKeys: Set<string> = new Set();
+
+  constructor(private config: EnvManagerConfig) {
+    this.globalEnvPath = config.globalEnvFile
+      ? isAbsolute(config.globalEnvFile)
+        ? config.globalEnvFile
+        : resolve(config.cwd, config.globalEnvFile)
+      : resolve(config.cwd, ".env");
+
+    // Load custom env files first (before auto-discovery)
+    this.loadCustomEnvFiles();
     this.loadEnvFilesFromCwd();
-
-    // Load explicitly specified files
-    if (config.files) {
-      for (const [key, filePath] of Object.entries(config.files)) {
-        this.loadEnvFile(key, filePath);
-      }
-    }
+    this.watchCwdForNewFiles();
   }
 
-  registerFile(key: string, filePath: string): void {
-    this.loadEnvFile(key, filePath);
+  /**
+   * Register a custom env file for a key.
+   * Once registered, auto-discovered .env.{key} files will be ignored for this key.
+   */
+  public registerFile(key: string, filePath: string): void {
+    const absolutePath = isAbsolute(filePath) ? filePath : resolve(this.config.cwd, filePath);
+    this.customKeys.add(key);
+    this.loadEnvFile(key, absolutePath);
   }
 
-  getEnvForKey(key: string): Record<string, string> {
-    return this.env.get(key) ?? {};
+  /**
+   * Check if a key has a custom env file registered
+   */
+  public hasCustomFile(key: string): boolean {
+    return this.customKeys.has(key);
   }
 
   /**
-   * Load .env and .env.* files from the cwd
+   * Load custom env files from config
    */
-  private loadEnvFilesFromCwd(): void {
-    // Load .env file as global
-    const dotEnvPath = resolve(this.cwd, ".env");
-    if (existsSync(dotEnvPath)) {
-      this.loadEnvFile("global", dotEnvPath);
+  private loadCustomEnvFiles(): void {
+    if (!this.config.customEnvFiles) return;
+
+    for (const [key, filePath] of Object.entries(this.config.customEnvFiles)) {
+      this.registerFile(key, filePath);
     }
+  }
 
-    // Load .env.* files
-    try {
-      const pattern = join(this.cwd, ".env.*");
-      const envFiles = globSync(pattern);
+  public getEnvVars(key: string): Record<string, string> {
+    const specificEnv = this.env.get(key);
+    return {
+      ...this.globalEnv,
+      ...specificEnv,
+    };
+  }
 
+  private loadEnvFilesFromCwd(): void {
+    if (existsSync(this.globalEnvPath)) this.loadGlobalEnv(this.globalEnvPath);
+
+    try {
+      const envFiles = globSync(".env.*", { cwd: this.config.cwd });
       for (const filePath of envFiles) {
-        // Extract the suffix after .env.
-        const fileName = basename(filePath);
-        const match = fileName.match(/^\.env\.(.+)$/);
-        if (match) {
-          const suffix = match[1];
-          this.loadEnvFile(suffix, filePath);
+        const key = this.getEnvKeySuffix(basename(filePath));
+        // Skip if key has a custom file registered
+        if (key && !this.customKeys.has(key)) {
+          this.loadEnvFile(key, resolve(this.config.cwd, filePath));
         }
       }
     } catch (err) {
@@ -87,46 +96,49 @@ export class EnvManager {
     }
   }
 
-  /**
-   * Load a single env file and store it in the map
-   */
-  private loadEnvFile(key: string, filePath: string): void {
-    const absolutePath = resolve(this.cwd, filePath);
-
-    if (!existsSync(absolutePath)) {
-      return; // Silently skip non-existent files
-    }
-
+  private parseEnvFile(absolutePath: string): Record<string, string> | null {
     try {
       const content = readFileSync(absolutePath, "utf-8");
-      const parsed = parse(content);
-      this.env.set(key, parsed);
+      return parse(content) ?? {};
+    } catch (err) {
+      console.warn(`Failed to parse env file: ${absolutePath}`, err);
+      return null;
+    }
+  }
 
-      // Track which file maps to which key
-      if (!this.fileToKeys.has(absolutePath)) {
-        this.fileToKeys.set(absolutePath, new Set());
-      }
-      this.fileToKeys.get(absolutePath)!.add(key);
+  private getEnvKeySuffix(fileName: string): string | null {
+    const match = fileName.match(/^\.env\.(.+)$/);
+    return match ? match[1] : null;
+  }
 
-      // Start watching if enabled and not already watching
-      if (this.watchEnabled && !this.watchers.has(absolutePath)) {
-        this.watchFile(absolutePath);
-      }
-    } catch (err) {
-      console.warn(`Failed to load env file: ${absolutePath}`, err);
+  private loadGlobalEnv(absolutePath: string) {
+    if (!existsSync(absolutePath)) return;
+    const parsed = this.parseEnvFile(absolutePath);
+    if (parsed) {
+      this.globalEnv = parsed;
+      this.watchFile(absolutePath);
     }
   }
 
-  /**
-   * Watch a file for changes
-   */
+  private loadEnvFile(key: string, absolutePath: string) {
+    const parsed = this.parseEnvFile(absolutePath);
+    if (!parsed) return;
+
+    this.env.set(key, parsed);
+    this.fileToKey.set(absolutePath, key);
+    this.watchFile(absolutePath);
+  }
+
   private watchFile(absolutePath: string): void {
+    if (this.watchers.has(absolutePath)) return;
     try {
-      const watcher = watch(absolutePath, (eventType) => {
-        if (eventType === "change") {
+      const watcher = watch(absolutePath, { ignoreInitial: true })
+        .on("change", () => {
           this.handleFileChange(absolutePath);
-        }
-      });
+        })
+        .on("unlink", () => {
+          this.handleFileDelete(absolutePath);
+        });
 
       this.watchers.set(absolutePath, watcher);
     } catch (err) {
@@ -135,56 +147,80 @@ export class EnvManager {
   }
 
   /**
-   * Handle file change with debouncing
+   * Watch cwd for new .env.* files
    */
+  private watchCwdForNewFiles(): void {
+    try {
+      this.cwdWatcher = watch(this.config.cwd, {
+        ignoreInitial: true,
+        depth: 0,
+      }).on("add", (filePath) => {
+        this.handleNewFile(filePath);
+      });
+    } catch (err) {
+      console.warn(`Failed to watch cwd for new env files:`, err);
+    }
+  }
+
   private handleFileChange(absolutePath: string): void {
-    // Clear existing timer if any
-    const existingTimer = this.reloadDebounceTimers.get(absolutePath);
-    if (existingTimer) {
-      clearTimeout(existingTimer);
+    if (absolutePath === this.globalEnvPath) {
+      this.loadGlobalEnv(absolutePath);
+      this.notifyCallbacks({ type: "global" });
+      return;
     }
 
-    // Debounce reload by 100ms to avoid multiple rapid reloads
-    const timer = setTimeout(() => {
-      this.reloadFile(absolutePath);
-      this.reloadDebounceTimers.delete(absolutePath);
-    }, 100);
+    const key = this.fileToKey.get(absolutePath);
+    if (!key) return;
 
-    this.reloadDebounceTimers.set(absolutePath, timer);
+    const parsed = this.parseEnvFile(absolutePath);
+    if (!parsed) return;
+
+    this.env.set(key, parsed);
+    this.notifyCallbacks({ type: "process", key });
   }
 
-  /**
-   * Reload a file and notify callbacks
-   */
-  private reloadFile(absolutePath: string): void {
-    const keys = this.fileToKeys.get(absolutePath);
-    if (!keys) return;
-
-    readFile(absolutePath, "utf-8")
-      .then((content) => parse(content))
-      .then((parsed) => {
-        const changedKeys: string[] = [];
-        for (const key of keys) {
-          this.env.set(key, parsed);
-          changedKeys.push(key);
-        }
+  private handleFileDelete(absolutePath: string): void {
+    const watcher = this.watchers.get(absolutePath);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(absolutePath);
+    }
 
-        // Notify all callbacks
-        if (changedKeys.length > 0) {
-          for (const callback of this.changeCallbacks) {
-            callback(changedKeys);
-          }
-        }
-      })
-      .catch((err) => {
-        console.warn(`Failed to reload env file: ${absolutePath}`, err);
-      });
+    if (absolutePath === this.globalEnvPath) {
+      this.globalEnv = {};
+      this.notifyCallbacks({ type: "global" });
+      return;
+    }
+
+    const key = this.fileToKey.get(absolutePath);
+    if (key) {
+      this.env.delete(key);
+      this.fileToKey.delete(absolutePath);
+      this.notifyCallbacks({ type: "process", key });
+    }
+  }
+
+  private handleNewFile(filePath: string): void {
+    const absolutePath = isAbsolute(filePath) ? filePath : resolve(this.config.cwd, filePath);
+
+    if (absolutePath === this.globalEnvPath) {
+      this.loadGlobalEnv(absolutePath);
+      this.notifyCallbacks({ type: "global" });
+      return;
+    }
+
+    const key = this.getEnvKeySuffix(basename(filePath));
+    // Skip if key has a custom file registered or already loaded
+    if (key && !this.customKeys.has(key) && !this.env.has(key)) {
+      this.loadEnvFile(key, absolutePath);
+      this.notifyCallbacks({ type: "process", key });
+    }
+  }
+
+  private notifyCallbacks(event: EnvChangeEvent): void {
+    for (const callback of this.changeCallbacks) callback(event);
   }
 
-  /**
-   * Register a callback to be called when env files change
-   * Returns a function to unregister the callback
-   */
   onChange(callback: EnvChangeCallback): () => void {
     this.changeCallbacks.add(callback);
     return () => {
@@ -192,46 +228,17 @@ export class EnvManager {
     };
   }
 
-  /**
-   * Stop watching all files and cleanup
-   */
-  dispose(): void {
-    // Clear all timers
-    for (const timer of this.reloadDebounceTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.reloadDebounceTimers.clear();
-
-    // Close all watchers
+  close(): void {
     for (const watcher of this.watchers.values()) {
       watcher.close();
     }
     this.watchers.clear();
 
-    // Clear callbacks
-    this.changeCallbacks.clear();
-  }
-
-  /**
-   * Get environment variables for a specific process
-   * Merges global env with process-specific env
-   * Process-specific env variables override global ones
-   */
-  getEnvVars(processKey?: string): Record<string, string> {
-    const globalEnv = this.env.get("global") ?? {};
-
-    if (!processKey) {
-      return { ...globalEnv };
+    if (this.cwdWatcher) {
+      this.cwdWatcher.close();
+      this.cwdWatcher = null;
     }
 
-    const processEnv = this.env.get(processKey) ?? {};
-    return { ...globalEnv, ...processEnv };
-  }
-
-  /**
-   * Get all loaded env maps (for debugging/inspection)
-   */
-  getAllEnv(): ReadonlyMap<string, Record<string, string>> {
-    return this.env;
+    this.changeCallbacks.clear();
   }
 }

package/src/index.ts

@@ -10,4 +10,3 @@ export * from "./task-list.ts";
 export * from "./lazy-process.ts";
 export * from "./env-manager.ts";
 export * from "./logger.ts";
-export * from "./tree-kill.ts";

package/src/lazy-process.ts

@@ -1,20 +1,18 @@
-import { spawn, type ChildProcess } from "node:child_process";
-import readline from "node:readline";
-import { PassThrough } from "node:stream";
 import * as v from "valibot";
 import type { Logger } from "./logger.ts";
-import { treeKill } from "./tree-kill.ts";
+import { setTimeout } from "node:timers/promises";
+import { createInterface } from "node:readline/promises";
+import { spawn, type ChildProcess } from "node:child_process";
 
-export const ProcessDefinitionSchema = v.object({
+export const ProcessDefinition = v.object({
   command: v.string(),
   args: v.optional(v.array(v.string())),
   cwd: v.optional(v.string()),
   env: v.optional(v.record(v.string(), v.string())),
 });
+export type ProcessDefinition = v.InferOutput<typeof ProcessDefinition>;
 
-export type ProcessDefinition = v.InferOutput<typeof ProcessDefinitionSchema>;
-
-export const ProcessStateSchema = v.picklist([
+export const ProcessState = v.picklist([
   "idle",
   "starting",
   "running",
@@ -22,35 +20,31 @@ export const ProcessStateSchema = v.picklist([
   "stopped",
   "error",
 ]);
-
-export type ProcessState = v.InferOutput<typeof ProcessStateSchema>;
+export type ProcessState = v.InferOutput<typeof ProcessState>;
 
 /**
- * Kill a process and all its descendants (children, grandchildren, etc.)
- * Falls back to simple child.kill() if tree kill fails.
+ * Kill a process group (the process and all its descendants).
+ * Uses negative PID to target the entire process group.
  */
-async function killProcessTree(child: ChildProcess, signal: NodeJS.Signals): Promise<boolean> {
-  const pid = child.pid;
-  if (pid === undefined) {
-    return false;
-  }
-
+function killProcessGroup(pid: number, signal: NodeJS.Signals): boolean {
   try {
-    await treeKill(pid, signal);
+    // Negative PID kills the entire process group
+    process.kill(-pid, signal);
     return true;
-  } catch {
-    // Fallback to simple kill if tree kill fails
-    try {
-      return child.kill(signal);
-    } catch {
-      return false;
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    // ESRCH = No such process (already dead)
+    // EPERM = Permission denied (might happen if some children already exited)
+    if (code === "ESRCH" || code === "EPERM") {
+      return true;
     }
+    return false;
   }
 }
 
 export class LazyProcess {
   readonly name: string;
-  private definition: ProcessDefinition;
+  definition: ProcessDefinition;
   private logger: Logger;
   private childProcess: ChildProcess | null = null;
   private _state: ProcessState = "idle";
@@ -60,14 +54,14 @@ export class LazyProcess {
   constructor(name: string, definition: ProcessDefinition, logger: Logger) {
     this.name = name;
     this.definition = definition;
-    this.logger = logger;
+    this.logger = logger.withPrefix("SYS");
   }
 
   get state(): ProcessState {
     return this._state;
   }
 
-  start(): void {
+  async start() {
     if (this._state === "running" || this._state === "starting") {
       throw new Error(`Process "${this.name}" is already ${this._state}`);
     }
@@ -78,7 +72,7 @@ export class LazyProcess {
 
     this._state = "starting";
     this.processExit = Promise.withResolvers<void>();
-    this.logger.info(`Starting process: ${this.definition.command}`);
+    this.logger.debug(`Starting process: ${this.definition.command}`);
 
     try {
       const env = this.definition.env ? { ...process.env, ...this.definition.env } : process.env;
@@ -87,37 +81,23 @@ export class LazyProcess {
         cwd: this.definition.cwd,
         env,
         stdio: ["ignore", "pipe", "pipe"],
+        detached: true,
       });
 
       this._state = "running";
 
-      // Combine stdout and stderr into a single stream for unified logging
-      const combined = new PassThrough();
-      let streamCount = 0;
-
       if (this.childProcess.stdout) {
-        streamCount++;
-        this.childProcess.stdout.pipe(combined, { end: false });
-        this.childProcess.stdout.on("end", () => {
-          if (--streamCount === 0) combined.end();
-        });
+        const rl = createInterface({ input: this.childProcess.stdout });
+        rl.on("line", (line) => this.logger.withPrefix("OUT").info(line));
+        this.processExit.promise.then(() => rl.close());
       }
 
       if (this.childProcess.stderr) {
-        streamCount++;
-        this.childProcess.stderr.pipe(combined, { end: false });
-        this.childProcess.stderr.on("end", () => {
-          if (--streamCount === 0) combined.end();
-        });
+        const rl = createInterface({ input: this.childProcess.stderr });
+        rl.on("line", (line) => this.logger.withPrefix("ERR").info(line));
+        this.processExit.promise.then(() => rl.close());
       }
 
-      // Use readline to handle line-by-line output properly
-      const rl = readline.createInterface({ input: combined });
-      rl.on("line", (line) => {
-        this.logger.info(line);
-      });
-
-      // Handle process exit
       this.childProcess.on("exit", (code, signal) => {
         this.exitCode = code;
 
@@ -137,7 +117,6 @@ export class LazyProcess {
         this.processExit.resolve();
       });
 
-      // Handle spawn errors
       this.childProcess.on("error", (err) => {
         if (this._state !== "stopping" && this._state !== "stopped") {
           this._state = "error";
@@ -169,44 +148,34 @@ export class LazyProcess {
     }
 
     this._state = "stopping";
-    this.logger.info(`Stopping process with SIGTERM`);
-
-    // Send SIGTERM for graceful shutdown (to entire process tree)
-    await killProcessTree(this.childProcess, "SIGTERM");
+    const pid = this.childProcess.pid;
 
-    const timeoutMs = timeout ?? 5000;
+    if (pid === undefined) {
+      this._state = "stopped";
+      this.cleanup();
+      return;
+    }
 
-    // Wait for process to exit or timeout
-    const timeoutPromise = new Promise<"timeout">((resolve) =>
-      setTimeout(() => resolve("timeout"), timeoutMs),
-    );
+    this.logger.debug(`Stopping process group (pid: ${pid}) with SIGTERM`);
 
-    this.logger.info(`Waiting for process exit (timeout: ${timeoutMs}ms)`);
-    const result = await Promise.race([
+    const timeoutMs = timeout ?? 5000;
+    const resultRace = Promise.race([
       this.processExit.promise.then(() => "exited" as const),
-      timeoutPromise,
+      setTimeout(timeoutMs, "timeout"),
     ]);
-    this.logger.info(`Stop race result: ${result}`);
 
-    if (result === "timeout" && this.childProcess) {
-      const pid = this.childProcess.pid;
+    killProcessGroup(pid, "SIGTERM");
+
+    this.logger.debug(`Waiting for process exit (timeout: ${timeoutMs}ms)`);
+    const result = await resultRace;
+    this.logger.debug(`process exit result: ${result}`);
+
+    if (result === "timeout") {
       this.logger.warn(`Process did not exit within ${timeoutMs}ms, sending SIGKILL (pid: ${pid})`);
-      const killed = await killProcessTree(this.childProcess, "SIGKILL");
-      this.logger.info(`SIGKILL sent via tree-kill: ${killed ? "success" : "failed"}`);
-
-      // If tree-kill failed, try direct kill as last resort
-      if (!killed && this.childProcess) {
-        this.logger.warn(`Tree-kill failed, attempting direct SIGKILL`);
-        try {
-          this.childProcess.kill("SIGKILL");
-          this.logger.info(`Direct SIGKILL sent`);
-        } catch (err) {
-          this.logger.error(`Direct SIGKILL failed:`, err);
-        }
-      }
+      const killed = killProcessGroup(pid, "SIGKILL");
+      this.logger.info(`SIGKILL sent to process group: ${killed ? "success" : "failed"}`);
 
-      // Give SIGKILL a short timeout
-      const killTimeout = new Promise<void>((resolve) => setTimeout(resolve, 1000));
+      const killTimeout = setTimeout(1000, "timeout");
       await Promise.race([this.processExit.promise, killTimeout]);
 
       if (this.childProcess && !this.childProcess.killed) {
@@ -220,9 +189,9 @@ export class LazyProcess {
   }
 
   async reset(): Promise<void> {
-    if (this.childProcess) {
-      // Kill the entire process tree if running
-      await killProcessTree(this.childProcess, "SIGKILL");
+    if (this.childProcess?.pid !== undefined) {
+      // Kill the entire process group
+      killProcessGroup(this.childProcess.pid, "SIGKILL");
       await this.processExit.promise;
       this.cleanup();
     }
@@ -238,19 +207,13 @@ export class LazyProcess {
   }
 
   async waitForExit(): Promise<ProcessState> {
-    if (!this.childProcess) {
-      return this._state;
-    }
-
+    if (!this.childProcess) return this._state;
     await this.processExit.promise;
     return this._state;
   }
 
   private cleanup(): void {
     if (this.childProcess) {
-      // Remove all listeners to prevent memory leaks
-      this.childProcess.stdout?.removeAllListeners();
-      this.childProcess.stderr?.removeAllListeners();
       this.childProcess.removeAllListeners();
       this.childProcess = null;
     }