@remnic/core 1.1.12 → 1.1.13

package/dist/chunk-LPMVBPA3.js

@@ -0,0 +1,236 @@
+import {
+  expandTildePath
+} from "./chunk-QRNI5JBH.js";
+
+// src/connectors/live/state-store.ts
+import { promises as fs } from "fs";
+import path from "path";
+
+// src/connectors/live/framework.ts
+var CONNECTOR_ID_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/;
+function isValidConnectorId(id) {
+  return typeof id === "string" && CONNECTOR_ID_PATTERN.test(id);
+}
+
+// src/connectors/live/state-store.ts
+var STATE_DIR_NAME = "state";
+var CONNECTORS_DIR_NAME = "connectors";
+var MAX_ERROR_LENGTH = 1024;
+var VALID_SYNC_STATUSES = /* @__PURE__ */ new Set([
+  "success",
+  "error",
+  "never"
+]);
+var ConnectorStateCorruptionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectorStateCorruptionError";
+  }
+};
+function resolveConnectorsDir(memoryDir) {
+  if (typeof memoryDir !== "string" || memoryDir.length === 0) {
+    throw new TypeError("memoryDir must be a non-empty string");
+  }
+  return path.join(expandTildePath(memoryDir), STATE_DIR_NAME, CONNECTORS_DIR_NAME);
+}
+function resolveConnectorStatePath(memoryDir, id) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  return path.join(resolveConnectorsDir(memoryDir), `${id}.json`);
+}
+function isConnectorStateShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  if (typeof v.id !== "string") return false;
+  if (typeof v.lastSyncStatus !== "string") return false;
+  if (!["success", "error", "never"].includes(v.lastSyncStatus)) return false;
+  if (typeof v.totalDocsImported !== "number" || !Number.isInteger(v.totalDocsImported)) return false;
+  if (v.totalDocsImported < 0) return false;
+  if (typeof v.updatedAt !== "string") return false;
+  if (v.lastSyncAt !== null && typeof v.lastSyncAt !== "string") return false;
+  if (v.cursor !== null) {
+    if (typeof v.cursor !== "object" || v.cursor === null) return false;
+    const c = v.cursor;
+    if (typeof c.kind !== "string" || typeof c.value !== "string" || typeof c.updatedAt !== "string") {
+      return false;
+    }
+  }
+  if (v.lastSyncError !== void 0 && typeof v.lastSyncError !== "string") return false;
+  return true;
+}
+async function assertNoSymlinkOnPath(memoryDir, filePath) {
+  const expandedRoot = expandTildePath(memoryDir);
+  const root = path.resolve(expandedRoot);
+  const target = path.resolve(filePath);
+  const rel = path.relative(root, target);
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    throw new Error(
+      `connector state path ${target} escapes memory root ${root}`
+    );
+  }
+  const segments = rel.length === 0 ? [] : rel.split(path.sep);
+  let current = root;
+  const componentsToCheck = [current];
+  for (const seg of segments) {
+    current = path.join(current, seg);
+    componentsToCheck.push(current);
+  }
+  for (const component of componentsToCheck) {
+    let stat;
+    try {
+      stat = await fs.lstat(component);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    if (stat.isSymbolicLink()) {
+      throw new Error(
+        `connector state path component ${component} is a symlink; refusing to follow`
+      );
+    }
+  }
+}
+async function readConnectorState(memoryDir, id) {
+  const filePath = resolveConnectorStatePath(memoryDir, id);
+  await assertNoSymlinkOnPath(memoryDir, filePath);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} is not valid JSON: ${err.message}`
+    );
+  }
+  if (!isConnectorStateShape(parsed)) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} does not match ConnectorState shape`
+    );
+  }
+  if (parsed.id !== id) {
+    throw new ConnectorStateCorruptionError(
+      `connector state at ${filePath} has mismatched id ${JSON.stringify(parsed.id)}; expected ${JSON.stringify(id)}`
+    );
+  }
+  return parsed;
+}
+async function writeConnectorState(memoryDir, id, state) {
+  if (!isValidConnectorId(id)) {
+    throw new TypeError(
+      `invalid connector id ${JSON.stringify(id)} \u2014 must match /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/`
+    );
+  }
+  if (state.id !== id) {
+    throw new Error(
+      `writeConnectorState(): state.id ${JSON.stringify(state.id)} does not match id argument ${JSON.stringify(id)}`
+    );
+  }
+  if (!VALID_SYNC_STATUSES.has(state.lastSyncStatus)) {
+    throw new Error(
+      `writeConnectorState(): lastSyncStatus must be one of ${[...VALID_SYNC_STATUSES].join(", ")}, got ${JSON.stringify(state.lastSyncStatus)}`
+    );
+  }
+  if (state.lastSyncAt !== null && typeof state.lastSyncAt !== "string") {
+    throw new Error(
+      `writeConnectorState(): lastSyncAt must be a string or null, got ${typeof state.lastSyncAt}`
+    );
+  }
+  if (state.cursor !== null) {
+    if (typeof state.cursor !== "object") {
+      throw new Error(`writeConnectorState(): cursor must be an object or null`);
+    }
+    if (typeof state.cursor.kind !== "string" || typeof state.cursor.value !== "string" || typeof state.cursor.updatedAt !== "string") {
+      throw new Error(
+        `writeConnectorState(): cursor must have string kind, value, and updatedAt`
+      );
+    }
+  }
+  if (typeof state.totalDocsImported !== "number" || !Number.isInteger(state.totalDocsImported) || state.totalDocsImported < 0) {
+    throw new Error(
+      `writeConnectorState(): totalDocsImported must be a non-negative integer`
+    );
+  }
+  if (state.lastSyncError !== void 0 && typeof state.lastSyncError !== "string") {
+    throw new Error(`writeConnectorState(): lastSyncError must be a string when provided`);
+  }
+  const truncatedError = state.lastSyncError !== void 0 && state.lastSyncError.length > MAX_ERROR_LENGTH ? state.lastSyncError.slice(0, MAX_ERROR_LENGTH) : state.lastSyncError;
+  const finalState = {
+    id: state.id,
+    cursor: state.cursor,
+    lastSyncAt: state.lastSyncAt,
+    lastSyncStatus: state.lastSyncStatus,
+    ...truncatedError !== void 0 ? { lastSyncError: truncatedError } : {},
+    totalDocsImported: state.totalDocsImported,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const dir = resolveConnectorsDir(memoryDir);
+  const targetPath = path.join(dir, `${id}.json`);
+  await assertNoSymlinkOnPath(memoryDir, targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const body = `${JSON.stringify(finalState, null, 2)}
+`;
+  try {
+    await fs.writeFile(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    await fs.rename(tmpPath, targetPath);
+  } catch (err) {
+    try {
+      await fs.unlink(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  return finalState;
+}
+async function listConnectorStates(memoryDir) {
+  const dir = resolveConnectorsDir(memoryDir);
+  await assertNoSymlinkOnPath(memoryDir, dir);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  const out = [];
+  for (const entry of entries) {
+    if (!entry.endsWith(".json")) continue;
+    const id = entry.slice(0, -".json".length);
+    if (!isValidConnectorId(id)) continue;
+    try {
+      const state = await readConnectorState(memoryDir, id);
+      if (state !== null) out.push(state);
+    } catch (err) {
+      if (err instanceof ConnectorStateCorruptionError) {
+        continue;
+      }
+      throw err;
+    }
+  }
+  out.sort((a, b) => a.id.localeCompare(b.id));
+  return out;
+}
+function _connectorStatePathForTest(memoryDir, id) {
+  return resolveConnectorStatePath(memoryDir, id);
+}
+
+export {
+  CONNECTOR_ID_PATTERN,
+  isValidConnectorId,
+  readConnectorState,
+  writeConnectorState,
+  listConnectorStates,
+  _connectorStatePathForTest
+};
+//# sourceMappingURL=chunk-LPMVBPA3.js.map

package/dist/chunk-LT3NLYSI.js

@@ -0,0 +1,50 @@
+// src/maintenance/observation-ledger-utils.ts
+import path from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+function toHourBucketIso(timestamp) {
+  const normalized = /(?:Z|[+-]\d{2}:\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;
+  const ms = Date.parse(normalized);
+  if (!Number.isFinite(ms)) return null;
+  const d = new Date(ms);
+  d.setUTCMinutes(0, 0, 0);
+  return d.toISOString();
+}
+async function backupAndWriteRebuiltObservations(options) {
+  const stamp = options.now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+  const archiveRoot = path.join(options.memoryDir, "archive", "observations", stamp);
+  let backupPath = path.join(
+    archiveRoot,
+    "state",
+    "observation-ledger",
+    "rebuilt-observations.jsonl"
+  );
+  try {
+    const existing = await readFile(options.outputPath, "utf-8");
+    await mkdir(path.dirname(backupPath), { recursive: true });
+    await writeFile(backupPath, existing, "utf-8");
+  } catch (err) {
+    const code = err.code;
+    if (code && code === "ENOENT") {
+      backupPath = void 0;
+    } else {
+      throw err;
+    }
+  }
+  const rebuiltAt = options.now.toISOString();
+  const lines = options.rows.map(
+    (row) => JSON.stringify({
+      ...row,
+      rebuiltAt
+    })
+  );
+  await mkdir(path.dirname(options.outputPath), { recursive: true });
+  await writeFile(options.outputPath, lines.length > 0 ? `${lines.join("\n")}
+` : "", "utf-8");
+  return backupPath;
+}
+
+export {
+  toHourBucketIso,
+  backupAndWriteRebuiltObservations
+};
+//# sourceMappingURL=chunk-LT3NLYSI.js.map

package/dist/chunk-LT3NLYSI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/observation-ledger-utils.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\n\ninterface LedgerWriteOptions<T extends object> {\n  memoryDir: string;\n  outputPath: string;\n  rows: T[];\n  now: Date;\n}\n\nexport function toHourBucketIso(timestamp: string): string | null {\n  const normalized = /(?:Z|[+-]\\d{2}:\\d{2})$/u.test(timestamp) ? timestamp : `${timestamp}Z`;\n  const ms = Date.parse(normalized);\n  if (!Number.isFinite(ms)) return null;\n  const d = new Date(ms);\n  d.setUTCMinutes(0, 0, 0);\n  return d.toISOString();\n}\n\nexport async function backupAndWriteRebuiltObservations<T extends object>(\n  options: LedgerWriteOptions<T>,\n): Promise<string | undefined> {\n  const stamp = options.now.toISOString().replace(/[-:]/g, \"\").replace(/\\.\\d{3}Z$/, \"Z\");\n  const archiveRoot = path.join(options.memoryDir, \"archive\", \"observations\", stamp);\n  let backupPath: string | undefined = path.join(\n    archiveRoot,\n    \"state\",\n    \"observation-ledger\",\n    \"rebuilt-observations.jsonl\",\n  );\n  try {\n    const existing = await readFile(options.outputPath, \"utf-8\");\n    await mkdir(path.dirname(backupPath), { recursive: true });\n    await writeFile(backupPath, existing, \"utf-8\");\n  } catch (err) {\n    const code = (err as NodeJS.ErrnoException).code;\n    if (code && code === \"ENOENT\") {\n      backupPath = undefined;\n    } else {\n      throw err;\n    }\n  }\n\n  const rebuiltAt = options.now.toISOString();\n  const lines = options.rows.map((row) =>\n    JSON.stringify({\n      ...row,\n      rebuiltAt,\n    }),\n  );\n  await mkdir(path.dirname(options.outputPath), { recursive: true });\n  await writeFile(options.outputPath, lines.length > 0 ? `${lines.join(\"\\n\")}\\n` : \"\", \"utf-8\");\n  return backupPath;\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,SAAS,OAAO,UAAU,iBAAiB;AASpC,SAAS,gBAAgB,WAAkC;AAChE,QAAM,aAAa,0BAA0B,KAAK,SAAS,IAAI,YAAY,GAAG,SAAS;AACvF,QAAM,KAAK,KAAK,MAAM,UAAU;AAChC,MAAI,CAAC,OAAO,SAAS,EAAE,EAAG,QAAO;AACjC,QAAM,IAAI,IAAI,KAAK,EAAE;AACrB,IAAE,cAAc,GAAG,GAAG,CAAC;AACvB,SAAO,EAAE,YAAY;AACvB;AAEA,eAAsB,kCACpB,SAC6B;AAC7B,QAAM,QAAQ,QAAQ,IAAI,YAAY,EAAE,QAAQ,SAAS,EAAE,EAAE,QAAQ,aAAa,GAAG;AACrF,QAAM,cAAc,KAAK,KAAK,QAAQ,WAAW,WAAW,gBAAgB,KAAK;AACjF,MAAI,aAAiC,KAAK;AAAA,IACxC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACA,MAAI;AACF,UAAM,WAAW,MAAM,SAAS,QAAQ,YAAY,OAAO;AAC3D,UAAM,MAAM,KAAK,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACzD,UAAM,UAAU,YAAY,UAAU,OAAO;AAAA,EAC/C,SAAS,KAAK;AACZ,UAAM,OAAQ,IAA8B;AAC5C,QAAI,QAAQ,SAAS,UAAU;AAC7B,mBAAa;AAAA,IACf,OAAO;AACL,YAAM;AAAA,IACR;AAAA,EACF;AAEA,QAAM,YAAY,QAAQ,IAAI,YAAY;AAC1C,QAAM,QAAQ,QAAQ,KAAK;AAAA,IAAI,CAAC,QAC9B,KAAK,UAAU;AAAA,MACb,GAAG;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH;AACA,QAAM,MAAM,KAAK,QAAQ,QAAQ,UAAU,GAAG,EAAE,WAAW,KAAK,CAAC;AACjE,QAAM,UAAU,QAAQ,YAAY,MAAM,SAAS,IAAI,GAAG,MAAM,KAAK,IAAI,CAAC;AAAA,IAAO,IAAI,OAAO;AAC5F,SAAO;AACT;","names":[]}

package/dist/chunk-LUDTDZLK.js

@@ -0,0 +1,287 @@
+import {
+  validateRouteTarget
+} from "./chunk-U3PN77QT.js";
+import {
+  log
+} from "./chunk-2ODBA7MQ.js";
+
+// src/routing/store.ts
+import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+function defaultState() {
+  return {
+    version: 1,
+    updatedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+    rules: []
+  };
+}
+function stableRuleId(rule) {
+  const seed = JSON.stringify({
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: rule.priority,
+    target: rule.target
+  });
+  return `route-${createHash("sha256").update(seed).digest("hex").slice(0, 12)}`;
+}
+function resolveStatePath(memoryDir, stateFile) {
+  const root = path.resolve(memoryDir);
+  const defaultPath = path.join(root, "state", "routing-rules.json");
+  if (path.isAbsolute(stateFile)) {
+    const absolute = path.resolve(stateFile);
+    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;
+  }
+  const resolved = path.resolve(root, stateFile);
+  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;
+}
+function normalizeRule(rule, options) {
+  if (!rule || typeof rule !== "object") return null;
+  if (rule.enabled === false) return null;
+  if (rule.patternType !== "keyword" && rule.patternType !== "regex") return null;
+  if (typeof rule.pattern !== "string" || rule.pattern.trim().length === 0) return null;
+  if (typeof rule.priority !== "number" || !Number.isFinite(rule.priority)) return null;
+  const targetValidation = validateRouteTarget(rule.target, options);
+  if (!targetValidation.ok || !targetValidation.target) return null;
+  const normalizedPriority = Math.trunc(rule.priority);
+  const normalizedTarget = targetValidation.target;
+  const id = typeof rule.id === "string" && rule.id.trim().length > 0 ? rule.id.trim() : stableRuleId({
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: normalizedPriority,
+    target: normalizedTarget
+  });
+  return {
+    id,
+    patternType: rule.patternType,
+    pattern: rule.pattern.trim(),
+    priority: normalizedPriority,
+    target: normalizedTarget,
+    enabled: true
+  };
+}
+function isEnoent(err) {
+  return err instanceof Error && "code" in err && err.code === "ENOENT";
+}
+var RoutingRulesStore = class {
+  memoryRoot;
+  statePath;
+  lockPath;
+  writeQueue = Promise.resolve();
+  constructor(memoryDir, stateFile = "state/routing-rules.json") {
+    this.memoryRoot = path.resolve(memoryDir);
+    this.statePath = resolveStatePath(memoryDir, stateFile);
+    this.lockPath = `${this.statePath}.lock`;
+  }
+  async read(options) {
+    try {
+      const persisted = await this.readPersistedRules();
+      return persisted.map((rule) => normalizeRule(rule, options)).filter((rule) => rule !== null);
+    } catch {
+      return [];
+    }
+  }
+  async write(rules, options) {
+    return this.withWriteLock(async () => {
+      await this.readPersistedRules();
+      return this.writeNormalized(rules, options);
+    });
+  }
+  async upsert(rule, options) {
+    return this.withWriteLock(async () => {
+      const existing = await this.readPersistedRules();
+      const normalized = normalizeRule(rule, options);
+      if (!normalized) return existing;
+      const next = existing.filter((entry) => entry.id !== normalized.id);
+      next.push(normalized);
+      return this.writeNormalized(next);
+    });
+  }
+  async removeByPattern(pattern) {
+    return this.withWriteLock(async () => {
+      const trimmed = pattern.trim();
+      const existing = await this.readPersistedRules();
+      const next = existing.filter((entry) => entry.pattern !== trimmed);
+      if (next.length === existing.length) return existing;
+      return this.writeNormalized(next);
+    });
+  }
+  async reset() {
+    await this.withWriteLock(async () => {
+      await this.writeState(defaultState());
+    });
+  }
+  dedupeById(rules) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const rule of rules) {
+      byId.set(rule.id, rule);
+    }
+    return Array.from(byId.values());
+  }
+  async readPersistedRules() {
+    await this.assertStatePathScoped();
+    let raw;
+    try {
+      raw = await readFile(this.statePath, "utf-8");
+    } catch (err) {
+      if (isEnoent(err)) {
+        return [];
+      }
+      throw err;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new Error(
+        `failed to parse routing rules state at ${this.statePath}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error(`invalid routing rules state at ${this.statePath}: expected object`);
+    }
+    const state = parsed;
+    if (!Array.isArray(state.rules)) {
+      throw new Error(`invalid routing rules state at ${this.statePath}: rules must be an array`);
+    }
+    const normalized = state.rules.map((rule) => normalizeRule(rule)).filter((rule) => rule !== null);
+    return this.dedupeById(normalized);
+  }
+  async writeNormalized(rules, options) {
+    const normalized = this.dedupeById(
+      rules.map((rule) => normalizeRule(rule, options)).filter((rule) => rule !== null)
+    );
+    const payload = {
+      version: 1,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      rules: normalized
+    };
+    await this.writeState(payload);
+    return normalized;
+  }
+  async writeState(payload) {
+    const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;
+    try {
+      await this.assertStatePathScoped();
+      await writeFile(tmpPath, JSON.stringify(payload, null, 2), "utf-8");
+      await rename(tmpPath, this.statePath);
+    } catch (err) {
+      log.debug(`routing rules write failed: ${err}`);
+      throw err;
+    } finally {
+      await rm(tmpPath, { force: true }).catch(() => {
+      });
+    }
+  }
+  async withWriteLock(op) {
+    const previous = this.writeQueue;
+    let release = () => {
+    };
+    this.writeQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    let unlock = null;
+    try {
+      unlock = await this.acquireFileLock();
+      return await op();
+    } finally {
+      if (unlock) await unlock();
+      release();
+    }
+  }
+  async acquireFileLock() {
+    const start = Date.now();
+    const staleMs = 3e4;
+    const timeoutMs = 5e3;
+    let unexpectedLockError = null;
+    await this.assertStatePathScoped();
+    await mkdir(path.dirname(this.lockPath), { recursive: true });
+    while (Date.now() - start < timeoutMs) {
+      try {
+        await mkdir(this.lockPath);
+        return async () => {
+          try {
+            await rm(this.lockPath, { recursive: true, force: true });
+          } catch {
+          }
+        };
+      } catch (err) {
+        const code = err.code;
+        if (code !== "EEXIST") {
+          unexpectedLockError = err;
+          break;
+        }
+        try {
+          const lockStat = await stat(this.lockPath);
+          if (Date.now() - lockStat.mtimeMs > staleMs) {
+            await rm(this.lockPath, { recursive: true, force: true });
+            continue;
+          }
+        } catch {
+        }
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    if (unexpectedLockError) {
+      throw unexpectedLockError;
+    }
+    throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);
+  }
+  async assertStatePathScoped() {
+    await mkdir(this.memoryRoot, { recursive: true });
+    const canonicalRoot = await realpath(this.memoryRoot);
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));
+    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));
+    if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
+      throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
+    }
+    await mkdir(path.dirname(this.statePath), { recursive: true });
+    try {
+      const stateStats = await lstat(this.statePath);
+      if (stateStats.isSymbolicLink()) {
+        throw new Error(`routing rules state path must not be a symlink: ${this.statePath}`);
+      }
+    } catch (err) {
+      const code = err.code;
+      if (code !== "ENOENT") {
+        throw err;
+      }
+    }
+  }
+  isPathInside(root, candidate) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
+    if (normalizedCandidate === normalizedRoot) return true;
+    if (normalizedRoot === path.parse(normalizedRoot).root) {
+      return normalizedCandidate.startsWith(normalizedRoot);
+    }
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);
+  }
+  async canonicalizePathWithoutCreating(targetPath) {
+    const absoluteTarget = path.resolve(targetPath);
+    let probe = absoluteTarget;
+    while (true) {
+      try {
+        const canonicalProbe = await realpath(probe);
+        const remainder = path.relative(probe, absoluteTarget);
+        return path.resolve(canonicalProbe, remainder);
+      } catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT") {
+          throw err;
+        }
+        const parent = path.dirname(probe);
+        if (parent === probe) {
+          return absoluteTarget;
+        }
+        probe = parent;
+      }
+    }
+  }
+};
+
+export {
+  RoutingRulesStore
+};
+//# sourceMappingURL=chunk-LUDTDZLK.js.map

package/dist/chunk-LUDTDZLK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing/store.ts"],"sourcesContent":["import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport { validateRouteTarget, type RouteRule, type RoutingEngineOptions } from \"./engine.js\";\n\ntype RoutingRulesState = {\n  version: 1;\n  updatedAt: string;\n  rules: RouteRule[];\n};\n\nfunction defaultState(): RoutingRulesState {\n  return {\n    version: 1,\n    updatedAt: new Date(0).toISOString(),\n    rules: [],\n  };\n}\n\nfunction stableRuleId(rule: Pick<RouteRule, \"patternType\" | \"pattern\" | \"priority\" | \"target\">): string {\n  const seed = JSON.stringify({\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: rule.priority,\n    target: rule.target,\n  });\n  return `route-${createHash(\"sha256\").update(seed).digest(\"hex\").slice(0, 12)}`;\n}\n\nfunction resolveStatePath(memoryDir: string, stateFile: string): string {\n  const root = path.resolve(memoryDir);\n  const defaultPath = path.join(root, \"state\", \"routing-rules.json\");\n  if (path.isAbsolute(stateFile)) {\n    const absolute = path.resolve(stateFile);\n    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;\n  }\n  const resolved = path.resolve(root, stateFile);\n  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;\n}\n\nfunction normalizeRule(rule: RouteRule, options?: RoutingEngineOptions): RouteRule | null {\n  if (!rule || typeof rule !== \"object\") return null;\n  if (rule.enabled === false) return null;\n  if (rule.patternType !== \"keyword\" && rule.patternType !== \"regex\") return null;\n  if (typeof rule.pattern !== \"string\" || rule.pattern.trim().length === 0) return null;\n  if (typeof rule.priority !== \"number\" || !Number.isFinite(rule.priority)) return null;\n\n  const targetValidation = validateRouteTarget(rule.target, options);\n  if (!targetValidation.ok || !targetValidation.target) return null;\n\n  const normalizedPriority = Math.trunc(rule.priority);\n  const normalizedTarget = targetValidation.target;\n  const id = typeof rule.id === \"string\" && rule.id.trim().length > 0\n    ? rule.id.trim()\n    : stableRuleId({\n      patternType: rule.patternType,\n      pattern: rule.pattern.trim(),\n      priority: normalizedPriority,\n      target: normalizedTarget,\n    });\n  return {\n    id,\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: normalizedPriority,\n    target: normalizedTarget,\n    enabled: true,\n  };\n}\n\nfunction isEnoent(err: unknown): boolean {\n  return err instanceof Error && \"code\" in err && (err as NodeJS.ErrnoException).code === \"ENOENT\";\n}\n\nexport class RoutingRulesStore {\n  private readonly memoryRoot: string;\n  private readonly statePath: string;\n  private readonly lockPath: string;\n  private writeQueue: Promise<void> = Promise.resolve();\n\n  constructor(memoryDir: string, stateFile = \"state/routing-rules.json\") {\n    this.memoryRoot = path.resolve(memoryDir);\n    this.statePath = resolveStatePath(memoryDir, stateFile);\n    this.lockPath = `${this.statePath}.lock`;\n  }\n\n  async read(options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    try {\n      const persisted = await this.readPersistedRules();\n      return persisted\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null);\n    } catch {\n      return [];\n    }\n  }\n\n  async write(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      await this.readPersistedRules();\n      return this.writeNormalized(rules, options);\n    });\n  }\n\n  async upsert(rule: RouteRule, options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const existing = await this.readPersistedRules();\n      const normalized = normalizeRule(rule, options);\n      if (!normalized) return existing;\n\n      const next = existing.filter((entry) => entry.id !== normalized.id);\n      next.push(normalized);\n      return this.writeNormalized(next);\n    });\n  }\n\n  async removeByPattern(pattern: string): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const trimmed = pattern.trim();\n      const existing = await this.readPersistedRules();\n      const next = existing.filter((entry) => entry.pattern !== trimmed);\n      if (next.length === existing.length) return existing;\n      return this.writeNormalized(next);\n    });\n  }\n\n  async reset(): Promise<void> {\n    await this.withWriteLock(async () => {\n      await this.writeState(defaultState());\n    });\n  }\n\n  private dedupeById(rules: RouteRule[]): RouteRule[] {\n    const byId = new Map<string, RouteRule>();\n    for (const rule of rules) {\n      byId.set(rule.id, rule);\n    }\n    return Array.from(byId.values());\n  }\n\n  private async readPersistedRules(): Promise<RouteRule[]> {\n    await this.assertStatePathScoped();\n    let raw: string;\n    try {\n      raw = await readFile(this.statePath, \"utf-8\");\n    } catch (err) {\n      if (isEnoent(err)) {\n        return [];\n      }\n      throw err;\n    }\n\n    let parsed: unknown;\n    try {\n      parsed = JSON.parse(raw);\n    } catch (err) {\n      throw new Error(\n        `failed to parse routing rules state at ${this.statePath}: ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n\n    if (!parsed || typeof parsed !== \"object\" || Array.isArray(parsed)) {\n      throw new Error(`invalid routing rules state at ${this.statePath}: expected object`);\n    }\n    const state = parsed as Partial<RoutingRulesState>;\n    if (!Array.isArray(state.rules)) {\n      throw new Error(`invalid routing rules state at ${this.statePath}: rules must be an array`);\n    }\n    const normalized = state.rules\n      .map((rule) => normalizeRule(rule))\n      .filter((rule): rule is RouteRule => rule !== null);\n    return this.dedupeById(normalized);\n  }\n\n  private async writeNormalized(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    const normalized = this.dedupeById(\n      rules\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null),\n    );\n\n    const payload: RoutingRulesState = {\n      version: 1,\n      updatedAt: new Date().toISOString(),\n      rules: normalized,\n    };\n\n    await this.writeState(payload);\n\n    return normalized;\n  }\n\n  private async writeState(payload: RoutingRulesState): Promise<void> {\n    const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;\n    try {\n      await this.assertStatePathScoped();\n      await writeFile(tmpPath, JSON.stringify(payload, null, 2), \"utf-8\");\n      await rename(tmpPath, this.statePath);\n    } catch (err) {\n      log.debug(`routing rules write failed: ${err}`);\n      throw err;\n    } finally {\n      await rm(tmpPath, { force: true }).catch(() => {});\n    }\n  }\n\n  private async withWriteLock<T>(op: () => Promise<T>): Promise<T> {\n    const previous = this.writeQueue;\n    let release: () => void = () => {};\n    this.writeQueue = new Promise<void>((resolve) => {\n      release = resolve;\n    });\n    await previous;\n    let unlock: (() => Promise<void>) | null = null;\n    try {\n      unlock = await this.acquireFileLock();\n      return await op();\n    } finally {\n      if (unlock) await unlock();\n      release();\n    }\n  }\n\n  private async acquireFileLock(): Promise<() => Promise<void>> {\n    const start = Date.now();\n    const staleMs = 30_000;\n    const timeoutMs = 5_000;\n    let unexpectedLockError: unknown = null;\n    await this.assertStatePathScoped();\n    await mkdir(path.dirname(this.lockPath), { recursive: true });\n\n    while (Date.now() - start < timeoutMs) {\n      try {\n        await mkdir(this.lockPath);\n        return async () => {\n          try {\n            await rm(this.lockPath, { recursive: true, force: true });\n          } catch {\n            // Fail-open: lock cleanup should not fail writes.\n          }\n        };\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"EEXIST\") {\n          unexpectedLockError = err;\n          break;\n        }\n        try {\n          const lockStat = await stat(this.lockPath);\n          if (Date.now() - lockStat.mtimeMs > staleMs) {\n            await rm(this.lockPath, { recursive: true, force: true });\n            continue;\n          }\n        } catch {\n          // Lock may have been released between stat/rm attempts.\n        }\n        await new Promise((resolve) => setTimeout(resolve, 25));\n      }\n    }\n\n    if (unexpectedLockError) {\n      throw unexpectedLockError;\n    }\n    throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);\n  }\n\n  private async assertStatePathScoped(): Promise<void> {\n    await mkdir(this.memoryRoot, { recursive: true });\n    const canonicalRoot = await realpath(this.memoryRoot);\n    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));\n    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));\n    if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {\n      throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);\n    }\n    await mkdir(path.dirname(this.statePath), { recursive: true });\n    try {\n      const stateStats = await lstat(this.statePath);\n      if (stateStats.isSymbolicLink()) {\n        throw new Error(`routing rules state path must not be a symlink: ${this.statePath}`);\n      }\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code !== \"ENOENT\") {\n        throw err;\n      }\n    }\n  }\n\n  private isPathInside(root: string, candidate: string): boolean {\n    const normalizedRoot = path.resolve(root);\n    const normalizedCandidate = path.resolve(candidate);\n    if (normalizedCandidate === normalizedRoot) return true;\n    if (normalizedRoot === path.parse(normalizedRoot).root) {\n      return normalizedCandidate.startsWith(normalizedRoot);\n    }\n    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);\n  }\n\n  private async canonicalizePathWithoutCreating(targetPath: string): Promise<string> {\n    const absoluteTarget = path.resolve(targetPath);\n    let probe = absoluteTarget;\n    while (true) {\n      try {\n        const canonicalProbe = await realpath(probe);\n        const remainder = path.relative(probe, absoluteTarget);\n        return path.resolve(canonicalProbe, remainder);\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"ENOENT\") {\n          throw err;\n        }\n        const parent = path.dirname(probe);\n        if (parent === probe) {\n          return absoluteTarget;\n        }\n        probe = parent;\n      }\n    }\n  }\n}\n"],"mappings":"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","names":[]}