mesozoic 1.0.0

package/dist/daemon/supervisor.js

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/daemon/supervisor.ts
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+import { createGzip } from "zlib";
+import { pipeline } from "stream/promises";
+var configJson = process.argv[2];
+if (!configJson) {
+  console.error("supervisor: missing config argument");
+  process.exit(1);
+}
+var config = JSON.parse(configJson);
+var RESTART_DELAY_BASE = 3e3;
+var RESTART_DELAY_MAX = 6e4;
+var RESTART_BACKOFF = 1.5;
+var MAX_RESTARTS = 50;
+var RESTART_WINDOW = 36e5;
+var LOG_MAX_BYTES = 10 * 1024 * 1024;
+var LOG_RETAIN = 7;
+var LOG_CHECK_INTERVAL = 6e4;
+var MEMORY_CHECK_INTERVAL = 3e4;
+var KILL_TIMEOUT = 5e3;
+var children = [];
+var shuttingDown = false;
+function ts() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
+}
+function log(msg) {
+  const line = `${ts()} ${msg}
+`;
+  process.stdout.write(line);
+}
+function openLogStream(filePath) {
+  return fs.createWriteStream(filePath, { flags: "a" });
+}
+function pipeWithTimestamp(readable, stream) {
+  let partial = "";
+  readable.on("data", (chunk) => {
+    const text = partial + chunk.toString();
+    const lines = text.split("\n");
+    partial = lines.pop() || "";
+    for (const line of lines) {
+      if (line) stream.write(`${ts()} ${line}
+`);
+    }
+  });
+  readable.on("end", () => {
+    if (partial) stream.write(`${ts()} ${partial}
+`);
+    partial = "";
+  });
+}
+async function rotateLog(filePath) {
+  try {
+    const stat = fs.statSync(filePath);
+    if (stat.size < LOG_MAX_BYTES) return;
+  } catch {
+    return;
+  }
+  for (let i = LOG_RETAIN; i >= 1; i--) {
+    const from = i === 1 ? filePath : `${filePath}.${i - 1}`;
+    const to = `${filePath}.${i}`;
+    try {
+      if (i === LOG_RETAIN) {
+        fs.unlinkSync(`${filePath}.${LOG_RETAIN}`);
+        try {
+          fs.unlinkSync(`${filePath}.${LOG_RETAIN}.gz`);
+        } catch {
+        }
+      }
+      if (fs.existsSync(from)) fs.renameSync(from, to);
+    } catch {
+    }
+  }
+  for (let i = 2; i <= LOG_RETAIN; i++) {
+    const file = `${filePath}.${i}`;
+    if (fs.existsSync(file) && !fs.existsSync(`${file}.gz`)) {
+      try {
+        const src = fs.createReadStream(file);
+        const dest = fs.createWriteStream(`${file}.gz`);
+        await pipeline(src, createGzip(), dest);
+        fs.unlinkSync(file);
+      } catch {
+      }
+    }
+  }
+}
+async function checkLogRotation() {
+  for (const child of children) {
+    const needsOutRotation = needsRotation(child.outPath);
+    const needsErrRotation = needsRotation(child.errPath);
+    if (needsOutRotation) {
+      child.outStream?.end();
+      await rotateLog(child.outPath);
+      child.outStream = openLogStream(child.outPath);
+      if (child.process?.stdout) pipeWithTimestamp(child.process.stdout, child.outStream);
+    }
+    if (needsErrRotation) {
+      child.errStream?.end();
+      await rotateLog(child.errPath);
+      child.errStream = openLogStream(child.errPath);
+      if (child.process?.stderr) pipeWithTimestamp(child.process.stderr, child.errStream);
+    }
+  }
+}
+function needsRotation(filePath) {
+  try {
+    return fs.statSync(filePath).size >= LOG_MAX_BYTES;
+  } catch {
+    return false;
+  }
+}
+function checkMemory() {
+  for (const child of children) {
+    if (!child.config.maxMemoryMB || !child.process || child.status !== "running") continue;
+    const pid = child.process.pid;
+    if (!pid) continue;
+    try {
+      const rssKB = parseInt(
+        __require("child_process").execSync(`ps -o rss= -p ${pid}`, { encoding: "utf-8" }).trim(),
+        10
+      );
+      const rssMB = rssKB / 1024;
+      if (rssMB > child.config.maxMemoryMB) {
+        log(`[${child.config.name}] Memory ${Math.round(rssMB)}MB exceeds limit ${child.config.maxMemoryMB}MB, restarting`);
+        child.process.kill("SIGTERM");
+      }
+    } catch {
+    }
+  }
+}
+function updateStateFile() {
+  try {
+    let state = {};
+    try {
+      state = JSON.parse(fs.readFileSync(config.stateFile, "utf-8"));
+    } catch {
+    }
+    if (!state.agents) state.agents = {};
+    state.agents[config.agentId] = {
+      supervisorPid: process.pid,
+      startedAt,
+      children: Object.fromEntries(
+        children.map((c) => [
+          c.config.name.replace(`meso-${config.agentId}`, "").replace(/^-/, "") || "channel",
+          {
+            pid: c.pid,
+            name: c.config.name,
+            restartCount: c.restartCount,
+            status: c.status,
+            startedAt: c.lastRestartAt ? new Date(c.lastRestartAt).toISOString() : startedAt
+          }
+        ])
+      )
+    };
+    const tmp = config.stateFile + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, config.stateFile);
+  } catch {
+  }
+}
+var startedAt = (/* @__PURE__ */ new Date()).toISOString();
+function getRestartDelay(restartCount) {
+  return Math.min(RESTART_DELAY_BASE * Math.pow(RESTART_BACKOFF, restartCount), RESTART_DELAY_MAX);
+}
+function spawnChild(state) {
+  if (shuttingDown) return;
+  state.outStream = openLogStream(state.outPath);
+  state.errStream = openLogStream(state.errPath);
+  const child = spawn("node", [state.config.script, ...state.config.args], {
+    cwd: config.cwd,
+    env: { ...process.env, ...config.env },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  state.process = child;
+  state.pid = child.pid || 0;
+  state.status = "running";
+  if (child.stdout) pipeWithTimestamp(child.stdout, state.outStream);
+  if (child.stderr) pipeWithTimestamp(child.stderr, state.errStream);
+  log(`[${state.config.name}] Started pid=${state.pid}`);
+  updateStateFile();
+  child.on("exit", (code, signal) => {
+    state.status = "stopped";
+    state.outStream?.end();
+    state.errStream?.end();
+    log(`[${state.config.name}] Exited code=${code} signal=${signal}`);
+    if (shuttingDown) {
+      updateStateFile();
+      return;
+    }
+    const now = Date.now();
+    if (state.firstRestartAt && now - state.firstRestartAt > RESTART_WINDOW) {
+      state.restartCount = 0;
+      state.firstRestartAt = 0;
+    }
+    if (state.restartCount >= MAX_RESTARTS) {
+      log(`[${state.config.name}] Max restarts (${MAX_RESTARTS}) reached, giving up`);
+      state.status = "errored";
+      updateStateFile();
+      return;
+    }
+    state.restartCount++;
+    if (!state.firstRestartAt) state.firstRestartAt = now;
+    state.lastRestartAt = now;
+    const delay = getRestartDelay(state.restartCount - 1);
+    log(`[${state.config.name}] Restarting in ${delay}ms (attempt ${state.restartCount}/${MAX_RESTARTS})`);
+    updateStateFile();
+    setTimeout(() => spawnChild(state), delay);
+  });
+}
+function shutdown(signal) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  log(`Supervisor received ${signal}, shutting down...`);
+  const alive = children.filter((c) => c.process && c.status === "running");
+  for (const child of alive) {
+    try {
+      child.process.kill("SIGTERM");
+    } catch {
+    }
+  }
+  const killTimer = setTimeout(() => {
+    for (const child of alive) {
+      try {
+        child.process.kill("SIGKILL");
+      } catch {
+      }
+    }
+    cleanup();
+  }, KILL_TIMEOUT);
+  let exited = 0;
+  for (const child of alive) {
+    child.process.on("exit", () => {
+      exited++;
+      if (exited >= alive.length) {
+        clearTimeout(killTimer);
+        cleanup();
+      }
+    });
+  }
+  if (alive.length === 0) {
+    clearTimeout(killTimer);
+    cleanup();
+  }
+}
+function cleanup() {
+  try {
+    const state = JSON.parse(fs.readFileSync(config.stateFile, "utf-8"));
+    delete state.agents?.[config.agentId];
+    const tmp = config.stateFile + ".tmp";
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, config.stateFile);
+  } catch {
+  }
+  log("Supervisor exiting.");
+  process.exit(0);
+}
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+process.on("SIGINT", () => shutdown("SIGINT"));
+fs.mkdirSync(config.logsDir, { recursive: true });
+for (const childConfig of config.children) {
+  const role = childConfig.name.replace(`meso-${config.agentId}`, "").replace(/^-/, "") || "channel";
+  const state = {
+    config: childConfig,
+    process: null,
+    pid: 0,
+    restartCount: 0,
+    lastRestartAt: 0,
+    firstRestartAt: 0,
+    status: "stopped",
+    outPath: path.join(config.logsDir, `${role}-out.log`),
+    errPath: path.join(config.logsDir, `${role}-err.log`),
+    outStream: null,
+    errStream: null
+  };
+  children.push(state);
+  spawnChild(state);
+}
+setInterval(() => checkLogRotation().catch(() => {
+}), LOG_CHECK_INTERVAL);
+setInterval(checkMemory, MEMORY_CHECK_INTERVAL);
+log(`Supervisor started for agent=${config.agentId} pid=${process.pid} children=${children.length}`);