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

package/dist/agent/chunks/install-CpHoUFtL.mjs

@@ -0,0 +1,188 @@
+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 { generatePassphrase } from "./index-CWrrF1wl.mjs";
+import { r as resolveGitPagesToken, c as createRemoteGitTransport } from "./s3-Dz50-NuA.mjs";
+import { i as instantiateStorageConnector } from "./registry-DijAKZ24.mjs";
+import { S as StorageError, s as subscribeToToasts } from "./http-Bk9ICb7I.mjs";
+import { s as setCredential, h as openStore } from "../agentcrm.mjs";
+import { adminOps, applyOps, buildConnector } from "./hosting-Bme7LxPc.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+import "./encoding-C9MzdP95.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+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";
+const PROBE_PATH = ".agentcrm-probe.txt";
+const REQUIRED = {
+  "git-pages": (s) => [...s.provider === "gitlab" ? ["project"] : ["owner", "repo"], "branch", "siteUrl"],
+  s3: () => ["bucket", "accessKeyId", "secretAccessKey", "siteUrl"]
+};
+function missingFields(connectorId, settings, ignore = []) {
+  const required = (REQUIRED[connectorId]?.(settings) ?? []).filter((k) => !ignore.includes(k));
+  return required.filter((k) => typeof settings[k] !== "string" || !settings[k].trim());
+}
+async function testStorageConnection(connectorId, settings, opts = {}) {
+  const missing = missingFields(connectorId, settings, opts.ignore);
+  if (missing.length) return { ok: false, detail: `missing: ${missing.join(", ")}` };
+  try {
+    if (connectorId === "git-pages") ;
+    const connector = instantiateStorageConnector(connectorId, settings);
+    if (connectorId === "browser-mirror") ;
+    await connector.put({ path: PROBE_PATH, content: `AgentCRM connection test ${(/* @__PURE__ */ new Date()).toISOString()}
+` });
+    const echoed = await connector.get(PROBE_PATH).catch(() => null);
+    const listed = connector.listPrefix ? await connector.listPrefix(".agentcrm-").catch(() => null) : [PROBE_PATH];
+    await connector.delete(PROBE_PATH);
+    if (echoed === null) return { ok: false, detail: "write succeeded but read-back failed" };
+    if (!listed || !listed.includes(PROBE_PATH)) return { ok: false, detail: "write succeeded but listing failed (ListBucket permission / CORS)" };
+    return { ok: true, detail: await connector.publicUrl("") };
+  } catch (err) {
+    const status = err instanceof StorageError ? ` (${err.status})` : "";
+    return { ok: false, detail: `${err.message}${status}` };
+  }
+}
+function collectToasts() {
+  const notices = [];
+  const stop = subscribeToToasts((t) => notices.push({ level: t.level, message: t.message }));
+  return { notices, stop };
+}
+function gitTransport(settings) {
+  const s = settings;
+  return createRemoteGitTransport(
+    s.provider === "gitlab" ? { provider: "gitlab", project: s.project ?? "", branch: s.branch ?? "main", token: s.token ?? "", apiBaseUrl: s.apiBaseUrl } : { provider: "github", owner: s.owner ?? "", repo: s.repo ?? "", branch: s.branch ?? "main", token: s.token ?? "", apiBaseUrl: s.apiBaseUrl }
+  );
+}
+async function probeTarget(target, opts) {
+  try {
+    if (target.connectorId === "git-pages") {
+      const transport = gitTransport(target.settings);
+      const perms = await transport.permissions();
+      if (!perms.canWrite) return { ok: false, detail: `${perms.login}: read-only access to ${transport.label}` };
+      if (opts.requirePrivate && perms.visibility === "public") {
+        return { ok: false, detail: `${transport.label} is PUBLIC: CRM data (personal data) must live in a private repository. Make it private (Settings → General → Danger Zone) and retry.` };
+      }
+      return { ok: true, detail: `${perms.login} → ${transport.label}${perms.visibility ? ` (${perms.visibility})` : ""}` };
+    }
+    if (target.connectorId === "s3") {
+      return await testStorageConnection("s3", target.settings, { ignore: opts.requireSiteUrl ? [] : ["siteUrl"] });
+    }
+    const connector = buildConnector(target);
+    const probe = ".agentcrm-probe.txt";
+    await connector.put({ path: probe, content: `AgentCRM connection test ${(/* @__PURE__ */ new Date()).toISOString()}
+` });
+    const back = await connector.getBytes?.(probe);
+    const listed = await connector.listPrefix?.(".agentcrm-");
+    await connector.delete(probe);
+    if (!back || !listed?.includes(probe)) return { ok: false, detail: "write succeeded but read-back / listing failed" };
+    return { ok: true, detail: await connector.publicUrl("") };
+  } catch (err) {
+    const status = err.status;
+    return { ok: false, detail: `${err.message}${status ? ` (${status})` : ""}` };
+  }
+}
+async function checkPlan(plan) {
+  let data;
+  if (plan.runtime.backend === "journal" && plan.dataTarget) {
+    const access = await probeTarget(plan.dataTarget, { requireSiteUrl: false, requirePrivate: true });
+    if (!access.ok) data = { ...access, existing: false };
+    else {
+      try {
+        const connector = buildConnector(plan.dataTarget);
+        const root = plan.runtime.journal.root;
+        const keyinfo = await connector.getBytes(`${root ? `${root}/` : ""}keyinfo.json`);
+        if (!keyinfo) {
+          data = { ok: true, detail: `${access.detail} — new ${plan.runtime.journal.encrypted ? "encrypted " : ""}dataset in "${root || "/"}"`, existing: false };
+        } else {
+          const info = JSON.parse(new TextDecoder().decode(keyinfo));
+          if (info.encrypted && !plan.passphrase) {
+            data = { ok: false, detail: `an encrypted dataset already exists in "${root}": store its passphrase as ${plan.passphraseAccount ?? "passphrase:<alias>"} and set data.encryption.credential`, existing: true };
+          } else {
+            const store = await openStore(plan.runtime, { dataTarget: plan.dataTarget, passphrase: plan.passphrase });
+            try {
+              await store.ready();
+              const count = store.list("records").length;
+              data = { ok: true, detail: `${access.detail} — existing ${info.encrypted ? "encrypted " : ""}dataset (${count} records): it is kept, only what's missing is seeded`, existing: true };
+            } finally {
+              store.close?.();
+            }
+          }
+        }
+      } catch (err) {
+        const e = err;
+        data = { ok: false, detail: e.name === "PassphraseError" ? `wrong passphrase in ${plan.passphraseAccount}` : e.message, existing: false };
+      }
+    }
+  } else if (plan.runtime.backend === "git-json") {
+    const access = await probeTarget({ connectorId: "git-pages", settings: { ...plan.runtime.git, ...plan.backendSecrets ?? {} } }, { requireSiteUrl: false, requirePrivate: true });
+    data = { ...access, existing: false };
+  } else {
+    data = { ok: true, detail: `Firebase project ${plan.runtime.firebase.projectId} (checked at install: sign-in + rules)`, existing: false };
+  }
+  const hosting = plan.hostingTarget ? await probeTarget(plan.hostingTarget, { requireSiteUrl: plan.hostingTarget.connectorId !== "local-folder" }) : null;
+  return { data, hosting };
+}
+async function runInstall(plan, onStep) {
+  const toasts = collectToasts();
+  try {
+    let generatedPassphrase = false;
+    if (plan.passphraseAccount && !plan.passphrase) {
+      plan.passphrase = generatePassphrase();
+      setCredential(plan.passphraseAccount, { passphrase: plan.passphrase });
+      generatedPassphrase = true;
+      onStep(`Generated the dataset passphrase (stored as ${plan.passphraseAccount})`);
+    }
+    onStep("Opening the dataset");
+    const store = await openStore(plan.runtime, { dataTarget: plan.dataTarget, secrets: plan.backendSecrets, passphrase: plan.passphrase });
+    let seed;
+    try {
+      await store.ready();
+      const { createOpsContext } = await import("./context-CxFfqS4D.mjs");
+      const { createPluginRegistry } = await import("./pluginRegistry-DyHtlkcr.mjs");
+      const { seedCrm } = await import("./seed-CugPGYZL.mjs");
+      const { setConfigDoc } = await import("./settings-BtvR_jdm.mjs");
+      const system = createOpsContext(store, null, { plugins: createPluginRegistry() });
+      onStep(`Seeding the CRM${plan.demo ? " (with demo data)" : ""}`);
+      const identity = plan.backend === "journal" ? null : await store.identity().catch(() => null);
+      const admin = identity?.uid ? { ...plan.owner, id: identity.uid } : plan.owner;
+      seed = await seedCrm(system, { name: plan.name, admin, demo: plan.demo, currency: plan.currency, locale: plan.locale });
+      if (plan.hosting) {
+        await setConfigDoc(system, "hosting", { connectorId: plan.hosting.connectorId, settings: plan.hosting.settings, folder: plan.hosting.folder, type: plan.hosting.type });
+      }
+    } finally {
+      store.close?.();
+    }
+    let adminVersion = null;
+    let files = 0;
+    if (plan.hostingTarget && plan.hosting) {
+      const { ops, version } = adminOps(plan.hosting.folder, plan.runtime);
+      onStep(`Uploading the admin (${ops.length} files) to ${plan.hosting.type}`);
+      await applyOps(buildConnector(plan.hostingTarget), ops);
+      adminVersion = version;
+      files = ops.length;
+    }
+    return { seed, adminVersion, files, generatedPassphrase, notices: toasts.notices };
+  } finally {
+    toasts.stop();
+  }
+}
+export {
+  checkPlan,
+  collectToasts,
+  probeTarget,
+  runInstall
+};

package/dist/agent/chunks/jsx-runtime-Ca2uwGDr.mjs

@@ -0,0 +1,76 @@
+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";
+import { a as requireReact } from "./index-Bnmav-Oh.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 jsxRuntime$1 = { exports: {} };
+var reactJsxRuntime_production_min = {};
+/**
+ * @license React
+ * react-jsx-runtime.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 hasRequiredReactJsxRuntime_production_min;
+function requireReactJsxRuntime_production_min() {
+  if (hasRequiredReactJsxRuntime_production_min) return reactJsxRuntime_production_min;
+  hasRequiredReactJsxRuntime_production_min = 1;
+  var f = requireReact(), k = Symbol.for("react.element"), l = Symbol.for("react.fragment"), m = Object.prototype.hasOwnProperty, n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, p = { key: true, ref: true, __self: true, __source: true };
+  function q(c, a, g) {
+    var b, d = {}, e = null, h = null;
+    void 0 !== g && (e = "" + g);
+    void 0 !== a.key && (e = "" + a.key);
+    void 0 !== a.ref && (h = a.ref);
+    for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
+    if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]);
+    return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current };
+  }
+  reactJsxRuntime_production_min.Fragment = l;
+  reactJsxRuntime_production_min.jsx = q;
+  reactJsxRuntime_production_min.jsxs = q;
+  return reactJsxRuntime_production_min;
+}
+var hasRequiredJsxRuntime;
+function requireJsxRuntime() {
+  if (hasRequiredJsxRuntime) return jsxRuntime$1.exports;
+  hasRequiredJsxRuntime = 1;
+  {
+    jsxRuntime$1.exports = requireReactJsxRuntime_production_min();
+  }
+  return jsxRuntime$1.exports;
+}
+var jsxRuntimeExports = requireJsxRuntime();
+const jsxRuntime = /* @__PURE__ */ getDefaultExportFromCjs(jsxRuntimeExports);
+const ReactJsxRuntime = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: jsxRuntime
+}, [jsxRuntimeExports]);
+export {
+  ReactJsxRuntime as R,
+  jsxRuntimeExports as j
+};

package/dist/agent/chunks/loader-C9nm3iwx.mjs

@@ -0,0 +1,184 @@
+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 { h as RUNTIME_DIR, g as RUNTIME_MODULES, i as isCompatibleApiVersion, j as RUNTIME_GLOBAL } from "./api-B6OqNVWp.mjs";
+import { rewriteRuntimeImports, fingerprint, bundleImports } from "./package-DWbn3t2R.mjs";
+import { listLoadedExtensions, deactivateExtension, getLoadedExtension, setExtensionStatus, activateExtension } from "./registry-Ceexawxl.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+import "./featureRegistry-C9nbVShp.mjs";
+import "./index-Bnmav-Oh.mjs";
+import "./index-BM8qeGOb.mjs";
+import "./modules-CqdVQVJb.mjs";
+import "./context-CxFfqS4D.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./settings-BtvR_jdm.mjs";
+import "./store-5gqRSKXg.mjs";
+import "./runtimeConfig-CCOFg1RM.mjs";
+import "./tools-Bew8lxKx.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 "./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 "./extensionActions-D2HtpQz4.mjs";
+import "./forms-BKU5F9WF.mjs";
+import "./schema-7-4-qtSS.mjs";
+import "./appearance-BaShelzt.mjs";
+import "./themes-DPZFv3yc.mjs";
+import "./extensions-BP1k60md.mjs";
+import "./files-CjsPJSR6.mjs";
+import "./files-q8Xu5bft.mjs";
+import "./index-RCmo-uld.mjs";
+import "./http-Bk9ICb7I.mjs";
+async function prepareRuntime(specifiers) {
+  const g = globalThis;
+  await g[RUNTIME_GLOBAL]?.prepare?.(specifiers);
+}
+function createBrowserImportBundle(baseUrl) {
+  return async (code) => {
+    const base = baseUrl ?? document.baseURI;
+    const rewritten = rewriteRuntimeImports(code, (spec) => new URL(`${RUNTIME_DIR}/${RUNTIME_MODULES[spec]}`, base).href);
+    const url = URL.createObjectURL(new Blob([rewritten], { type: "text/javascript" }));
+    try {
+      return await import(
+        /* @vite-ignore */
+        url
+      );
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+  };
+}
+let shiftHeldAtBoot = false;
+function trackSafeModeKey(win = window) {
+  const on = (e) => {
+    if (e.key === "Shift" || e.shiftKey) shiftHeldAtBoot = true;
+  };
+  win.addEventListener("keydown", on);
+  const t = setTimeout(() => win.removeEventListener("keydown", on), 2500);
+  return () => {
+    clearTimeout(t);
+    win.removeEventListener("keydown", on);
+  };
+}
+function isSafeMode(loc = typeof location !== "undefined" ? location : void 0) {
+  if (shiftHeldAtBoot) return true;
+  if (!loc) return false;
+  const hashQuery = loc.hash.includes("?") ? loc.hash.slice(loc.hash.indexOf("?")) : "";
+  return [loc.search, hashQuery].some((q) => {
+    const v = new URLSearchParams(q).get("safe");
+    return v === "1" || v === "true";
+  });
+}
+function resetSafeModeKey() {
+  shiftHeldAtBoot = false;
+}
+function wantedDocs(store) {
+  return store.list("extensions").filter((d) => d && typeof d.id === "string" && d.manifest);
+}
+async function loadOne(doc, importBundle) {
+  const code = doc.files?.["bundle.js"];
+  if (typeof code !== "string" || !code) throw new Error("bundle.js is missing (upload incomplete?).");
+  await prepareRuntime(bundleImports(code));
+  const mod = await importBundle(code, { id: doc.id, version: doc.manifest.version });
+  activateExtension(doc, mod, fingerprint(doc.manifest, doc.files));
+}
+let queue = Promise.resolve();
+function syncExtensions(store, opts = {}) {
+  const run = async () => {
+    const report = { loaded: [], unloaded: [], failed: [], skipped: [] };
+    const importBundle = opts.importBundle ?? createBrowserImportBundle();
+    const docs = wantedDocs(store);
+    const ids = new Set(docs.map((d) => d.id));
+    for (const e of listLoadedExtensions()) {
+      if (!ids.has(e.id)) {
+        if (e.status === "loaded") report.unloaded.push(e.id);
+        deactivateExtension(e.id);
+      }
+    }
+    for (const doc of docs) {
+      const current = getLoadedExtension(doc.id);
+      if (opts.safeMode) {
+        if (current?.status !== "skipped") setExtensionStatus(doc, "skipped");
+        report.skipped.push(doc.id);
+        continue;
+      }
+      if (!doc.enabled) {
+        if (current?.status === "loaded") report.unloaded.push(doc.id);
+        if (current?.status !== "disabled") setExtensionStatus(doc, "disabled");
+        continue;
+      }
+      if (!isCompatibleApiVersion(doc.manifest.apiVersion)) {
+        if (current?.status !== "incompatible") setExtensionStatus(doc, "incompatible", `apiVersion ${doc.manifest.apiVersion} is not supported.`);
+        continue;
+      }
+      const fp = doc.files?.["bundle.js"] ? fingerprint(doc.manifest, doc.files) : "";
+      if (current?.status === "loaded" && current.fingerprint === fp) continue;
+      if (current?.status === "error" && current.fingerprint === fp) continue;
+      try {
+        await loadOne(doc, importBundle);
+        report.loaded.push(doc.id);
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err));
+        console.error(`[extensions] ${doc.id} failed to load:`, error);
+        setExtensionStatus(doc, "error", error.message);
+        const st = getLoadedExtension(doc.id);
+        if (st) st.fingerprint = fp;
+        report.failed.push({ id: doc.id, error: error.message });
+        opts.onError?.(doc.id, error);
+      }
+    }
+    return report;
+  };
+  const next = queue.then(run, run);
+  queue = next.catch(() => void 0);
+  return next;
+}
+function watchExtensions(store, opts = {}) {
+  let stopped = false;
+  const sync = () => void syncExtensions(store, opts).then((r) => {
+    if (!stopped) opts.onSync?.(r);
+  });
+  const off = store.subscribe((changed) => {
+    if (changed.has("extensions")) sync();
+  });
+  return () => {
+    stopped = true;
+    off();
+  };
+}
+export {
+  createBrowserImportBundle,
+  isSafeMode,
+  resetSafeModeKey,
+  syncExtensions,
+  trackSafeModeKey,
+  watchExtensions
+};