opencode-swarm 7.163.1 → 7.164.1

package/dist/cli/index-y2f5s2cf.js

@@ -0,0 +1,403 @@
+// @bun
+import {
+  DbWriteError,
+  applySynchronousForClass,
+  batchDurabilityClass,
+  canonicalProjectKey,
+  classifyDbWriteError,
+  getProjectDb
+} from "./index-hcn69kp0.js";
+import {
+  init_logger,
+  log,
+  warn
+} from "./index-zgwm4ryv.js";
+
+// src/background/event-bus.ts
+class AutomationEventBus {
+  listeners = new Map;
+  eventHistory = [];
+  maxHistorySize;
+  constructor(options) {
+    this.maxHistorySize = options?.maxHistorySize ?? 100;
+  }
+  subscribe(type, listener) {
+    if (!this.listeners.has(type)) {
+      this.listeners.set(type, new Set);
+    }
+    this.listeners.get(type).add(listener);
+    return () => {
+      this.listeners.get(type)?.delete(listener);
+    };
+  }
+  async publish(type, payload, source) {
+    const event = {
+      type,
+      timestamp: Date.now(),
+      payload,
+      source
+    };
+    this.eventHistory.push(event);
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift();
+    }
+    log(`[EventBus] ${type}`, {
+      source,
+      payload: typeof payload === "object" ? "..." : payload
+    });
+    const listeners = this.listeners.get(type);
+    if (listeners) {
+      await Promise.all(Array.from(listeners).map(async (listener) => {
+        try {
+          await listener(event);
+        } catch (error) {
+          log(`[EventBus] Listener error for ${type}`, { error });
+        }
+      }));
+    }
+  }
+  getHistory(types) {
+    if (!types || types.length === 0) {
+      return [...this.eventHistory];
+    }
+    return this.eventHistory.filter((e) => types.includes(e.type));
+  }
+  clearHistory() {
+    this.eventHistory = [];
+  }
+  getListenerCount(type) {
+    return this.listeners.get(type)?.size ?? 0;
+  }
+  hasListeners(type) {
+    return this.getListenerCount(type) > 0;
+  }
+}
+var globalEventBus = null;
+function getGlobalEventBus() {
+  if (!globalEventBus) {
+    globalEventBus = new AutomationEventBus;
+  }
+  return globalEventBus;
+}
+
+// src/db/group-commit-writer.ts
+init_logger();
+function isClosedHandleError(err) {
+  const msg = (err instanceof Error ? err.message : String(err)).toLowerCase();
+  return msg.includes("database has closed") || msg.includes("database is closed") || msg.includes("cannot use a closed database") || msg.includes("database is not open");
+}
+var MAX_QUEUED_OPS = 1024;
+var FLUSH_THRESHOLD_OPS = 64;
+var DEGRADED_COOLDOWN_MS = 60000;
+var _writers = new Map;
+var _internals = {
+  getProjectDb,
+  isClosedHandleError
+};
+
+class GroupCommitWriter {
+  db;
+  queue = [];
+  flushing = false;
+  degraded = null;
+  lastAdvisoryAt = 0;
+  closed = false;
+  registryKey = null;
+  constructor(db) {
+    this.db = db;
+  }
+  get queuedOpCount() {
+    return this.queue.length;
+  }
+  bindRegistryKey(key) {
+    this.registryKey = key;
+  }
+  enqueue(op) {
+    if (this.closed) {
+      throw new DbWriteError("unknown", "group-commit writer is closed");
+    }
+    if (this.queue.length >= MAX_QUEUED_OPS) {
+      this.flushSync();
+    }
+    this.queue.push(op);
+    if (this.queue.length >= FLUSH_THRESHOLD_OPS) {
+      this.flushSync();
+    }
+  }
+  flushSync() {
+    if (this.closed || this.flushing || this.queue.length === 0)
+      return;
+    this.flushing = true;
+    const batch = this.queue;
+    this.queue = [];
+    try {
+      try {
+        this.applyBatch(batch);
+      } catch (err) {
+        if (!isClosedHandleError(err) || this.registryKey === null)
+          throw err;
+        this.db = _internals.getProjectDb(this.registryKey);
+        this.applyBatch(batch);
+      }
+    } catch (err) {
+      const category = classifyDbWriteError(err);
+      if (isClosedHandleError(err)) {
+        this.close();
+        if (this.registryKey !== null)
+          _writers.delete(this.registryKey);
+      }
+      if (category === "busy" || category === "disk_full" || category === "read_only") {
+        this.queue = [...batch, ...this.queue];
+        this.noteDegraded(category);
+      } else {
+        this.noteDegraded(category);
+      }
+      throw new DbWriteError(category, `swarm.db group-commit flush failed (${category}): ${err instanceof Error ? err.message : String(err)}`);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async flush() {
+    this.flushSync();
+  }
+  close() {
+    this.closed = true;
+    this.queue = [];
+  }
+  applyBatch(batch) {
+    const cls = batchDurabilityClass(batch.map((op) => op.durability));
+    applySynchronousForClass(this.db, cls);
+    try {
+      this.db.run("BEGIN IMMEDIATE");
+    } catch (err) {
+      applySynchronousForClass(this.db, "normal");
+      throw err;
+    }
+    try {
+      for (const op of batch) {
+        op.run(this.db);
+      }
+      this.db.run("COMMIT");
+    } catch (err) {
+      try {
+        this.db.run("ROLLBACK");
+      } catch {}
+      throw err;
+    } finally {
+      applySynchronousForClass(this.db, "normal");
+    }
+  }
+  noteDegraded(category) {
+    const now = Date.now();
+    this.degraded = { category, until: now + DEGRADED_COOLDOWN_MS };
+    if (now - this.lastAdvisoryAt < DEGRADED_COOLDOWN_MS)
+      return;
+    this.lastAdvisoryAt = now;
+    warn(`[swarm.db] durable-state writer degraded (category=${category}); queued writes retry on the next flush`);
+  }
+  get degradation() {
+    if (!this.degraded)
+      return null;
+    if (Date.now() > this.degraded.until)
+      return null;
+    return this.degraded;
+  }
+}
+function getGroupCommitWriter(directory) {
+  const key = canonicalProjectKey(directory);
+  let writer = _writers.get(key);
+  if (!writer) {
+    writer = new GroupCommitWriter(getProjectDb(directory));
+    writer.bindRegistryKey(key);
+    _writers.set(key, writer);
+  }
+  return writer;
+}
+function closeGroupCommitWriter(directory) {
+  const key = canonicalProjectKey(directory);
+  const writer = _writers.get(key);
+  if (writer) {
+    try {
+      writer.flushSync();
+    } catch {}
+    writer.close();
+    _writers.delete(key);
+  }
+}
+
+// src/db/legacy-import.ts
+init_logger();
+import {
+  existsSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  statSync
+} from "fs";
+import { join } from "path";
+var RENAME_RETRIES = 20;
+var RENAME_RETRY_DELAY_MS = 5;
+var warnedStaleLegacy = new Set;
+var MAX_LEGACY_IMPORT_BYTES = 32 * 1024 * 1024;
+function sleepSync(ms) {
+  const shared = new SharedArrayBuffer(4);
+  Atomics.wait(new Int32Array(shared), 0, 0, ms);
+}
+function renameWithRetry(from, to) {
+  let lastErr;
+  for (let attempt = 0;attempt < RENAME_RETRIES; attempt++) {
+    try {
+      _internals2.renameSync(from, to);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (code !== "EPERM" && code !== "EACCES" && code !== "EBUSY")
+        throw err;
+      sleepSync(RENAME_RETRY_DELAY_MS);
+    }
+  }
+  throw lastErr;
+}
+function warnStaleLegacyOnce(key, fileName) {
+  const guard = `${key}::${fileName}`;
+  if (warnedStaleLegacy.has(guard))
+    return;
+  warnedStaleLegacy.add(guard);
+  warn(`[swarm.db] legacy artifact ${fileName} is present but the target table is non-empty; leaving the file untouched (it is inert \u2014 readers use swarm.db)`);
+}
+var _internals2 = {
+  renameSync,
+  warnStaleLegacyOnce,
+  maxLegacyImportBytes: () => MAX_LEGACY_IMPORT_BYTES
+};
+function importLegacyJsonl(directory, opts) {
+  const root = canonicalProjectKey(directory);
+  const filePath = join(root, ".swarm", opts.fileName);
+  if (!existsSync(filePath)) {
+    return { imported: 0, skipped: 0, archived: false };
+  }
+  const db = getProjectDb(directory);
+  let content;
+  try {
+    if (statSync(filePath).size > _internals2.maxLegacyImportBytes()) {
+      warn(`[swarm.db] legacy artifact ${opts.fileName} exceeds the import size cap; leaving it inert (not imported, not renamed)`);
+      return { imported: 0, skipped: 0, archived: false };
+    }
+    content = readFileSync(filePath, "utf-8");
+  } catch {
+    return { imported: 0, skipped: 0, archived: false };
+  }
+  const payloads = [];
+  let skipped = 0;
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const payload = opts.parseLine(trimmed);
+    if (payload === null) {
+      skipped++;
+      continue;
+    }
+    payloads.push(payload);
+  }
+  let imported = 0;
+  db.run("BEGIN IMMEDIATE");
+  try {
+    if (opts.streamCount(db) === 0) {
+      for (const payload of payloads) {
+        imported += 1;
+        opts.insertRow(db, imported, payload);
+      }
+    }
+    db.run("COMMIT");
+  } catch (err) {
+    try {
+      db.run("ROLLBACK");
+    } catch {}
+    throw err;
+  }
+  if (imported > 0) {
+    try {
+      renameWithRetry(filePath, `${filePath}.imported`);
+      return { imported, skipped, archived: true };
+    } catch {
+      return { imported, skipped, archived: false };
+    }
+  }
+  if (payloads.length > 0) {
+    _internals2.warnStaleLegacyOnce(root, opts.fileName);
+  }
+  return { imported: 0, skipped, archived: false };
+}
+function importLegacyJsonFiles(directory, opts) {
+  const root = canonicalProjectKey(directory);
+  const swarmDir = join(root, ".swarm");
+  let entries;
+  try {
+    entries = readdirSync(swarmDir);
+  } catch {
+    return { imported: 0, skipped: 0, archived: false };
+  }
+  const suffix = ".json";
+  const phaseRe = new RegExp(`^${opts.filePrefix}(\\d+)\\${suffix}$`);
+  const files = entries.filter((name) => name.startsWith(opts.filePrefix) && name.endsWith(suffix) && !name.includes(".imported"));
+  if (files.length === 0) {
+    return { imported: 0, skipped: 0, archived: false };
+  }
+  const parsed = [];
+  let skipped = 0;
+  for (const fileName of files) {
+    const match = phaseRe.exec(fileName);
+    if (!match) {
+      skipped++;
+      continue;
+    }
+    try {
+      const abs = join(swarmDir, fileName);
+      if (statSync(abs).size > _internals2.maxLegacyImportBytes()) {
+        skipped++;
+        continue;
+      }
+      const raw = readFileSync(abs, "utf-8");
+      JSON.parse(raw);
+      parsed.push({ phase: Number(match[1]), payload: raw, fileName });
+    } catch {
+      skipped++;
+    }
+  }
+  const db = getProjectDb(directory);
+  let imported = 0;
+  const archivedNames = [];
+  db.run("BEGIN IMMEDIATE");
+  try {
+    if (opts.kindCount(db) === 0 && parsed.length > 0) {
+      for (const item of parsed) {
+        imported += 1;
+        opts.upsertRow(db, item.phase, item.payload);
+        archivedNames.push(item.fileName);
+      }
+    }
+    db.run("COMMIT");
+  } catch (err) {
+    try {
+      db.run("ROLLBACK");
+    } catch {}
+    throw err;
+  }
+  if (imported > 0) {
+    for (const fileName of archivedNames) {
+      try {
+        renameWithRetry(join(swarmDir, fileName), join(swarmDir, `${fileName}.imported`));
+      } catch {}
+    }
+    return { imported, skipped, archived: archivedNames.length > 0 };
+  }
+  if (parsed.length > 0) {
+    _internals2.warnStaleLegacyOnce(root, `${opts.filePrefix}*`);
+  }
+  return { imported: 0, skipped, archived: false };
+}
+
+export { getGroupCommitWriter, closeGroupCommitWriter, importLegacyJsonl, importLegacyJsonFiles, getGlobalEventBus };