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

package/dist/agent/chunks/registry-Ceexawxl.mjs

@@ -0,0 +1,182 @@
+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 { i as isCompatibleApiVersion } from "./api-B6OqNVWp.mjs";
+import { registerExternalFeature } from "./featureRegistry-C9nbVShp.mjs";
+import { registerAiTool } from "./tools-Bew8lxKx.mjs";
+import { registerAutomationAction } from "./extensionActions-D2HtpQz4.mjs";
+import { plugins } from "./pluginRegistry-DyHtlkcr.mjs";
+import { registerExternalTheme } from "./themes-DPZFv3yc.mjs";
+import "./index-Bnmav-Oh.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./modules-CqdVQVJb.mjs";
+import "./context-CxFfqS4D.mjs";
+import "./settings-BtvR_jdm.mjs";
+import "./store-5gqRSKXg.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+import "./fields-B0bitgmr.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 "./activities-Cj_SIOay.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./relations-B9TynBmA.mjs";
+import "./dedupe-BepmsaHv.mjs";
+import "./importCsv-DmE_sBch.mjs";
+import "./papaparse-DjBYnQM2.mjs";
+import "stream";
+import "./utils-DmI8FtXP.mjs";
+import "./records-DoqiT9xR.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./pipelines-DCdRBNBV.mjs";
+import "./reports-BB59N6ke.mjs";
+import "./schema-DlHt2PxI.mjs";
+import "./automations-BWrvLqP6.mjs";
+import "./forms-BKU5F9WF.mjs";
+import "./schema-7-4-qtSS.mjs";
+import "./appearance-BaShelzt.mjs";
+import "./extensions-BP1k60md.mjs";
+import "./package-DWbn3t2R.mjs";
+import "./index-w03ReRs4.mjs";
+import "events";
+import "buffer";
+import "util";
+import "./files-CjsPJSR6.mjs";
+import "./files-q8Xu5bft.mjs";
+import "./index-RCmo-uld.mjs";
+import "./http-Bk9ICb7I.mjs";
+const entries = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+let snapshot = [];
+function notify() {
+  snapshot = [...entries.values()].map((e) => e.state).sort((a, b) => a.id.localeCompare(b.id));
+  for (const l of [...listeners]) l();
+}
+function listLoadedExtensions() {
+  return snapshot;
+}
+function getLoadedExtension(id) {
+  return entries.get(id)?.state;
+}
+function subscribeLoadedExtensions(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function setExtensionStatus(doc, status, error) {
+  const prev = entries.get(doc.id);
+  if (prev) prev.dispose();
+  entries.set(doc.id, { state: { id: doc.id, kind: doc.kind, version: doc.manifest.version, status, ...error ? { error } : {} }, dispose: () => void 0 });
+  notify();
+}
+function deactivateExtension(id) {
+  const e = entries.get(id);
+  if (!e) return;
+  entries.delete(id);
+  try {
+    e.dispose();
+  } catch (err) {
+    console.error(`[extensions] dispose of ${id} failed:`, err);
+  }
+  notify();
+}
+function deactivateAllExtensions() {
+  for (const id of [...entries.keys()]) deactivateExtension(id);
+}
+function asDefinition(mod) {
+  const m = mod;
+  const def = m && typeof m === "object" && "default" in m ? m.default : null;
+  return def && typeof def === "object" ? def : null;
+}
+function checkDefinition(doc, def) {
+  if (!def) throw new Error("bundle.js has no default export (export default defineModule({...}) / defineTheme({...})).");
+  if (def.id !== doc.id) throw new Error(`bundle id "${String(def.id)}" doesn't match manifest id "${doc.id}".`);
+  if (!isCompatibleApiVersion(def.apiVersion)) throw new Error(`bundle apiVersion "${String(def.apiVersion)}" is not supported.`);
+}
+function styleInjector(id, css) {
+  if (!css || typeof document === "undefined") return () => void 0;
+  const el = document.createElement("style");
+  el.dataset.agentcrmExtension = id;
+  el.textContent = css;
+  document.head.appendChild(el);
+  return () => el.remove();
+}
+function activateModule(doc, def) {
+  const disposers = [];
+  const track = (off) => {
+    disposers.push(off);
+    return off;
+  };
+  try {
+    const m = doc.manifest;
+    const feature = {
+      routes: [],
+      i18n: { en: {} },
+      ...def.feature ?? {},
+      id: doc.id,
+      module: { name: m.name, description: m.description, icon: m.icon ?? "Puzzle", category: m.category ?? "customisation", ...m.dependsOn?.length ? { dependsOn: m.dependsOn } : {} },
+      ...def.settingsPage ? { settingsPage: def.settingsPage } : {}
+    };
+    track(registerExternalFeature(feature));
+    for (const tool of def.aiTools ?? []) track(registerAiTool(tool));
+    for (const action of def.automationActions ?? []) track(registerAutomationAction(action));
+    track(styleInjector(doc.id, doc.files["style.css"]));
+    if (typeof def.register === "function") {
+      const api = {
+        moduleId: doc.id,
+        addAction: ((hook, fn, priority) => track(plugins.addAction(hook, fn, priority))),
+        addFilter: (hook, fn, priority) => track(plugins.addFilter(hook, fn, priority)),
+        registerAiTool: (tool) => track(registerAiTool(tool)),
+        registerAutomationAction: (action) => track(registerAutomationAction(action)),
+        onDispose: (fn) => void disposers.push(fn)
+      };
+      const cleanup = def.register(api);
+      if (typeof cleanup === "function") disposers.push(cleanup);
+    }
+  } catch (err) {
+    for (const d of disposers.reverse()) d();
+    throw err;
+  }
+  return () => {
+    for (const d of disposers.reverse()) {
+      try {
+        d();
+      } catch (err) {
+        console.error(`[extensions] cleanup of ${doc.id} failed:`, err);
+      }
+    }
+  };
+}
+function activateTheme(doc, def) {
+  if (!def.appearance || typeof def.appearance !== "object") throw new Error("defineTheme({ appearance }) is required.");
+  if (typeof def.name !== "string" || !def.name) throw new Error("defineTheme({ name }) is required.");
+  const css = [def.css, doc.files["style.css"]].filter(Boolean).join("\n");
+  return registerExternalTheme({ id: doc.id, apiVersion: def.apiVersion, name: def.name, ...def.description ? { description: def.description } : {}, appearance: { ...def.appearance }, ...css ? { css } : {} });
+}
+function activateExtension(doc, mod, fingerprint) {
+  const def = asDefinition(mod);
+  checkDefinition(doc, def);
+  deactivateExtension(doc.id);
+  const dispose = doc.kind === "theme" ? activateTheme(doc, def) : activateModule(doc, def);
+  entries.set(doc.id, { state: { id: doc.id, kind: doc.kind, version: doc.manifest.version, status: "loaded", fingerprint }, dispose });
+  notify();
+}
+export {
+  activateExtension,
+  deactivateAllExtensions,
+  deactivateExtension,
+  getLoadedExtension,
+  listLoadedExtensions,
+  setExtensionStatus,
+  subscribeLoadedExtensions
+};

package/dist/agent/chunks/registry-DijAKZ24.mjs

@@ -0,0 +1,431 @@
+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 { i as instance } from "./index-BM8qeGOb.mjs";
+import { S as StorageError, t as toast } from "./http-Bk9ICb7I.mjs";
+import "./index-w03ReRs4.mjs";
+import { c as changeToBytes, d as base64ToBytes, a as base64ToUtf8 } from "./encoding-C9MzdP95.mjs";
+import { G as GitConflictError, g as gitPagesFactory, s as s3Factory } from "./s3-Dz50-NuA.mjs";
+const IGNORED = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", "Thumbs.db"]);
+async function ensureFolderPermission(handle, request) {
+  const dir = handle;
+  const desc = { mode: "readwrite" };
+  if (await dir.queryPermission?.(desc) === "granted") return true;
+  return false;
+}
+function fingerprint(entries) {
+  let h = 2166136261;
+  for (const e of entries) {
+    const line = `${e.path}\0${e.sha}
+`;
+    for (let i = 0; i < line.length; i++) {
+      h ^= line.charCodeAt(i);
+      h = Math.imul(h, 16777619);
+    }
+  }
+  return `local-${entries.length}-${(h >>> 0).toString(16)}`;
+}
+function createLocalFsTransport(handle) {
+  const root = handle;
+  const files = /* @__PURE__ */ new Map();
+  async function walk(dir, prefix, out) {
+    for await (const [name, child] of dir.entries()) {
+      if (IGNORED.has(name)) continue;
+      const path = prefix + name;
+      if (child.kind === "directory") {
+        await walk(child, path + "/", out);
+      } else {
+        const file = await child.getFile();
+        files.set(path, child);
+        out.push({ path, sha: `${file.size}:${file.lastModified}`, size: file.size });
+      }
+    }
+  }
+  async function listTree() {
+    files.clear();
+    const entries = [];
+    await walk(root, "", entries);
+    entries.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    return { headSha: fingerprint(entries), entries };
+  }
+  async function fileHandle(path) {
+    const cached = files.get(path);
+    if (cached) return cached;
+    const parts = path.split("/");
+    let dir = root;
+    for (const part of parts.slice(0, -1)) dir = await dir.getDirectoryHandle(part);
+    return dir.getFileHandle(parts[parts.length - 1]);
+  }
+  async function readTexts(entries) {
+    const out = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      try {
+        out.set(e.path, await (await (await fileHandle(e.path)).getFile()).text());
+      } catch {
+      }
+    }
+    return out;
+  }
+  async function readBytes(entry) {
+    const file = await (await fileHandle(entry.path)).getFile();
+    return new Uint8Array(await file.arrayBuffer());
+  }
+  async function writeFile(path, bytes) {
+    const parts = path.split("/");
+    let dir = root;
+    for (const part of parts.slice(0, -1)) dir = await dir.getDirectoryHandle(part, { create: true });
+    const file = await dir.getFileHandle(parts[parts.length - 1], { create: true });
+    const writable = await file.createWritable();
+    await writable.write(bytes);
+    await writable.close();
+    files.set(path, file);
+  }
+  async function removeFile(path) {
+    const parts = path.split("/");
+    try {
+      let dir = root;
+      for (const part of parts.slice(0, -1)) dir = await dir.getDirectoryHandle(part);
+      await dir.removeEntry(parts[parts.length - 1]);
+    } catch {
+    }
+    files.delete(path);
+  }
+  async function commit(changes, opts) {
+    if (opts.expectedHeadSha !== void 0) {
+      const current = (await listTree()).headSha;
+      if (current !== opts.expectedHeadSha) throw new GitConflictError("Folder changed on disk", current);
+    }
+    for (const change of changes) {
+      if (change.type === "delete") await removeFile(change.path);
+      else await writeFile(change.path, changeToBytes(change));
+    }
+    return (await listTree()).headSha;
+  }
+  return {
+    kind: "local",
+    label: root.name,
+    headSha: async () => (await listTree()).headSha,
+    listTree,
+    readTexts,
+    readBytes,
+    commit,
+    permissions: async () => ({
+      login: "local",
+      canWrite: await ensureFolderPermission(handle),
+      isAdmin: true
+    })
+  };
+}
+const DB_NAME = "agentcrm-folder-handles";
+const STORE = "handles";
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function loadFolderHandle(key) {
+  try {
+    const db = await openDb();
+    return await new Promise((resolve) => {
+      const req = db.transaction(STORE, "readonly").objectStore(STORE).get(key);
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => resolve(null);
+    });
+  } catch {
+    return null;
+  }
+}
+function createKvStore(dbName, storeName = "kv") {
+  const memory = /* @__PURE__ */ new Map();
+  let dbPromise = null;
+  function db() {
+    if (!dbPromise) {
+      dbPromise = new Promise((resolve) => {
+        try {
+          if (typeof indexedDB === "undefined") return resolve(null);
+          const req = indexedDB.open(dbName, 1);
+          req.onupgradeneeded = () => req.result.createObjectStore(storeName);
+          req.onsuccess = () => resolve(req.result);
+          req.onerror = () => resolve(null);
+          req.onblocked = () => resolve(null);
+        } catch {
+          resolve(null);
+        }
+      });
+    }
+    return dbPromise;
+  }
+  function run(mode, fn) {
+    return db().then(
+      (d) => new Promise((resolve, reject) => {
+        if (!d) return resolve(void 0);
+        const tx = d.transaction(storeName, mode);
+        const req = fn(tx.objectStore(storeName));
+        tx.oncomplete = () => resolve(req ? req.result : void 0);
+        tx.onerror = () => reject(tx.error);
+        tx.onabort = () => reject(tx.error);
+      })
+    );
+  }
+  return {
+    async get(key) {
+      if (!await db()) return memory.get(key);
+      return run("readonly", (s) => s.get(key));
+    },
+    async set(key, value) {
+      if (!await db()) return void memory.set(key, value);
+      await run("readwrite", (s) => void s.put(value, key));
+    },
+    async delete(key) {
+      if (!await db()) return void memory.delete(key);
+      await run("readwrite", (s) => void s.delete(key));
+    },
+    async keys() {
+      if (!await db()) return [...memory.keys()];
+      return (await run("readonly", (s) => s.getAllKeys()) ?? []).map(String);
+    },
+    async entries() {
+      if (!await db()) return [...memory.entries()];
+      const out = [];
+      await run("readonly", (s) => {
+        const req = s.openCursor();
+        req.onsuccess = () => {
+          const cursor = req.result;
+          if (!cursor) return;
+          out.push([String(cursor.key), cursor.value]);
+          cursor.continue();
+        };
+      });
+      return out;
+    },
+    async clear() {
+      if (!await db()) return void memory.clear();
+      await run("readwrite", (s) => void s.clear());
+    }
+  };
+}
+const mirror = createKvStore("agentcrm-site-mirror", "files");
+function createBrowserMirrorConnector(settings) {
+  const siteUrl = (settings.siteUrl ?? "").replace(/\/+$/, "");
+  const norm = (path) => path.replace(/^\/+/, "");
+  return {
+    id: "browser-mirror",
+    model: "files",
+    capabilities: {
+      list: true,
+      rename: false,
+      renameFolder: false,
+      folders: false,
+      deletePrefix: true
+    },
+    async put(input) {
+      await mirror.set(norm(input.path), {
+        content: input.content,
+        encoding: input.encoding === "base64" ? "base64" : "utf-8",
+        updatedAt: Date.now()
+      });
+    },
+    async get(path) {
+      const file = await mirror.get(norm(path));
+      if (!file) throw new StorageError(`File not found: ${path}`, 404);
+      return file.encoding === "base64" ? base64ToUtf8(file.content) : file.content;
+    },
+    async getBytes(path) {
+      const file = await mirror.get(norm(path));
+      if (!file) return null;
+      return file.encoding === "base64" ? base64ToBytes(file.content) : new TextEncoder().encode(file.content);
+    },
+    delete: (path) => mirror.delete(norm(path)),
+    async deletePrefix(path) {
+      const prefix = norm(path).replace(/\/+$/, "") + "/";
+      for (const key of await mirror.keys()) if (key.startsWith(prefix)) await mirror.delete(key);
+    },
+    async list(page, perPage) {
+      const all = (await mirror.keys()).sort().map((path) => ({ path, type: "file", url: siteUrl ? `${siteUrl}/${path}` : `/${path}` }));
+      return { items: all.slice((page - 1) * perPage, page * perPage), page, per_page: perPage, total: all.length };
+    },
+    async listPrefix(under) {
+      const want = norm(under);
+      return (await mirror.keys()).filter((k) => k.startsWith(want)).sort();
+    },
+    async publicUrl(path) {
+      return siteUrl ? `${siteUrl}/${norm(path)}` : `/${norm(path)}`;
+    }
+  };
+}
+const browserMirrorFactory = {
+  id: "browser-mirror",
+  create: createBrowserMirrorConnector
+};
+const LOCAL_PUBLISH_HANDLE_KEY = "publish-target";
+function createLocalFolderConnector(settings) {
+  const siteUrl = (settings.siteUrl ?? "").replace(/\/+$/, "");
+  let transport = null;
+  async function open() {
+    if (transport) return transport;
+    const handle = await loadFolderHandle(settings.handleKey || LOCAL_PUBLISH_HANDLE_KEY);
+    if (!handle || !await ensureFolderPermission(handle)) {
+      const message = instance.t("storage.errors.folderAccess");
+      toast.error(message);
+      throw new StorageError(message, 403);
+    }
+    transport = createLocalFsTransport(handle);
+    return transport;
+  }
+  async function entry(path) {
+    const tree = await (await open()).listTree();
+    return tree.entries.find((e) => e.path === path.replace(/^\/+/, ""));
+  }
+  return {
+    id: "local-folder",
+    model: "files",
+    capabilities: {
+      list: true,
+      rename: false,
+      renameFolder: false,
+      folders: false,
+      deletePrefix: true
+    },
+    async put(input) {
+      await (await open()).commit([{ type: "put", ...input, path: input.path.replace(/^\/+/, "") }], { message: "" });
+    },
+    async get(path) {
+      const e = await entry(path);
+      const text = e ? (await (await open()).readTexts([e])).get(e.path) : void 0;
+      if (text === void 0) throw new StorageError(`File not found: ${path}`, 404);
+      return text;
+    },
+    async getBytes(path) {
+      const e = await entry(path);
+      return e ? (await open()).readBytes(e) : null;
+    },
+    async delete(path) {
+      await (await open()).commit([{ type: "delete", path: path.replace(/^\/+/, "") }], { message: "" });
+    },
+    async deletePrefix(path) {
+      const t = await open();
+      const prefix = path.replace(/^\/+|\/+$/g, "") + "/";
+      const doomed = (await t.listTree()).entries.filter((e) => e.path.startsWith(prefix));
+      await t.commit(doomed.map((e) => ({ type: "delete", path: e.path })), { message: "" });
+    },
+    async list(page, perPage) {
+      const all = (await (await open()).listTree()).entries.map((e) => ({
+        path: e.path,
+        type: "file",
+        size: e.size,
+        url: siteUrl ? `${siteUrl}/${e.path}` : `/${e.path}`
+      }));
+      return { items: all.slice((page - 1) * perPage, page * perPage), page, per_page: perPage, total: all.length };
+    },
+    async listPrefix(under) {
+      const want = under.replace(/^\/+/, "");
+      return (await (await open()).listTree()).entries.map((e) => e.path).filter((p) => p.startsWith(want));
+    },
+    async publicUrl(path) {
+      const clean = path.replace(/^\/+/, "");
+      return siteUrl ? `${siteUrl}/${clean}` : `/${clean}`;
+    }
+  };
+}
+const localFolderFactory = {
+  id: "local-folder",
+  create: createLocalFolderConnector
+};
+let configSource = async () => null;
+function setStorageConfigSource(source) {
+  configSource = source;
+  active = null;
+}
+function getStorageConfig() {
+  return configSource();
+}
+const DEFAULT_CONNECTOR_ID = "browser-mirror";
+let active = null;
+const connectors = new Map(
+  [
+    gitPagesFactory,
+    s3Factory,
+    browserMirrorFactory,
+    localFolderFactory
+  ].map((e) => [e.id, e])
+);
+function isFactory(entry) {
+  return typeof entry.create === "function";
+}
+function registerStorageConnector(entry) {
+  connectors.set(entry.id, entry);
+  if (active && active.id === entry.id) active = null;
+}
+function defaultConnectorId() {
+  return DEFAULT_CONNECTOR_ID;
+}
+function listStorageConnectorIds() {
+  return [...connectors.keys()];
+}
+function instantiateStorageConnector(id, settings) {
+  const entry = connectors.get(id);
+  if (!entry) {
+    throw new StorageError(instance.t("storage.errors.unknownConnector", { connector: id }), 501);
+  }
+  return isFactory(entry) ? entry.create(settings) : entry;
+}
+async function resolveActive() {
+  let config = null;
+  try {
+    config = await getStorageConfig();
+  } catch (err) {
+    console.warn("[storage] could not read storage config, using the default target:", err);
+  }
+  const id = config?.connectorId ?? defaultConnectorId();
+  try {
+    return instantiateStorageConnector(id, config?.settings ?? {});
+  } catch (err) {
+    toast.error(err.message);
+    throw err;
+  }
+}
+async function getActiveStorageConnector() {
+  if (!active) {
+    const connector = resolveActive();
+    active = { id: "", connector };
+    connector.then(
+      (c) => {
+        if (active?.connector === connector) active.id = c.id;
+      },
+      () => {
+        if (active?.connector === connector) active = null;
+      }
+    );
+  }
+  return active.connector;
+}
+function invalidateActiveStorageConnector() {
+  active = null;
+}
+const registry = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  DEFAULT_CONNECTOR_ID,
+  defaultConnectorId,
+  getActiveStorageConnector,
+  getStorageConfig,
+  instantiateStorageConnector,
+  invalidateActiveStorageConnector,
+  listStorageConnectorIds,
+  registerStorageConnector,
+  setStorageConfigSource
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  createKvStore as a,
+  createLocalFsTransport as c,
+  ensureFolderPermission as e,
+  getActiveStorageConnector as g,
+  instantiateStorageConnector as i,
+  loadFolderHandle as l,
+  registry as r
+};