@virtengine/openfleet 0.25.0

package/update-check.mjs

@@ -0,0 +1,465 @@
+/**
+ * update-check.mjs — Self-updating system for openfleet.
+ *
+ * Capabilities:
+ *   - `checkForUpdate(currentVersion)` — non-blocking startup check, prints notice
+ *   - `forceUpdate(currentVersion)` — interactive `npm install -g` with confirmation
+ *   - `startAutoUpdateLoop(opts)` — background polling loop (default 10 min) that
+ *       auto-installs updates and restarts the process. Zero user interaction.
+ *
+ * Respects:
+ *   - CODEX_MONITOR_SKIP_UPDATE_CHECK=1 — disable startup check
+ *   - CODEX_MONITOR_SKIP_AUTO_UPDATE=1 — disable polling auto-update
+ *   - CODEX_MONITOR_UPDATE_INTERVAL_MS — override poll interval (default 10 min)
+ *   - Caches the last check timestamp so we don't query npm too aggressively
+ */
+
+import { execFileSync } from "node:child_process";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_NAME = "@virtengine/openfleet";
+const CACHE_FILE = resolve(__dirname, "logs", ".update-check-cache.json");
+const STARTUP_CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 hour (startup notice)
+const AUTO_UPDATE_INTERVAL_MS = 10 * 60 * 1000; // 10 minutes (polling loop)
+
+function runNpmCommand(args, options = {}) {
+  const npmExecPath = process.env.npm_execpath;
+  if (npmExecPath && existsSync(npmExecPath)) {
+    return execFileSync(process.execPath, [npmExecPath, ...args], options);
+  }
+
+  const nodeBinDir = dirname(process.execPath);
+  const candidates =
+    process.platform === "win32"
+      ? [
+          join(nodeBinDir, "npm.cmd"),
+          join(nodeBinDir, "npm.exe"),
+          join(nodeBinDir, "npm"),
+        ]
+      : [join(nodeBinDir, "npm")];
+
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return execFileSync(candidate, args, options);
+    }
+  }
+
+  const fallback = process.platform === "win32" ? "npm.cmd" : "npm";
+  return execFileSync(fallback, args, options);
+}
+
+// ── Semver comparison ────────────────────────────────────────────────────────
+
+function parseVersion(v) {
+  const parts = v.replace(/^v/, "").split(".").map(Number);
+  return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 };
+}
+
+function isNewer(remote, local) {
+  const r = parseVersion(remote);
+  const l = parseVersion(local);
+  if (r.major !== l.major) return r.major > l.major;
+  if (r.minor !== l.minor) return r.minor > l.minor;
+  return r.patch > l.patch;
+}
+
+// ── Cache ────────────────────────────────────────────────────────────────────
+
+async function readCache() {
+  try {
+    const raw = await readFile(CACHE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+async function writeCache(data) {
+  try {
+    await mkdir(dirname(CACHE_FILE), { recursive: true });
+    await writeFile(CACHE_FILE, JSON.stringify(data, null, 2));
+  } catch {
+    // non-critical
+  }
+}
+
+// ── Registry query ───────────────────────────────────────────────────────────
+
+async function fetchLatestVersion() {
+  // Try native fetch (Node 18+), fall back to npm view
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${PKG_NAME}/latest`, {
+      headers: { Accept: "application/json" },
+      signal: AbortSignal.timeout(10000),
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return data.version || null;
+    }
+  } catch {
+    // fetch failed, try npm view
+  }
+
+  try {
+    const out = runNpmCommand(["view", PKG_NAME, "version"], {
+      encoding: "utf8",
+      timeout: 15000,
+      stdio: ["pipe", "pipe", "ignore"],
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Non-blocking update check. Prints a notice if an update is available.
+ * Called on startup — must never throw or delay the main process.
+ */
+export async function checkForUpdate(currentVersion) {
+  if (process.env.CODEX_MONITOR_SKIP_UPDATE_CHECK) return;
+
+  try {
+    // Rate-limit: at most once per hour
+    const cache = await readCache();
+    const now = Date.now();
+    if (cache.lastCheck && now - cache.lastCheck < STARTUP_CHECK_INTERVAL_MS) {
+      // Use cached result if still fresh
+      if (cache.latestVersion && isNewer(cache.latestVersion, currentVersion)) {
+        printUpdateNotice(currentVersion, cache.latestVersion);
+      }
+      return;
+    }
+
+    const latest = await fetchLatestVersion();
+    await writeCache({ lastCheck: now, latestVersion: latest });
+
+    if (latest && isNewer(latest, currentVersion)) {
+      printUpdateNotice(currentVersion, latest);
+    }
+  } catch {
+    // Silent — never interfere with startup
+  }
+}
+
+/**
+ * Force-update to the latest version.
+ * Prompts for confirmation, then runs npm install -g.
+ */
+export async function forceUpdate(currentVersion) {
+  console.log(`\n  Current version: v${currentVersion}`);
+  console.log("  Checking npm registry...\n");
+
+  const latest = await fetchLatestVersion();
+
+  if (!latest) {
+    console.log("  ❌ Could not reach npm registry. Check your connection.\n");
+    return;
+  }
+
+  if (!isNewer(latest, currentVersion)) {
+    console.log(`  ✅ Already up to date (v${currentVersion})\n`);
+    return;
+  }
+
+  console.log(`  📦 Update available: v${currentVersion} → v${latest}\n`);
+
+  const confirmed = await promptConfirm("  Install update now? [Y/n]: ");
+
+  if (!confirmed) {
+    console.log("  Skipped.\n");
+    return;
+  }
+
+  console.log(`\n  Installing ${PKG_NAME}@${latest}...\n`);
+
+  try {
+    runNpmCommand(["install", "-g", `${PKG_NAME}@${latest}`], {
+      stdio: "inherit",
+      timeout: 120000,
+    });
+    console.log(
+      `\n  ✅ Updated to v${latest}. Restart openfleet to use the new version.\n`,
+    );
+  } catch (err) {
+    console.error(`\n  ❌ Update failed: ${err.message}`);
+    console.error(`  Try manually: npm install -g ${PKG_NAME}@latest\n`);
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Read the current version from package.json (on-disk, not cached import).
+ * After an auto-update, the on-disk package.json reflects the new version.
+ */
+export function getCurrentVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(resolve(__dirname, "package.json"), "utf8"),
+    );
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+
+// ── Auto-update polling loop ─────────────────────────────────────────────────
+
+let autoUpdateTimer = null;
+let autoUpdateRunning = false;
+let parentPid = null;
+let parentCheckInterval = null;
+let cleanupHandlersRegistered = false;
+
+/**
+ * Start a background polling loop that checks for updates every `intervalMs`
+ * (default 10 min). When a newer version is found, it:
+ *   1. Runs `npm install -g @virtengine/openfleet@<version>`
+ *   2. Calls `onRestart()` (or `process.exit(0)` if not provided)
+ *
+ * This is fully autonomous — no user interaction required.
+ *
+ * Safety features to prevent zombie processes:
+ *   - Monitors parent process health (terminates if parent dies)
+ *   - Registers cleanup handlers for SIGTERM, SIGINT, SIGHUP
+ *   - Cleans up intervals on process exit or uncaught exceptions
+ *   - Periodic parent health check every 30 seconds
+ *
+ * @param {object} opts
+ * @param {function} [opts.onRestart] - Called after successful update (should restart process)
+ * @param {function} [opts.onNotify]  - Called with message string for Telegram/log
+ * @param {number}   [opts.intervalMs] - Poll interval (default: 10 min)
+ * @param {number}   [opts.parentPid]  - Parent process PID to monitor (default: process.ppid)
+ */
+export function startAutoUpdateLoop(opts = {}) {
+  if (process.env.CODEX_MONITOR_SKIP_AUTO_UPDATE === "1") {
+    console.log("[auto-update] Disabled via CODEX_MONITOR_SKIP_AUTO_UPDATE=1");
+    return;
+  }
+
+  const intervalMs =
+    Number(process.env.CODEX_MONITOR_UPDATE_INTERVAL_MS) ||
+    opts.intervalMs ||
+    AUTO_UPDATE_INTERVAL_MS;
+  const onRestart = opts.onRestart || (() => process.exit(0));
+  const onNotify = opts.onNotify || ((msg) => console.log(msg));
+
+  // Register cleanup handlers to prevent zombie processes
+  registerCleanupHandlers();
+
+  // Track parent process if provided
+  if (opts.parentPid) {
+    parentPid = opts.parentPid;
+    console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+  } else {
+    parentPid = process.ppid; // Track parent by default
+    console.log(`[auto-update] Monitoring parent process PID ${parentPid}`);
+  }
+
+  console.log(
+    `[auto-update] Polling every ${Math.round(intervalMs / 1000 / 60)} min for upstream changes`,
+  );
+
+  async function poll() {
+    // Safety check: Is parent process still alive?
+    if (!isParentAlive()) {
+      console.log(
+        `[auto-update] Parent process ${parentPid} no longer exists. Terminating.`,
+      );
+      stopAutoUpdateLoop();
+      process.exit(0);
+    }
+
+    if (autoUpdateRunning) return;
+    autoUpdateRunning = true;
+    try {
+      const currentVersion = getCurrentVersion();
+      const latest = await fetchLatestVersion();
+
+      if (!latest) {
+        autoUpdateRunning = false;
+        return; // registry unreachable — try again next cycle
+      }
+
+      if (!isNewer(latest, currentVersion)) {
+        autoUpdateRunning = false;
+        return; // already up to date
+      }
+
+      // ── Update detected! ──────────────────────────────────────────────
+      const msg = `[auto-update] 🔄 Update detected: v${currentVersion} → v${latest}. Installing...`;
+      console.log(msg);
+      onNotify(msg);
+
+      try {
+        runNpmCommand(["install", "-g", `${PKG_NAME}@${latest}`], {
+          timeout: 180000,
+          stdio: ["pipe", "pipe", "pipe"],
+        });
+      } catch (installErr) {
+        const errMsg = `[auto-update] ❌ Install failed: ${installErr.message || installErr}`;
+        console.error(errMsg);
+        onNotify(errMsg);
+        autoUpdateRunning = false;
+        return;
+      }
+
+      // Verify the install actually changed the on-disk version
+      const newVersion = getCurrentVersion();
+      if (!isNewer(newVersion, currentVersion) && newVersion !== latest) {
+        const errMsg = `[auto-update] ⚠️ Install ran but version unchanged (${newVersion}). Skipping restart.`;
+        console.warn(errMsg);
+        onNotify(errMsg);
+        autoUpdateRunning = false;
+        return;
+      }
+
+      await writeCache({ lastCheck: Date.now(), latestVersion: latest });
+
+      const successMsg = `[auto-update] ✅ Updated to v${latest}. Restarting...`;
+      console.log(successMsg);
+      onNotify(successMsg);
+
+      // Give Telegram a moment to deliver the notification
+      await new Promise((r) => setTimeout(r, 2000));
+
+      onRestart(`auto-update v${currentVersion} → v${latest}`);
+    } catch (err) {
+      console.warn(`[auto-update] Poll error: ${err.message || err}`);
+    } finally {
+      autoUpdateRunning = false;
+    }
+  }
+
+  // Set up parent health check (every 30s)
+  if (parentPid) {
+    parentCheckInterval = setInterval(() => {
+      if (!isParentAlive()) {
+        console.log(`[auto-update] Parent process ${parentPid} died. Exiting.`);
+        stopAutoUpdateLoop();
+        process.exit(0);
+      }
+    }, 30 * 1000);
+  }
+
+  // First poll after 60s (let startup settle), then every intervalMs
+  setTimeout(() => {
+    void poll();
+    autoUpdateTimer = setInterval(() => void poll(), intervalMs);
+  }, 60 * 1000);
+}
+
+/**
+ * Stop the auto-update polling loop (for clean shutdown).
+ */
+export function stopAutoUpdateLoop() {
+  if (autoUpdateTimer) {
+    clearInterval(autoUpdateTimer);
+    autoUpdateTimer = null;
+  }
+  if (parentCheckInterval) {
+    clearInterval(parentCheckInterval);
+    parentCheckInterval = null;
+  }
+  parentPid = null;
+}
+
+/**
+ * Check if parent process is still alive.
+ * If parent dies, this child polling loop should terminate too.
+ */
+function isParentAlive() {
+  if (!parentPid) return true; // No parent tracking configured
+  try {
+    // On Windows and Unix, kill(pid, 0) checks if process exists without sending signal
+    process.kill(parentPid, 0);
+    return true;
+  } catch (err) {
+    // ESRCH = no such process
+    if (err.code === "ESRCH") {
+      return false;
+    }
+    // Other errors (EPERM) mean process exists but we can't signal it
+    return true;
+  }
+}
+
+/**
+ * Register cleanup handlers to prevent zombie processes.
+ */
+function registerCleanupHandlers() {
+  if (cleanupHandlersRegistered) return;
+  cleanupHandlersRegistered = true;
+
+  const cleanup = (signal) => {
+    console.log(`[auto-update] Received ${signal}, cleaning up...`);
+    stopAutoUpdateLoop();
+    // Don't call process.exit() - let the signal handler chain continue
+  };
+
+  // Handle graceful shutdown signals
+  process.on("SIGTERM", () => cleanup("SIGTERM"));
+  process.on("SIGINT", () => cleanup("SIGINT"));
+  process.on("SIGHUP", () => cleanup("SIGHUP"));
+
+  // Handle process exit
+  process.on("exit", () => {
+    stopAutoUpdateLoop();
+  });
+
+  // Handle uncaught exceptions (last resort)
+  const originalUncaughtException = process.listeners("uncaughtException");
+  process.on("uncaughtException", (err) => {
+    console.error(`[auto-update] Uncaught exception, cleaning up:`, err);
+    stopAutoUpdateLoop();
+    // Re-emit for other handlers
+    if (originalUncaughtException.length > 0) {
+      for (const handler of originalUncaughtException) {
+        handler(err);
+      }
+    }
+  });
+}
+
+function printUpdateNotice(current, latest) {
+  console.log("");
+  console.log("  ╭──────────────────────────────────────────────────────────╮");
+  console.log(
+    `  │  Update available: v${current} → v${latest}${" ".repeat(Math.max(0, 38 - current.length - latest.length))}│`,
+  );
+  console.log("  │                                                          │");
+  console.log(`  │  Run: npm install -g ${PKG_NAME}@latest      │`);
+  console.log("  │  Or:  openfleet --update                             │");
+  console.log("  ╰──────────────────────────────────────────────────────────╯");
+  console.log("");
+}
+
+function promptConfirm(question) {
+  return new Promise((res) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: process.stdin.isTTY && process.stdout.isTTY,
+    });
+    rl.question(question, (answer) => {
+      try {
+        rl.close();
+      } catch (err) {
+        const msg = err?.message || String(err || "");
+        if (!msg.includes("setRawMode EIO")) {
+          throw err;
+        }
+      }
+      const a = answer.trim().toLowerCase();
+      res(!a || a === "y" || a === "yes");
+    });
+  });
+}

package/utils.mjs

@@ -0,0 +1,172 @@
+/**
+ * Pure utility functions for openfleet
+ * Extracted for unit testing (no I/O, no side effects)
+ */
+
+/**
+ * Normalize text for deduplication by stripping timestamps and IDs
+ * @param {string} text - Input text to normalize
+ * @returns {string} Normalized text with numbers replaced by N
+ */
+export function normalizeDedupKey(text) {
+  return (
+    String(text || "")
+      .trim()
+      // Replace numbers (integers and decimals) with N, preserving surrounding text
+      .replaceAll(/\d+(\.\d+)?/g, "N")
+      // Collapse any resulting multi-N sequences (e.g., "N.N" → "N")
+      .replaceAll(/N[.\-/:]N/g, "N")
+      // Collapse whitespace
+      .replaceAll(/\s+/g, " ")
+  );
+}
+
+/**
+ * Strip ANSI escape codes from text
+ * PowerShell and colored CLI output includes \x1b[...m sequences that show
+ * as garbage in Telegram messages.
+ * @param {string} text - Input text with potential ANSI codes
+ * @returns {string} Clean text without ANSI codes
+ */
+export function stripAnsi(text) {
+  // eslint-disable-next-line no-control-regex
+  return String(text || "")
+    .replace(/\x1b\[[0-9;]*m/g, "")
+    .replace(/\[\d+;?\d*m/g, "");
+}
+
+/**
+ * Check if a line mentions "error" in a benign/summary context
+ * (e.g. "errors=0", "0 errors", "no errors found").
+ * Shared by isErrorLine() and autofix fallback to avoid false positives.
+ * @param {string} line - Log line to check
+ * @returns {boolean} True if the "error" mention is benign
+ */
+export function isBenignErrorMention(line) {
+  const benign = [
+    /errors?[=:]\s*0\b/i,
+    /\b0\s+errors?\b/i,
+    /\bno\s+errors?\b/i,
+    /\bcomplete\b.*\berrors?[=:]\s*0/i,
+    /\bpassed\b.*\berrors?\b/i,
+    /\bclean\b.*\berrors?\b/i,
+    /\bsuccess\b.*\berrors?\b/i,
+    /errors?\s*(count|total|sum|rate)\s*[=:]\s*0/i,
+  ];
+  return benign.some((rx) => rx.test(line));
+}
+
+/**
+ * Check if a line matches error patterns (excluding noise patterns)
+ * @param {string} line - Log line to check
+ * @param {RegExp[]} errorPatterns - Patterns that indicate errors
+ * @param {RegExp[]} errorNoisePatterns - Patterns to exclude from error detection
+ * @returns {boolean} True if line is an error
+ */
+export function isErrorLine(line, errorPatterns, errorNoisePatterns) {
+  if (errorNoisePatterns.some((pattern) => pattern.test(line))) {
+    return false;
+  }
+  if (isBenignErrorMention(line)) {
+    return false;
+  }
+  return errorPatterns.some((pattern) => pattern.test(line));
+}
+
+/**
+ * Escape HTML special characters
+ * @param {any} value - Value to escape
+ * @returns {string} HTML-escaped string
+ */
+export function escapeHtml(value) {
+  return String(value)
+    .replace(/&/g, "&")
+    .replace(/"/g, """)
+    .replace(/'/g, "'")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;");
+}
+
+/**
+ * Format an HTML link with proper escaping
+ * @param {string} url - URL for the link
+ * @param {string} label - Display text for the link
+ * @returns {string} HTML anchor tag or escaped label if no URL
+ */
+export function formatHtmlLink(url, label) {
+  if (!url) {
+    return escapeHtml(label);
+  }
+  return `<a href="${escapeHtml(url)}">${escapeHtml(label)}</a>`;
+}
+
+/**
+ * Generate a normalized fingerprint for an error line (for deduplication)
+ * Strips timestamps, attempt IDs, and branch-specific parts
+ * @param {string} line - Error line to fingerprint
+ * @returns {string} Normalized fingerprint
+ */
+export function getErrorFingerprint(line) {
+  // Normalize: strip timestamps, attempt IDs, branch-specific parts
+  return line
+    .replace(/\[\d{2}:\d{2}:\d{2}\]\s*/g, "")
+    .replace(/\b[0-9a-f]{8}\b/gi, "<ID>") // attempt IDs
+    .replace(/ve\/[\w.-]+/g, "ve/<BRANCH>") // branch names
+    .trim();
+}
+
+/**
+ * Parse -MaxParallel argument from command line arguments
+ * Supports: -MaxParallel N, --maxparallel=N, --max-parallel N
+ * Falls back to VK_MAX_PARALLEL or MAX_PARALLEL env vars
+ * @param {string[]} argsList - Command line arguments array
+ * @returns {number|null} Maximum parallel value or null if not found
+ */
+export function getMaxParallelFromArgs(argsList) {
+  if (!Array.isArray(argsList)) {
+    return null;
+  }
+  for (let i = 0; i < argsList.length; i += 1) {
+    const arg = String(argsList[i] ?? "");
+    const directMatch =
+      arg.match(/^-{1,2}maxparallel(?:=|:)?(\d+)$/i) ||
+      arg.match(/^--max-parallel(?:=|:)?(\d+)$/i);
+    if (directMatch) {
+      const value = Number(directMatch[1]);
+      if (Number.isFinite(value) && value > 0) {
+        return value;
+      }
+    }
+    const normalized = arg.toLowerCase();
+    if (
+      normalized === "-maxparallel" ||
+      normalized === "--maxparallel" ||
+      normalized === "--max-parallel"
+    ) {
+      const next = Number(argsList[i + 1]);
+      if (Number.isFinite(next) && next > 0) {
+        return next;
+      }
+    }
+  }
+  const envValue = Number(
+    process.env.VK_MAX_PARALLEL || process.env.MAX_PARALLEL,
+  );
+  if (Number.isFinite(envValue) && envValue > 0) {
+    return envValue;
+  }
+  return null;
+}
+
+/**
+ * Extract PR number from a GitHub pull request URL
+ * @param {string} url - GitHub PR URL
+ * @returns {number|null} PR number or null if not found
+ */
+export function parsePrNumberFromUrl(url) {
+  if (!url) return null;
+  const match = String(url).match(/\/pull\/(\d+)/i);
+  if (!match) return null;
+  const num = Number(match[1]);
+  return Number.isFinite(num) ? num : null;
+}