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

package/dist/agent/chunks/http-Bk9ICb7I.mjs

@@ -0,0 +1,127 @@
+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";
+const subscribers = /* @__PURE__ */ new Set();
+function newToastId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function showToast(input) {
+  const toast2 = { ...input, id: newToastId(), createdAt: Date.now() };
+  subscribers.forEach((fn) => {
+    try {
+      fn(toast2);
+    } catch (err) {
+      console.error("Toast subscriber threw:", err);
+    }
+  });
+  return toast2;
+}
+const toast = {
+  info: (message, durationMs) => showToast({ level: "info", message, durationMs }),
+  success: (message, durationMs) => showToast({ level: "success", message, durationMs }),
+  warn: (message, durationMs) => showToast({ level: "warn", message, durationMs }),
+  error: (message, durationMs) => showToast({ level: "error", message, durationMs })
+};
+function subscribeToToasts(fn) {
+  subscribers.add(fn);
+  return () => subscribers.delete(fn);
+}
+class StorageError extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "StorageError";
+  }
+}
+function actionLabel(action) {
+  return instance.t(`storage.actions.${action}`);
+}
+function extractDetail(body) {
+  if (!body) return "";
+  let text = body.trim();
+  try {
+    const parsed = JSON.parse(text);
+    text = parsed.error ?? parsed.message ?? text;
+  } catch {
+  }
+  if (text.length > 240) text = text.slice(0, 240) + "…";
+  return text;
+}
+function buildErrorMessage(action, status, body) {
+  const label = actionLabel(action);
+  const detail = extractDetail(body);
+  switch (status) {
+    case 401:
+    case 403:
+      return instance.t("storage.errors.auth", { action: label });
+    case 404:
+      return instance.t("storage.errors.notFound", { action: label });
+    case 413:
+      return instance.t("storage.errors.tooLarge", { action: label });
+    case 429:
+      return instance.t("storage.errors.rateLimited", { action: label });
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return instance.t("storage.errors.serverError", { action: label, status });
+    default:
+      return instance.t("storage.errors.generic", {
+        action: label,
+        status,
+        detail: detail ? `: ${detail}` : ""
+      });
+  }
+}
+async function performRequest(action, fetcher) {
+  let res;
+  try {
+    res = await fetcher();
+  } catch (err) {
+    if (err?.name === "AbortError") throw err;
+    toast.error(instance.t("storage.errors.network", { action: actionLabel(action) }));
+    throw err;
+  }
+  if (res.ok) return res;
+  const body = await res.text().catch(() => "");
+  const isSilenced = (action === "delete" || action === "deleteFolder") && res.status === 404;
+  const message = buildErrorMessage(action, res.status, body);
+  if (!isSilenced) toast.error(message);
+  throw new StorageError(message, res.status, body);
+}
+async function gitFetch(action, url, init, allow = []) {
+  let res;
+  try {
+    res = await fetch(url, init);
+  } catch (err) {
+    return performRequest(action, () => Promise.reject(err));
+  }
+  if (res.ok || allow.includes(res.status)) return res;
+  return performRequest(action, async () => res);
+}
+async function mapLimit(items, limit, worker) {
+  const results = new Array(items.length);
+  let next = 0;
+  async function lane() {
+    while (next < items.length) {
+      const i = next++;
+      results[i] = await worker(items[i]);
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, lane));
+  return results;
+}
+export {
+  StorageError as S,
+  gitFetch as g,
+  mapLimit as m,
+  performRequest as p,
+  subscribeToToasts as s,
+  toast as t
+};

package/dist/agent/chunks/ids-CvnmrMJX.mjs

@@ -0,0 +1,59 @@
+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 ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+function randomChars(n) {
+  const bytes = new Uint8Array(n);
+  crypto.getRandomValues(bytes);
+  let out = "";
+  for (const b of bytes) out += ALPHABET[b % 36];
+  return out;
+}
+let lastTime = 0;
+let lastRandom = "";
+function newId(now = Date.now()) {
+  const time = Math.max(0, Math.floor(now)).toString(36).padStart(9, "0").slice(-9);
+  if (now === lastTime && lastRandom) {
+    lastRandom = increment(lastRandom);
+  } else {
+    lastTime = now;
+    lastRandom = randomChars(7);
+  }
+  return time + lastRandom;
+}
+function increment(s) {
+  const chars = s.split("");
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const idx = ALPHABET.indexOf(chars[i]);
+    if (idx < 35) {
+      chars[i] = ALPHABET[idx + 1];
+      return chars.join("");
+    }
+    chars[i] = "0";
+  }
+  return chars.join("") + "0";
+}
+function seededId(seed) {
+  let h1 = 2166136261;
+  let h2 = 16777619;
+  for (let i = 0; i < seed.length; i++) {
+    const c = seed.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 16777619);
+    h2 = Math.imul(h2 ^ c, 1540483477);
+  }
+  return ((h1 >>> 0).toString(36) + (h2 >>> 0).toString(36)).padStart(14, "0");
+}
+function slugId(label, taken = []) {
+  const base = label.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "item";
+  const used = new Set(taken);
+  if (!used.has(base)) return base;
+  for (let i = 2; ; i++) if (!used.has(`${base}-${i}`)) return `${base}-${i}`;
+}
+export {
+  seededId as a,
+  newId as n,
+  slugId as s
+};

package/dist/agent/chunks/ids-u-noYcy5.mjs

@@ -0,0 +1,14 @@
+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 FILE_ID_RE = /^[A-Za-z0-9_-]{1,80}$/;
+function assertFileId(id) {
+  if (!FILE_ID_RE.test(id)) throw new Error(`Invalid file id "${id}".`);
+}
+export {
+  FILE_ID_RE as F,
+  assertFileId as a
+};

package/dist/agent/chunks/importCsv-LVmMTaWU.mjs

@@ -0,0 +1,334 @@
+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 { findOption, normalizeEmail, coerceFieldValue, recordLabel, normalizeDomain } from "./fields-B0bitgmr.mjs";
+import { n as newId } from "./ids-CvnmrMJX.mjs";
+import { c as camelId } from "./utils-DmI8FtXP.mjs";
+import { assertCan, OpsError, actorId, emit } from "./context-CxFfqS4D.mjs";
+import { prepareRecordFields, recordPatchMutation } from "./records-DcHFelq5.mjs";
+import { requireObject, thaw, recordsOf, usersOf, asDoc, objectOf } from "./store-5gqRSKXg.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./standardObjects-CheqfDqa.mjs";
+import "./relations-B9TynBmA.mjs";
+function parseCsv(text, opts = {}) {
+  const res = Papa.parse(text.replace(/^/, ""), {
+    header: true,
+    skipEmptyLines: "greedy",
+    delimiter: opts.delimiter ?? "",
+    transformHeader: (h) => h.trim()
+  });
+  return {
+    headers: (res.meta.fields ?? []).filter((h) => h !== ""),
+    rows: res.data,
+    errors: res.errors.map((e) => ({ row: (e.row ?? 0) + 2, message: e.message }))
+  };
+}
+const MAPPING_OWNER = "$owner";
+const MAPPING_ID = "$id";
+const MAPPING_SKIP = "";
+const ALIASES = {
+  firstName: ["first name", "firstname", "first", "given name", "prénom", "prenom"],
+  lastName: ["last name", "lastname", "last", "surname", "family name", "nom de famille", "nom"],
+  name: ["name", "full name", "fullname", "company name", "deal name", "nom complet", "raison sociale"],
+  email: ["email", "e-mail", "email address", "mail", "courriel", "adresse e-mail"],
+  phone: ["phone", "phone number", "telephone", "tel", "mobile", "téléphone"],
+  jobTitle: ["job title", "title", "position", "role", "poste", "fonction"],
+  company: ["company", "organization", "organisation", "account", "société", "entreprise"],
+  domain: ["domain", "website", "web site", "url", "site", "site web"],
+  city: ["city", "town", "ville"],
+  linkedin: ["linkedin", "linkedin url", "linkedin profile"],
+  amount: ["amount", "value", "deal value", "montant"],
+  stage: ["stage", "deal stage", "étape", "statut"],
+  closeDate: ["close date", "closing date", "expected close", "date de clôture"],
+  industry: ["industry", "sector", "secteur"],
+  employees: ["employees", "headcount", "company size", "employés", "effectif"],
+  annualRevenue: ["annual revenue", "revenue", "chiffre d'affaires", "ca"],
+  leadSource: ["lead source", "source", "origine"],
+  lifecycleStage: ["lifecycle stage", "lifecycle", "status", "cycle de vie"],
+  tags: ["tags", "labels", "étiquettes"]
+};
+function norm(s) {
+  return s.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function suggestMapping(object, headers) {
+  const out = {};
+  const used = /* @__PURE__ */ new Set();
+  for (const h of headers) {
+    const n = norm(h);
+    let match = object.fields.find((f) => norm(f.id) === n || norm(f.label) === n || camelId(h) === f.id) ?? object.fields.find((f) => (ALIASES[f.id] ?? []).some((a) => norm(a) === n));
+    if (!match && (n === "owner" || n === "assigned to" || n === "proprietaire")) {
+      out[h] = MAPPING_OWNER;
+      continue;
+    }
+    if (!match && n === "id") {
+      out[h] = MAPPING_ID;
+      continue;
+    }
+    if (match && used.has(match.id)) match = void 0;
+    out[h] = match?.id ?? MAPPING_SKIP;
+    if (match) used.add(match.id);
+  }
+  return out;
+}
+function dedupeKey(object, fields) {
+  if (object.id === "people" || object.fields.some((f) => f.id === "email" && f.unique)) {
+    const e = normalizeEmail(fields.email);
+    if (e) return `email:${e}`;
+  }
+  if (object.id === "companies" || object.fields.some((f) => f.id === "domain" && f.unique)) {
+    const d = normalizeDomain(fields.domain);
+    if (d) return `domain:${d}`;
+  }
+  const label = fields[object.labelField];
+  if (object.id !== "people" && typeof label === "string" && label.trim()) return `label:${label.trim().toLowerCase()}`;
+  return null;
+}
+async function importCsv(ctx, opts) {
+  assertCan(ctx, "import");
+  const baseObject = requireObject(ctx.store, opts.object);
+  const parsed = parseCsv(opts.csv, { delimiter: opts.delimiter });
+  const mapping = opts.mapping ?? suggestMapping(baseObject, parsed.headers);
+  for (const target of Object.values(mapping)) {
+    if (target && target !== MAPPING_OWNER && target !== MAPPING_ID && !baseObject.fields.some((f) => f.id === target)) {
+      throw new OpsError("validation", `Mapping targets unknown field "${target}" on ${baseObject.labelPlural}.`);
+    }
+  }
+  const onDuplicate = opts.onDuplicate ?? "update";
+  const createOptions = opts.createOptions !== false;
+  const createRelated = opts.createRelated !== false;
+  const report = {
+    object: baseObject.id,
+    dryRun: !!opts.dryRun,
+    total: parsed.rows.length,
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    failed: 0,
+    mapping,
+    unmappedColumns: parsed.headers.filter((h) => !mapping[h]),
+    newOptions: [],
+    createdRelated: [],
+    rows: []
+  };
+  const object = thaw(baseObject);
+  if (createOptions) {
+    for (const [header, fieldId] of Object.entries(mapping)) {
+      const field = object.fields.find((f) => f.id === fieldId);
+      if (!field || field.type !== "select" && field.type !== "multiSelect" || field.system) continue;
+      const fresh = [];
+      for (const row of parsed.rows) {
+        const raw = row[header];
+        if (!raw?.trim()) continue;
+        const parts = field.type === "multiSelect" ? raw.split(/[,;|]/) : [raw];
+        for (const p of parts.map((x) => x.trim()).filter(Boolean)) {
+          if (!findOption(field, p) && !fresh.some((x) => x.toLowerCase() === p.toLowerCase())) fresh.push(p);
+        }
+      }
+      if (fresh.length) {
+        const start = field.options?.length ?? 0;
+        field.options = [...field.options ?? [], ...fresh.map((label, i) => ({ id: uniqueOptionId(field, label), label, color: ["gray", "blue", "green", "yellow", "orange", "red", "purple", "pink", "teal", "indigo"][(start + i) % 10] }))];
+        report.newOptions.push({ field: field.id, labels: fresh });
+      }
+    }
+  }
+  const existing = recordsOf(ctx.store, object.id);
+  const byKey = /* @__PURE__ */ new Map();
+  for (const r of existing) {
+    const k = dedupeKey(object, r.fields);
+    if (k && !byKey.has(k)) byKey.set(k, r);
+  }
+  const lookups = /* @__PURE__ */ new Map();
+  const lookupFor = (target) => {
+    let m = lookups.get(target);
+    if (!m) {
+      m = /* @__PURE__ */ new Map();
+      const o = objectOf(ctx.store, target);
+      for (const r of recordsOf(ctx.store, target)) {
+        m.set(r.id, r.id);
+        m.set(recordLabel(o, r).toLowerCase(), r.id);
+        const d = normalizeDomain(r.fields.domain);
+        if (d) m.set(d, r.id);
+        const e = normalizeEmail(r.fields.email);
+        if (e) m.set(e, r.id);
+      }
+      lookups.set(target, m);
+    }
+    return m;
+  };
+  const usersByKey = /* @__PURE__ */ new Map();
+  for (const u of usersOf(ctx.store)) {
+    usersByKey.set(u.id, u.id);
+    usersByKey.set(normalizeEmail(u.email), u.id);
+    usersByKey.set(u.name.toLowerCase(), u.id);
+  }
+  const mutations = [];
+  const createdDocs = [];
+  const updatedDocs = [];
+  const pendingRelated = /* @__PURE__ */ new Map();
+  const seenInFile = /* @__PURE__ */ new Map();
+  const now = ctx.now();
+  const vctx = {
+    ...ctx,
+    store: {
+      ...ctx.store,
+      kind: ctx.store.kind,
+      list: (c) => ctx.store.list(c),
+      get: (c, id) => {
+        if (c === "objects" && id === object.id) return asDoc(object);
+        if (c === "records" && pendingRelated.has(id)) return asDoc(pendingRelated.get(id));
+        return ctx.store.get(c, id);
+      }
+    }
+  };
+  parsed.rows.forEach((row, index) => {
+    const rowNo = index + 2;
+    const messages = [];
+    const input = {};
+    let ownerId;
+    let explicitId;
+    for (const [header, target] of Object.entries(mapping)) {
+      const raw = row[header];
+      if (!target || raw === void 0) continue;
+      if (target === MAPPING_OWNER) {
+        if (raw.trim()) {
+          ownerId = usersByKey.get(raw.trim().toLowerCase()) ?? usersByKey.get(normalizeEmail(raw));
+          if (!ownerId) messages.push(`Unknown owner "${raw}" (ignored).`);
+        }
+        continue;
+      }
+      if (target === MAPPING_ID) {
+        explicitId = raw.trim() || void 0;
+        continue;
+      }
+      const field = object.fields.find((f) => f.id === target);
+      if (field.type === "relation") {
+        const resolved = resolveRelation(field, raw);
+        if (resolved !== void 0) input[target] = resolved;
+        continue;
+      }
+      if (field.type === "user") {
+        if (raw.trim()) {
+          const uid = usersByKey.get(raw.trim().toLowerCase()) ?? usersByKey.get(normalizeEmail(raw));
+          if (uid) input[target] = uid;
+          else messages.push(`${field.label}: unknown user "${raw}" (ignored).`);
+        }
+        continue;
+      }
+      const res = coerceFieldValue(field, raw, { dayFirst: opts.dayFirst, unknownOptions: "fail" });
+      if (!res.ok) messages.push(res.message);
+      else if (res.value !== void 0) input[target] = res.value;
+    }
+    if (messages.some((m) => !m.endsWith("(ignored)."))) {
+      report.failed++;
+      report.rows.push({ row: rowNo, action: "error", messages });
+      return;
+    }
+    const key = dedupeKey(object, input);
+    const dupInFile = key ? seenInFile.get(key) : void 0;
+    const existingRecord = explicitId ? existing.find((r) => r.id === explicitId) : key ? byKey.get(key) : void 0;
+    if (dupInFile && onDuplicate !== "create") {
+      report.skipped++;
+      report.rows.push({ row: rowNo, action: "skip", id: dupInFile, messages: [...messages, `Duplicate of row with the same ${key.split(":")[0]} earlier in the file.`] });
+      return;
+    }
+    try {
+      if (existingRecord && onDuplicate !== "create") {
+        if (onDuplicate === "skip") {
+          report.skipped++;
+          report.rows.push({ row: rowNo, action: "skip", id: existingRecord.id, label: recordLabel(object, existingRecord), messages: [...messages, "Already exists."] });
+          return;
+        }
+        const prepared2 = prepareRecordFields(vctx, object, input, existingRecord, { unknownFields: "drop" });
+        if (prepared2.changed.length || ownerId && ownerId !== existingRecord.ownerId) {
+          mutations.push(recordPatchMutation(ctx, existingRecord, prepared2.fields, prepared2.changed, ownerId ? { ownerId } : {}));
+          updatedDocs.push({ before: existingRecord, changed: prepared2.changed });
+        }
+        report.updated++;
+        if (key) seenInFile.set(key, existingRecord.id);
+        report.rows.push({ row: rowNo, action: "update", id: existingRecord.id, label: recordLabel(object, existingRecord), ...messages.length ? { messages } : {} });
+        return;
+      }
+      const prepared = prepareRecordFields(vctx, object, input, null, { unknownFields: "drop" });
+      const id = explicitId && !existing.some((r) => r.id === explicitId) ? explicitId : newId(now);
+      const record = {
+        id,
+        object: object.id,
+        fields: prepared.fields,
+        ...ownerId ?? actorId(ctx) ? { ownerId: ownerId ?? actorId(ctx) } : {},
+        createdAt: now,
+        updatedAt: now,
+        ...actorId(ctx) ? { createdBy: actorId(ctx), updatedBy: actorId(ctx) } : {}
+      };
+      mutations.push({ op: "set", collection: "records", doc: asDoc(record) });
+      createdDocs.push(record);
+      if (key) seenInFile.set(key, id);
+      report.created++;
+      report.rows.push({ row: rowNo, action: "create", id, label: recordLabel(object, record), ...messages.length ? { messages } : {} });
+    } catch (err) {
+      report.failed++;
+      const details = err.details;
+      report.rows.push({ row: rowNo, action: "error", messages: [...messages, ...details?.map((d) => d.message) ?? [err.message]] });
+    }
+  });
+  function resolveRelation(field, raw) {
+    const target = field.relation.object;
+    const parts = field.relation.cardinality === "many" ? raw.split(/[,;|]/) : [raw];
+    const ids = [];
+    for (const part of parts.map((p) => p.trim()).filter(Boolean)) {
+      const m = lookupFor(target);
+      const hit = m.get(part) ?? m.get(part.toLowerCase()) ?? m.get(normalizeDomain(part)) ?? m.get(normalizeEmail(part));
+      if (hit) {
+        ids.push(hit);
+        continue;
+      }
+      if (createRelated && target === "companies") {
+        const targetObject = objectOf(ctx.store, target);
+        const isDomain = /^[a-z0-9-]+(\.[a-z0-9-]+)+$/i.test(part) && !part.includes(" ");
+        const id = newId(now);
+        const fields = isDomain ? { name: part.split(".")[0].replace(/^./, (c) => c.toUpperCase()), domain: `https://${normalizeDomain(part)}` } : { name: part };
+        const rec = { id, object: target, fields, ...actorId(ctx) ? { ownerId: actorId(ctx), createdBy: actorId(ctx) } : {}, createdAt: now, updatedAt: now };
+        pendingRelated.set(id, rec);
+        m.set(part.toLowerCase(), id);
+        if (isDomain) m.set(normalizeDomain(part), id);
+        mutations.push({ op: "set", collection: "records", doc: asDoc(rec) });
+        createdDocs.push(rec);
+        report.createdRelated.push({ object: target, label: recordLabel(targetObject, rec) });
+        ids.push(id);
+      }
+    }
+    if (!ids.length) return void 0;
+    return field.relation.cardinality === "many" ? ids : ids[0];
+  }
+  if (opts.dryRun) return report;
+  if (report.newOptions.length) mutations.unshift({ op: "set", collection: "objects", doc: asDoc({ ...object, updatedAt: now }) });
+  if (mutations.length) {
+    await ctx.store.write(mutations, { message: `Import ${report.created} new / ${report.updated} updated ${object.labelPlural}` });
+    for (const r of createdDocs) await emit(ctx, "record.created", { record: r });
+    for (const u of updatedDocs) {
+      const after = ctx.store.get("records", u.before.id);
+      if (after) await emit(ctx, "record.updated", { record: after, before: u.before, changed: u.changed });
+    }
+  }
+  return report;
+}
+function uniqueOptionId(field, label) {
+  const base = label.normalize("NFKD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "option";
+  const taken = new Set((field.options ?? []).map((o) => o.id));
+  if (!taken.has(base)) return base;
+  for (let i = 2; ; i++) if (!taken.has(`${base}-${i}`)) return `${base}-${i}`;
+}
+export {
+  MAPPING_ID,
+  MAPPING_OWNER,
+  MAPPING_SKIP,
+  importCsv,
+  parseCsv,
+  suggestMapping
+};