pid1 0.0.0-dev.0

package/src/env.ts

@@ -0,0 +1,74 @@
+import { readFileSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { parse } from "dotenv";
+import { globalLogger } from "./logger";
+
+export type EnvFileConfig = {
+  envFile?: string | false;
+};
+
+const logger = globalLogger.child("env");
+
+function loadEnvFile(path: string): Record<string, string> {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(path, "utf-8");
+    const parsed = parse(content);
+    logger.debug(`Loaded env file: ${path}`);
+    return parsed;
+  } catch (error) {
+    logger.warn(`Failed to parse env file ${path}: ${error}`);
+    return {};
+  }
+}
+
+export type LoadEnvOptions = {
+  configDir: string;
+  processName: string;
+  globalEnvFile?: string | false;
+  processEnvFile?: string | false;
+  configEnv?: Record<string, string>;
+};
+
+export function loadEnvForProcess(
+  options: LoadEnvOptions,
+): Record<string, string> {
+  const {
+    configDir,
+    processName,
+    globalEnvFile,
+    processEnvFile,
+    configEnv = {},
+  } = options;
+
+  const baseEnv = Object.fromEntries(
+    Object.entries(process.env).filter(([, value]) => value !== undefined),
+  ) as Record<string, string>;
+
+  let globalEnv: Record<string, string> = {};
+  if (globalEnvFile !== false) {
+    const globalPath = globalEnvFile ?? join(configDir, ".env");
+    globalEnv = loadEnvFile(globalPath);
+  }
+
+  let processEnv: Record<string, string> = {};
+  if (processEnvFile !== false) {
+    const processPath =
+      processEnvFile ?? join(configDir, `.env.${processName}`);
+    processEnv = loadEnvFile(processPath);
+  }
+
+  return {
+    ...baseEnv,
+    ...globalEnv,
+    ...configEnv,
+    ...processEnv,
+  };
+}
+
+export function getConfigDir(configPath: string): string {
+  return dirname(configPath);
+}

package/src/exec.ts

@@ -0,0 +1,85 @@
+import { processLogger } from "./logger";
+import { x } from "tinyexec";
+
+type ExecType = "task" | "process";
+
+type ExecWithLoggingParams = {
+  name: string;
+  command: string;
+  args: string[];
+  env: Record<string, string>;
+  cwd: string;
+  logFile: string;
+  abortSignal?: AbortSignal;
+  type: ExecType;
+};
+
+type TinyExecProcess = ReturnType<typeof x>;
+
+export type SpawnedProcess = {
+  proc: TinyExecProcess;
+  done: Promise<number | null>;
+  kill: (signal?: NodeJS.Signals) => boolean;
+};
+
+export function spawnWithLogging({
+  name,
+  command,
+  args,
+  env,
+  cwd,
+  logFile,
+  abortSignal,
+  type,
+}: ExecWithLoggingParams): SpawnedProcess {
+  const proc = x(command, args, {
+    nodeOptions: { cwd, env },
+    signal: abortSignal,
+    throwOnError: true,
+  });
+
+  const kill = (signal: NodeJS.Signals = "SIGTERM"): boolean => {
+    if (proc.pid) {
+      try {
+        process.kill(proc.pid, signal);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  };
+
+  const done = (async () => {
+    const logger = processLogger({ name: `${type}:${name}`, logFile });
+
+    logger.info(
+      `Starting: command=${command}, args=[${args.join(", ")}], cwd=${cwd}`,
+    );
+
+    for await (const line of proc) {
+      logger.info(line);
+    }
+
+    await proc;
+
+    const exitCode = proc.exitCode;
+
+    if (
+      proc.aborted ||
+      proc.killed ||
+      exitCode === null ||
+      exitCode === undefined
+    ) {
+      logger.info(`${name} was terminated`);
+    } else if (exitCode === 0) {
+      logger.info(`${name} completed successfully`);
+    } else {
+      logger.info(`${name} exited with code ${exitCode}`);
+    }
+
+    return proc.exitCode ?? null;
+  })();
+
+  return { proc, done, kill };
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+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";

package/src/logger.ts

@@ -0,0 +1,155 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+const ANSI_COLORS = {
+  GREEN: "\x1b[32m",
+  CYAN: "\x1b[36m",
+  YELLOW: "\x1b[33m",
+  RED: "\x1b[31m",
+  RESET: "\x1b[0m",
+  BOLD: "\x1b[1m",
+  GRAY: "\x1b[90m",
+};
+
+const COLORS = {
+  debug: (text: string) => `${ANSI_COLORS.GREEN}${text}${ANSI_COLORS.RESET}`,
+  info: (text: string) => `${ANSI_COLORS.CYAN}${text}${ANSI_COLORS.RESET}`,
+  warn: (text: string) => `${ANSI_COLORS.YELLOW}${text}${ANSI_COLORS.RESET}`,
+  error: (text: string) => `${ANSI_COLORS.RED}${text}${ANSI_COLORS.RESET}`,
+  gray: (text: string) => `${ANSI_COLORS.GRAY}${text}${ANSI_COLORS.RESET}`,
+  bold: (text: string) => `${ANSI_COLORS.BOLD}${text}${ANSI_COLORS.RESET}`,
+};
+
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+} as const;
+
+type LogLevel = keyof typeof LOG_LEVELS;
+
+function formatTime() {
+  return Intl.DateTimeFormat("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    timeZone: "UTC",
+    hourCycle: "h23",
+  }).format(new Date());
+}
+
+function formatLevel(level: LogLevel, color: boolean): string {
+  const upper = level.toUpperCase().padStart(5);
+  return color ? `${COLORS[level](upper)}` : upper;
+}
+
+export type LoggerOptions = {
+  name: string;
+  level?: LogLevel;
+  prettyLogFile?: string | null;
+  jsonLogFile?: string | null;
+  stdout?: boolean;
+};
+
+export class Logger {
+  private name: string;
+  private level: number;
+  private prettyLogFile?: string | null;
+  private jsonLogFile?: string | null;
+  private stdout: boolean;
+
+  constructor(options: LoggerOptions) {
+    this.name = options.name;
+    this.level = LOG_LEVELS[options.level ?? "info"];
+    this.prettyLogFile = options.prettyLogFile;
+    this.jsonLogFile = options.jsonLogFile;
+    this.stdout = options.stdout ?? true;
+
+    if (this.prettyLogFile) {
+      mkdirSync(dirname(this.prettyLogFile), { recursive: true });
+    }
+    if (this.jsonLogFile) {
+      mkdirSync(dirname(this.jsonLogFile), { recursive: true });
+    }
+  }
+
+  private log(level: LogLevel, message: string): void {
+    if (LOG_LEVELS[level] < this.level) return;
+
+    const time = formatTime();
+
+    if (this.stdout) {
+      const colorLevel = formatLevel(level, true);
+      console.log(
+        `${COLORS.gray(`[${time}]`)} ${colorLevel} ${COLORS.bold(`(${this.name})`)}  ${message}`,
+      );
+    }
+
+    if (this.prettyLogFile) {
+      const plainLevel = formatLevel(level, false);
+      const line = `[${time}] ${plainLevel} (${this.name})  ${message}\n`;
+      appendFileSync(this.prettyLogFile, line);
+    }
+
+    if (this.jsonLogFile) {
+      const logObj = {
+        time: new Date().toISOString(),
+        level,
+        name: this.name,
+        msg: message,
+      };
+      appendFileSync(this.jsonLogFile, JSON.stringify(logObj) + "\n");
+    }
+  }
+
+  debug(message: string): void {
+    this.log("debug", message);
+  }
+
+  info(message: string): void {
+    this.log("info", message);
+  }
+
+  warn(message: string): void {
+    this.log("warn", message);
+  }
+
+  error(message: string): void {
+    this.log("error", message);
+  }
+
+  child(name: string, options: Partial<LoggerOptions> = {}): Logger {
+    const hasPrettyLogFile = "prettyLogFile" in options;
+    const hasJsonLogFile = "jsonLogFile" in options;
+    const hasStdout = "stdout" in options;
+
+    return new Logger({
+      name: `${this.name}:${name}`,
+      level: options.level ?? (Object.keys(LOG_LEVELS)[this.level] as LogLevel),
+      prettyLogFile: hasPrettyLogFile ? options.prettyLogFile : this.prettyLogFile,
+      jsonLogFile: hasJsonLogFile ? options.jsonLogFile : this.jsonLogFile,
+      stdout: hasStdout ? options.stdout : this.stdout,
+    });
+  }
+}
+
+mkdirSync("logs", { recursive: true });
+export const globalLogger = new Logger({
+  name: "pid1",
+  level: "debug",
+  jsonLogFile: "logs/pid1.log",
+});
+
+type ProcessLoggerParams = {
+  name: string;
+  logFile: string;
+};
+
+export function processLogger({ name, logFile }: ProcessLoggerParams): Logger {
+  mkdirSync(dirname(logFile), { recursive: true });
+  return globalLogger.child(name, {
+    prettyLogFile: logFile,
+    jsonLogFile: null,
+  });
+}