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

package/dist/agent/chunks/backup-ClSmxmFZ.mjs

@@ -0,0 +1,103 @@
+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 { J as JSZip } from "./index-w03ReRs4.mjs";
+import { F as FILE_ID_RE } from "./ids-u-noYcy5.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { exportJson, importJson } from "./exportCsv-B5hRvkNm.mjs";
+import { filesOf } from "./store-5gqRSKXg.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./papaparse-DjBYnQM2.mjs";
+import "./fields-B0bitgmr.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./types-BOy9PUl7.mjs";
+import "./records-DoqiT9xR.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./relations-B9TynBmA.mjs";
+const BACKUP_DATA_FILE = "data.json";
+const BACKUP_FILES_DIR = "files/";
+async function exportBackupZip(ctx, opts = {}) {
+  assertCan(ctx, "export");
+  const zip = new JSZip();
+  const data = exportJson(ctx);
+  zip.file(BACKUP_DATA_FILE, JSON.stringify(data, null, 2));
+  const report = { files: 0, missing: [], bytes: 0 };
+  if (opts.includeFiles !== false && ctx.store.files) {
+    for (const f of filesOf(ctx.store)) {
+      for (const id of [f.id, ...f.thumbId ? [f.thumbId] : []]) {
+        const bytes = await ctx.store.files.get(id).catch(() => null);
+        if (!bytes) {
+          if (id === f.id) report.missing.push(f.id);
+          continue;
+        }
+        zip.file(`${BACKUP_FILES_DIR}${id}.bin`, bytes, { binary: true });
+        report.bytes += bytes.length;
+        if (id === f.id) report.files++;
+      }
+    }
+  }
+  const out = await zip.generateAsync({ type: "uint8array", compression: "DEFLATE", compressionOptions: { level: 6 } });
+  return { zip: out, report };
+}
+async function importBackupZip(ctx, input, opts = {}) {
+  assertCan(ctx, "settings.write");
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(input);
+  } catch {
+    throw new OpsError("validation", "Not a ZIP archive.");
+  }
+  const entry = zip.file(BACKUP_DATA_FILE);
+  if (!entry) throw new OpsError("validation", `Not an AgentCRM backup (no ${BACKUP_DATA_FILE}).`);
+  let data;
+  try {
+    data = JSON.parse(await entry.async("string"));
+  } catch {
+    throw new OpsError("validation", `${BACKUP_DATA_FILE} is not valid JSON.`);
+  }
+  let files = 0;
+  const blobs = Object.keys(zip.files).filter((p) => p.startsWith(BACKUP_FILES_DIR) && p.endsWith(".bin"));
+  if (blobs.length) {
+    if (!ctx.store.files) throw new OpsError("invalid", `The "${ctx.store.kind}" backend can't store files: restore the data JSON only.`);
+    const metaIds = new Set((data.collections.files ?? []).map((f) => f.id));
+    for (const p of blobs) {
+      const id = p.slice(BACKUP_FILES_DIR.length, -".bin".length);
+      if (!FILE_ID_RE.test(id)) continue;
+      await ctx.store.files.put(id, await zip.file(p).async("uint8array"));
+      if (metaIds.has(id)) files++;
+    }
+  }
+  const res = await importJson(ctx, data, { mode: opts.mode });
+  return { ...res, files };
+}
+async function readBackupZipInfo(input) {
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(input);
+  } catch {
+    throw new OpsError("validation", "Not a ZIP archive.");
+  }
+  const entry = zip.file(BACKUP_DATA_FILE);
+  if (!entry) throw new OpsError("validation", `Not an AgentCRM backup (no ${BACKUP_DATA_FILE}).`);
+  const data = JSON.parse(await entry.async("string"));
+  if (data?.format !== "agentcrm-export") throw new OpsError("validation", "Not an AgentCRM export.");
+  const metaIds = new Set((data.collections.files ?? []).map((f) => f.id));
+  const files = Object.keys(zip.files).filter((p) => p.startsWith(BACKUP_FILES_DIR) && metaIds.has(p.slice(BACKUP_FILES_DIR.length, -".bin".length))).length;
+  return { data, files };
+}
+export {
+  BACKUP_DATA_FILE,
+  BACKUP_FILES_DIR,
+  exportBackupZip,
+  importBackupZip,
+  readBackupZipInfo
+};

package/dist/agent/chunks/batch-CVETiJj5.mjs

@@ -0,0 +1,142 @@
+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 { g as getActiveStorageConnector } from "./registry-DijAKZ24.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./http-Bk9ICb7I.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+import "./encoding-C9MzdP95.mjs";
+import "./s3-Dz50-NuA.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+let open = null;
+function normalizePrefix(path) {
+  return path.replace(/^\/+|\/+$/g, "");
+}
+function isUnder(path, prefix) {
+  return path === prefix || path.startsWith(prefix + "/");
+}
+function currentBatch() {
+  return open;
+}
+function stagePut(batch, input) {
+  batch.files.set(input.path, { type: "put", ...input });
+}
+function stageDelete(batch, path) {
+  batch.files.set(path, { type: "delete", path });
+}
+function stageDeletePrefix(batch, path) {
+  const prefix = normalizePrefix(path);
+  for (const key of [...batch.files.keys()]) {
+    if (isUnder(key, prefix)) batch.files.delete(key);
+  }
+  batch.prefixes.add(prefix);
+}
+function readStaged(batch, path) {
+  const op = batch.files.get(path);
+  if (op?.type === "put") {
+    if (op.encoding !== "base64") return { kind: "content", content: op.content };
+    const bytes = Uint8Array.from(atob(op.content), (c) => c.charCodeAt(0));
+    return { kind: "content", content: new TextDecoder().decode(bytes) };
+  }
+  if (op?.type === "delete") return { kind: "deleted" };
+  for (const prefix of batch.prefixes) {
+    if (isUnder(path, prefix)) return { kind: "deleted" };
+  }
+  return null;
+}
+function collectOps(batch) {
+  const ops = [];
+  for (const path of batch.prefixes) ops.push({ type: "deletePrefix", path });
+  for (const op of batch.files.values()) ops.push(op);
+  return ops;
+}
+const IMPLICIT_IDLE_MS = 1500;
+let implicit = null;
+function scheduleImplicitFlush() {
+  if (!implicit) return;
+  if (implicit.timer) clearTimeout(implicit.timer);
+  implicit.timer = setTimeout(() => void flushImplicitBatch(), IMPLICIT_IDLE_MS);
+}
+function implicitBatchFor(connector) {
+  if (!implicit || implicit.connector !== connector) {
+    implicit = { connector, depth: 0, files: /* @__PURE__ */ new Map(), prefixes: /* @__PURE__ */ new Set(), timer: null, flushing: null };
+  }
+  scheduleImplicitFlush();
+  return implicit;
+}
+function pendingImplicitBatch() {
+  return implicit;
+}
+async function flushImplicitBatch() {
+  const batch = implicit;
+  if (!batch) return;
+  if (batch.timer) clearTimeout(batch.timer);
+  implicit = null;
+  const ops = collectOps(batch);
+  if (ops.length === 0) return;
+  try {
+    await batch.connector.commitBatch(ops);
+  } catch (err) {
+    console.error("[storage] deferred commit failed:", err);
+  }
+}
+if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+  window.addEventListener("beforeunload", (e) => {
+    if (implicit && (implicit.files.size > 0 || implicit.prefixes.size > 0)) {
+      void flushImplicitBatch();
+      e.preventDefault();
+    }
+  });
+}
+async function withStorageBatch(fn) {
+  const connector = await getActiveStorageConnector();
+  if (!connector.commitBatch) return fn();
+  await flushImplicitBatch();
+  if (!open) open = { connector, depth: 0, files: /* @__PURE__ */ new Map(), prefixes: /* @__PURE__ */ new Set() };
+  const batch = open;
+  batch.depth++;
+  let failed = false;
+  let error;
+  let result;
+  try {
+    result = await fn();
+  } catch (err) {
+    failed = true;
+    error = err;
+  }
+  batch.depth--;
+  if (batch.depth === 0) {
+    open = null;
+    const ops = collectOps(batch);
+    if (ops.length > 0) {
+      try {
+        await batch.connector.commitBatch(ops);
+      } catch (commitErr) {
+        if (!failed) throw commitErr;
+        console.error("[storage] batch commit failed after an earlier error:", commitErr);
+      }
+    }
+  }
+  if (failed) throw error;
+  return result;
+}
+export {
+  IMPLICIT_IDLE_MS,
+  currentBatch,
+  flushImplicitBatch,
+  implicitBatchFor,
+  pendingImplicitBatch,
+  readStaged,
+  stageDelete,
+  stageDeletePrefix,
+  stagePut,
+  withStorageBatch
+};

package/dist/agent/chunks/compact-CsFPaAAq.mjs

@@ -0,0 +1,69 @@
+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 { assertCan } from "./context-CxFfqS4D.mjs";
+import { b as fileCleanupMutations } from "./relations-B9TynBmA.mjs";
+import { purgeFiles } from "./files-q8Xu5bft.mjs";
+import { hardDeleteMutations } from "./records-DoqiT9xR.mjs";
+import { recordsOf, activitiesOf, automationRunsOf } from "./store-5gqRSKXg.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./fields-B0bitgmr.mjs";
+import "./files-CjsPJSR6.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./index-RCmo-uld.mjs";
+import "./http-Bk9ICb7I.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./activities-Cj_SIOay.mjs";
+import "./query-C5nJB_3C.mjs";
+import "../agentcrm.mjs";
+import "node:util";
+import "node:fs";
+import "node:path";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+import "./standardObjects-CheqfDqa.mjs";
+async function compactData(ctx, opts = {}) {
+  assertCan(ctx, "compact");
+  const cutoff = ctx.now() - (opts.olderThanDays ?? 0) * 864e5;
+  const records = recordsOf(ctx.store, void 0, { includeDeleted: true }).filter((r) => r.deletedAt && r.deletedAt <= cutoff);
+  const ids = records.map((r) => r.id);
+  const mutations = ids.length ? hardDeleteMutations(ctx, ids) : [];
+  const alreadyDeleted = new Set(mutations.filter((m) => m.op === "delete" && m.collection === "activities").map((m) => m.id));
+  let purgedActivities = alreadyDeleted.size;
+  const purgedActivityIds = [];
+  for (const a of activitiesOf(ctx.store, { includeDeleted: true })) {
+    if (a.deletedAt && a.deletedAt <= cutoff && !alreadyDeleted.has(a.id)) {
+      mutations.push({ op: "delete", collection: "activities", id: a.id });
+      purgedActivityIds.push(a.id);
+      purgedActivities++;
+    }
+  }
+  mutations.push(...fileCleanupMutations(ctx, { activities: purgedActivityIds }));
+  const keep = opts.keepRuns ?? 500;
+  const runs = automationRunsOf(ctx.store).sort((a, b) => b.startedAt - a.startedAt);
+  const oldRuns = runs.slice(keep);
+  for (const r of oldRuns) mutations.push({ op: "delete", collection: "automationRuns", id: r.id });
+  const report = { purgedRecords: ids, purgedActivities, purgedRuns: oldRuns.length, purgedFiles: 0, storageCompacted: false, dryRun: !!opts.dryRun };
+  if (opts.dryRun) {
+    report.files = await purgeFiles(ctx, { olderThanDays: opts.olderThanDays, dryRun: true });
+    report.purgedFiles = report.files.purged.length;
+    return report;
+  }
+  if (mutations.length) await ctx.store.write(mutations, { message: `Purge ${ids.length} deleted records` });
+  report.files = await purgeFiles(ctx, { olderThanDays: opts.olderThanDays });
+  report.purgedFiles = report.files.purged.length;
+  if (ctx.store.compact) {
+    await ctx.store.compact();
+    report.storageCompacted = true;
+  }
+  return report;
+}
+export {
+  compactData
+};

package/dist/agent/chunks/context-CxFfqS4D.mjs

@@ -0,0 +1,65 @@
+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 { plugins } from "./pluginRegistry-DyHtlkcr.mjs";
+const READ = ["records.read", "activities.read", "views.read", "settings.read", "users.read", "reports.read"];
+const MEMBER = [...READ, "records.write", "records.delete", "activities.write", "views.writeOwn", "import", "export", "automations.run"];
+const ADMIN = [
+  ...MEMBER,
+  "views.writeShared",
+  "schema.write",
+  "pipelines.write",
+  "settings.write",
+  "users.write",
+  "automations.write",
+  "forms.write",
+  "compact",
+  "modules.write",
+  "appearance.write",
+  "extensions.write"
+];
+const PERMISSIONS = {
+  admin: new Set(ADMIN),
+  member: new Set(MEMBER),
+  viewer: new Set(READ)
+};
+class OpsError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "OpsError";
+  }
+}
+function can(user, action) {
+  if (user === null) return true;
+  if (user.disabled) return false;
+  return PERMISSIONS[user.role]?.has(action) ?? false;
+}
+function assertCan(ctx, action) {
+  if (!can(ctx.user, action)) {
+    const who = ctx.user ? `${ctx.user.email || ctx.user.name} (${ctx.user.disabled ? "disabled" : ctx.user.role})` : "anonymous";
+    throw new OpsError("forbidden", `Not allowed: ${who} can't ${action.replace(".", " ")}.`);
+  }
+}
+function createOpsContext(store, user, opts = {}) {
+  return { store, user, now: opts.now ?? Date.now, log: opts.log, plugins: opts.plugins, depth: opts.depth };
+}
+async function emit(ctx, name, payload) {
+  await (ctx.plugins ?? plugins).doAction(name, ctx, payload);
+}
+function actorId(ctx) {
+  return ctx.user?.id;
+}
+export {
+  OpsError,
+  PERMISSIONS,
+  actorId,
+  assertCan,
+  can,
+  createOpsContext,
+  emit
+};

package/dist/agent/chunks/core-Dy7vY9H6.mjs

@@ -0,0 +1,255 @@
+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 { COLLECTIONS } from "./types-BOy9PUl7.mjs";
+function isPlainObject(v) {
+  return !!v && typeof v === "object" && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+}
+function splitPath(path) {
+  return path.split(".").filter(Boolean);
+}
+function setPath(target, path, value) {
+  if (path.length === 0) return target;
+  const [head, ...rest] = path;
+  const out = { ...target };
+  if (rest.length === 0) {
+    if (value === void 0) delete out[head];
+    else out[head] = value;
+    return out;
+  }
+  const child = isPlainObject(out[head]) ? out[head] : {};
+  out[head] = setPath(child, rest, value);
+  return out;
+}
+function getPath(target, path) {
+  let cur = target;
+  for (const p of path) {
+    if (!isPlainObject(cur)) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function applyPatch(doc, fields) {
+  let out = { ...doc };
+  for (const [key, value] of Object.entries(fields)) {
+    const path = splitPath(key);
+    if (path[0] === "id") continue;
+    out = setPath(out, path, value);
+  }
+  return out;
+}
+function normalizeDoc(value) {
+  if (Array.isArray(value)) return Object.freeze(value.map(normalizeDoc));
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) if (v !== void 0) out[k] = normalizeDoc(v);
+    return Object.freeze(out);
+  }
+  return value;
+}
+function plainCopy(value) {
+  return value === void 0 ? value : JSON.parse(JSON.stringify(value));
+}
+function emptySnapshot() {
+  return Object.fromEntries(COLLECTIONS.map((c) => [c, /* @__PURE__ */ new Map()]));
+}
+function cloneSnapshot(s) {
+  return Object.fromEntries(COLLECTIONS.map((c) => [c, new Map(s[c] ?? [])]));
+}
+function snapshotFromDocs(docs) {
+  const s = emptySnapshot();
+  for (const c of COLLECTIONS) for (const d of docs[c] ?? []) s[c].set(d.id, normalizeDoc(d));
+  return s;
+}
+function applyMutations(base, mutations) {
+  const next = cloneSnapshot(base);
+  const changed = /* @__PURE__ */ new Set();
+  for (const m of mutations) {
+    if (m.op === "set") {
+      next[m.collection].set(m.doc.id, normalizeDoc(m.doc));
+      changed.add(m.collection);
+    } else if (m.op === "patch") {
+      const current = next[m.collection].get(m.id);
+      if (!current) continue;
+      next[m.collection].set(m.id, normalizeDoc(applyPatch(current, m.fields)));
+      changed.add(m.collection);
+    } else {
+      if (next[m.collection].delete(m.id)) changed.add(m.collection);
+    }
+  }
+  return { next, changed };
+}
+function diffCollections(a, b) {
+  const changed = /* @__PURE__ */ new Set();
+  for (const c of COLLECTIONS) {
+    if (a[c].size !== b[c].size) {
+      changed.add(c);
+      continue;
+    }
+    for (const [id, doc] of a[c]) {
+      const other = b[c].get(id);
+      if (other === doc) continue;
+      if (!other || JSON.stringify(other) !== JSON.stringify(doc)) {
+        changed.add(c);
+        break;
+      }
+    }
+  }
+  return changed;
+}
+function mutationId(m) {
+  return m.op === "set" ? m.doc.id : m.id;
+}
+function validate(mutations) {
+  for (const m of mutations) {
+    if (!COLLECTIONS.includes(m.collection)) throw new Error(`Unknown collection "${m.collection}".`);
+    const id = mutationId(m);
+    if (typeof id !== "string" || !id) throw new Error(`Mutation on ${m.collection} without an id.`);
+  }
+}
+function createStoreCore(backend) {
+  let snapshot = emptySnapshot();
+  let loading = null;
+  let loaded = false;
+  let queue = Promise.resolve();
+  let pending = 0;
+  const listeners = /* @__PURE__ */ new Set();
+  let timer = null;
+  let unwatch = null;
+  let closed = false;
+  function notify(changed) {
+    if (changed.size === 0) return;
+    for (const l of [...listeners]) {
+      try {
+        l(changed);
+      } catch (err) {
+        console.error("[datastore] listener failed:", err);
+      }
+    }
+  }
+  function adopt(fresh) {
+    if (pending > 0) return;
+    const changed = diffCollections(snapshot, fresh);
+    snapshot = fresh;
+    notify(changed);
+  }
+  function ready() {
+    if (!loading) {
+      loading = backend.load().then(
+        (s) => {
+          snapshot = s;
+          loaded = true;
+          notify(new Set(COLLECTIONS));
+        },
+        (err) => {
+          loading = null;
+          throw err;
+        }
+      );
+    }
+    return loading;
+  }
+  async function refresh() {
+    await ready();
+    if (!backend.poll || pending > 0) return;
+    const fresh = await backend.poll();
+    if (fresh) adopt(fresh);
+  }
+  function start() {
+    if (closed) return;
+    if (backend.watch && !unwatch) {
+      unwatch = backend.watch((fresh) => {
+        void ready().then(() => adopt(fresh));
+      });
+    }
+    if (backend.poll && !timer) {
+      timer = setInterval(() => {
+        refresh().catch((err) => console.warn("[datastore] poll failed:", err));
+      }, backend.pollIntervalMs ?? 3e4);
+      timer.unref?.();
+    }
+  }
+  function stop() {
+    if (timer) clearInterval(timer);
+    timer = null;
+    unwatch?.();
+    unwatch = null;
+  }
+  const store = {
+    kind: backend.kind,
+    ready,
+    refresh,
+    identity: () => backend.identity(),
+    list(collection) {
+      return [...snapshot[collection]?.values() ?? []];
+    },
+    get(collection, id) {
+      return snapshot[collection]?.get(id);
+    },
+    async write(mutations, opts) {
+      if (!loaded) await ready();
+      if (mutations.length === 0) return;
+      validate(mutations);
+      const before = snapshot;
+      const { next, changed } = applyMutations(before, mutations);
+      snapshot = next;
+      notify(changed);
+      pending++;
+      const run = queue.then(() => backend.persist(mutations, before, next, opts?.message ?? "Update data"));
+      queue = run.catch(() => void 0);
+      try {
+        await run;
+      } catch (err) {
+        const reverted = cloneSnapshot(snapshot);
+        for (const m of mutations) {
+          const id = mutationId(m);
+          const original = before[m.collection].get(id);
+          if (original) reverted[m.collection].set(id, original);
+          else reverted[m.collection].delete(id);
+        }
+        snapshot = reverted;
+        notify(changed);
+        throw err;
+      } finally {
+        pending--;
+      }
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      start();
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) stop();
+      };
+    },
+    close() {
+      closed = true;
+      stop();
+      listeners.clear();
+      backend.close?.();
+    }
+  };
+  if (backend.compact) {
+    store.compact = async () => {
+      await ready();
+      await queue;
+      const result = await backend.compact(snapshot);
+      if (result) adopt(result);
+    };
+  }
+  return store;
+}
+export {
+  splitPath as a,
+  setPath as b,
+  createStoreCore as c,
+  applyMutations as d,
+  emptySnapshot as e,
+  getPath as g,
+  normalizeDoc as n,
+  plainCopy as p,
+  snapshotFromDocs as s
+};