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

package/dist/agent/chunks/index-Bnmav-Oh.mjs

@@ -0,0 +1,311 @@
+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 getDefaultExportFromCjs } from "./_commonjsHelpers-ClciMIcB.mjs";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var react = { exports: {} };
+var react_production_min = {};
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var hasRequiredReact_production_min;
+function requireReact_production_min() {
+  if (hasRequiredReact_production_min) return react_production_min;
+  hasRequiredReact_production_min = 1;
+  var l = Symbol.for("react.element"), n = Symbol.for("react.portal"), p = Symbol.for("react.fragment"), q = Symbol.for("react.strict_mode"), r = Symbol.for("react.profiler"), t = Symbol.for("react.provider"), u = Symbol.for("react.context"), v = Symbol.for("react.forward_ref"), w = Symbol.for("react.suspense"), x = Symbol.for("react.memo"), y = Symbol.for("react.lazy"), z = Symbol.iterator;
+  function A(a) {
+    if (null === a || "object" !== typeof a) return null;
+    a = z && a[z] || a["@@iterator"];
+    return "function" === typeof a ? a : null;
+  }
+  var B = { isMounted: function() {
+    return false;
+  }, enqueueForceUpdate: function() {
+  }, enqueueReplaceState: function() {
+  }, enqueueSetState: function() {
+  } }, C = Object.assign, D = {};
+  function E(a, b, e) {
+    this.props = a;
+    this.context = b;
+    this.refs = D;
+    this.updater = e || B;
+  }
+  E.prototype.isReactComponent = {};
+  E.prototype.setState = function(a, b) {
+    if ("object" !== typeof a && "function" !== typeof a && null != a) throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+    this.updater.enqueueSetState(this, a, b, "setState");
+  };
+  E.prototype.forceUpdate = function(a) {
+    this.updater.enqueueForceUpdate(this, a, "forceUpdate");
+  };
+  function F() {
+  }
+  F.prototype = E.prototype;
+  function G(a, b, e) {
+    this.props = a;
+    this.context = b;
+    this.refs = D;
+    this.updater = e || B;
+  }
+  var H = G.prototype = new F();
+  H.constructor = G;
+  C(H, E.prototype);
+  H.isPureReactComponent = true;
+  var I = Array.isArray, J = Object.prototype.hasOwnProperty, K = { current: null }, L = { key: true, ref: true, __self: true, __source: true };
+  function M(a, b, e) {
+    var d, c = {}, k = null, h = null;
+    if (null != b) for (d in void 0 !== b.ref && (h = b.ref), void 0 !== b.key && (k = "" + b.key), b) J.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
+    var g = arguments.length - 2;
+    if (1 === g) c.children = e;
+    else if (1 < g) {
+      for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
+      c.children = f;
+    }
+    if (a && a.defaultProps) for (d in g = a.defaultProps, g) void 0 === c[d] && (c[d] = g[d]);
+    return { $$typeof: l, type: a, key: k, ref: h, props: c, _owner: K.current };
+  }
+  function N(a, b) {
+    return { $$typeof: l, type: a.type, key: b, ref: a.ref, props: a.props, _owner: a._owner };
+  }
+  function O(a) {
+    return "object" === typeof a && null !== a && a.$$typeof === l;
+  }
+  function escape(a) {
+    var b = { "=": "=0", ":": "=2" };
+    return "$" + a.replace(/[=:]/g, function(a2) {
+      return b[a2];
+    });
+  }
+  var P = /\/+/g;
+  function Q(a, b) {
+    return "object" === typeof a && null !== a && null != a.key ? escape("" + a.key) : b.toString(36);
+  }
+  function R(a, b, e, d, c) {
+    var k = typeof a;
+    if ("undefined" === k || "boolean" === k) a = null;
+    var h = false;
+    if (null === a) h = true;
+    else switch (k) {
+      case "string":
+      case "number":
+        h = true;
+        break;
+      case "object":
+        switch (a.$$typeof) {
+          case l:
+          case n:
+            h = true;
+        }
+    }
+    if (h) return h = a, c = c(h), a = "" === d ? "." + Q(h, 0) : d, I(c) ? (e = "", null != a && (e = a.replace(P, "$&/") + "/"), R(c, b, e, "", function(a2) {
+      return a2;
+    })) : null != c && (O(c) && (c = N(c, e + (!c.key || h && h.key === c.key ? "" : ("" + c.key).replace(P, "$&/") + "/") + a)), b.push(c)), 1;
+    h = 0;
+    d = "" === d ? "." : d + ":";
+    if (I(a)) for (var g = 0; g < a.length; g++) {
+      k = a[g];
+      var f = d + Q(k, g);
+      h += R(k, b, e, f, c);
+    }
+    else if (f = A(a), "function" === typeof f) for (a = f.call(a), g = 0; !(k = a.next()).done; ) k = k.value, f = d + Q(k, g++), h += R(k, b, e, f, c);
+    else if ("object" === k) throw b = String(a), Error("Objects are not valid as a React child (found: " + ("[object Object]" === b ? "object with keys {" + Object.keys(a).join(", ") + "}" : b) + "). If you meant to render a collection of children, use an array instead.");
+    return h;
+  }
+  function S(a, b, e) {
+    if (null == a) return a;
+    var d = [], c = 0;
+    R(a, d, "", "", function(a2) {
+      return b.call(e, a2, c++);
+    });
+    return d;
+  }
+  function T(a) {
+    if (-1 === a._status) {
+      var b = a._result;
+      b = b();
+      b.then(function(b2) {
+        if (0 === a._status || -1 === a._status) a._status = 1, a._result = b2;
+      }, function(b2) {
+        if (0 === a._status || -1 === a._status) a._status = 2, a._result = b2;
+      });
+      -1 === a._status && (a._status = 0, a._result = b);
+    }
+    if (1 === a._status) return a._result.default;
+    throw a._result;
+  }
+  var U = { current: null }, V = { transition: null }, W = { ReactCurrentDispatcher: U, ReactCurrentBatchConfig: V, ReactCurrentOwner: K };
+  function X() {
+    throw Error("act(...) is not supported in production builds of React.");
+  }
+  react_production_min.Children = { map: S, forEach: function(a, b, e) {
+    S(a, function() {
+      b.apply(this, arguments);
+    }, e);
+  }, count: function(a) {
+    var b = 0;
+    S(a, function() {
+      b++;
+    });
+    return b;
+  }, toArray: function(a) {
+    return S(a, function(a2) {
+      return a2;
+    }) || [];
+  }, only: function(a) {
+    if (!O(a)) throw Error("React.Children.only expected to receive a single React element child.");
+    return a;
+  } };
+  react_production_min.Component = E;
+  react_production_min.Fragment = p;
+  react_production_min.Profiler = r;
+  react_production_min.PureComponent = G;
+  react_production_min.StrictMode = q;
+  react_production_min.Suspense = w;
+  react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = W;
+  react_production_min.act = X;
+  react_production_min.cloneElement = function(a, b, e) {
+    if (null === a || void 0 === a) throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + a + ".");
+    var d = C({}, a.props), c = a.key, k = a.ref, h = a._owner;
+    if (null != b) {
+      void 0 !== b.ref && (k = b.ref, h = K.current);
+      void 0 !== b.key && (c = "" + b.key);
+      if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
+      for (f in b) J.call(b, f) && !L.hasOwnProperty(f) && (d[f] = void 0 === b[f] && void 0 !== g ? g[f] : b[f]);
+    }
+    var f = arguments.length - 2;
+    if (1 === f) d.children = e;
+    else if (1 < f) {
+      g = Array(f);
+      for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
+      d.children = g;
+    }
+    return { $$typeof: l, type: a.type, key: c, ref: k, props: d, _owner: h };
+  };
+  react_production_min.createContext = function(a) {
+    a = { $$typeof: u, _currentValue: a, _currentValue2: a, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null };
+    a.Provider = { $$typeof: t, _context: a };
+    return a.Consumer = a;
+  };
+  react_production_min.createElement = M;
+  react_production_min.createFactory = function(a) {
+    var b = M.bind(null, a);
+    b.type = a;
+    return b;
+  };
+  react_production_min.createRef = function() {
+    return { current: null };
+  };
+  react_production_min.forwardRef = function(a) {
+    return { $$typeof: v, render: a };
+  };
+  react_production_min.isValidElement = O;
+  react_production_min.lazy = function(a) {
+    return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T };
+  };
+  react_production_min.memo = function(a, b) {
+    return { $$typeof: x, type: a, compare: void 0 === b ? null : b };
+  };
+  react_production_min.startTransition = function(a) {
+    var b = V.transition;
+    V.transition = {};
+    try {
+      a();
+    } finally {
+      V.transition = b;
+    }
+  };
+  react_production_min.unstable_act = X;
+  react_production_min.useCallback = function(a, b) {
+    return U.current.useCallback(a, b);
+  };
+  react_production_min.useContext = function(a) {
+    return U.current.useContext(a);
+  };
+  react_production_min.useDebugValue = function() {
+  };
+  react_production_min.useDeferredValue = function(a) {
+    return U.current.useDeferredValue(a);
+  };
+  react_production_min.useEffect = function(a, b) {
+    return U.current.useEffect(a, b);
+  };
+  react_production_min.useId = function() {
+    return U.current.useId();
+  };
+  react_production_min.useImperativeHandle = function(a, b, e) {
+    return U.current.useImperativeHandle(a, b, e);
+  };
+  react_production_min.useInsertionEffect = function(a, b) {
+    return U.current.useInsertionEffect(a, b);
+  };
+  react_production_min.useLayoutEffect = function(a, b) {
+    return U.current.useLayoutEffect(a, b);
+  };
+  react_production_min.useMemo = function(a, b) {
+    return U.current.useMemo(a, b);
+  };
+  react_production_min.useReducer = function(a, b, e) {
+    return U.current.useReducer(a, b, e);
+  };
+  react_production_min.useRef = function(a) {
+    return U.current.useRef(a);
+  };
+  react_production_min.useState = function(a) {
+    return U.current.useState(a);
+  };
+  react_production_min.useSyncExternalStore = function(a, b, e) {
+    return U.current.useSyncExternalStore(a, b, e);
+  };
+  react_production_min.useTransition = function() {
+    return U.current.useTransition();
+  };
+  react_production_min.version = "18.3.1";
+  return react_production_min;
+}
+var hasRequiredReact;
+function requireReact() {
+  if (hasRequiredReact) return react.exports;
+  hasRequiredReact = 1;
+  {
+    react.exports = requireReact_production_min();
+  }
+  return react.exports;
+}
+var reactExports = requireReact();
+const index = /* @__PURE__ */ getDefaultExportFromCjs(reactExports);
+const React = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: index
+}, [reactExports]);
+export {
+  React as R,
+  requireReact as a,
+  reactExports as r
+};

package/dist/agent/chunks/index-CRkw3_iF.mjs

@@ -0,0 +1,147 @@
+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 { l as loadFolderHandle, e as ensureFolderPermission, a as createKvStore, i as instantiateStorageConnector } from "./registry-DijAKZ24.mjs";
+import { createJournalStore } from "./index-B-4W0-P4.mjs";
+import "./index-CWrrF1wl.mjs";
+import { isCollectionName } from "./types-BOy9PUl7.mjs";
+import { COLLECTIONS, DocConflictError, StoreNotReadyError } from "./types-BOy9PUl7.mjs";
+import "./index-BM8qeGOb.mjs";
+import { c as createStoreCore, p as plainCopy, e as emptySnapshot } from "./core-Dy7vY9H6.mjs";
+import { s } from "./core-Dy7vY9H6.mjs";
+import { w as withFileStore } from "./index-RCmo-uld.mjs";
+import { a as assertFileId } from "./ids-u-noYcy5.mjs";
+import { createMemoryStore } from "./memory-WNR3VHUJ.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";
+const CONNECTOR_SECRET_FIELDS = {
+  s3: ["accessKeyId", "secretAccessKey"],
+  "git-pages": ["token"],
+  "local-folder": [],
+  "browser-mirror": []
+};
+const LOCAL_DATA_HANDLE_KEY = "data-folder";
+async function missingJournalAccess(connectorId, settings) {
+  const missing = (CONNECTOR_SECRET_FIELDS[connectorId] ?? []).filter((k) => typeof settings[k] !== "string" || !settings[k].trim());
+  if (connectorId === "local-folder") {
+    if (typeof indexedDB === "undefined") return missing;
+    const handle = await loadFolderHandle(typeof settings.handleKey === "string" && settings.handleKey ? settings.handleKey : LOCAL_DATA_HANDLE_KEY);
+    if (!handle || !await ensureFolderPermission(handle).catch(() => false)) missing.push("folder");
+  }
+  return missing;
+}
+const LOCAL_FILES_DB_NAME = "agentcrm-local-files";
+function createLocalFileStore(opts = {}) {
+  const kv = createKvStore(opts.dbName ?? LOCAL_FILES_DB_NAME, "files");
+  return {
+    kind: "local",
+    async put(id, bytes) {
+      assertFileId(id);
+      await kv.set(id, new Uint8Array(bytes));
+    },
+    async putMany(items) {
+      for (const it of items) {
+        assertFileId(it.id);
+        await kv.set(it.id, new Uint8Array(it.bytes));
+      }
+    },
+    async get(id) {
+      const v = await kv.get(id);
+      if (!v) return null;
+      return v instanceof Uint8Array ? v : new Uint8Array(v);
+    },
+    async delete(id) {
+      await kv.delete(id);
+    },
+    async list() {
+      return (await kv.keys()).sort();
+    }
+  };
+}
+const LOCAL_DB_NAME = "agentcrm-local-data";
+const keyOf = (collection, id) => `${collection}/${id}`;
+function createLocalStore(opts = {}) {
+  const kv = createKvStore(opts.dbName ?? LOCAL_DB_NAME, "docs");
+  const store = createStoreCore({
+    kind: "local",
+    async load() {
+      const snapshot = emptySnapshot();
+      for (const [key, doc] of await kv.entries()) {
+        const collection = key.slice(0, key.indexOf("/"));
+        if (isCollectionName(collection)) snapshot[collection].set(doc.id, Object.freeze(doc));
+      }
+      return snapshot;
+    },
+    async persist(mutations, _before, after) {
+      const touched = /* @__PURE__ */ new Map();
+      for (const m of mutations) {
+        const id = m.op === "set" ? m.doc.id : m.id;
+        touched.set(keyOf(m.collection, id), { collection: m.collection, id });
+      }
+      for (const [key, { collection, id }] of touched) {
+        const doc = after[collection].get(id);
+        if (doc) await kv.set(key, plainCopy(doc));
+        else await kv.delete(key);
+      }
+    },
+    async identity() {
+      return { uid: "local", email: "admin@localhost", displayName: "Local admin", role: "admin" };
+    }
+  });
+  return withFileStore(store, createLocalFileStore({ dbName: opts.filesDbName }));
+}
+const factories = /* @__PURE__ */ new Map();
+function registerBackend(kind, factory) {
+  factories.set(kind, factory);
+}
+function getBackendFactory(kind) {
+  return factories.get(kind);
+}
+registerBackend("local", () => createLocalStore());
+registerBackend("memory", () => createMemoryStore());
+registerBackend("journal", (config, opts) => {
+  const cfg = config.journal;
+  const settings = { ...cfg.settings, ...opts.secrets ?? {} };
+  const connector = instantiateStorageConnector(cfg.connectorId, settings);
+  const store = createJournalStore({
+    connector,
+    root: cfg.root,
+    encrypted: cfg.encrypted,
+    passphrase: opts.passphrase,
+    clientId: opts.clientId,
+    pollIntervalMs: opts.pollIntervalMs
+  });
+  const identity = store.identity.bind(store);
+  store.identity = async () => (await missingJournalAccess(cfg.connectorId, settings)).length ? null : identity();
+  return store;
+});
+registerBackend("firebase", async (config, opts) => (await import("./firebase-DxGVQV9E.mjs")).createFirebaseStore(config, opts));
+registerBackend("git-json", async (config, opts) => (await import("./gitJson-fjr8mcHe.mjs")).createGitJsonStore(config, opts));
+async function createDataStore(config, opts = {}) {
+  const factory = getBackendFactory(config.backend);
+  if (!factory) throw new Error(`Unknown data backend "${config.backend}".`);
+  return factory(config, opts);
+}
+export {
+  COLLECTIONS,
+  DocConflictError,
+  StoreNotReadyError,
+  createDataStore,
+  createMemoryStore,
+  createStoreCore,
+  emptySnapshot,
+  isCollectionName,
+  registerBackend,
+  s as snapshotFromDocs
+};

package/dist/agent/chunks/index-CWrrF1wl.mjs

@@ -0,0 +1,111 @@
+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);
+const MAGIC = new TextEncoder().encode("ACRMENC1");
+const HEADER_LENGTH = MAGIC.length + 4 + 16 + 12;
+const PBKDF2_ITERATIONS = 6e5;
+class PassphraseError extends Error {
+  constructor(reason) {
+    super(reason === "missing" ? "This data is encrypted: enter its passphrase." : "Wrong passphrase: the data could not be decrypted.");
+    this.reason = reason;
+    this.name = "PassphraseError";
+  }
+}
+function isEncrypted(bytes) {
+  return !!bytes && bytes.length >= HEADER_LENGTH && MAGIC.every((b, i) => bytes[i] === b);
+}
+const keyCache = /* @__PURE__ */ new Map();
+function hex(bytes) {
+  return [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function deriveKey(passphrase, salt, iterations) {
+  const id = `${iterations}:${hex(salt)}:${passphrase}`;
+  let key = keyCache.get(id);
+  if (!key) {
+    key = (async () => {
+      const material = await crypto.subtle.importKey(
+        "raw",
+        new TextEncoder().encode(passphrase.normalize("NFC")),
+        "PBKDF2",
+        false,
+        ["deriveKey"]
+      );
+      return crypto.subtle.deriveKey(
+        { name: "PBKDF2", hash: "SHA-256", salt, iterations },
+        material,
+        { name: "AES-GCM", length: 256 },
+        false,
+        ["encrypt", "decrypt"]
+      );
+    })();
+    key.catch(() => keyCache.delete(id));
+    keyCache.set(id, key);
+  }
+  return key;
+}
+function newEncryptionParams(iterations = PBKDF2_ITERATIONS) {
+  return { salt: crypto.getRandomValues(new Uint8Array(16)), iterations };
+}
+function encryptionParams(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return {
+    iterations: view.getUint32(MAGIC.length),
+    salt: bytes.slice(MAGIC.length + 4, MAGIC.length + 20)
+  };
+}
+async function encryptBytes(plain, passphrase, params) {
+  if (!passphrase) throw new PassphraseError("missing");
+  const { salt, iterations } = params ?? newEncryptionParams();
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveKey(passphrase, salt, iterations);
+  const cipher = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, plain));
+  const out = new Uint8Array(HEADER_LENGTH + cipher.length);
+  out.set(MAGIC, 0);
+  new DataView(out.buffer).setUint32(MAGIC.length, iterations);
+  out.set(salt, MAGIC.length + 4);
+  out.set(iv, MAGIC.length + 20);
+  out.set(cipher, HEADER_LENGTH);
+  return out;
+}
+async function decryptBytes(bytes, passphrase) {
+  if (!passphrase) throw new PassphraseError("missing");
+  if (!isEncrypted(bytes)) throw new Error("Not an AgentCRM encrypted file (bad magic).");
+  const { salt, iterations } = encryptionParams(bytes);
+  const iv = bytes.slice(MAGIC.length + 20, HEADER_LENGTH);
+  const key = await deriveKey(passphrase, salt, iterations);
+  try {
+    return new Uint8Array(await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, bytes.slice(HEADER_LENGTH)));
+  } catch {
+    throw new PassphraseError("wrong");
+  }
+}
+async function encryptText(text, passphrase, params) {
+  return encryptBytes(new TextEncoder().encode(text), passphrase, params);
+}
+async function decryptText(bytes, passphrase) {
+  return new TextDecoder().decode(await decryptBytes(bytes, passphrase));
+}
+function generatePassphrase() {
+  const alphabet = "abcdefghjkmnpqrstuvwxyz23456789";
+  const pick = crypto.getRandomValues(new Uint8Array(30));
+  const chars = [...pick].map((b) => alphabet[b % alphabet.length]);
+  return Array.from({ length: 6 }, (_, i) => chars.slice(i * 5, i * 5 + 5).join("")).join("-");
+}
+export {
+  HEADER_LENGTH,
+  MAGIC,
+  PBKDF2_ITERATIONS,
+  PassphraseError,
+  decryptBytes,
+  decryptText,
+  deriveKey,
+  encryptBytes,
+  encryptText,
+  encryptionParams,
+  generatePassphrase,
+  isEncrypted,
+  newEncryptionParams
+};