opencode-swarm 7.83.0 → 7.85.0

package/dist/cli/index-eb85wtx9.js

@@ -0,0 +1,242 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-ckntc5gf.js";
+import {
+  log
+} from "./index-yx44zd0p.js";
+import {
+  withEvidenceLock
+} from "./index-bcp79s17.js";
+import {
+  exports_external
+} from "./index-293f68mj.js";
+
+// src/background/pr-subscriptions.ts
+import * as fs from "fs";
+import * as path from "path";
+var PR_SUBSCRIPTIONS_FILE = "pr-monitor/subscriptions.jsonl";
+var STORE_LOCK_AGENT = "pr-monitor";
+var STORE_LOCK_TASK = "pr-subscriptions";
+var onSubscriptionCreated = null;
+function setOnSubscriptionCreated(callback) {
+  onSubscriptionCreated = callback;
+}
+var RecordSchema = exports_external.object({
+  correlationId: exports_external.string().min(1),
+  sessionID: exports_external.string().min(1),
+  prNumber: exports_external.number().int().positive(),
+  repoFullName: exports_external.string().regex(/^[^/]+\/[^/]+$/, "Must be owner/repo format"),
+  prUrl: exports_external.string().min(1).regex(/^https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+$/, "Must be a valid GitHub PR URL"),
+  headRefOid: exports_external.string().optional(),
+  lastCheckedAt: exports_external.number(),
+  lastCommentId: exports_external.string().optional(),
+  lastCheckRunSet: exports_external.string().optional(),
+  mergeableState: exports_external.string().optional(),
+  isWatching: exports_external.boolean(),
+  hasUnaddressedEvents: exports_external.boolean(),
+  status: exports_external.enum(["active", "removed", "expired"]),
+  createdAt: exports_external.number(),
+  updatedAt: exports_external.number(),
+  errorCount: exports_external.number().int().min(0),
+  customPollIntervalSeconds: exports_external.number().int().positive().optional(),
+  customFailureThreshold: exports_external.number().int().min(0).optional(),
+  customCooldownSeconds: exports_external.number().int().min(0).optional()
+}).strict();
+function storePath(directory) {
+  return validateSwarmPath(directory, PR_SUBSCRIPTIONS_FILE);
+}
+function ensureSwarmDir(directory) {
+  fs.mkdirSync(path.resolve(directory, ".swarm", "pr-monitor"), {
+    recursive: true
+  });
+}
+function buildCorrelationId(sessionID, repoFullName, prNumber) {
+  return `${sessionID}::${repoFullName}::${prNumber}`;
+}
+function readAllRecords(directory) {
+  let raw;
+  try {
+    raw = fs.readFileSync(storePath(directory), "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    log(`[pr-monitor] readAllRecords failed: ${err instanceof Error ? err.message : String(err)}`);
+    return [];
+  }
+  const folded = new Map;
+  for (const line of raw.split(`
+`)) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+      continue;
+    let parsedJson;
+    try {
+      parsedJson = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    const result = RecordSchema.safeParse(parsedJson);
+    if (!result.success)
+      continue;
+    folded.set(result.data.correlationId, result.data);
+  }
+  return [...folded.values()];
+}
+function appendRecord(directory, record) {
+  const result = RecordSchema.safeParse(record);
+  if (!result.success) {
+    throw new Error(`Invalid subscription record: ${result.error.message}`);
+  }
+  ensureSwarmDir(directory);
+  fs.appendFileSync(storePath(directory), `${JSON.stringify(record)}
+`, "utf-8");
+}
+async function subscribe(directory, input) {
+  if (!directory || directory.trim() === "") {
+    throw new Error("directory is required");
+  }
+  if (!input.sessionID || input.sessionID.trim() === "") {
+    throw new Error("sessionID is required and must be non-empty");
+  }
+  if (!input.repoFullName || input.repoFullName.trim() === "") {
+    throw new Error("repoFullName is required and must be non-empty");
+  }
+  if (!input.prUrl || input.prUrl.trim() === "") {
+    throw new Error("prUrl is required and must be non-empty");
+  }
+  if (!input.prNumber || !Number.isInteger(input.prNumber) || input.prNumber <= 0) {
+    throw new Error("prNumber is required and must be a positive integer");
+  }
+  const correlationId = buildCorrelationId(input.sessionID, input.repoFullName, input.prNumber);
+  const now = Date.now();
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existing = readAllRecords(directory);
+    const match = existing.find((r) => r.correlationId === correlationId && r.status === "active");
+    if (match) {
+      onSubscriptionCreated?.(directory, match);
+      return match;
+    }
+    if (input.maxSubscriptions !== undefined && input.maxSubscriptions > 0) {
+      const activeCount = existing.filter((r) => r.status === "active").length;
+      if (activeCount >= input.maxSubscriptions) {
+        throw new Error(`PR subscription limit reached: ${activeCount}/${input.maxSubscriptions}`);
+      }
+    }
+    const record = {
+      correlationId,
+      sessionID: input.sessionID,
+      prNumber: input.prNumber,
+      repoFullName: input.repoFullName,
+      prUrl: input.prUrl,
+      lastCheckedAt: now,
+      isWatching: true,
+      hasUnaddressedEvents: false,
+      status: "active",
+      createdAt: now,
+      updatedAt: now,
+      errorCount: 0
+    };
+    appendRecord(directory, record);
+    onSubscriptionCreated?.(directory, record);
+    return record;
+  });
+}
+async function unsubscribe(directory, correlationId) {
+  if (!correlationId)
+    return null;
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existing = readAllRecords(directory);
+    const match = existing.find((r) => r.correlationId === correlationId && r.status === "active");
+    if (!match)
+      return null;
+    const now = Date.now();
+    const removed = {
+      ...match,
+      status: "removed",
+      isWatching: false,
+      updatedAt: now
+    };
+    appendRecord(directory, removed);
+    return removed;
+  });
+}
+async function listActive(directory) {
+  return readAllRecords(directory).filter((r) => r.status === "active");
+}
+async function lookupByPr(directory, repoFullName, prNumber) {
+  for (const record of readAllRecords(directory)) {
+    if (record.status === "active" && record.repoFullName === repoFullName && record.prNumber === prNumber) {
+      return record;
+    }
+  }
+  return null;
+}
+async function updateSnapshot(directory, correlationId, updates) {
+  if (!correlationId)
+    return null;
+  return withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+    const existing = readAllRecords(directory);
+    const match = existing.find((r) => r.correlationId === correlationId && r.status === "active");
+    if (!match)
+      return null;
+    const updated = {
+      ...match,
+      ...updates,
+      correlationId,
+      sessionID: match.sessionID,
+      repoFullName: match.repoFullName,
+      prNumber: match.prNumber,
+      prUrl: match.prUrl,
+      createdAt: match.createdAt,
+      updatedAt: Date.now()
+    };
+    appendRecord(directory, updated);
+    return updated;
+  });
+}
+async function sweepStale(directory, ttlDays, mergedPrs) {
+  if (!ttlDays || ttlDays <= 0)
+    return 0;
+  const ttlMs = ttlDays * 86400000;
+  const now = Date.now();
+  try {
+    return await withEvidenceLock(directory, PR_SUBSCRIPTIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      let swept = 0;
+      for (const record of readAllRecords(directory)) {
+        if (record.status !== "active")
+          continue;
+        const prKey = `${record.repoFullName}::${record.prNumber}`;
+        const isMerged = mergedPrs?.has(prKey) ?? false;
+        const isStale = now - record.updatedAt > ttlMs;
+        if (isMerged) {
+          appendRecord(directory, {
+            ...record,
+            status: "expired",
+            isWatching: false,
+            updatedAt: now
+          });
+          swept += 1;
+          log(`[pr-monitor] Swept subscription: merged/closed: ${prKey}`);
+          continue;
+        }
+        if (isStale && !record.hasUnaddressedEvents) {
+          appendRecord(directory, {
+            ...record,
+            status: "expired",
+            isWatching: false,
+            updatedAt: now
+          });
+          swept += 1;
+          log(`[pr-monitor] Swept subscription: stale (TTL ${ttlDays}d): ${prKey}`);
+        }
+      }
+      return swept;
+    });
+  } catch (err) {
+    log(`[pr-monitor] sweepStale failed: ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
+
+export { PR_SUBSCRIPTIONS_FILE, setOnSubscriptionCreated, buildCorrelationId, subscribe, unsubscribe, listActive, lookupByPr, updateSnapshot, sweepStale };