@remnic/cli 10.0.60 → 10.0.62

package/dist/buffer-drain-worker.js

@@ -0,0 +1,117 @@
+import {
+  matchesFilters,
+  sessionNamespaceResolver
+} from "./chunk-SXTPIL7I.js";
+
+// src/buffer-drain-worker.ts
+import { randomUUID } from "crypto";
+import fs from "fs";
+import { Orchestrator, parseConfig, resolveRemnicConfigRecord } from "@remnic/core";
+import { BufferDrainRunner } from "@remnic/core/orchestration/buffer-drain-runner.js";
+function parseWorkerArgs(argv) {
+  const options = { concurrency: 1, sessions: [], dryRun: false, json: false };
+  let configPath = "";
+  let memoryDir = "";
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const value = argv[index + 1];
+    if (arg === "--config" && value) {
+      configPath = value;
+      index += 1;
+    } else if (arg === "--memory-dir" && value) {
+      memoryDir = value;
+      index += 1;
+    } else if (arg === "--session" && value) {
+      options.sessions.push(value);
+      index += 1;
+    } else if (arg === "--namespace" && value) {
+      options.namespace = value;
+      index += 1;
+    }
+  }
+  return { configPath, memoryDir, options };
+}
+function emit(payload) {
+  process.stdout.write(`${JSON.stringify(payload)}
+`);
+}
+async function main() {
+  const args = parseWorkerArgs(process.argv.slice(2));
+  if (!args.configPath || !args.memoryDir) {
+    emit({ type: "error", error: "drain worker requires --config and --memory-dir" });
+    return 2;
+  }
+  const raw = fs.existsSync(args.configPath) ? JSON.parse(fs.readFileSync(args.configPath, "utf8")) : {};
+  const config = parseConfig(resolveRemnicConfigRecord(raw));
+  config.memoryDir = args.memoryDir;
+  const orchestrator = new Orchestrator(config);
+  await orchestrator.initialize();
+  await orchestrator.deferredReady;
+  const runner = new BufferDrainRunner(orchestrator);
+  const ownerId = `drain-${process.pid}-${randomUUID().slice(0, 8)}`;
+  const abort = new AbortController();
+  const stop = () => {
+    abort.abort(new Error("buffer drain interrupted"));
+  };
+  process.on("SIGTERM", stop);
+  process.on("SIGINT", stop);
+  const attempted = /* @__PURE__ */ new Set();
+  let failures = 0;
+  try {
+    for (; ; ) {
+      if (abort.signal.aborted) break;
+      const state = await orchestrator.storage.loadBuffer();
+      const entries = state.entries ?? {};
+      const claimed = await runner.claims.list();
+      const resolveNamespace = sessionNamespaceResolver(config);
+      const candidates = [];
+      for (const [key, entry] of Object.entries(entries)) {
+        const turns = entry.turns.length + (entry.retainedTurns?.length ?? 0);
+        if (turns === 0) continue;
+        if (!matchesFilters(key, entry, args.options, resolveNamespace)) continue;
+        candidates.push({ key, turns });
+      }
+      for (const listed of claimed) {
+        if (candidates.some((candidate) => candidate.key === listed.key)) continue;
+        if (args.options.sessions.length > 0 && !args.options.sessions.includes(listed.key)) continue;
+        const claim = await runner.claims.load(listed.key);
+        const entry = claim?.entry ?? { turns: [], lastExtractionAt: null, extractionCount: 0 };
+        if (!matchesFilters(listed.key, entry, args.options, resolveNamespace)) continue;
+        candidates.push({ key: listed.key, turns: listed.turnCount });
+      }
+      const next = candidates.find((candidate) => !attempted.has(candidate.key) && candidate.turns > 0);
+      if (!next) break;
+      attempted.add(next.key);
+      await runner.claim(next.key, ownerId);
+      const outcome = await runner.drainSession(next.key, {
+        ownerId,
+        signal: abort.signal,
+        onEvent: (event) => {
+          if (event.type === "session_started") {
+            emit({ type: "session_started", key: event.key, turns: event.turns });
+          }
+        }
+      });
+      if (outcome.status === "failed") failures += 1;
+      emit({ type: "session_finished", outcome });
+    }
+  } catch (err) {
+    emit({ type: "error", error: err instanceof Error ? err.message : String(err) });
+    failures += 1;
+  }
+  try {
+    await orchestrator.destroy();
+  } catch {
+  }
+  emit({ type: "done", failures });
+  return failures > 0 ? 1 : 0;
+}
+main().then(
+  (code) => {
+    process.exitCode = code;
+  },
+  (err) => {
+    emit({ type: "error", error: err instanceof Error ? err.message : String(err) });
+    process.exitCode = 1;
+  }
+);