agentel 0.2.0

package/src/supervisor.js

@@ -0,0 +1,217 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+const { ensureBaseDirs, paths, readJson, writeJson } = require("./paths");
+const { effectiveImportSources, loadConfig } = require("./config");
+const { startCollector } = require("./collector");
+const { reindexIfNeeded } = require("./search");
+const { hasRemoteTarget, syncArchiveIfConfigured } = require("./sync");
+
+let tickRunning = false;
+
+function startSupervisorDetached() {
+  const p = paths();
+  ensureBaseDirs(p);
+  const out = fs.openSync(path.join(p.logs, "supervisor.log"), "a");
+  const err = fs.openSync(path.join(p.logs, "supervisor.err.log"), "a");
+  const child = spawn(process.execPath, [path.resolve(__dirname, "..", "bin", "agentlog.js"), "start", "--foreground"], {
+    detached: true,
+    stdio: ["ignore", out, err]
+  });
+  child.unref();
+  return child.pid;
+}
+
+async function runSupervisorForeground(env = process.env) {
+  const p = paths(env);
+  ensureBaseDirs(p);
+  fs.writeFileSync(p.pid, String(process.pid), { mode: 0o600 });
+  log("supervisor started", env);
+  const collector = startCollector(env, {
+    onError: (error) => log(`collector failed: ${error.message}`, env)
+  });
+  if (collector) log(`collector listening on ${loadConfig(env).collector.otlpEndpoint}`, env);
+
+  let stopping = false;
+  const stop = () => {
+    if (stopping) return;
+    stopping = true;
+    log("supervisor stopping", env);
+    try {
+      fs.unlinkSync(p.pid);
+    } catch {
+      // Already gone.
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+
+  await tick(env);
+  const timer = setInterval(() => {
+    if (tickRunning) {
+      log("tick skipped: previous tick still running", env);
+      return;
+    }
+    tick(env).catch((error) => log(`tick failed: ${error.message}`, env));
+  }, 30 * 1000);
+
+  await new Promise(() => {});
+}
+
+async function tick(env) {
+  tickRunning = true;
+  try {
+    const cfg = loadConfig(env);
+    const sources = effectiveImportSources(cfg);
+    const importSources = Array.isArray(sources) && sources.length ? sources : ["all"];
+    for (const source of importSources) {
+      try {
+        const importCliHistory = loadImportCliHistory();
+        const imports = importCliHistory(supervisorImportOptionsForSource(source, cfg), env);
+        for (const result of imports) {
+          const summary = supervisorImportResultLog(result, source);
+          if (summary) log(summary, env);
+          if (result.errors?.length) log(`${result.provider} import errors from ${source}: ${result.errors.length}`, env);
+        }
+      } catch (error) {
+        log(`${source} history import skipped: ${error.message}`, env);
+      }
+    }
+  } catch (error) {
+    log(`history import skipped: ${error.message}`, env);
+  }
+
+  try {
+    const result = reindexIfNeeded(env);
+    if (result.index?.docCount != null) log(`index ready (${result.index.docCount} chunk(s))`, env);
+  } catch (error) {
+    log(`index skipped: ${error.message}`, env);
+  }
+
+  try {
+    const cfg = loadConfig(env);
+    if (hasRemoteTarget(cfg, env) && shouldRunScheduledSync(cfg, env)) {
+      markScheduledSyncAttempt(env);
+      const result = await syncArchiveIfConfigured(env);
+      if (result.configured !== false && (result.uploaded || result.errors?.length)) {
+        log(`remote sync uploaded=${result.uploaded} current=${result.skipped} retried=${result.retried || 0} errors=${result.errors.length}`, env);
+      }
+    }
+  } catch (error) {
+    log(`remote sync skipped: ${error.message}`, env);
+  } finally {
+    tickRunning = false;
+  }
+}
+
+function shouldRunScheduledSync(config, env = process.env, now = new Date()) {
+  const intervalMinutes = Number(config?.sync?.intervalMinutes ?? 30);
+  if (!Number.isFinite(intervalMinutes) || intervalMinutes <= 0) return false;
+  const state = readJson(path.join(paths(env).state, "sync-supervisor.json"), {});
+  if (!state.lastAttemptedAt) return true;
+  const last = new Date(state.lastAttemptedAt);
+  if (Number.isNaN(last.getTime())) return true;
+  return now.getTime() - last.getTime() >= intervalMinutes * 60 * 1000;
+}
+
+function markScheduledSyncAttempt(env = process.env, now = new Date()) {
+  writeJson(path.join(paths(env).state, "sync-supervisor.json"), { lastAttemptedAt: now.toISOString() });
+}
+
+function supervisorImportOptionsForSource(source, config) {
+  const sinceDays = Math.max(1, Number(config?.imports?.defaultSinceDays || 30));
+  return {
+    source,
+    since: `${sinceDays}d`,
+    cursorRecovery: false,
+    supervisor: true
+  };
+}
+
+function supervisorImportResultLog(result, source) {
+  const parts = [];
+  if (result.imported) parts.push(`imported ${result.imported}`);
+  if (result.pruned) parts.push(`pruned ${result.pruned}`);
+  if (!parts.length) return "";
+  const details = [];
+  if (result.details?.rawCompanionFragmentsMerged) details.push(`raw companion merged=${result.details.rawCompanionFragmentsMerged}`);
+  if (result.details?.rawCompanionFragmentsDropped) details.push(`raw companion dropped=${result.details.rawCompanionFragmentsDropped}`);
+  return `${result.provider} from ${source}: ${parts.join(", ")}${details.length ? ` (${details.join(", ")})` : ""}`;
+}
+
+function stopSupervisor(env = process.env) {
+  const p = paths(env);
+  const pid = readPid(env);
+  if (!pid) return false;
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch (error) {
+    if (error?.code !== "EPERM") {
+      try {
+        fs.unlinkSync(p.pid);
+      } catch {
+        // No-op.
+      }
+    }
+    return false;
+  }
+}
+
+function supervisorStatus(env = process.env) {
+  const pid = readPid(env);
+  return {
+    pid,
+    running: pid ? isAlive(pid) : false
+  };
+}
+
+function readPid(env = process.env) {
+  try {
+    const pid = Number(fs.readFileSync(paths(env).pid, "utf8").trim());
+    return Number.isFinite(pid) && pid > 0 ? pid : 0;
+  } catch {
+    return 0;
+  }
+}
+
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error?.code === "EPERM") return true;
+    return false;
+  }
+}
+
+function loadImportCliHistory() {
+  const modulePath = require.resolve("./importers");
+  const loaded = require(modulePath);
+  if (typeof loaded.importCliHistory === "function") return loaded.importCliHistory;
+
+  delete require.cache[modulePath];
+  const reloaded = require(modulePath);
+  if (typeof reloaded.importCliHistory === "function") return reloaded.importCliHistory;
+  throw new Error("importer module did not expose importCliHistory; restart agentlog or reinstall");
+}
+
+function log(message, env = process.env) {
+  const p = paths(env);
+  ensureBaseDirs(p);
+  fs.appendFileSync(path.join(p.logs, "supervisor.log"), `${new Date().toISOString()} ${message}\n`);
+}
+
+module.exports = {
+  runSupervisorForeground,
+  startSupervisorDetached,
+  stopSupervisor,
+  supervisorImportResultLog,
+  supervisorImportOptionsForSource,
+  supervisorStatus,
+  shouldRunScheduledSync,
+  tick
+};