@ashx-j/lunr 0.2.20 → 0.2.22

package/dist/node-runtime/chunk-RMQZU2YU.js

@@ -0,0 +1,117 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getAgentDir
+} from "./chunk-FQMM2EZ2.js";
+
+// packages/coding-agent/dist/gateway/pairing.js
+import { randomInt } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var CODE_ALPHABET = "ABCDEFGHJKMNPQRSTUVWXYZ23456789", CODE_LENGTH = 8, DEFAULT_TTL_MS = 3600 * 1e3, DEFAULT_RATE_LIMIT_MS = 600 * 1e3, DEFAULT_MAX_PENDING = 3, DEFAULT_MAX_FAILS = 5, DEFAULT_LOCKOUT_MS = 3600 * 1e3;
+function normalizeCode(code) {
+  return code.replace(/-/g, "").trim().toUpperCase();
+}
+function generateCode() {
+  let code = "";
+  for (let i = 0; i < CODE_LENGTH; i++)
+    code += CODE_ALPHABET[randomInt(0, CODE_ALPHABET.length)];
+  return code;
+}
+function createPairingStore(options = {}) {
+  let dir = options.dir ?? join(getAgentDir(), "pairing"), ttlMs = options.ttlMs ?? DEFAULT_TTL_MS, rateLimitMs = options.rateLimitMs ?? DEFAULT_RATE_LIMIT_MS, maxPending = options.maxPending ?? DEFAULT_MAX_PENDING, maxFails = options.maxFails ?? DEFAULT_MAX_FAILS, lockoutMs = options.lockoutMs ?? DEFAULT_LOCKOUT_MS, now = options.now ?? (() => Date.now());
+  function storeFile() {
+    return join(dir, "store.json");
+  }
+  function read() {
+    let path = storeFile();
+    if (!existsSync(path))
+      return { pending: [], approved: [] };
+    try {
+      let parsed = JSON.parse(readFileSync(path, "utf-8"));
+      if (parsed == null || typeof parsed != "object" || Array.isArray(parsed))
+        return { pending: [], approved: [] };
+      let p = parsed, pending = Array.isArray(p.pending) ? p.pending : [], approved = Array.isArray(p.approved) ? p.approved : [];
+      return {
+        pending: pending.filter((c) => typeof c?.code == "string" && typeof c?.platform == "string" && typeof c?.userId == "string"),
+        approved: approved.filter((u) => typeof u?.platform == "string" && typeof u?.userId == "string"),
+        failedAttempts: typeof p.failedAttempts == "object" && p.failedAttempts !== null && !Array.isArray(p.failedAttempts) ? p.failedAttempts : void 0,
+        lockedOutUntil: typeof p.lockedOutUntil == "object" && p.lockedOutUntil !== null && !Array.isArray(p.lockedOutUntil) ? p.lockedOutUntil : void 0
+      };
+    } catch {
+      return { pending: [], approved: [] };
+    }
+  }
+  function write(data) {
+    existsSync(dir) || mkdirSync(dir, { recursive: !0 });
+    let path = storeFile(), tmp = `${path}.tmp-${process.pid}`;
+    writeFileSync(tmp, `${JSON.stringify(data, null, 2)}
+`, "utf-8"), renameSync(tmp, path);
+    try {
+      chmodSync(path, 384);
+    } catch {
+    }
+  }
+  function isLockedOut(platform) {
+    let until = read().lockedOutUntil?.[platform] ?? 0;
+    return now() < until;
+  }
+  function recordFailedAttempt(platform) {
+    let data = read(), failed = data.failedAttempts ?? {};
+    if (failed[platform] = (failed[platform] ?? 0) + 1, failed[platform] >= maxFails) {
+      let locked = data.lockedOutUntil ?? {};
+      locked[platform] = now() + lockoutMs, failed[platform] = 0, data.lockedOutUntil = locked;
+    }
+    data.failedAttempts = failed, write(data);
+  }
+  function livePending(data) {
+    let cutoff = now() - ttlMs;
+    return data.pending.filter((c) => c.issuedAt >= cutoff);
+  }
+  return {
+    issueCode(platform, userId) {
+      if (isLockedOut(platform))
+        return null;
+      let data = read(), lastIssued = data.pending.filter((c) => c.platform === platform && c.userId === userId).reduce((max, c) => Math.max(max, c.issuedAt), 0);
+      if (lastIssued > 0 && now() - lastIssued < rateLimitMs)
+        return null;
+      let live = livePending(data);
+      if (live.filter((c) => c.platform === platform).length >= maxPending)
+        return null;
+      let entry = {
+        code: generateCode(),
+        platform,
+        userId,
+        issuedAt: now()
+      };
+      return data.pending = [...live, entry], write(data), entry.code;
+    },
+    approve(platform, code) {
+      if (isLockedOut(platform))
+        return null;
+      let data = read(), live = livePending(data), normalized = normalizeCode(code), match = live.find((c) => c.platform === platform && c.code === normalized);
+      return match ? (data.pending = live.filter((c) => c !== match), data.approved = [
+        ...data.approved.filter((u) => !(u.platform === platform && u.userId === match.userId)),
+        { platform, userId: match.userId, approvedAt: now() }
+      ], write(data), match.userId) : (recordFailedAttempt(platform), null);
+    },
+    isPaired(platform, userId) {
+      return read().approved.some((u) => u.platform === platform && u.userId === userId);
+    },
+    listPending() {
+      let data = read();
+      return livePending(data).map((c) => ({
+        code: c.code,
+        platform: c.platform,
+        userId: c.userId,
+        expiresAt: c.issuedAt + ttlMs
+      }));
+    },
+    listApproved() {
+      return read().approved.map((u) => ({ platform: u.platform, userId: u.userId, approvedAt: u.approvedAt }));
+    }
+  };
+}
+
+export {
+  createPairingStore
+};