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

package/dist/agent/chunks/dedupe-BepmsaHv.mjs

@@ -0,0 +1,123 @@
+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 { isEmptyFieldValue, normalizeEmail, normalizeDomain, recordLabel } from "./fields-B0bitgmr.mjs";
+import { assertCan, OpsError, actorId, emit } from "./context-CxFfqS4D.mjs";
+import { c as rewriteReferences, d as fileMergeMutations } from "./relations-B9TynBmA.mjs";
+import { requireRecord, requireObject, activitiesOf, asDoc, recordsOf } from "./store-5gqRSKXg.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+function normLabel(s) {
+  return typeof s === "string" ? s.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/\b(inc|llc|ltd|sas|sarl|gmbh|corp|corporation|co)\b\.?/g, "").replace(/[^a-z0-9]+/g, " ").trim() : "";
+}
+function findDuplicates(ctx, objectId, opts = {}) {
+  assertCan(ctx, "records.read");
+  const object = requireObject(ctx.store, objectId);
+  const has = (id) => object.fields.some((f) => f.id === id);
+  const by = opts.by ?? [...has("email") ? ["email"] : [], ...has("domain") ? ["domain"] : [], "name"];
+  const records = recordsOf(ctx.store, objectId);
+  const groups = [];
+  const grouped = /* @__PURE__ */ new Set();
+  for (const reason of by) {
+    const buckets = /* @__PURE__ */ new Map();
+    for (const r of records) {
+      const key = reason === "email" ? normalizeEmail(r.fields.email) : reason === "domain" ? normalizeDomain(r.fields.domain) : reason === "phone" ? String(r.fields.phone ?? "").replace(/[^\d]/g, "").slice(-9) : normLabel(recordLabel(object, r));
+      if (!key || reason === "phone" && key.length < 6) continue;
+      const list = buckets.get(key) ?? [];
+      list.push(r);
+      buckets.set(key, list);
+    }
+    for (const [key, list] of buckets) {
+      if (list.length < 2) continue;
+      const sig = list.map((r) => r.id).sort().join(",");
+      if (grouped.has(sig)) continue;
+      grouped.add(sig);
+      groups.push({
+        reason,
+        key,
+        records: list.sort((a, b) => b.updatedAt - a.updatedAt).map((r) => ({ id: r.id, label: recordLabel(object, r), updatedAt: r.updatedAt }))
+      });
+    }
+  }
+  return groups;
+}
+function mergedFields(object, primary, others, pick) {
+  const all = [primary, ...[...others].sort((a, b) => b.updatedAt - a.updatedAt)];
+  const out = { ...primary.fields };
+  for (const field of object.fields) {
+    const chosen = pick[field.id];
+    if (chosen) {
+      const src = all.find((r) => r.id === chosen);
+      if (src) {
+        if (isEmptyFieldValue(field, src.fields[field.id])) delete out[field.id];
+        else out[field.id] = src.fields[field.id];
+      }
+      continue;
+    }
+    const isArray = field.type === "tags" || field.type === "multiSelect" || field.type === "files" || field.type === "relation" && field.relation?.cardinality === "many";
+    if (isArray) {
+      const union = [...new Set(all.flatMap((r) => Array.isArray(r.fields[field.id]) ? r.fields[field.id] : []))];
+      if (union.length) out[field.id] = union;
+      continue;
+    }
+    if (isEmptyFieldValue(field, out[field.id])) {
+      const donor = all.find((r) => !isEmptyFieldValue(field, r.fields[field.id]));
+      if (donor) out[field.id] = donor.fields[field.id];
+    }
+  }
+  return out;
+}
+async function mergeRecords(ctx, primaryId, duplicateIds, opts = {}) {
+  assertCan(ctx, "records.write");
+  assertCan(ctx, "records.delete");
+  const primary = requireRecord(ctx.store, primaryId);
+  const ids = [...new Set(duplicateIds)].filter((id) => id !== primaryId);
+  if (!ids.length) throw new OpsError("validation", "Nothing to merge: give at least one other record.");
+  const others = ids.map((id) => requireRecord(ctx.store, id));
+  for (const o of others) if (o.object !== primary.object) throw new OpsError("validation", `Can't merge a ${o.object} record into a ${primary.object} record.`);
+  const object = requireObject(ctx.store, primary.object);
+  const fields = mergedFields(object, primary, others, opts.pick ?? {});
+  for (const f of object.fields) {
+    if (f.type !== "relation" || f.relation?.object !== object.id) continue;
+    const v = fields[f.id];
+    if (Array.isArray(v)) {
+      const rest = v.filter((x) => x !== primaryId && !ids.includes(x));
+      if (rest.length) fields[f.id] = rest;
+      else delete fields[f.id];
+    } else if (v === primaryId || ids.includes(v)) delete fields[f.id];
+  }
+  const now = ctx.now();
+  const record = {
+    ...primary,
+    fields,
+    ownerId: primary.ownerId ?? others.find((o) => o.ownerId)?.ownerId,
+    createdAt: Math.min(primary.createdAt, ...others.map((o) => o.createdAt)),
+    updatedAt: now,
+    ...actorId(ctx) ? { updatedBy: actorId(ctx) } : {}
+  };
+  if (!record.ownerId) delete record.ownerId;
+  const refs = rewriteReferences(ctx, ids, primaryId);
+  const mutations = [{ op: "set", collection: "records", doc: asDoc(record) }, ...refs];
+  let movedActivities = 0;
+  const doomed = new Set(ids);
+  for (const a of activitiesOf(ctx.store, { includeDeleted: true })) {
+    if (!a.targets.some((t) => doomed.has(t.id))) continue;
+    movedActivities++;
+    const targets = a.targets.map((t) => doomed.has(t.id) ? { object: primary.object, id: primaryId } : t);
+    const unique = targets.filter((t, i) => targets.findIndex((x) => x.id === t.id) === i);
+    mutations.push({ op: "patch", collection: "activities", id: a.id, fields: { targets: unique, updatedAt: now } });
+  }
+  for (const id of ids) mutations.push({ op: "delete", collection: "records", id });
+  mutations.push(...fileMergeMutations(ctx, ids, { object: primary.object, id: primaryId }));
+  await ctx.store.write(mutations, { message: `Merge ${ids.length + 1} ${object.labelPlural}` });
+  const stored = requireRecord(ctx.store, primaryId);
+  await emit(ctx, "record.updated", { record: stored, before: primary, changed: Object.keys(fields).filter((k) => JSON.stringify(fields[k]) !== JSON.stringify(primary.fields[k])) });
+  for (const o of others) await emit(ctx, "record.deleted", { record: o, hard: true });
+  return { record: stored, merged: ids, movedActivities, rewiredReferences: refs.length };
+}
+export {
+  findDuplicates,
+  mergeRecords
+};

package/dist/agent/chunks/encoding-C9MzdP95.mjs

@@ -0,0 +1,36 @@
+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);
+function bytesToBase64(bytes) {
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+function base64ToBytes(base64) {
+  const binary = atob(base64.replace(/\s+/g, ""));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+function utf8ToBase64(text) {
+  return bytesToBase64(new TextEncoder().encode(text));
+}
+function base64ToUtf8(base64) {
+  return new TextDecoder().decode(base64ToBytes(base64));
+}
+function changeToBytes(change) {
+  return change.encoding === "base64" ? base64ToBytes(change.content) : new TextEncoder().encode(change.content);
+}
+export {
+  base64ToUtf8 as a,
+  bytesToBase64 as b,
+  changeToBytes as c,
+  base64ToBytes as d,
+  utf8ToBase64 as u
+};

package/dist/agent/chunks/exportCsv-C6e6XEmB.mjs

@@ -0,0 +1,130 @@
+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 { P as Papa } from "./papaparse-Df7i1dHr.mjs";
+import { formatAddress, formatFieldValue } from "./fields-B0bitgmr.mjs";
+import { a as applySorts, b as applyFilters, r as resolveField, g as getRecordValue } from "./query-C5nJB_3C.mjs";
+import { COLLECTIONS } from "./types-BOy9PUl7.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { queryContext } from "./records-DcHFelq5.mjs";
+import { requireObject, recordsOf, userOf } from "./store-5gqRSKXg.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./ids-CvnmrMJX.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./relations-B9TynBmA.mjs";
+function exportCsv(ctx, objectId, opts = {}) {
+  assertCan(ctx, "export");
+  const object = requireObject(ctx.store, objectId);
+  let filters = opts.filters ?? [];
+  let sorts = opts.sorts ?? [];
+  if (opts.viewId) {
+    const view = ctx.store.get("views", opts.viewId);
+    if (!view) throw new OpsError("notFound", `View "${opts.viewId}" not found.`);
+    filters = [...view.filters, ...filters];
+    if (!sorts.length) sorts = view.sorts;
+  }
+  const qctx = queryContext(ctx, object);
+  const records = applySorts(applyFilters(recordsOf(ctx.store, objectId, { includeDeleted: opts.includeDeleted }), filters, qctx), sorts, qctx);
+  const fieldIds = opts.fields ?? object.fields.map((f) => f.id);
+  const columns = [...opts.includeId !== false ? ["id"] : [], ...fieldIds.filter((f) => f !== "id")];
+  const raw = opts.values === "raw";
+  const header = columns.map((c) => c === "id" ? "ID" : resolveField(object, c)?.label ?? c);
+  const rows = records.map(
+    (r) => columns.map((c) => {
+      const field = resolveField(object, c);
+      const value = getRecordValue(r, c);
+      if (value === void 0 || value === null) return "";
+      if (raw) {
+        if (field?.type === "address") return formatAddress(value);
+        return Array.isArray(value) ? value.join(", ") : typeof value === "object" ? JSON.stringify(value) : String(value);
+      }
+      if (!field) return String(value);
+      if (field.type === "datetime" && typeof value === "number") return new Date(value).toISOString();
+      if (field.type === "date" || field.type === "number" || field.type === "currency" || field.type === "percent") return String(value);
+      if (c === "ownerId" || c === "createdBy" || c === "updatedBy") return userOf(ctx.store, String(value))?.email ?? String(value);
+      return formatFieldValue(field, value, qctx);
+    })
+  );
+  return Papa.unparse({ fields: header, data: rows }, { newline: "\n" });
+}
+function exportJson(ctx, opts = {}) {
+  assertCan(ctx, "export");
+  const wanted = opts.collections ?? COLLECTIONS.filter((c) => c !== "automationRuns");
+  return {
+    format: "agentcrm-export",
+    version: 1,
+    exportedAt: new Date(ctx.now()).toISOString(),
+    collections: Object.fromEntries(wanted.map((c) => [c, ctx.store.list(c)]))
+  };
+}
+function planImportJson(ctx, data, opts = {}) {
+  assertCan(ctx, "settings.write");
+  if (data?.format !== "agentcrm-export") throw new OpsError("validation", "Not an AgentCRM JSON export.");
+  const mode = opts.mode ?? "merge";
+  const plan = { mode, collections: {}, added: 0, overwritten: 0, deleted: 0, warnings: [] };
+  for (const c of COLLECTIONS) {
+    const docs = data.collections[c];
+    if (!docs) continue;
+    const ids = new Set(docs.filter((d) => d && typeof d.id === "string").map((d) => d.id));
+    let added = 0;
+    let overwritten = 0;
+    for (const id of ids) ctx.store.get(c, id) ? overwritten++ : added++;
+    const deleted = mode === "replace" ? ctx.store.list(c).filter((d) => !ids.has(d.id)).length : 0;
+    plan.collections[c] = { added, overwritten, deleted };
+    plan.added += added;
+    plan.overwritten += overwritten;
+    plan.deleted += deleted;
+  }
+  const here = ctx.store.get("settings", "general");
+  const there = (data.collections.settings ?? []).find((d) => d.id === "general");
+  if (here?.name && there?.name && here.name !== there.name) {
+    plan.sourceName = there.name;
+    plan.warnings.push(`This backup comes from another CRM ("${there.name}"): its settings, users and schema replace the ones with the same ids here (this CRM becomes "${there.name}").`);
+  }
+  const users = data.collections.users ?? [];
+  const replacedUsers = users.filter((u) => {
+    const cur = ctx.store.get("users", u.id);
+    return cur?.email && u.email && cur.email.toLowerCase() !== u.email.toLowerCase();
+  });
+  if (replacedUsers.length) {
+    plan.warnings.push(`${replacedUsers.length} user(s) of this CRM are replaced by different people with the same id: ${replacedUsers.map((u) => `${String(ctx.store.get("users", u.id).email)} → ${String(u.email)}`).join(", ")}.`);
+  }
+  return plan;
+}
+async function importJson(ctx, data, opts = {}) {
+  assertCan(ctx, "settings.write");
+  if (data?.format !== "agentcrm-export") throw new OpsError("validation", "Not an AgentCRM JSON export.");
+  const mutations = [];
+  let deleted = 0;
+  for (const c of COLLECTIONS) {
+    const docs = data.collections[c];
+    if (!docs) continue;
+    const ids = /* @__PURE__ */ new Set();
+    for (const doc of docs) {
+      if (!doc || typeof doc.id !== "string") continue;
+      ids.add(doc.id);
+      mutations.push({ op: "set", collection: c, doc });
+    }
+    if (opts.mode === "replace") {
+      for (const existing of ctx.store.list(c)) {
+        if (!ids.has(existing.id)) {
+          mutations.push({ op: "delete", collection: c, id: existing.id });
+          deleted++;
+        }
+      }
+    }
+  }
+  await ctx.store.write(mutations, { message: "Restore JSON export" });
+  return { written: mutations.length - deleted, deleted };
+}
+export {
+  exportCsv,
+  exportJson,
+  importJson,
+  planImportJson
+};

package/dist/agent/chunks/extCheck-GgHG1dYB.mjs

@@ -0,0 +1,200 @@
+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 { b as EXTENSION_MIN_API_VERSION, E as EXTENSION_API_VERSION, a as EXTENSION_LIMITS, R as RUNTIME_SPECIFIERS } from "./api-Cz0Ubj-B.mjs";
+import { bundleImports, validateManifest, ExtensionPackageError } from "./package-B7mI6HGi.mjs";
+import { n as nodeImportBundle } from "../agentcrm.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 bytes = (s) => s ? new TextEncoder().encode(s).length : 0;
+function countKeys(o) {
+  if (!o || typeof o !== "object") return 0;
+  return Object.values(o).reduce((n, v) => n + (v && typeof v === "object" ? countKeys(v) : 1), 0);
+}
+function withTimeout(p, ms) {
+  return Promise.race([p, new Promise((_, reject) => setTimeout(() => reject(new Error(`timed out after ${ms} ms`)), ms).unref?.())]);
+}
+async function checkExtension(raw, opts = {}) {
+  const errors = [...raw.problems];
+  const warnings = [];
+  const bundle = raw.files["bundle.js"];
+  const style = raw.files["style.css"];
+  const m = raw.manifest && typeof raw.manifest === "object" ? raw.manifest : {};
+  const report = {
+    valid: false,
+    source: raw.source,
+    sourceType: raw.sourceType,
+    id: typeof m.id === "string" ? m.id : null,
+    kind: m.kind === "module" || m.kind === "theme" ? m.kind : null,
+    name: typeof m.name === "string" ? m.name : null,
+    version: typeof m.version === "string" ? m.version : null,
+    apiVersion: typeof m.apiVersion === "string" ? m.apiVersion : null,
+    hostApi: { version: EXTENSION_API_VERSION, min: EXTENSION_MIN_API_VERSION },
+    size: { bundle: bytes(bundle), style: bytes(style), ...raw.zipBytes !== void 0 ? { zip: raw.zipBytes } : {} },
+    imports: bundle ? bundleImports(bundle) : [],
+    errors,
+    warnings,
+    loaded: false
+  };
+  let manifest = null;
+  if (raw.manifest) {
+    try {
+      manifest = validateManifest(raw.manifest);
+    } catch (err) {
+      if (err instanceof ExtensionPackageError) {
+        if (err.code === "incompatibleApi") errors.push({ code: "incompatibleApi", message: err.message, hint: `Set "apiVersion" between ${EXTENSION_MIN_API_VERSION} and ${EXTENSION_API_VERSION} (manifest.json and the default export).` });
+        else for (const d of err.details?.length ? err.details : [err.message]) errors.push({ code: "manifest", message: d });
+      } else throw err;
+    }
+  }
+  if (manifest && opts.kind && manifest.kind !== opts.kind) errors.push({ code: "kind", message: `Expected a ${opts.kind}, the manifest says ${manifest.kind}.` });
+  if (manifest && !manifest.description) warnings.push({ code: "description", message: "manifest.json has no description (shown in Settings → Modules and the install plan)." });
+  if (manifest && !manifest.author) warnings.push({ code: "author", message: "manifest.json has no author (shown in the install plan, helps admins trust it)." });
+  if (bundle !== void 0) {
+    if (!bundle.trim()) errors.push({ code: "missingEntry", message: "bundle.js is empty." });
+    if (bytes(bundle) > EXTENSION_LIMITS.bundle) errors.push({ code: "tooLarge", message: `bundle.js is ${(bytes(bundle) / 1024 / 1024).toFixed(2)} MB — the limit is ${EXTENSION_LIMITS.bundle / 1024 / 1024} MB.`, hint: "Keep react, react-i18next, lucide-react and @agent-crm/runtime external (vite.config.ts)." });
+    const foreign = report.imports.filter((s) => !RUNTIME_SPECIFIERS.includes(s));
+    if (foreign.length) errors.push({ code: "imports", message: `bundle.js imports modules the admin doesn't provide: ${foreign.join(", ")}.`, hint: `Bundle them, or import only from ${RUNTIME_SPECIFIERS.join(", ")}.` });
+    if (/\bjsxDEV\b|react\/jsx-dev-runtime/.test(bundle)) errors.push({ code: "devJsx", message: "bundle.js uses the development JSX runtime.", hint: 'Build in production mode (esbuild: { jsx: "automatic", jsxDev: false }).' });
+    if (!/\bexport\s*(?:default\b|\{[^}]*\bas\s+default\b)/.test(bundle)) errors.push({ code: "noDefaultExport", message: "bundle.js has no default export.", hint: "export default defineModule({...}) / defineTheme({...})." });
+  } else if (!errors.some((e) => e.code === "notBuilt")) {
+    errors.push({ code: "missingEntry", message: "The package has no bundle.js." });
+  }
+  if (manifest?.style && style === void 0) errors.push({ code: "missingStyle", message: 'manifest.json declares "style": "style.css" but there is no style.css.', hint: "Add src/style.css (projects) or style.css next to bundle.js." });
+  if (style !== void 0 && bytes(style) > EXTENSION_LIMITS.style) errors.push({ code: "tooLarge", message: `style.css is larger than ${EXTENSION_LIMITS.style / 1024} KB.` });
+  if (style !== void 0) cssWarnings(style, "style.css", warnings);
+  for (const f of raw.ignored) warnings.push({ code: "ignored", message: `${f} is not part of the package (only manifest.json, bundle.js and style.css are).${/style\.css$/.test(f) ? ' Declare "style": "style.css" in manifest.json to ship it.' : ""}` });
+  if (!errors.length && manifest && bundle) await loadInSandbox(report, manifest, { "bundle.js": bundle, ...style ? { "style.css": style } : {} }, opts);
+  report.valid = errors.length === 0;
+  return report;
+}
+function cssWarnings(css, label, warnings) {
+  if (/@import\s+(?:url\(\s*)?["']?\s*(?:https?:)?\/\//i.test(css)) warnings.push({ code: "css", message: `${label} @imports a remote stylesheet: every user's browser would fetch it.`, hint: `Inline the CSS; for fonts set the theme's "font" (the CRM loads Google Fonts itself).` });
+  if (/<\/?(?:style|script)/i.test(css)) warnings.push({ code: "css", message: `${label} contains <style> / <script> tags: it must be plain CSS.` });
+}
+async function loadInSandbox(report, manifest, files, opts) {
+  const importBundle = await nodeImportBundle();
+  const [{ createMemoryStore }, { createOpsContext }, { createPluginRegistry, plugins }, { seedCrm }, { usersOf }, loader, registry, aiTools, actions, features, themes, schema] = await Promise.all([
+    import("./memory-WNR3VHUJ.mjs"),
+    import("./context-CxFfqS4D.mjs"),
+    import("./pluginRegistry-DyHtlkcr.mjs"),
+    import("./seed-6MRmQQBR.mjs"),
+    import("./store-5gqRSKXg.mjs"),
+    import("./loader-MPD9iAvh.mjs"),
+    import("./registry-COfJrSmg.mjs"),
+    import("./tools-iSH-yMpl.mjs"),
+    import("./extensionActions-D2HtpQz4.mjs"),
+    import("./featureRegistry-DSsZbhrh.mjs"),
+    import("./themes-DPZFv3yc.mjs"),
+    import("./schema-DnLj8dUO.mjs").then((n) => n.s)
+  ]);
+  const store = createMemoryStore();
+  await store.ready();
+  const sandboxPlugins = createPluginRegistry(() => void 0);
+  const system = createOpsContext(store, null, { plugins: sandboxPlugins });
+  await seedCrm(system, { admin: { name: "Check Admin", email: "check@example.com" }, demo: true, name: "Extension check" });
+  const admin = createOpsContext(store, usersOf(store).find((u) => u.role === "admin") ?? null, { plugins: sandboxPlugins });
+  const now = Date.now();
+  const doc = { id: manifest.id, kind: manifest.kind, manifest, enabled: true, files, installedAt: now, updatedAt: now };
+  await store.write([{ op: "set", collection: "extensions", doc }]);
+  const { BUILTIN_MODULES } = await import("./api-Cz0Ubj-B.mjs").then((n) => n.m);
+  const missingDeps = (manifest.dependsOn ?? []).filter((d) => !BUILTIN_MODULES.some((b) => b.id === d));
+  for (const d of missingDeps) report.warnings.push({ code: "dependency", message: `Depends on "${d}", which is not a built-in module: install that extension first on the real CRM.` });
+  const toolsBefore = new Set(aiTools.listAiTools().map((t) => t.name));
+  const actionsBefore = new Set(actions.listAutomationActions().map((a) => a.id));
+  const hooksBefore = plugins.listHooks();
+  const sync = await loader.syncExtensions(store, { importBundle, onError: () => void 0 });
+  try {
+    const failure = sync.failed.find((f) => f.id === manifest.id);
+    if (failure || registry.getLoadedExtension(manifest.id)?.status !== "loaded") {
+      const reason = failure?.error ?? registry.getLoadedExtension(manifest.id)?.error ?? "not loaded";
+      report.errors.push({ code: "load", message: `The bundle failed to load: ${reason}`, hint: "Check the default export (id and apiVersion equal to manifest.json), AI tool names (snake_case, unique) and automation action ids (<moduleId>.<action>)." });
+      return;
+    }
+    report.loaded = true;
+    if (manifest.kind === "theme") {
+      const theme = themes.getExternalTheme(manifest.id);
+      if (!theme) {
+        report.errors.push({ code: "theme", message: "The theme did not register." });
+        return;
+      }
+      const { errors } = schema.validateAppearancePatch(theme.appearance);
+      for (const e of errors) report.errors.push({ code: "appearance", message: `Theme appearance: ${e}` });
+      for (const k of ["logo", "favicon", "themeId", "preset"]) if (k in (theme.appearance ?? {})) report.warnings.push({ code: "appearance", message: `Theme appearance sets "${k}" — themes should leave it to the workspace.` });
+      const ownCss = (theme.css ?? "").replace(files["style.css"] ?? "", "");
+      if (ownCss.trim()) cssWarnings(ownCss, "The theme's css", report.warnings);
+      report.theme = { name: theme.name, appearance: { ...theme.appearance }, css: bytes(theme.css) };
+      return;
+    }
+    const feature = features.getAllFeatures().find((f) => f.id === manifest.id);
+    const slots = {};
+    for (const [name, items] of Object.entries(feature?.slots ?? {})) {
+      if (!items) continue;
+      slots[name] = Array.isArray(items) ? items.map((x, i) => x && typeof x === "object" && "id" in x ? String(x.id) : `#${i}`) : ["(component)"];
+    }
+    const en = feature?.i18n?.en ?? {};
+    const fr = feature?.i18n?.fr;
+    const tools = aiTools.listAiTools().filter((t) => !toolsBefore.has(t.name));
+    const hooksAfter = plugins.listHooks();
+    report.registered = {
+      routes: (feature?.routes ?? []).map((r2) => r2.path),
+      navItems: (feature?.navItems ?? []).map((n) => ({ id: n.id, to: n.to, label: n.label })),
+      slots,
+      settingsPage: typeof feature?.settingsPage === "function" || typeof feature?.settingsPage === "object" && feature?.settingsPage !== null,
+      i18n: { en: countKeys(en), fr: countKeys(fr) },
+      aiTools: tools.map((t) => ({ name: t.name, mutating: t.mutating, description: t.description })),
+      automationActions: actions.listAutomationActions().filter((a) => !actionsBefore.has(a.id)).map((a) => ({ id: a.id, label: a.label, ...a.objects ? { objects: a.objects } : {} })),
+      hooks: { actions: hooksAfter.actions.filter((h) => !hooksBefore.actions.includes(h)), filters: hooksAfter.filters.filter((h) => !hooksBefore.filters.includes(h)) }
+    };
+    const r = report.registered;
+    if (!r.routes.length && !r.navItems.length && !Object.keys(r.slots).length && !r.settingsPage && !r.aiTools.length && !r.automationActions.length && !r.hooks.actions.length && !r.hooks.filters.length) {
+      report.warnings.push({ code: "empty", message: "The module registers nothing (no route, slot, settings page, AI tool, automation action or hook)." });
+    }
+    if (r.i18n.en && !fr) report.warnings.push({ code: "i18n", message: "No French bundle (feature.i18n.fr): French users see the English strings." });
+    for (const n of r.navItems) {
+      if (!r.routes.includes(n.to)) report.warnings.push({ code: "nav", message: `Navigation entry "${n.id}" points to ${n.to}, which no route of this module serves.` });
+      const key = n.label.startsWith(`${manifest.id}:`) ? n.label.slice(manifest.id.length + 1) : null;
+      if (key && !key.split(".").reduce((o, k) => o && typeof o === "object" ? o[k] : void 0, en)) report.warnings.push({ code: "i18n", message: `Navigation label "${n.label}" has no English string.` });
+    }
+    for (const t of tools) {
+      const snake = manifest.id.replace(/-/g, "_");
+      if (!t.name.includes(snake) && !t.name.startsWith(snake.split("_")[0])) report.warnings.push({ code: "toolName", message: `AI tool "${t.name}" doesn't start with the module id: prefix it to avoid clashes with other extensions.` });
+      if ((t.description ?? "").length < 20) report.warnings.push({ code: "toolDescription", message: `AI tool "${t.name}" needs a clearer description (the model reads it to decide when to call it).` });
+    }
+    for (const a of r.automationActions) if (!a.id.startsWith(`${manifest.id}.`)) report.warnings.push({ code: "actionId", message: `Automation action "${a.id}" should be namespaced "${manifest.id}.<action>".` });
+    if (opts.callTools !== false) {
+      report.toolCalls = [];
+      for (const t of tools) {
+        if (t.inputSchema.required?.length) continue;
+        try {
+          await withTimeout(Promise.resolve(aiTools.callTool(admin, t.name, {})), 1e4);
+          report.toolCalls.push({ name: t.name, ok: true });
+        } catch (err) {
+          const message = err?.message ?? String(err);
+          report.toolCalls.push({ name: t.name, ok: false, error: message });
+          report.warnings.push({ code: "toolCall", message: `AI tool "${t.name}" failed when called with {} on demo data: ${message}` });
+        }
+      }
+    }
+  } finally {
+    registry.deactivateExtension(manifest.id);
+  }
+}
+export {
+  checkExtension
+};

package/dist/agent/chunks/extPackage-DuZ6GZhp.mjs

@@ -0,0 +1,115 @@
+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 { existsSync, statSync, readFileSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { a as EXTENSION_LIMITS } from "./api-Cz0Ubj-B.mjs";
+import { validatePackage, ExtensionPackageError } from "./package-B7mI6HGi.mjs";
+import { C as CliError } from "../agentcrm.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+import "node:util";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+function parseManifest(text, problems) {
+  if (text === void 0) {
+    problems.push({ code: "missingManifest", message: "No manifest.json found.", hint: "Point at the project folder (manifest.json at its root), an unpacked package or the .zip." });
+    return null;
+  }
+  try {
+    return JSON.parse(text.replace(/^/, ""));
+  } catch (err) {
+    problems.push({ code: "invalidManifest", message: `manifest.json is not valid JSON (${err.message}).` });
+    return null;
+  }
+}
+async function readZip(source) {
+  const problems = [];
+  const data = readFileSync(source);
+  const { default: JSZip } = await import("./index-w03ReRs4.mjs").then((n) => n.i);
+  let zip;
+  try {
+    zip = await JSZip.loadAsync(data);
+  } catch (err) {
+    throw new CliError("invalid-zip", `${source} is not a readable ZIP: ${err.message}`, void 0, 2);
+  }
+  const names = Object.keys(zip.files).filter((n) => !zip.files[n].dir);
+  const kept = names.filter((n) => !n.startsWith("__MACOSX/") && !n.split("/").pop().startsWith("."));
+  let prefix = "";
+  if (!kept.includes("manifest.json")) {
+    const candidates = kept.filter((n) => /^[^/]+\/manifest\.json$/.test(n));
+    if (candidates.length === 1) prefix = candidates[0].slice(0, -"manifest.json".length);
+  }
+  const read = async (name) => {
+    const f = zip.file(prefix + name);
+    return f ? f.async("string") : void 0;
+  };
+  const known = new Set(["manifest.json", "bundle.js", "style.css"].map((n) => prefix + n));
+  const manifest = parseManifest(await read("manifest.json"), problems);
+  const bundle = await read("bundle.js");
+  const style = await read("style.css");
+  if (data.byteLength > EXTENSION_LIMITS.zip) problems.push({ code: "tooLarge", message: `The ZIP is ${(data.byteLength / 1024 / 1024).toFixed(2)} MB — the limit is ${EXTENSION_LIMITS.zip / 1024 / 1024} MB.` });
+  return {
+    source,
+    sourceType: "zip",
+    manifest,
+    files: { ...bundle !== void 0 ? { "bundle.js": bundle } : {}, ...style !== void 0 ? { "style.css": style } : {} },
+    zipBytes: data.byteLength,
+    problems,
+    ignored: names.filter((n) => !known.has(n))
+  };
+}
+function readText(path) {
+  return existsSync(path) && statSync(path).isFile() ? readFileSync(path, "utf8") : void 0;
+}
+function readFolder(source) {
+  const problems = [];
+  const manifest = parseManifest(readText(join(source, "manifest.json")), problems);
+  const declaresStyle = !!manifest && typeof manifest === "object" && manifest.style === "style.css";
+  if (existsSync(join(source, "bundle.js")) && !existsSync(join(source, "package.json"))) {
+    const bundle2 = readText(join(source, "bundle.js"));
+    const style2 = readText(join(source, "style.css"));
+    return { source, sourceType: "folder", manifest, files: { ...bundle2 !== void 0 ? { "bundle.js": bundle2 } : {}, ...style2 !== void 0 ? { "style.css": style2 } : {} }, problems, ignored: [] };
+  }
+  const bundle = readText(join(source, "dist", "bundle.js"));
+  if (bundle === void 0) problems.push({ code: "notBuilt", message: "dist/bundle.js not found.", hint: "Build the project first: npm run build (vite build)." });
+  const stylePath = [join(source, "dist", "style.css"), join(source, "src", "style.css"), join(source, "style.css")].find((p) => existsSync(p));
+  const style = declaresStyle && stylePath ? readText(stylePath) : void 0;
+  return { source, sourceType: "project", manifest, files: { ...bundle !== void 0 ? { "bundle.js": bundle } : {}, ...style !== void 0 ? { "style.css": style } : {} }, problems, ignored: stylePath && !declaresStyle ? [stylePath] : [] };
+}
+async function readRawPackage(input) {
+  const source = resolve(input);
+  if (!existsSync(source)) throw new CliError("not-found", `${input} does not exist.`, "Pass the extension's project folder, an unpacked package folder or its .zip.", 2);
+  if (statSync(source).isFile()) {
+    if (!/\.zip$/i.test(source)) throw new CliError("usage", `${input} is not a .zip.`, "Pass the extension's .zip, its project folder or an unpacked folder.", 2);
+    return readZip(source);
+  }
+  return readFolder(source);
+}
+async function readPackage(input) {
+  const raw = await readRawPackage(input);
+  if (raw.problems.length) {
+    const p = raw.problems[0];
+    throw new CliError(p.code === "notBuilt" ? "not-built" : "invalid-package", raw.problems.map((x) => x.message).join(" "), p.hint ?? "Run `agentcrm ext check` on it for the full report.", 2);
+  }
+  try {
+    return { raw, pkg: validatePackage({ manifest: raw.manifest, files: raw.files }) };
+  } catch (err) {
+    if (err instanceof ExtensionPackageError) throw new CliError("invalid-package", err.message, "Run `agentcrm ext check` on it for the full report.", 2);
+    throw err;
+  }
+}
+export {
+  readPackage,
+  readRawPackage
+};