pidnap 0.0.0-dev.0

package/src/lazy-process.ts

@@ -0,0 +1,228 @@
+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";
+
+export const ProcessDefinitionSchema = 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 ProcessDefinitionSchema>;
+
+export const ProcessStateSchema = v.picklist([
+  "idle",
+  "starting",
+  "running",
+  "stopping",
+  "stopped",
+  "error",
+]);
+
+export type ProcessState = v.InferOutput<typeof ProcessStateSchema>;
+
+/**
+ * Kill a process. Tries to kill the process group first (if available),
+ * then falls back to killing just the process.
+ */
+function killProcess(child: ChildProcess, signal: NodeJS.Signals): boolean {
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+
+export class LazyProcess {
+  readonly name: string;
+  private definition: ProcessDefinition;
+  private logger: Logger;
+  private childProcess: ChildProcess | null = null;
+  private _state: ProcessState = "idle";
+  private processExit = Promise.withResolvers<void>();
+  public exitCode: number | null = null;
+
+  constructor(name: string, definition: ProcessDefinition, logger: Logger) {
+    this.name = name;
+    this.definition = definition;
+    this.logger = logger;
+  }
+
+  get state(): ProcessState {
+    return this._state;
+  }
+
+  start(): void {
+    if (this._state === "running" || this._state === "starting") {
+      throw new Error(`Process "${this.name}" is already ${this._state}`);
+    }
+
+    if (this._state === "stopping") {
+      throw new Error(`Process "${this.name}" is currently stopping`);
+    }
+
+    this._state = "starting";
+    this.logger.info(`Starting process: ${this.definition.command}`);
+
+    try {
+      const env = this.definition.env ? { ...process.env, ...this.definition.env } : process.env;
+
+      this.childProcess = spawn(this.definition.command, this.definition.args ?? [], {
+        cwd: this.definition.cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      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();
+        });
+      }
+
+      if (this.childProcess.stderr) {
+        streamCount++;
+        this.childProcess.stderr.pipe(combined, { end: false });
+        this.childProcess.stderr.on("end", () => {
+          if (--streamCount === 0) combined.end();
+        });
+      }
+
+      // 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;
+
+        if (this._state === "running") {
+          if (code === 0) {
+            this._state = "stopped";
+            this.logger.info(`Process exited with code ${code}`);
+          } else if (signal) {
+            this._state = "stopped";
+            this.logger.info(`Process killed with signal ${signal}`);
+          } else {
+            this._state = "error";
+            this.logger.error(`Process exited with code ${code}`);
+          }
+        }
+
+        this.processExit.resolve();
+      });
+
+      // Handle spawn errors
+      this.childProcess.on("error", (err) => {
+        if (this._state !== "stopping" && this._state !== "stopped") {
+          this._state = "error";
+          this.logger.error(`Process error:`, err);
+        }
+        this.processExit.resolve();
+      });
+    } catch (err) {
+      this._state = "error";
+      this.logger.error(`Failed to start process:`, err);
+      throw err;
+    }
+  }
+
+  async stop(timeout?: number): Promise<void> {
+    if (this._state === "idle" || this._state === "stopped" || this._state === "error") {
+      return;
+    }
+
+    if (this._state === "stopping") {
+      // Already stopping, wait for completion
+      await this.processExit.promise;
+      return;
+    }
+
+    if (!this.childProcess) {
+      this._state = "stopped";
+      return;
+    }
+
+    this._state = "stopping";
+    this.logger.info(`Stopping process with SIGTERM`);
+
+    // Send SIGTERM for graceful shutdown (to entire process group)
+    killProcess(this.childProcess, "SIGTERM");
+
+    const timeoutMs = timeout ?? 5000;
+
+    // Wait for process to exit or timeout
+    const timeoutPromise = new Promise<"timeout">((resolve) =>
+      setTimeout(() => resolve("timeout"), timeoutMs),
+    );
+
+    const result = await Promise.race([
+      this.processExit.promise.then(() => "exited" as const),
+      timeoutPromise,
+    ]);
+
+    if (result === "timeout" && this.childProcess) {
+      this.logger.warn(`Process did not exit within ${timeoutMs}ms, sending SIGKILL`);
+      killProcess(this.childProcess, "SIGKILL");
+
+      // Give SIGKILL a short timeout
+      const killTimeout = new Promise<void>((resolve) => setTimeout(resolve, 1000));
+      await Promise.race([this.processExit.promise, killTimeout]);
+    }
+
+    this._state = "stopped";
+    this.cleanup();
+    this.logger.info(`Process stopped`);
+  }
+
+  async reset(): Promise<void> {
+    if (this.childProcess) {
+      // Kill the process group if running
+      killProcess(this.childProcess, "SIGKILL");
+      await this.processExit.promise;
+      this.cleanup();
+    }
+
+    this._state = "idle";
+    // Create a fresh promise for the next process lifecycle
+    this.processExit = Promise.withResolvers<void>();
+    this.logger.info(`Process reset to idle`);
+  }
+
+  updateDefinition(definition: ProcessDefinition): void {
+    this.definition = definition;
+  }
+
+  async waitForExit(): Promise<ProcessState> {
+    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;
+    }
+
+    this.exitCode = null;
+  }
+}

package/src/logger.ts

@@ -0,0 +1,108 @@
+import { appendFileSync } from "node:fs";
+import { format } from "node:util";
+
+const colors = {
+  reset: "\x1b[0m",
+  gray: "\x1b[90m",
+  white: "\x1b[37m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  bold: "\x1b[1m",
+} as const;
+
+const levelColors = {
+  debug: colors.gray,
+  info: colors.green,
+  warn: colors.yellow,
+  error: colors.red,
+} as const;
+
+const formatTime = (date: Date) =>
+  Intl.DateTimeFormat("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    fractionalSecondDigits: 3,
+    hourCycle: "h23",
+  }).format(date);
+
+const formatPrefixNoColor = (level: string, name: string, time: Date) => {
+  const levelFormatted = level.toUpperCase().padStart(5);
+  const timestamp = formatTime(time);
+  return `[${timestamp}] ${levelFormatted} (${name})`;
+};
+
+const formatPrefixWithColor = (level: string, name: string, time: Date) => {
+  const levelFormatted = level.toUpperCase().padStart(5);
+  const timestamp = formatTime(time);
+  const levelTint = levelColors[level as keyof typeof levelColors] ?? "";
+  return `${colors.gray}[${timestamp}]${colors.reset} ${levelTint}${levelFormatted}${colors.reset} (${name})`;
+};
+
+type LoggerConfig = {
+  name: string;
+  stdout: boolean;
+  logFile?: string;
+};
+
+type LoggerInput = {
+  name: string;
+  stdout?: boolean;
+  logFile?: string;
+};
+
+const writeLogFile = (logFile: string | undefined, line: string) => {
+  if (!logFile) return;
+  appendFileSync(logFile, `${line}\n`);
+};
+
+const logLine = (config: LoggerConfig, level: "debug" | "info" | "warn" | "error", args: any[]) => {
+  const message = args.length > 0 ? format(...args) : "";
+  const time = new Date();
+  const plainPrefix = formatPrefixNoColor(level, config.name, time);
+  const plainLine = `${plainPrefix}  ${message}`;
+
+  writeLogFile(config.logFile, plainLine);
+
+  if (!config.stdout) return;
+  const coloredPrefix = formatPrefixWithColor(level, config.name, time);
+  const coloredLine = `${coloredPrefix}  ${message}`;
+
+  switch (level) {
+    case "error":
+      console.error(coloredLine);
+      break;
+    case "warn":
+      console.warn(coloredLine);
+      break;
+    case "info":
+      console.info(coloredLine);
+      break;
+    default:
+      console.debug(coloredLine);
+      break;
+  }
+};
+
+export const logger = (input: LoggerInput) => {
+  const config: LoggerConfig = {
+    stdout: true,
+    ...input,
+  };
+
+  return {
+    info: (...args: any[]) => logLine(config, "info", args),
+    error: (...args: any[]) => logLine(config, "error", args),
+    warn: (...args: any[]) => logLine(config, "warn", args),
+    debug: (...args: any[]) => logLine(config, "debug", args),
+    child: (suffix: string, overrides: Partial<Omit<LoggerConfig, "name">> = {}) =>
+      logger({
+        ...config,
+        ...overrides,
+        name: `${config.name}:${suffix}`,
+      }),
+  };
+};
+
+export type Logger = ReturnType<typeof logger>;