@fleox-agent-crm/agentcrm 0.0.0-stage → 0.3.0

package/dist/agent/chunks/index-B-4W0-P4.mjs

@@ -0,0 +1,535 @@
+import { createRequire as __acrmRequire } from "node:module";
+import { fileURLToPath as __acrmPath } from "node:url";
+import { dirname as __acrmDirname } from "node:path";
+const require2 = __acrmRequire(import.meta.url);
+const __filename = __acrmPath(import.meta.url);
+const __dirname = __acrmDirname(__filename);
+import { isEncrypted, decryptBytes, encryptBytes, PassphraseError, decryptText, newEncryptionParams, PBKDF2_ITERATIONS, encryptText } from "./index-CWrrF1wl.mjs";
+import { b as bytesToBase64, d as base64ToBytes } from "./encoding-C9MzdP95.mjs";
+import { m as mapLimit } from "./http-Bk9ICb7I.mjs";
+import { b as setPath, a as splitPath, n as normalizeDoc, e as emptySnapshot, c as createStoreCore } from "./core-Dy7vY9H6.mjs";
+import { w as withFileStore } from "./index-RCmo-uld.mjs";
+import { a as assertFileId } from "./ids-u-noYcy5.mjs";
+import { COLLECTIONS } from "./types-BOy9PUl7.mjs";
+import "./index-BM8qeGOb.mjs";
+const MAX_COUNTER = 36 ** 4 - 1;
+const MAX_DRIFT_MS = 24 * 36e5;
+function formatHlc(h) {
+  return `${String(Math.floor(h.wall)).padStart(13, "0")}-${h.counter.toString(36).padStart(4, "0")}-${h.node}`;
+}
+function parseHlc(s) {
+  const m = /^(\d{13})-([0-9a-z]{4})-(.+)$/.exec(s);
+  if (!m) throw new Error(`Invalid HLC timestamp "${s}"`);
+  return { wall: Number(m[1]), counter: parseInt(m[2], 36), node: m[3] };
+}
+function maxHlc(a, b) {
+  if (!a) return b;
+  if (!b) return a;
+  return a > b ? a : b;
+}
+function createHlcClock(node, wallClock = Date.now) {
+  if (!/^[0-9a-z]+$/i.test(node)) throw new Error(`Invalid HLC node id "${node}"`);
+  let state = { wall: 0, counter: 0, node };
+  let issued = false;
+  function bump(wall, counter) {
+    if (counter > MAX_COUNTER) {
+      state = { wall: wall + 1, counter: 0, node };
+    } else {
+      state = { wall, counter, node };
+    }
+  }
+  return {
+    node,
+    now() {
+      const physical = wallClock();
+      if (physical > state.wall) bump(physical, 0);
+      else bump(state.wall, state.counter + 1);
+      issued = true;
+      return formatHlc(state);
+    },
+    receive(stamp) {
+      const remote = parseHlc(stamp);
+      const physical = wallClock();
+      if (remote.wall > physical + MAX_DRIFT_MS) return;
+      if (remote.wall > state.wall) bump(remote.wall, remote.counter + 1);
+      else if (remote.wall === state.wall && remote.counter >= state.counter) bump(state.wall, remote.counter + 1);
+      issued = true;
+    },
+    last() {
+      return issued ? formatHlc(state) : "";
+    }
+  };
+}
+function createJournalFileStore(opts) {
+  const { connector, folder } = opts;
+  const path = (id) => `${folder}${id}.bin`;
+  async function encode(bytes) {
+    const key = await opts.key();
+    return key ? encryptBytes(bytes, key.passphrase, key.params) : bytes;
+  }
+  const put = async (id, bytes) => {
+    assertFileId(id);
+    const data = await encode(bytes);
+    await connector.put({ path: path(id), content: bytesToBase64(data), encoding: "base64" });
+  };
+  return {
+    kind: "journal",
+    put,
+    async putMany(items) {
+      for (const it of items) await put(it.id, it.bytes);
+    },
+    async get(id) {
+      assertFileId(id);
+      const bytes = await connector.getBytes(path(id));
+      if (!bytes) return null;
+      return isEncrypted(bytes) ? decryptBytes(bytes, opts.passphrase()) : bytes;
+    },
+    async delete(id) {
+      assertFileId(id);
+      await connector.delete(path(id));
+    },
+    async list() {
+      if (!connector.listPrefix) return [];
+      return (await connector.listPrefix(folder)).filter((p) => p.endsWith(".bin")).map((p) => p.slice(folder.length, -".bin".length)).filter((id) => !id.includes("/"));
+    }
+  };
+}
+const GZIP_MAGIC = [31, 139];
+function hasCompressionStream() {
+  return typeof CompressionStream !== "undefined" && typeof DecompressionStream !== "undefined";
+}
+async function nodeZlib() {
+  const specifier = "node:zlib";
+  return await import(
+    /* @vite-ignore */
+    specifier
+  );
+}
+async function pipe(bytes, transform) {
+  const stream = new Blob([bytes]).stream().pipeThrough(transform);
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function gzip(bytes) {
+  if (hasCompressionStream()) return pipe(bytes, new CompressionStream("gzip"));
+  return new Uint8Array((await nodeZlib()).gzipSync(bytes));
+}
+async function gunzip(bytes) {
+  if (hasCompressionStream()) return pipe(bytes, new DecompressionStream("gzip"));
+  return new Uint8Array((await nodeZlib()).gunzipSync(bytes));
+}
+function isGzip(bytes) {
+  return bytes.length > 2 && bytes[0] === GZIP_MAGIC[0] && bytes[1] === GZIP_MAGIC[1];
+}
+async function encodeJson(value, key) {
+  const compressed = await gzip(new TextEncoder().encode(JSON.stringify(value)));
+  return key ? encryptBytes(compressed, key.passphrase, key.params) : compressed;
+}
+async function decodeJson(bytes, passphrase) {
+  let data = bytes;
+  if (isEncrypted(data)) data = await decryptBytes(data, passphrase);
+  if (isGzip(data)) data = await gunzip(data);
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function emptyMergeState() {
+  return Object.fromEntries(COLLECTIONS.map((c) => [c, /* @__PURE__ */ new Map()]));
+}
+function toJournalOp(m, t) {
+  if (m.op === "set") return { t, op: "set", c: m.collection, doc: m.doc };
+  if (m.op === "delete") return { t, op: "delete", c: m.collection, id: m.id };
+  return {
+    t,
+    op: "patch",
+    c: m.collection,
+    id: m.id,
+    f: Object.entries(m.fields).filter(([k]) => splitPath(k)[0] !== "id").map(([k, v]) => v === void 0 ? [k] : [k, v])
+  };
+}
+function docState(state, c, id) {
+  let ds = state[c].get(id);
+  if (!ds) {
+    ds = { e: {} };
+    state[c].set(id, ds);
+  }
+  return ds;
+}
+function isDescendant(path, ancestor) {
+  return path.length > ancestor.length && path.startsWith(ancestor) && path[ancestor.length] === ".";
+}
+function applyEntry(ds, path, entry) {
+  if (ds.reset && entry.t < ds.reset) return false;
+  const parts = splitPath(path);
+  for (let i = 1; i <= parts.length; i++) {
+    const existing = ds.e[parts.slice(0, i).join(".")];
+    if (existing && (i === parts.length ? existing.t >= entry.t : existing.t > entry.t)) return false;
+  }
+  for (const key of Object.keys(ds.e)) {
+    if (isDescendant(key, path) && ds.e[key].t < entry.t) delete ds.e[key];
+  }
+  ds.e[path] = entry;
+  return true;
+}
+function applySet(ds, t, doc) {
+  if (ds.reset && ds.reset >= t) return false;
+  ds.reset = t;
+  for (const [key, entry] of Object.entries(ds.e)) if (entry.t < t) delete ds.e[key];
+  for (const [key, value] of Object.entries(doc)) {
+    if (key === "id" || value === void 0) continue;
+    applyEntry(ds, key, { t, v: value });
+  }
+  return true;
+}
+function applyOp(state, op) {
+  if (!state[op.c]) return false;
+  const id = op.op === "set" ? op.doc.id : op.id;
+  if (typeof id !== "string" || !id) return false;
+  const ds = docState(state, op.c, id);
+  if (op.op === "set") return applySet(ds, op.t, op.doc);
+  if (op.op === "delete") {
+    if (ds.del && ds.del >= op.t) return false;
+    ds.del = op.t;
+    return true;
+  }
+  let changed = false;
+  for (const item of op.f) {
+    const entry = item.length === 1 ? { t: op.t, u: 1 } : { t: op.t, v: item[1] };
+    if (applyEntry(ds, item[0], entry)) changed = true;
+  }
+  return changed;
+}
+function mergeStates(into, other) {
+  const touched = /* @__PURE__ */ new Set();
+  for (const c of COLLECTIONS) {
+    for (const [id, src] of other[c] ?? []) {
+      const ds = docState(into, c, id);
+      let changed = false;
+      if (src.reset && (!ds.reset || src.reset > ds.reset)) {
+        ds.reset = src.reset;
+        for (const [key, entry] of Object.entries(ds.e)) if (entry.t < src.reset) delete ds.e[key];
+        changed = true;
+      }
+      if (src.del && (!ds.del || src.del > ds.del)) {
+        ds.del = src.del;
+        changed = true;
+      }
+      for (const [path, entry] of Object.entries(src.e).sort((a, b) => a[1].t < b[1].t ? -1 : 1)) {
+        if (applyEntry(ds, path, entry)) changed = true;
+      }
+      if (changed) touched.add(`${c}/${id}`);
+    }
+  }
+  return touched;
+}
+function isVisible(ds) {
+  return !!ds.reset && (!ds.del || ds.reset > ds.del);
+}
+function materializeDoc(id, ds) {
+  if (!isVisible(ds)) return null;
+  let out = {};
+  const entries = Object.entries(ds.e).sort((a, b) => a[1].t < b[1].t ? -1 : a[1].t > b[1].t ? 1 : a[0].length - b[0].length);
+  for (const [path, entry] of entries) out = setPath(out, splitPath(path), entry.u ? void 0 : entry.v);
+  out.id = id;
+  return normalizeDoc(out);
+}
+function maxStamp(state) {
+  let max = "";
+  for (const c of COLLECTIONS) {
+    for (const ds of state[c].values()) {
+      if (ds.reset && ds.reset > max) max = ds.reset;
+      if (ds.del && ds.del > max) max = ds.del;
+      for (const e of Object.values(ds.e)) if (e.t > max) max = e.t;
+    }
+  }
+  return max;
+}
+function purgeState(state) {
+  let purged = 0;
+  for (const c of COLLECTIONS) {
+    for (const [id, ds] of state[c]) {
+      if (isVisible(ds)) continue;
+      if (Object.keys(ds.e).length || ds.reset) purged++;
+      if (ds.del) state[c].set(id, { del: ds.del, e: {} });
+      else state[c].delete(id);
+    }
+  }
+  return purged;
+}
+function serializeState(state) {
+  const out = {};
+  for (const c of COLLECTIONS) {
+    if (state[c].size === 0) continue;
+    out[c] = Object.fromEntries(state[c]);
+  }
+  return out;
+}
+function deserializeState(raw) {
+  const state = emptyMergeState();
+  for (const c of COLLECTIONS) {
+    for (const [id, ds] of Object.entries(raw?.[c] ?? {})) {
+      state[c].set(id, { ...ds.reset ? { reset: ds.reset } : {}, ...ds.del ? { del: ds.del } : {}, e: { ...ds.e ?? {} } });
+    }
+  }
+  return state;
+}
+function cloneMergeState(state) {
+  return deserializeState(JSON.parse(JSON.stringify(serializeState(state))));
+}
+const JOURNAL_FORMAT = "agentcrm-journal";
+const JOURNAL_VERSION = 1;
+const DEFAULT_POLL_MS = 2e4;
+const KEY_CHECK = "agentcrm-keycheck";
+function newClientId() {
+  const bytes = crypto.getRandomValues(new Uint8Array(6));
+  return [...bytes].map((b) => (b % 36).toString(36)).join("") + Date.now().toString(36).slice(-2);
+}
+function join(root, path) {
+  const r = root.replace(/^\/+|\/+$/g, "");
+  return r ? `${r}/${path}` : path;
+}
+function createJournalStore(opts) {
+  const connector = opts.connector;
+  if (!connector.listPrefix) throw new Error(`The "${connector.id}" storage can't list files: it can't hold a journal dataset.`);
+  if (!connector.getBytes) throw new Error(`The "${connector.id}" storage can't read binary files: it can't hold a journal dataset.`);
+  const listPrefix = connector.listPrefix.bind(connector);
+  const getBytes = connector.getBytes.bind(connector);
+  const clientId = (opts.clientId ?? newClientId()).toLowerCase().replace(/[^0-9a-z]/g, "") || newClientId();
+  const clock = createHlcClock(clientId, opts.wallClock);
+  const paths = {
+    keyinfo: join(opts.root, "keyinfo.json"),
+    snapshot: join(opts.root, "snapshot.bin"),
+    journal: join(opts.root, "journal/"),
+    files: join(opts.root, "files/")
+  };
+  const segmentPath = (name) => `${paths.journal}${name}`;
+  let keyInfo = null;
+  let key = null;
+  let state = emptyMergeState();
+  const applied = /* @__PURE__ */ new Set();
+  let snapshotApplied = /* @__PURE__ */ new Set();
+  let materialized = emptySnapshot();
+  function passphrase() {
+    const p = typeof opts.passphrase === "function" ? opts.passphrase() : opts.passphrase;
+    return p ?? null;
+  }
+  async function readText(path) {
+    const bytes = await getBytes(path);
+    return bytes ? new TextDecoder().decode(bytes) : null;
+  }
+  async function loadKey() {
+    const raw = await readText(paths.keyinfo);
+    if (raw) {
+      const info = JSON.parse(raw);
+      if (info.format !== JOURNAL_FORMAT) throw new Error(`${paths.keyinfo} is not an AgentCRM journal key file.`);
+      keyInfo = info;
+    }
+    const encrypted = keyInfo ? keyInfo.encrypted : opts.encrypted !== false;
+    if (!encrypted) {
+      key = null;
+      return;
+    }
+    const pass = passphrase();
+    if (!pass) throw new PassphraseError("missing");
+    if (keyInfo?.kdf) {
+      const params = { salt: base64ToBytes(keyInfo.kdf.salt), iterations: keyInfo.kdf.iterations };
+      if (keyInfo.check) {
+        const check = await decryptText(base64ToBytes(keyInfo.check), pass);
+        if (check !== KEY_CHECK) throw new PassphraseError("wrong");
+      }
+      key = { passphrase: pass, params };
+    } else {
+      key = { passphrase: pass, params: newEncryptionParams(opts.iterations ?? PBKDF2_ITERATIONS) };
+    }
+  }
+  async function ensureKeyInfo() {
+    if (keyInfo) return;
+    const info = { format: JOURNAL_FORMAT, version: JOURNAL_VERSION, encrypted: !!key, createdAt: Date.now() };
+    if (key) {
+      info.kdf = { name: "PBKDF2-SHA256", iterations: key.params.iterations, salt: bytesToBase64(key.params.salt) };
+      info.check = bytesToBase64(await encryptText(KEY_CHECK, key.passphrase, key.params));
+    }
+    await connector.put({ path: paths.keyinfo, content: JSON.stringify(info, null, 2) + "\n" });
+    keyInfo = info;
+  }
+  async function readSnapshot() {
+    const bytes = await getBytes(paths.snapshot);
+    if (!bytes) return null;
+    const file = await decodeJson(bytes, passphrase());
+    if (file.format !== "agentcrm-snapshot") throw new Error(`${paths.snapshot} is not an AgentCRM snapshot.`);
+    return file;
+  }
+  function adoptSnapshot(file) {
+    if (!file) return /* @__PURE__ */ new Set();
+    if (file.hlc) clock.receive(file.hlc);
+    snapshotApplied = new Set(file.applied);
+    for (const name of file.applied) applied.add(name);
+    return mergeStates(state, deserializeState(file.state));
+  }
+  function applySegment(name, seg, touched) {
+    for (const op of seg.ops ?? []) {
+      if (!COLLECTIONS.includes(op.c)) continue;
+      clock.receive(op.t);
+      if (applyOp(state, op)) touched.add(`${op.c}/${op.op === "set" ? op.doc.id : op.id}`);
+    }
+    applied.add(name);
+  }
+  async function sync(withSnapshot) {
+    const touched = /* @__PURE__ */ new Set();
+    const listed = (await listPrefix(paths.journal)).filter((p) => p.endsWith(".bin")).map((p) => p.slice(paths.journal.length));
+    if (withSnapshot) for (const k of adoptSnapshot(await readSnapshot())) touched.add(k);
+    let todo = listed.filter((n) => !applied.has(n)).sort();
+    for (let attempt = 0; todo.length && attempt < 3; attempt++) {
+      const missing = [];
+      const read = await mapLimit(todo, 6, async (name) => {
+        const bytes = await getBytes(segmentPath(name));
+        if (!bytes) {
+          missing.push(name);
+          return null;
+        }
+        return { name, seg: await decodeJson(bytes, passphrase()) };
+      });
+      for (const r of read) if (r) applySegment(r.name, r.seg, touched);
+      if (!missing.length) break;
+      for (const k of adoptSnapshot(await readSnapshot())) touched.add(k);
+      todo = missing.filter((n) => !applied.has(n));
+    }
+    return touched;
+  }
+  function rematerialize(touched) {
+    const next = emptySnapshot();
+    for (const c of COLLECTIONS) {
+      if (touched === null) {
+        for (const [id, ds] of state[c]) {
+          const doc = materializeDoc(id, ds);
+          if (doc) next[c].set(id, doc);
+        }
+      } else {
+        for (const [id, doc] of materialized[c]) next[c].set(id, doc);
+      }
+    }
+    if (touched) {
+      for (const key2 of touched) {
+        const slash = key2.indexOf("/");
+        const c = key2.slice(0, slash);
+        const id = key2.slice(slash + 1);
+        const ds = state[c].get(id);
+        const doc = ds ? materializeDoc(id, ds) : null;
+        if (doc) next[c].set(id, doc);
+        else next[c].delete(id);
+      }
+    }
+    materialized = next;
+    return next;
+  }
+  const core = createStoreCore({
+    kind: "journal",
+    pollIntervalMs: opts.pollIntervalMs ?? DEFAULT_POLL_MS,
+    async load() {
+      await loadKey();
+      state = emptyMergeState();
+      applied.clear();
+      await sync(true);
+      return rematerialize(null);
+    },
+    async persist(mutations, before, _after, message) {
+      const effective = mutations.filter((m) => m.op !== "patch" || before[m.collection].has(m.id));
+      if (effective.length === 0) return;
+      const ops = effective.map((m) => toJournalOp(m, clock.now()));
+      const name = `${ops[0].t}.bin`;
+      const seg = { format: "agentcrm-segment", version: JOURNAL_VERSION, client: clientId, message, ops };
+      await ensureKeyInfo();
+      const bytes = await encodeJson(seg, key);
+      await connector.put({ path: segmentPath(name), content: bytesToBase64(bytes), encoding: "base64" });
+      const touched = /* @__PURE__ */ new Set();
+      applySegment(name, seg, touched);
+      rematerialize(touched);
+    },
+    async poll() {
+      const touched = await sync(false);
+      return touched.size ? rematerialize(touched) : null;
+    },
+    async identity() {
+      return opts.identity === void 0 ? { uid: "owner", email: "", displayName: "Owner", role: "admin" } : opts.identity;
+    },
+    async compact() {
+      await sync(true);
+      const next = cloneMergeState(state);
+      purgeState(next);
+      const merged = (await listPrefix(paths.journal)).filter((p) => p.endsWith(".bin")).map((p) => p.slice(paths.journal.length)).filter((n) => applied.has(n));
+      const compactionId = `${clientId}-${clock.now()}`;
+      const file = {
+        format: "agentcrm-snapshot",
+        version: JOURNAL_VERSION,
+        hlc: maxHlc(clock.last(), maxStamp(next)) ?? "",
+        applied: merged.sort(),
+        compactionId,
+        createdAt: Date.now(),
+        createdBy: clientId,
+        state: serializeState(next)
+      };
+      await ensureKeyInfo();
+      await connector.put({ path: paths.snapshot, content: bytesToBase64(await encodeJson(file, key)), encoding: "base64" });
+      const check = await readSnapshot();
+      if (check?.compactionId === compactionId) {
+        await mapLimit(merged, 4, (name) => connector.delete(segmentPath(name)));
+      }
+      state = next;
+      snapshotApplied = new Set(merged);
+      return rematerialize(null);
+    }
+  });
+  const store = core;
+  Object.defineProperty(store, "clientId", { value: clientId });
+  withFileStore(
+    store,
+    createJournalFileStore({
+      connector,
+      folder: paths.files,
+      async key() {
+        if (!keyInfo && !key) await loadKey();
+        await ensureKeyInfo();
+        return key;
+      },
+      passphrase
+    })
+  );
+  store.stats = async () => {
+    const listed = (await listPrefix(paths.journal)).filter((p) => p.endsWith(".bin"));
+    let documents = 0;
+    let tombstones = 0;
+    for (const c of COLLECTIONS) {
+      for (const ds of state[c].values()) {
+        if (materializeDoc("x", ds)) documents++;
+        else tombstones++;
+      }
+    }
+    return {
+      segments: listed.length,
+      pendingSegments: listed.filter((p) => !snapshotApplied.has(p.slice(paths.journal.length))).length,
+      snapshotSegments: snapshotApplied.size,
+      documents,
+      tombstones
+    };
+  };
+  return store;
+}
+export {
+  DEFAULT_POLL_MS,
+  JOURNAL_FORMAT,
+  applyEntry,
+  applyOp,
+  cloneMergeState,
+  createJournalStore,
+  decodeJson,
+  deserializeState,
+  emptyMergeState,
+  encodeJson,
+  gunzip,
+  gzip,
+  isVisible,
+  materializeDoc,
+  maxStamp,
+  mergeStates,
+  newClientId,
+  purgeState,
+  serializeState,
+  toJournalOp
+};