@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.1

package/src/approvals.js

@@ -0,0 +1,121 @@
+import { randomUUID } from "node:crypto";
+class ApprovalRegistry {
+  records = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  closed = false;
+  defaultTimeoutMs;
+  maxPending;
+  maxPerRun;
+  maxPerStep;
+  maxRecords;
+  constructor(options = {}) {
+    this.defaultTimeoutMs = bounded(options.defaultTimeoutMs, 2 * 6e4, 10 * 6e4);
+    this.maxPending = bounded(options.maxPending, 128, 1024);
+    this.maxPerRun = bounded(options.maxPerRun, 32, this.maxPending);
+    this.maxPerStep = bounded(options.maxPerStep, 8, this.maxPerRun);
+    this.maxRecords = Math.max(this.maxPending, bounded(options.maxRecords, 512, 1e4));
+  }
+  request(runId, stepId, raw, signal, options = {}) {
+    if (this.closed || signal.aborted) return Promise.resolve("decline");
+    const request = validateRequest(raw);
+    if (!runId || !stepId || !request) return Promise.resolve("decline");
+    const active = [...this.records.values()].filter((record2) => record2.status === "pending");
+    if (this.pending.size >= this.maxPending || active.filter((record2) => record2.runId === runId).length >= this.maxPerRun || active.filter((record2) => record2.runId === runId && record2.stepId === stepId).length >= this.maxPerStep || active.some((record2) => record2.runId === runId && record2.stepId === stepId && record2.requestId === request.id)) return Promise.resolve("decline");
+    const createdAt = Date.now();
+    const timeoutMs = bounded(options.timeoutMs, this.defaultTimeoutMs, 10 * 6e4);
+    const id = randomUUID();
+    const { id: requestId, ...action } = request;
+    const record = { ...action, id, requestId, runId, stepId, createdAt, expiresAt: createdAt + timeoutMs, status: "pending" };
+    this.records.set(id, record);
+    const promise = new Promise((resolve) => {
+      const cancel = () => {
+        this.finish(id, "cancelled");
+      };
+      const timer = setTimeout(() => this.finish(id, "expired"), timeoutMs);
+      this.pending.set(id, { resolve, timer, cleanup: () => signal.removeEventListener("abort", cancel) });
+      signal.addEventListener("abort", cancel, { once: true });
+      if (signal.aborted) cancel();
+    });
+    this.trim();
+    this.emit();
+    return promise;
+  }
+  list(runId) {
+    this.expire();
+    return [...this.records.values()].filter((record) => !runId || record.runId === runId).sort((a, b) => b.createdAt - a.createdAt || a.id.localeCompare(b.id)).map((record) => structuredClone(record));
+  }
+  respond(id, decision, scope = {}) {
+    if (decision !== "approve" && decision !== "decline") return false;
+    const record = this.records.get(id);
+    if (!record || record.status !== "pending" || scope.runId !== void 0 && scope.runId !== record.runId || scope.stepId !== void 0 && scope.stepId !== record.stepId) return false;
+    if (Date.now() >= record.expiresAt) {
+      this.finish(id, "expired");
+      return false;
+    }
+    return this.finish(id, decision === "approve" ? "approved" : "declined");
+  }
+  cancelRun(runId) {
+    for (const record of this.records.values()) if (record.runId === runId) this.finish(record.id, "cancelled");
+  }
+  cancelStep(runId, stepId) {
+    for (const record of this.records.values()) if (record.runId === runId && record.stepId === stepId) this.finish(record.id, "cancelled");
+  }
+  close() {
+    this.closed = true;
+    for (const id of this.pending.keys()) this.finish(id, "cancelled");
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  expire() {
+    for (const record of this.records.values()) if (record.status === "pending" && Date.now() >= record.expiresAt) this.finish(record.id, "expired");
+  }
+  finish(id, status) {
+    const pending = this.pending.get(id);
+    const record = this.records.get(id);
+    if (!pending || !record || record.status !== "pending") return false;
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    pending.cleanup();
+    record.status = status;
+    record.resolvedAt = Date.now();
+    pending.resolve(status === "approved" ? "approve" : "decline");
+    this.trim();
+    this.emit();
+    return true;
+  }
+  trim() {
+    for (const [id, record] of this.records) {
+      if (this.records.size <= this.maxRecords) break;
+      if (record.status !== "pending") this.records.delete(id);
+    }
+  }
+  emit() {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+}
+function validateRequest(raw) {
+  if (!raw || typeof raw.id !== "string" || !raw.id || raw.id.length > 240 || !["command", "file-change"].includes(raw.kind)) return;
+  for (const [value, limit] of [[raw.command, 16e3], [raw.cwd, 4096], [raw.reason, 4e3]]) if (value !== void 0 && (typeof value !== "string" || value.length > limit || value.includes("\0"))) return;
+  if (raw.kind === "command" && !raw.command?.trim()) return;
+  if (raw.kind === "file-change" && (!raw.paths?.length || raw.paths.length > 200)) return;
+  if (raw.paths !== void 0 && (!Array.isArray(raw.paths) || raw.paths.some((path) => typeof path !== "string" || !path || path.length > 4096 || path.includes("\0")))) return;
+  return structuredClone({ id: raw.id, kind: raw.kind, ...raw.command ? { command: raw.command } : {}, ...raw.cwd ? { cwd: raw.cwd } : {}, ...raw.reason ? { reason: raw.reason } : {}, ...raw.paths ? { paths: raw.paths } : {} });
+}
+function bounded(value, fallback, maximum) {
+  return Math.min(maximum, Number.isFinite(value) && Number(value) > 0 ? Math.max(1, Math.round(value)) : fallback);
+}
+const approvals = new ApprovalRegistry();
+export {
+  ApprovalRegistry,
+  approvals
+};