pidnap 0.0.0-dev.0

package/src/cron-process.ts

@@ -0,0 +1,255 @@
+import { Cron } from "croner";
+import * as v from "valibot";
+import { LazyProcess, type ProcessDefinition } from "./lazy-process.ts";
+import type { Logger } from "./logger.ts";
+
+// Retry configuration schema
+export const RetryConfigSchema = v.object({
+  maxRetries: v.number(),
+  delayMs: v.optional(v.number()),
+});
+
+export type RetryConfig = v.InferOutput<typeof RetryConfigSchema>;
+
+// Cron process options schema
+export const CronProcessOptionsSchema = v.object({
+  schedule: v.string(),
+  retry: v.optional(RetryConfigSchema),
+  runOnStart: v.optional(v.boolean()),
+});
+
+export type CronProcessOptions = v.InferOutput<typeof CronProcessOptionsSchema>;
+
+// State
+export const CronProcessStateSchema = v.picklist([
+  "idle",
+  "scheduled",
+  "running",
+  "retrying",
+  "queued",
+  "stopping",
+  "stopped",
+]);
+
+export type CronProcessState = v.InferOutput<typeof CronProcessStateSchema>;
+
+const DEFAULT_RETRY_DELAY = 1000;
+
+export class CronProcess {
+  readonly name: string;
+  private lazyProcess: LazyProcess;
+  private options: CronProcessOptions;
+  private logger: Logger;
+  private cronJob: Cron | null = null;
+
+  // State tracking
+  private _state: CronProcessState = "idle";
+  private _runCount: number = 0;
+  private _failCount: number = 0;
+  private currentRetryAttempt: number = 0;
+  private queuedRun: boolean = false;
+  private stopRequested: boolean = false;
+  private retryTimeout: ReturnType<typeof setTimeout> | null = null;
+
+  constructor(
+    name: string,
+    definition: ProcessDefinition,
+    options: CronProcessOptions,
+    logger: Logger,
+  ) {
+    this.name = name;
+    this.options = options;
+    this.logger = logger;
+    this.lazyProcess = new LazyProcess(name, definition, logger);
+  }
+
+  get state(): CronProcessState {
+    return this._state;
+  }
+
+  get runCount(): number {
+    return this._runCount;
+  }
+
+  get failCount(): number {
+    return this._failCount;
+  }
+
+  get nextRun(): Date | null {
+    if (!this.cronJob) return null;
+    const next = this.cronJob.nextRun();
+    return next ?? null;
+  }
+
+  start(): void {
+    if (this._state === "scheduled" || this._state === "running" || this._state === "queued") {
+      throw new Error(`CronProcess "${this.name}" is already ${this._state}`);
+    }
+
+    if (this._state === "stopping") {
+      throw new Error(`CronProcess "${this.name}" is currently stopping`);
+    }
+
+    this.stopRequested = false;
+    this.logger.info(`Starting cron schedule: ${this.options.schedule}`);
+
+    // Create cron job with UTC timezone
+    this.cronJob = new Cron(this.options.schedule, { timezone: "UTC" }, () => {
+      this.onCronTick();
+    });
+
+    this._state = "scheduled";
+
+    // Run immediately if configured
+    if (this.options.runOnStart) {
+      this.executeJob();
+    }
+  }
+
+  async stop(timeout?: number): Promise<void> {
+    this.stopRequested = true;
+
+    // Stop the cron job
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.cronJob = null;
+    }
+
+    // Clear any pending retry timeout
+    if (this.retryTimeout) {
+      clearTimeout(this.retryTimeout);
+      this.retryTimeout = null;
+    }
+
+    if (this._state === "idle" || this._state === "stopped") {
+      this._state = "stopped";
+      return;
+    }
+
+    // If running, stop the current job
+    if (this._state === "running" || this._state === "retrying" || this._state === "queued") {
+      this._state = "stopping";
+      await this.lazyProcess.stop(timeout);
+    }
+
+    this._state = "stopped";
+    this.queuedRun = false;
+    this.logger.info(`CronProcess stopped`);
+  }
+
+  async trigger(): Promise<void> {
+    if (this.stopRequested) {
+      throw new Error(`CronProcess "${this.name}" is stopped`);
+    }
+
+    // If already queued, just return (already have a run pending)
+    if (this._state === "queued") {
+      return;
+    }
+
+    // If already running, queue this trigger
+    if (this._state === "running" || this._state === "retrying") {
+      this.queuedRun = true;
+      this._state = "queued";
+      this.logger.info(`Run queued (current job still running)`);
+      return;
+    }
+
+    await this.executeJob();
+  }
+
+  private onCronTick(): void {
+    if (this.stopRequested) return;
+
+    // If already running, queue the next run
+    if (this._state === "running" || this._state === "retrying" || this._state === "queued") {
+      this.queuedRun = true;
+      if (this._state !== "queued") {
+        this._state = "queued";
+      }
+      this.logger.info(`Cron tick: run queued (current job still running)`);
+      return;
+    }
+
+    this.executeJob();
+  }
+
+  private async executeJob(): Promise<void> {
+    if (this.stopRequested) return;
+
+    this._state = "running";
+    this.currentRetryAttempt = 0;
+    this.logger.info(`Executing job`);
+
+    await this.runJobWithRetry();
+  }
+
+  private async runJobWithRetry(): Promise<void> {
+    if (this.stopRequested) return;
+
+    // Reset and start the process
+    await this.lazyProcess.reset();
+    this.lazyProcess.start();
+
+    const exitState = await this.lazyProcess.waitForExit();
+    if (this.stopRequested && exitState === "error") {
+      this._state = "stopped";
+      return;
+    }
+    this.handleJobComplete(exitState === "error");
+  }
+
+  private handleJobComplete(failed: boolean): void {
+    if (this.stopRequested) {
+      this._state = "stopped";
+      return;
+    }
+
+    if (failed) {
+      const maxRetries = this.options.retry?.maxRetries ?? 0;
+
+      if (this.currentRetryAttempt < maxRetries) {
+        // Retry
+        this.currentRetryAttempt++;
+        this._state = "retrying";
+        const delayMs = this.options.retry?.delayMs ?? DEFAULT_RETRY_DELAY;
+
+        this.logger.warn(
+          `Job failed, retrying in ${delayMs}ms (attempt ${this.currentRetryAttempt}/${maxRetries})`,
+        );
+
+        this.retryTimeout = setTimeout(() => {
+          this.retryTimeout = null;
+          if (this.stopRequested) {
+            this._state = "stopped";
+            return;
+          }
+          this.runJobWithRetry();
+        }, delayMs);
+        return;
+      }
+
+      // All retries exhausted
+      this._failCount++;
+      this.logger.error(`Job failed after ${this.currentRetryAttempt} retries`);
+    } else {
+      this._runCount++;
+      this.logger.info(`Job completed successfully`);
+    }
+
+    // Check for queued run
+    if (this.queuedRun) {
+      this.queuedRun = false;
+      this.logger.info(`Starting queued run`);
+      this.executeJob();
+      return;
+    }
+
+    // Back to scheduled state
+    if (this.cronJob) {
+      this._state = "scheduled";
+    } else {
+      this._state = "stopped";
+    }
+  }
+}

package/src/env-manager.ts

@@ -0,0 +1,237 @@
+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";
+
+export type EnvChangeCallback = (changedKeys: string[]) => void;
+
+export interface EnvManagerConfig {
+  /**
+   * Directory to search for .env files
+   * Defaults to process.cwd()
+   */
+  cwd?: 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>;
+
+  /**
+   * Enable file watching for env files
+   * Defaults to false
+   */
+  watch?: boolean;
+}
+
+export class EnvManager {
+  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 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
+    this.loadEnvFilesFromCwd();
+
+    // Load explicitly specified files
+    if (config.files) {
+      for (const [key, filePath] of Object.entries(config.files)) {
+        this.loadEnvFile(key, filePath);
+      }
+    }
+  }
+
+  registerFile(key: string, filePath: string): void {
+    this.loadEnvFile(key, filePath);
+  }
+
+  getEnvForKey(key: string): Record<string, string> {
+    return this.env.get(key) ?? {};
+  }
+
+  /**
+   * Load .env and .env.* files from the cwd
+   */
+  private loadEnvFilesFromCwd(): void {
+    // Load .env file as global
+    const dotEnvPath = resolve(this.cwd, ".env");
+    if (existsSync(dotEnvPath)) {
+      this.loadEnvFile("global", dotEnvPath);
+    }
+
+    // Load .env.* files
+    try {
+      const pattern = join(this.cwd, ".env.*");
+      const envFiles = globSync(pattern);
+
+      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);
+        }
+      }
+    } catch (err) {
+      console.warn("Failed to scan env files:", err);
+    }
+  }
+
+  /**
+   * 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
+    }
+
+    try {
+      const content = readFileSync(absolutePath, "utf-8");
+      const parsed = parse(content);
+      this.env.set(key, parsed);
+
+      // Track which file maps to which key
+      if (!this.fileToKeys.has(absolutePath)) {
+        this.fileToKeys.set(absolutePath, new Set());
+      }
+      this.fileToKeys.get(absolutePath)!.add(key);
+
+      // 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);
+    }
+  }
+
+  /**
+   * Watch a file for changes
+   */
+  private watchFile(absolutePath: string): void {
+    try {
+      const watcher = watch(absolutePath, (eventType) => {
+        if (eventType === "change") {
+          this.handleFileChange(absolutePath);
+        }
+      });
+
+      this.watchers.set(absolutePath, watcher);
+    } catch (err) {
+      console.warn(`Failed to watch env file: ${absolutePath}`, err);
+    }
+  }
+
+  /**
+   * Handle file change with debouncing
+   */
+  private handleFileChange(absolutePath: string): void {
+    // Clear existing timer if any
+    const existingTimer = this.reloadDebounceTimers.get(absolutePath);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+
+    // Debounce reload by 100ms to avoid multiple rapid reloads
+    const timer = setTimeout(() => {
+      this.reloadFile(absolutePath);
+      this.reloadDebounceTimers.delete(absolutePath);
+    }, 100);
+
+    this.reloadDebounceTimers.set(absolutePath, timer);
+  }
+
+  /**
+   * 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);
+        }
+
+        // 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);
+      });
+  }
+
+  /**
+   * 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 () => {
+      this.changeCallbacks.delete(callback);
+    };
+  }
+
+  /**
+   * 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
+    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 };
+    }
+
+    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;
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import type { ManagerConfig } from "./manager.ts";
+
+export function defineConfig(config: ManagerConfig) {
+  return config;
+}
+
+export * from "./restarting-process.ts";
+export * from "./cron-process.ts";
+export * from "./task-list.ts";
+export * from "./lazy-process.ts";
+export * from "./env-manager.ts";
+export * from "./logger.ts";