@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-4I7HGVVA.js

@@ -0,0 +1,363 @@
+import {
+  SessionCatalogProjectClient
+} from "./chunk-F3JWNST7.js";
+import {
+  sessionCatalogProjectServerMetadataPath
+} from "./chunk-AYW5YINX.js";
+
+// src/session-catalog/registry.ts
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var HEARTBEAT_INTERVAL_MS = 5e3;
+var AGENT_WRITE_THROTTLE_MS = 300;
+var MAX_PROJECT_CLIENTS = 128;
+var MAX_GLOBAL_ROOTS = 16;
+var ProjectSessionRegistry = class {
+  constructor(globalRoot) {
+    this.globalRoot = globalRoot;
+  }
+  globalRoot;
+  instanceId = randomUUID();
+  clients = /* @__PURE__ */ new Map();
+  current;
+  heartbeatTimer;
+  agentRevision = 0;
+  pendingAgents;
+  agentTimer;
+  lastAgentWriteAt = 0;
+  bindingKey(projectDir) {
+    const resolved = path.resolve(projectDir);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  }
+  async closeBinding(binding) {
+    if (this.current?.binding === binding) return;
+    const key = this.bindingKey(binding.projectDir);
+    if (this.clients.get(key) === binding) this.clients.delete(key);
+    await binding.client.close();
+  }
+  binding(projectSlug, projectRoot) {
+    const projectDir = path.join(this.globalRoot, "projects", projectSlug);
+    const key = this.bindingKey(projectDir);
+    let binding = this.clients.get(key);
+    if (!binding) {
+      if (this.clients.size >= MAX_PROJECT_CLIENTS) {
+        const oldest = [...this.clients.entries()].find(
+          ([, candidate]) => candidate !== this.current?.binding
+        );
+        if (oldest) {
+          this.clients.delete(oldest[0]);
+          void oldest[1].client.close();
+        }
+      }
+      binding = {
+        projectDir,
+        projectRoot: path.resolve(projectRoot),
+        client: new SessionCatalogProjectClient({ projectDir, projectRoot })
+      };
+      this.clients.set(key, binding);
+    } else {
+      this.clients.delete(key);
+      this.clients.set(key, binding);
+    }
+    return binding;
+  }
+  fullEntry(entry) {
+    const agents = entry.agents ?? [];
+    return {
+      ...entry,
+      status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentCount: agents.length,
+      agents
+    };
+  }
+  async register(entry) {
+    const full = this.fullEntry(entry);
+    if (this.current?.entry.sessionId === full.sessionId && this.current.entry.pid === full.pid) {
+      this.current.entry = full;
+      this.current.credential = await this.current.binding.client.call("heartbeat", {
+        credential: this.current.credential,
+        status: full.status
+      });
+      return;
+    }
+    const nextBinding = this.binding(full.projectSlug, full.projectRoot);
+    let nextCredential;
+    try {
+      nextCredential = await nextBinding.client.call("claim_new", {
+        entry: full,
+        ownerInstanceId: this.instanceId
+      });
+    } catch (error) {
+      await this.closeBinding(nextBinding).catch(() => void 0);
+      throw error;
+    }
+    const previous = this.current;
+    this.current = { binding: nextBinding, credential: nextCredential, entry: full };
+    this.agentRevision = 0;
+    this.cancelAgentTimer();
+    this.startHeartbeat();
+    if (previous) {
+      await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+      if (previous.binding !== nextBinding) await this.closeBinding(previous.binding);
+    }
+  }
+  /** Reserve before transcript hydration; activation swaps ownership only after the writer opened. */
+  async reserveResume(target) {
+    const binding = this.binding(target.projectSlug, target.projectRoot);
+    let reservation;
+    try {
+      reservation = await binding.client.call("reserve_resume", {
+        targetSessionId: target.sessionId,
+        requesterInstanceId: this.instanceId,
+        ...this.current ? { currentSessionId: this.current.entry.sessionId } : {},
+        ...target.reservationMs !== void 0 ? { reservationMs: target.reservationMs } : {}
+      });
+    } catch (error) {
+      await this.closeBinding(binding).catch(() => void 0);
+      throw error;
+    }
+    let settled = false;
+    return {
+      get reservation() {
+        return reservation;
+      },
+      renew: async (reservationMs) => {
+        if (settled) return false;
+        reservation = await binding.client.call("renew_reservation", {
+          reservationId: reservation.reservationId,
+          requesterInstanceId: this.instanceId,
+          ...reservationMs !== void 0 ? { reservationMs } : {}
+        });
+        return true;
+      },
+      activate: async (registration) => {
+        if (settled) throw new Error("Resume reservation is already settled");
+        const entry = this.fullEntry(registration);
+        const credential = await binding.client.call("activate_reservation", {
+          reservation,
+          entry
+        });
+        const previous = this.current;
+        this.current = { binding, credential, entry };
+        settled = true;
+        this.agentRevision = 0;
+        this.cancelAgentTimer();
+        this.startHeartbeat();
+        if (previous) {
+          await previous.binding.client.call("release", { credential: previous.credential }).catch(() => void 0);
+          if (previous.binding !== binding) await this.closeBinding(previous.binding);
+        }
+      },
+      cancel: async () => {
+        if (settled) return;
+        settled = true;
+        try {
+          await binding.client.call("cancel_reservation", {
+            reservationId: reservation.reservationId,
+            requesterInstanceId: this.instanceId
+          }).catch(() => void 0);
+        } finally {
+          await this.closeBinding(binding).catch(() => void 0);
+        }
+      }
+    };
+  }
+  async updateAgents(agents) {
+    if (!this.current) return;
+    this.pendingAgents = agents;
+    this.current.entry = {
+      ...this.current.entry,
+      agents,
+      agentCount: agents.length,
+      status: agents.some((agent) => agent.status !== "idle") ? "active" : "idle",
+      lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const elapsed = Date.now() - this.lastAgentWriteAt;
+    if (!this.agentTimer && elapsed >= AGENT_WRITE_THROTTLE_MS) {
+      await this.flushAgents();
+      return;
+    }
+    if (!this.agentTimer) {
+      this.agentTimer = setTimeout(
+        () => {
+          this.agentTimer = void 0;
+          void this.flushAgents();
+        },
+        Math.max(0, AGENT_WRITE_THROTTLE_MS - elapsed)
+      );
+      this.agentTimer.unref?.();
+    }
+  }
+  async flushAgents() {
+    const agents = this.pendingAgents;
+    const current = this.current;
+    if (!agents || !current) return;
+    this.pendingAgents = void 0;
+    this.lastAgentWriteAt = Date.now();
+    const revision = ++this.agentRevision;
+    await current.binding.client.call("publish_agents", {
+      credential: current.credential,
+      revision,
+      agents
+    });
+  }
+  async markClosing() {
+    this.stopHeartbeat();
+    this.cancelAgentTimer();
+    if (this.current)
+      await this.current.binding.client.call("mark_closing", {
+        credential: this.current.credential
+      });
+  }
+  async unregister() {
+    this.stopHeartbeat();
+    this.cancelAgentTimer();
+    const current = this.current;
+    this.current = void 0;
+    if (current) {
+      try {
+        await current.binding.client.call("release", { credential: current.credential });
+      } finally {
+        await this.closeBinding(current.binding);
+      }
+    }
+  }
+  async list() {
+    const projectsDir = path.join(this.globalRoot, "projects");
+    let directories = [];
+    try {
+      directories = (await fs.readdir(projectsDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).slice(0, 1e3).map((entry) => entry.name);
+    } catch {
+      return [];
+    }
+    const snapshots = await Promise.all(
+      directories.map(async (slug) => {
+        const projectDir = path.join(projectsDir, slug);
+        let client;
+        try {
+          const metadata = JSON.parse(
+            await fs.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+          );
+          if (typeof metadata.projectRoot !== "string" || !metadata.projectRoot) return [];
+          client = new SessionCatalogProjectClient({
+            projectDir,
+            projectRoot: metadata.projectRoot
+          });
+          return await client.callExisting("list_live", {});
+        } catch {
+          return [];
+        } finally {
+          await client?.close().catch(() => void 0);
+        }
+      })
+    );
+    return snapshots.flat();
+  }
+  async listByProject(projectSlug) {
+    const current = this.current;
+    if (current && path.basename(current.binding.projectDir) === projectSlug) {
+      return current.binding.client.call("list_live", {}).catch(() => []);
+    }
+    const projectDir = path.join(this.globalRoot, "projects", projectSlug);
+    let client;
+    try {
+      const metadata = JSON.parse(
+        await fs.readFile(sessionCatalogProjectServerMetadataPath(projectDir), "utf8")
+      );
+      if (typeof metadata.projectRoot !== "string") return [];
+      client = new SessionCatalogProjectClient({ projectDir, projectRoot: metadata.projectRoot });
+      return await client.callExisting("list_live", {}).catch(() => []);
+    } catch {
+      return [];
+    } finally {
+      await client?.close().catch(() => void 0);
+    }
+  }
+  async get(sessionId) {
+    return (await this.list()).find((entry) => entry.sessionId === sessionId);
+  }
+  subscribeProject(projectSlug, projectRoot, listener) {
+    const binding = this.binding(projectSlug, projectRoot);
+    return binding.client.subscribe(listener).then((unsubscribe) => async () => {
+      await unsubscribe();
+      await this.closeBinding(binding);
+    });
+  }
+  get registryPath() {
+    return path.join(this.globalRoot, "projects");
+  }
+  async dispose() {
+    await this.unregister().catch(() => void 0);
+    await Promise.all([...this.clients.values()].map((binding) => binding.client.close()));
+    this.clients.clear();
+  }
+  /** Whether this facade currently owns a live session lease. */
+  ownsSession() {
+    return this.current !== void 0;
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      void this.heartbeat();
+    }, HEARTBEAT_INTERVAL_MS);
+    this.heartbeatTimer.unref?.();
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = void 0;
+  }
+  cancelAgentTimer() {
+    if (this.agentTimer) clearTimeout(this.agentTimer);
+    this.agentTimer = void 0;
+    this.pendingAgents = void 0;
+  }
+  async heartbeat() {
+    const current = this.current;
+    if (!current) return;
+    try {
+      const credential = await current.binding.client.call("heartbeat", {
+        credential: current.credential,
+        status: current.entry.status
+      });
+      if (this.current === current) current.credential = credential;
+    } catch {
+    }
+  }
+};
+var registries = /* @__PURE__ */ new Map();
+var lastRegistryKey;
+function getProjectSessionRegistry(globalRoot) {
+  const key = globalRoot !== void 0 ? path.resolve(globalRoot) : lastRegistryKey;
+  if (!key)
+    throw new Error("SessionRegistry not initialized. Call getSessionRegistry(globalRoot) first.");
+  let registry = registries.get(key);
+  if (!registry) {
+    if (registries.size >= MAX_GLOBAL_ROOTS) {
+      const idle = [...registries.entries()].find(([, candidate]) => !candidate.ownsSession());
+      if (!idle)
+        throw new Error(`Session Registry global-root limit reached (${MAX_GLOBAL_ROOTS})`);
+      registries.delete(idle[0]);
+      void idle[1].dispose();
+    }
+    registry = new ProjectSessionRegistry(key);
+    registries.set(key, registry);
+  } else {
+    registries.delete(key);
+    registries.set(key, registry);
+  }
+  lastRegistryKey = key;
+  return registry;
+}
+function hasProjectSessionRegistry(globalRoot) {
+  if (globalRoot === void 0) return registries.size > 0;
+  return registries.has(path.resolve(globalRoot));
+}
+
+export {
+  ProjectSessionRegistry,
+  getProjectSessionRegistry,
+  hasProjectSessionRegistry
+};
+//# sourceMappingURL=chunk-4I7HGVVA.js.map

package/dist/chunk-4LCZVJVF.js

@@ -0,0 +1,317 @@
+import {
+  validateResolution,
+  validateTransition
+} from "./chunk-UJILKYES.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-6FHWXLPT.js";
+import {
+  atomicWrite,
+  withFileLock
+} from "./chunk-OSGLYW5J.js";
+
+// src/plugins/review-finding-store.ts
+import { randomUUID } from "node:crypto";
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var FINDING_RESOLVED_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var FINDING_IGNORED_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
+var FINDING_DEFAULT_PAGE_SIZE = 50;
+var NL = "\n";
+var LINE_SEPARATOR = NL;
+var FINDING_STORE_FILE = "review-findings.jsonl";
+function resolveFindingStorePath(projectDir) {
+  return path.join(projectDir, FINDING_STORE_FILE);
+}
+var JsonlFindingStore = class {
+  filePath;
+  constructor(projectDir) {
+    this.filePath = resolveFindingStorePath(projectDir);
+  }
+  get storePath() {
+    return this.filePath;
+  }
+  // ── Path helpers ─────────────────────────────────────────────────
+  async upsert(newFindings, context) {
+    if (newFindings.length === 0) return { created: 0, relinked: 0, reopened: 0 };
+    const result = { created: 0, relinked: 0, reopened: 0 };
+    return withFileLock(this.filePath, async () => {
+      const existing = await this._readAll();
+      for (const finding of newFindings) {
+        const match = existing.find((e) => e.finding.fingerprint === finding.fingerprint);
+        if (match) {
+          const materialized = this._materialize(match);
+          if (materialized.status === "resolved" || materialized.status === "ignored") {
+            const reopenEvent = this._makeEvent(
+              match.finding.id,
+              "reopened",
+              materialized.status,
+              "active",
+              context
+            );
+            match.finding.status = "active";
+            match.finding.resolution = void 0;
+            const updatedRecord = { __finding: 1, data: match.finding };
+            await fsp.appendFile(
+              this.filePath,
+              JSON.stringify(updatedRecord) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: reopenEvent }) + LINE_SEPARATOR,
+              { encoding: "utf8", mode: SECRET_FILE_MODE }
+            );
+            result.reopened++;
+          } else {
+            const relinkEvent = this._makeEvent(
+              match.finding.id,
+              "relinked",
+              match.finding.status,
+              match.finding.status,
+              context
+            );
+            await fsp.appendFile(
+              this.filePath,
+              JSON.stringify({ __findingEvent: 1, data: relinkEvent }) + LINE_SEPARATOR,
+              { encoding: "utf8", mode: SECRET_FILE_MODE }
+            );
+            result.relinked++;
+          }
+        } else {
+          const record = { __finding: 1, data: finding };
+          const createdEvent = this._makeEvent(finding.id, "created", null, "active", context);
+          const lines = JSON.stringify(record) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: createdEvent }) + LINE_SEPARATOR;
+          await fsp.appendFile(this.filePath, lines, { encoding: "utf8", mode: SECRET_FILE_MODE });
+          result.created++;
+        }
+      }
+      return result;
+    });
+  }
+  async transition(findingId, to, actor, opts) {
+    return withFileLock(this.filePath, async () => {
+      const all = await this._readAll();
+      const entry = all.find((e) => e.finding.id === findingId);
+      if (!entry) throw new Error(`Finding not found: ${findingId}`);
+      const from = this._materialize(entry).status;
+      validateTransition(from, to);
+      validateResolution(to, opts?.outcome);
+      const event = {
+        id: randomUUID(),
+        findingId,
+        eventType: to === "resolved" ? "resolved" : to === "ignored" ? "ignored" : this._eventTypeFor(to),
+        fromStatus: from,
+        toStatus: to,
+        actorId: actor.id,
+        actorKind: actor.kind,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        reason: opts?.reason
+      };
+      entry.finding.status = to;
+      if (to === "resolved" && opts?.outcome) {
+        entry.finding.resolution = {
+          outcome: opts.outcome,
+          resolvedAt: event.timestamp,
+          resolvedBy: actor.id,
+          notes: opts.reason
+        };
+      }
+      const updatedRecord = { __finding: 1, data: entry.finding };
+      await fsp.appendFile(
+        this.filePath,
+        JSON.stringify(updatedRecord) + LINE_SEPARATOR + JSON.stringify({ __findingEvent: 1, data: event }) + LINE_SEPARATOR,
+        { encoding: "utf8", mode: SECRET_FILE_MODE }
+      );
+      return { ...entry.finding };
+    });
+  }
+  async list(opts) {
+    const all = await this._readAll();
+    let findings = all.map((e) => this._materialize(e));
+    if (opts?.severities && opts.severities.length > 0) {
+      const sevs = new Set(opts.severities);
+      findings = findings.filter((f) => sevs.has(f.severity));
+    }
+    if (opts?.statuses && opts.statuses.length > 0) {
+      const sts = new Set(opts.statuses);
+      findings = findings.filter((f) => sts.has(f.status));
+    }
+    if (opts?.file) {
+      const pattern = opts.file.toLowerCase();
+      findings = findings.filter((f) => f.location?.file.toLowerCase().includes(pattern));
+    }
+    if (opts?.reportId) {
+      findings = findings.filter((f) => f.originReport.reportId === opts.reportId);
+    }
+    const severityRank = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    };
+    findings.sort((a, b) => {
+      const sa = severityRank[a.severity] - severityRank[b.severity];
+      if (sa !== 0) return sa;
+      return a.createdAt.localeCompare(b.createdAt);
+    });
+    const limit = opts?.limit ?? FINDING_DEFAULT_PAGE_SIZE;
+    return findings.slice(0, limit);
+  }
+  async get(idOrFingerprint) {
+    const all = await this._readAll();
+    const entry = all.find(
+      (e) => e.finding.id === idOrFingerprint || e.finding.fingerprint === idOrFingerprint
+    );
+    return entry ? this._materialize(entry) : null;
+  }
+  async getEvents(findingId) {
+    const all = await this._readAllLines();
+    const events = [];
+    for (const line of all) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isLifecycleEvent(parsed) && parsed.data.findingId === findingId) {
+          events.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return events.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  }
+  async compact(opts) {
+    return withFileLock(this.filePath, async () => {
+      const resolvedMaxAge = opts?.resolvedMaxAgeMs ?? FINDING_RESOLVED_RETENTION_MS;
+      const ignoredMaxAge = opts?.ignoredMaxAgeMs ?? FINDING_IGNORED_RETENTION_MS;
+      const now = Date.now();
+      const all = await this._readAll();
+      const kept = [];
+      let removed = 0;
+      let eventsFolded = 0;
+      for (const entry of all) {
+        const age = now - new Date(entry.finding.createdAt).getTime();
+        const isResolved = entry.finding.status === "resolved";
+        const isIgnored = entry.finding.status === "ignored";
+        const maxAge = isResolved ? resolvedMaxAge : isIgnored ? ignoredMaxAge : Infinity;
+        if (age > maxAge && (isResolved || isIgnored)) {
+          removed++;
+          eventsFolded += entry.events.length;
+          continue;
+        }
+        const oldEvents = entry.events.filter(
+          (ev) => now - new Date(ev.timestamp).getTime() > maxAge
+        );
+        if (oldEvents.length > 1) {
+          eventsFolded += oldEvents.length - 1;
+          const newestOld = oldEvents.sort((a, b) => b.timestamp.localeCompare(a.timestamp))[0];
+          entry.events = [
+            newestOld,
+            ...entry.events.filter((ev) => now - new Date(ev.timestamp).getTime() <= maxAge)
+          ];
+        }
+        kept.push({ record: { __finding: 1, data: entry.finding }, events: entry.events });
+      }
+      const lines = [];
+      for (const { record, events } of kept) {
+        if (record) lines.push(JSON.stringify(record));
+        for (const ev of events) {
+          lines.push(JSON.stringify({ __findingEvent: 1, data: ev }));
+        }
+      }
+      lines.push(
+        JSON.stringify({
+          __findingCompact: 1,
+          compactedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          removedFindings: removed,
+          foldedEvents: eventsFolded
+        })
+      );
+      await atomicWrite(this.filePath, lines.join(LINE_SEPARATOR) + LINE_SEPARATOR, {
+        mode: 384
+      });
+      return { removed, eventsFolded };
+    });
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  async _readAllLines() {
+    try {
+      const raw = await fsp.readFile(this.filePath, "utf8");
+      return raw.split(LINE_SEPARATOR).filter((l) => l.trim().length > 0);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+  }
+  _isFindingRecord(v) {
+    return typeof v === "object" && v !== null && v["__finding"] === 1;
+  }
+  _isLifecycleEvent(v) {
+    return typeof v === "object" && v !== null && v["__findingEvent"] === 1;
+  }
+  async _readAll() {
+    const lines = await this._readAllLines();
+    const findings = /* @__PURE__ */ new Map();
+    const eventsMap = /* @__PURE__ */ new Map();
+    for (const line of lines) {
+      try {
+        const parsed = JSON.parse(line);
+        if (this._isFindingRecord(parsed)) {
+          findings.set(parsed.data.id, parsed.data);
+          if (!eventsMap.has(parsed.data.id)) eventsMap.set(parsed.data.id, []);
+        } else if (this._isLifecycleEvent(parsed)) {
+          const list = eventsMap.get(parsed.data.findingId);
+          if (list) list.push(parsed.data);
+        }
+      } catch {
+      }
+    }
+    return Array.from(findings.entries()).map(([id, finding]) => ({
+      finding,
+      events: eventsMap.get(id) ?? []
+    }));
+  }
+  /** Materialize a finding's current status from its events. */
+  _materialize(entry) {
+    if (entry.events.length === 0) return { ...entry.finding };
+    const sorted = [...entry.events].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+    const latest = sorted[sorted.length - 1];
+    return {
+      ...entry.finding,
+      status: latest.toStatus
+    };
+  }
+  _makeEvent(findingId, eventType, fromStatus, toStatus, context) {
+    return {
+      id: randomUUID(),
+      findingId,
+      eventType,
+      fromStatus,
+      toStatus,
+      actorId: context.agentId,
+      actorKind: "agent",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      reason: `session:${context.sessionId} report:${context.reportId}`
+    };
+  }
+  _eventTypeFor(to) {
+    switch (to) {
+      case "triaged":
+        return "triaged";
+      case "in_progress":
+        return "started";
+      case "resolved":
+        return "resolved";
+      case "ignored":
+        return "ignored";
+      case "active":
+        return "reopened";
+      default:
+        return "created";
+    }
+  }
+};
+
+export {
+  FINDING_RESOLVED_RETENTION_MS,
+  FINDING_IGNORED_RETENTION_MS,
+  FINDING_DEFAULT_PAGE_SIZE,
+  FINDING_STORE_FILE,
+  resolveFindingStorePath,
+  JsonlFindingStore
+};
+//# sourceMappingURL=chunk-4LCZVJVF.js.map