pid1 0.0.0-dev.0 → 0.0.0-dev.3

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

@@ -1,14 +1,12 @@
-export {
-  ProcessManager,
-  type ProcessManagerOptions,
-  type ProcessStatus,
-  type ProcessConfig,
-  type ManagedProcess,
-  type ProcessInfo,
-} from "./process-manager.ts";
-export { defineConfig, loadConfigFile } from "./config.ts";
-export { globalLogger } from "./logger.ts";
-export { spawnWithLogging, type SpawnedProcess } from "./exec.ts";
-export { createServer, type ServerOptions, type Router } from "./api/server.ts";
-export { createClient, type Client, type ClientOptions } from "./api/client.ts";
-export { router } from "./api/router.ts";
+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";

package/src/lazy-process.ts

@@ -0,0 +1,198 @@
+import { x, type Result } from "tinyexec";
+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>;
+
+export class LazyProcess {
+  readonly name: string;
+  private definition: ProcessDefinition;
+  private logger: Logger;
+  private process: Result | null = null;
+  private _state: ProcessState = "idle";
+  private outputLoopPromise: Promise<void> | null = null;
+  private donePromise: Promise<ProcessState> | 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 {
+      this.process = x(this.definition.command, this.definition.args ?? [], {
+        nodeOptions: {
+          cwd: this.definition.cwd,
+          env: this.definition.env ? { ...process.env, ...this.definition.env } : undefined,
+        },
+      });
+
+      this._state = "running";
+
+      // Start async output logging loop
+      this.outputLoopPromise = this.logOutput();
+
+      // Handle process completion
+      this.donePromise = Promise.resolve(this.process)
+        .then((result) => {
+          if (this._state === "running") {
+            if (result.exitCode === 0) {
+              this._state = "stopped";
+              this.logger.info(`Process exited with code ${result.exitCode}`);
+            } else {
+              this._state = "error";
+              this.logger.error(`Process exited with code ${result.exitCode}`);
+            }
+          }
+          return this._state;
+        })
+        .catch((err) => {
+          if (this._state !== "stopping" && this._state !== "stopped") {
+            this._state = "error";
+            this.logger.error(`Process error:`, err);
+          }
+          return this._state;
+        });
+    } 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.waitForStop();
+      return;
+    }
+
+    if (!this.process) {
+      this._state = "stopped";
+      return;
+    }
+
+    this._state = "stopping";
+    this.logger.info(`Stopping process with SIGTERM`);
+
+    // Send SIGTERM for graceful shutdown
+    this.process.kill("SIGTERM");
+
+    const timeoutMs = timeout ?? 5000;
+
+    // Wait for process to exit or timeout
+    // Wrap PromiseLike in Promise.resolve to get proper Promise with .catch()
+    const exitPromise = Promise.resolve(this.process).catch(() => {});
+
+    const timeoutPromise = new Promise<"timeout">((resolve) =>
+      setTimeout(() => resolve("timeout"), timeoutMs),
+    );
+
+    const result = await Promise.race([exitPromise.then(() => "exited" as const), timeoutPromise]);
+
+    if (result === "timeout") {
+      this.logger.warn(`Process did not exit within ${timeoutMs}ms, sending SIGKILL`);
+      this.process.kill("SIGKILL");
+      await Promise.resolve(this.process).catch(() => {});
+    }
+
+    // Wait for output loop to finish
+    if (this.outputLoopPromise) {
+      await this.outputLoopPromise.catch(() => {});
+    }
+
+    this._state = "stopped";
+    this.process = null;
+    this.outputLoopPromise = null;
+    this.logger.info(`Process stopped`);
+  }
+
+  async reset(): Promise<void> {
+    if (this._state !== "idle" && this._state !== "stopped") {
+      await this.stop();
+    }
+
+    this._state = "idle";
+    this.process = null;
+    this.outputLoopPromise = null;
+    this.donePromise = null;
+    this.logger.info(`Process reset to idle`);
+  }
+
+  updateDefinition(definition: ProcessDefinition): void {
+    this.definition = definition;
+  }
+
+  async waitForExit(): Promise<ProcessState> {
+    if (!this.process || !this.donePromise) {
+      return this._state;
+    }
+
+    await this.donePromise.catch(() => {});
+
+    if (this.outputLoopPromise) {
+      await this.outputLoopPromise.catch(() => {});
+    }
+
+    return this._state;
+  }
+
+  private async logOutput(): Promise<void> {
+    if (!this.process) return;
+
+    try {
+      for await (const line of this.process) {
+        this.logger.info(line);
+      }
+    } catch {
+      // Process may have been killed, ignore iteration errors
+    }
+  }
+
+  private async waitForStop(): Promise<void> {
+    if (this.process) {
+      await Promise.resolve(this.process).catch(() => {});
+    }
+    if (this.outputLoopPromise) {
+      await this.outputLoopPromise.catch(() => {});
+    }
+  }
+}