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

package/dist/agent/chunks/pipelines-DCdRBNBV.mjs

@@ -0,0 +1,234 @@
+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 { dateValueToMs, colorAt } from "./fields-B0bitgmr.mjs";
+import { s as slugId } from "./ids-CvnmrMJX.mjs";
+import { s as stageOptions, p as pipelineOptions } from "./standardObjects-CheqfDqa.mjs";
+import { assertCan, OpsError } from "./context-CxFfqS4D.mjs";
+import { updateRecord } from "./records-DoqiT9xR.mjs";
+import { requireRecord, pipelinesOf, requireObject, requirePipeline, recordsOf, asDoc, thaw } from "./store-5gqRSKXg.mjs";
+import "./pluginRegistry-DyHtlkcr.mjs";
+import "./query-C5nJB_3C.mjs";
+import "./relations-B9TynBmA.mjs";
+function listPipelines(ctx, object) {
+  assertCan(ctx, "records.read");
+  return pipelinesOf(ctx.store, object);
+}
+function getPipeline(ctx, id) {
+  assertCan(ctx, "records.read");
+  return requirePipeline(ctx.store, id);
+}
+function pipelineOfRecord(ctx, record) {
+  const all = pipelinesOf(ctx.store, record.object);
+  const byField = all.find((p) => p.id === record.fields.pipeline);
+  if (byField) return byField;
+  return all.find((p) => p.stages.some((s) => s.id === record.fields[p.stageField])) ?? all[0];
+}
+function syncPipelineOptions(ctx, objectId, pipelines) {
+  const object = requireObject(ctx.store, objectId);
+  const stageFields = new Set(pipelines.map((p) => p.stageField));
+  let touched = false;
+  const fields = object.fields.map((f) => {
+    if (stageFields.has(f.id)) {
+      touched = true;
+      return { ...thaw(f), options: stageOptions(pipelines.filter((p) => p.stageField === f.id)) };
+    }
+    if (f.id === "pipeline" && f.type === "select") {
+      touched = true;
+      return { ...thaw(f), options: pipelineOptions(pipelines) };
+    }
+    return f;
+  });
+  if (!touched) return null;
+  const next = { ...object, fields, updatedAt: ctx.now() };
+  return { op: "set", collection: "objects", doc: asDoc(next) };
+}
+function normalizeStages(ctx, stages, selfId) {
+  if (!stages.length) throw new OpsError("validation", "A pipeline needs at least one stage.");
+  const taken = new Set(pipelinesOf(ctx.store).filter((p) => p.id !== selfId).flatMap((p) => p.stages.map((s) => s.id)));
+  const out = [];
+  stages.forEach((s, i) => {
+    const label = s.label?.trim();
+    if (!label) throw new OpsError("validation", `Stage ${i + 1} needs a label.`);
+    const id = s.id && !taken.has(s.id) && !out.some((x) => x.id === s.id) ? s.id : slugId(label, [...taken, ...out.map((x) => x.id)]);
+    const kind = s.kind ?? (/^(won|gagn)/i.test(label) ? "won" : /^(lost|perdu)/i.test(label) ? "lost" : "open");
+    const probability = Math.max(0, Math.min(100, Math.round(s.probability ?? (kind === "won" ? 100 : kind === "lost" ? 0 : Math.round((i + 1) / stages.length * 80)))));
+    out.push({ id, label, color: s.color ?? colorAt(i), probability, kind });
+  });
+  return out;
+}
+async function createPipeline(ctx, input) {
+  assertCan(ctx, "pipelines.write");
+  const object = requireObject(ctx.store, input.object ?? "deals");
+  const stageField = input.stageField ?? "stage";
+  const field = object.fields.find((f) => f.id === stageField);
+  if (!field || field.type !== "select") throw new OpsError("validation", `${object.labelPlural} has no select field "${stageField}" to hold stages.`);
+  const name = input.name?.trim();
+  if (!name) throw new OpsError("validation", "A pipeline needs a name.");
+  const id = input.id ?? slugId(name, pipelinesOf(ctx.store).map((p) => p.id));
+  const pipeline = { id, object: object.id, name, stageField, stages: normalizeStages(ctx, input.stages, null) };
+  const all = [...pipelinesOf(ctx.store, object.id), pipeline];
+  const sync = syncPipelineOptions(ctx, object.id, all);
+  await ctx.store.write([{ op: "set", collection: "pipelines", doc: asDoc(pipeline) }, ...sync ? [sync] : []], { message: `Create pipeline ${name}` });
+  return requirePipeline(ctx.store, id);
+}
+async function updatePipeline(ctx, id, patch) {
+  assertCan(ctx, "pipelines.write");
+  const before = requirePipeline(ctx.store, id);
+  const next = thaw(before);
+  if (patch.name !== void 0) {
+    if (!patch.name.trim()) throw new OpsError("validation", "A pipeline needs a name.");
+    next.name = patch.name.trim();
+  }
+  const mutations = [];
+  if (patch.stages) {
+    next.stages = normalizeStages(ctx, patch.stages, id);
+    const kept = new Set(next.stages.map((s) => s.id));
+    const removed = before.stages.filter((s) => !kept.has(s.id)).map((s) => s.id);
+    if (removed.length) {
+      const fallback = patch.moveRemovedTo ?? next.stages.find((s) => s.kind === "open")?.id ?? next.stages[0].id;
+      if (!kept.has(fallback)) throw new OpsError("validation", `Unknown stage "${fallback}".`);
+      const target = next.stages.find((s) => s.id === fallback);
+      for (const r of recordsOf(ctx.store, before.object, { includeDeleted: true })) {
+        if (removed.includes(r.fields[before.stageField])) {
+          mutations.push({ op: "patch", collection: "records", id: r.id, fields: { [`fields.${before.stageField}`]: fallback, "fields.probability": target.probability, updatedAt: ctx.now() } });
+        }
+      }
+    }
+  }
+  mutations.unshift({ op: "set", collection: "pipelines", doc: asDoc(next) });
+  const sync = syncPipelineOptions(ctx, before.object, pipelinesOf(ctx.store, before.object).map((p) => p.id === id ? next : p));
+  if (sync) mutations.push(sync);
+  await ctx.store.write(mutations, { message: `Update pipeline ${next.name}` });
+  return requirePipeline(ctx.store, id);
+}
+async function deletePipeline(ctx, id, opts = {}) {
+  assertCan(ctx, "pipelines.write");
+  const pipeline = requirePipeline(ctx.store, id);
+  const others = pipelinesOf(ctx.store, pipeline.object).filter((p) => p.id !== id);
+  if (!others.length) throw new OpsError("invalid", "The last pipeline of an object can't be deleted.");
+  const target = others.find((p) => p.id === opts.moveTo) ?? others[0];
+  const stageIds = new Set(pipeline.stages.map((s) => s.id));
+  const mutations = [{ op: "delete", collection: "pipelines", id }];
+  let moved = 0;
+  for (const r of recordsOf(ctx.store, pipeline.object, { includeDeleted: true })) {
+    if (r.fields.pipeline === id || stageIds.has(r.fields[pipeline.stageField])) {
+      moved++;
+      mutations.push({
+        op: "patch",
+        collection: "records",
+        id: r.id,
+        fields: { "fields.pipeline": target.id, [`fields.${target.stageField}`]: target.stages[0].id, "fields.probability": target.stages[0].probability, updatedAt: ctx.now() }
+      });
+    }
+  }
+  const sync = syncPipelineOptions(ctx, pipeline.object, others);
+  if (sync) mutations.push(sync);
+  for (const v of ctx.store.list("views")) {
+    if (v.pipelineId === id) mutations.push({ op: "patch", collection: "views", id: v.id, fields: { pipelineId: target.id } });
+  }
+  await ctx.store.write(mutations, { message: `Delete pipeline ${pipeline.name}` });
+  return { id, moved };
+}
+async function moveStage(ctx, recordId, stage, opts = {}) {
+  assertCan(ctx, "records.write");
+  const record = requireRecord(ctx.store, recordId);
+  const pipelines = pipelinesOf(ctx.store, record.object);
+  if (!pipelines.length) throw new OpsError("invalid", `${record.object} records have no pipeline.`);
+  const current = pipelineOfRecord(ctx, record);
+  const lower = stage.trim().toLowerCase();
+  const find = (p) => p.stages.find((s) => s.id === stage) ?? p.stages.find((s) => s.label.toLowerCase() === lower);
+  const ordered = current ? [current, ...pipelines.filter((p) => p !== current)] : pipelines;
+  let pipeline;
+  let target;
+  for (const p of ordered) {
+    target = find(p);
+    if (target) {
+      pipeline = p;
+      break;
+    }
+  }
+  if (!pipeline || !target) {
+    throw new OpsError("validation", `Unknown stage "${stage}". Stages: ${(current ?? pipelines[0]).stages.map((s) => s.label).join(", ")}.`);
+  }
+  const input = { [pipeline.stageField]: target.id, probability: target.probability };
+  const object = requireObject(ctx.store, record.object);
+  if (!object.fields.some((f) => f.id === "probability")) delete input.probability;
+  if (object.fields.some((f) => f.id === "pipeline")) input.pipeline = pipeline.id;
+  if (opts.lostReason !== void 0 && object.fields.some((f) => f.id === "lostReason")) input.lostReason = opts.lostReason;
+  if (target.kind !== "open" && object.fields.some((f) => f.id === "closeDate") && !record.fields.closeDate) {
+    input.closeDate = new Date(ctx.now()).toISOString().slice(0, 10);
+  }
+  return updateRecord(ctx, recordId, input, { message: `Move to ${target.label}` });
+}
+function amountOf(r) {
+  return typeof r.fields.amount === "number" ? r.fields.amount : 0;
+}
+function forecast(ctx, opts = {}) {
+  assertCan(ctx, "reports.read");
+  const all = pipelinesOf(ctx.store);
+  const pipeline = opts.pipelineId ? requirePipeline(ctx.store, opts.pipelineId) : all.find((p) => p.object === "deals") ?? all[0];
+  if (!pipeline) throw new OpsError("notFound", "No pipeline.");
+  const object = requireObject(ctx.store, pipeline.object);
+  const from = opts.from !== void 0 ? dateValueToMs(opts.from) : null;
+  const to = opts.to !== void 0 ? dateValueToMs(opts.to) : null;
+  const records = recordsOf(ctx.store, pipeline.object).filter((r) => {
+    if (opts.ownerId && r.ownerId !== opts.ownerId) return false;
+    if (pipelineOfRecord(ctx, r)?.id !== pipeline.id) return false;
+    const close = dateValueToMs(r.fields.closeDate);
+    if (from !== null && (close === null || close < from)) return false;
+    if (to !== null && (close === null || close > to)) return false;
+    return true;
+  });
+  const byStage = pipeline.stages.map((s) => ({ stageId: s.id, label: s.label, kind: s.kind, probability: s.probability, count: 0, amount: 0, weighted: 0 }));
+  const months = /* @__PURE__ */ new Map();
+  let wonAmount = 0;
+  let lostAmount = 0;
+  for (const r of records) {
+    const stage = byStage.find((s) => s.stageId === r.fields[pipeline.stageField]);
+    if (!stage) continue;
+    const amount = amountOf(r);
+    const probability = typeof r.fields.probability === "number" ? r.fields.probability : stage.probability;
+    const weighted = stage.kind === "won" ? amount : stage.kind === "lost" ? 0 : amount * probability / 100;
+    stage.count++;
+    stage.amount += amount;
+    stage.weighted += weighted;
+    if (stage.kind === "won") wonAmount += amount;
+    else if (stage.kind === "lost") lostAmount += amount;
+    else {
+      const close = typeof r.fields.closeDate === "string" ? r.fields.closeDate.slice(0, 7) : "none";
+      const m = months.get(close) ?? { month: close, count: 0, amount: 0, weighted: 0 };
+      m.count++;
+      m.amount += amount;
+      m.weighted += weighted;
+      months.set(close, m);
+    }
+  }
+  const open = byStage.filter((s) => s.kind === "open");
+  const round = (n) => Math.round(n * 100) / 100;
+  return {
+    pipelineId: pipeline.id,
+    currency: object.fields.find((f) => f.id === "amount")?.currency,
+    openCount: open.reduce((a, s) => a + s.count, 0),
+    openAmount: round(open.reduce((a, s) => a + s.amount, 0)),
+    weightedAmount: round(open.reduce((a, s) => a + s.weighted, 0)),
+    wonAmount: round(wonAmount),
+    lostAmount: round(lostAmount),
+    byStage: byStage.map((s) => ({ ...s, amount: round(s.amount), weighted: round(s.weighted) })),
+    byMonth: [...months.values()].sort((a, b) => a.month === "none" ? 1 : b.month === "none" ? -1 : a.month < b.month ? -1 : 1).map((m) => ({ ...m, amount: round(m.amount), weighted: round(m.weighted) }))
+  };
+}
+export {
+  createPipeline,
+  deletePipeline,
+  forecast,
+  getPipeline,
+  listPipelines,
+  moveStage,
+  pipelineOfRecord,
+  syncPipelineOptions,
+  updatePipeline
+};

package/dist/agent/chunks/plan-C0TBrU92.mjs

@@ -0,0 +1,254 @@
+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 { isAbsolute, resolve } from "node:path";
+import { splitSecretSettings } from "./runtimeConfig-CCOFg1RM.mjs";
+import { v as validateAlias, f as findBackend, a as parseAccount, g as getCredential, b as requireCredential, C as CliError, c as findLocation, L as LOCATIONS, d as findHosting, H as HOSTINGS } from "../agentcrm.mjs";
+import "node:util";
+import "node:fs";
+import "node:url";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+const SECRET_KEYS = ["token", "apiKey", "accessKeyId", "secretAccessKey", "passphrase", "password"];
+function fail(message, hint) {
+  throw new CliError("invalid-plan", message, hint ?? "Run `agentcrm options --json` for the expected fields.", 2);
+}
+function str(v) {
+  return typeof v === "string" ? v.trim() : "";
+}
+function cleanFolder(folder) {
+  return folder.trim().replace(/^\/+|\/+$/g, "");
+}
+function copySettings(spec, field) {
+  const out = {};
+  for (const [k, v] of Object.entries(spec.settings ?? {})) {
+    if (v === void 0 || v === null) continue;
+    if (SECRET_KEYS.includes(k)) fail(`${field}.settings.${k} must not be in the plan — store it with \`agentcrm credentials set\` and reference the account in ${field}.credential.`);
+    out[k] = typeof v === "string" ? v.trim() : v;
+  }
+  return out;
+}
+function credentialValues(account, allowed, field) {
+  const { type } = parseAccount(account);
+  if (!allowed.includes(type)) fail(`${field}.credential must be a ${allowed.join(" / ")} account, got ${type}.`);
+  return requireCredential(account).values;
+}
+function resolveLocation(spec, field = "data.location") {
+  const type = str(spec?.type);
+  const loc = findLocation(type);
+  if (!loc) fail(`Unknown ${field}.type "${type}" (one of ${LOCATIONS.map((l) => l.id).join(", ")}).`);
+  const s = copySettings(spec, field);
+  if (type === "local-folder") {
+    const path = str(s.path);
+    if (!path || !isAbsolute(path)) fail(`${field}.settings.path must be an absolute folder path.`);
+    return { target: { connectorId: "local-folder", settings: { handleKey: "data-folder", path: resolve(path) } }, type, path: resolve(path) };
+  }
+  const account = str(spec.credential);
+  if (!account) fail(`${field}.credential is required (${loc.credentialTypes.join(" / ")} account).`);
+  const secrets = credentialValues(account, loc.credentialTypes, field);
+  if (type === "s3") {
+    if (!str(s.bucket)) fail(`${field}.settings.bucket is required.`);
+    if (!str(s.region) && !str(s.endpoint)) fail(`${field}.settings.region is required.`);
+    return { target: { connectorId: "s3", settings: { region: str(s.region) || "us-east-1", ...s, siteUrl: "", ...secrets } }, account, type };
+  }
+  if (type === "github" && (!str(s.owner) || !str(s.repo))) fail(`${field}.settings.owner and .repo are required.`);
+  if (type === "gitlab" && !str(s.project)) fail(`${field}.settings.project is required.`);
+  return {
+    target: { connectorId: "git-pages", settings: { ...s, provider: type, branch: str(s.branch) || "main", host: "other", siteUrl: "", ...secrets } },
+    account,
+    type
+  };
+}
+function resolveHosting(spec, reuse) {
+  const type = str(spec?.type);
+  const h = findHosting(type);
+  if (!h) fail(`Unknown hosting.type "${type}" (one of ${HOSTINGS.map((x) => x.id).join(", ")}).`);
+  if (!h.cli) fail(`hosting "${type}" can't be set up from the CLI.`, h.notes.join(" "));
+  const s = copySettings(spec, "hosting");
+  const folder = cleanFolder(str(spec.folder) || "admin");
+  if (!/^[\w.-]+(\/[\w.-]+)*$/.test(folder)) fail("hosting.folder must be a relative folder name, e.g. admin.");
+  let settings;
+  let account = str(spec.credential);
+  if (type === "local-folder") {
+    const path = str(s.path);
+    if (!path || !isAbsolute(path)) fail("hosting.settings.path must be an absolute folder path.");
+    settings = { path: resolve(path), siteUrl: str(s.siteUrl) };
+    account = "";
+  } else {
+    if (type === "s3") {
+      if (!str(s.bucket)) fail("hosting.settings.bucket is required.");
+      settings = { region: str(s.region) || "us-east-1", ...s };
+    } else {
+      const provider = type === "github-pages" ? "github" : type === "gitlab-pages" ? "gitlab" : str(s.provider) || "github";
+      if (provider === "github" && (!str(s.owner) || !str(s.repo))) fail("hosting.settings.owner and .repo are required.");
+      if (provider === "gitlab" && !str(s.project)) fail("hosting.settings.project is required.");
+      const siteUrl2 = str(s.siteUrl) || (type === "github-pages" ? `https://${str(s.owner).toLowerCase()}.github.io/${str(s.repo)}` : "");
+      settings = {
+        ...s,
+        provider,
+        branch: str(s.branch) || "main",
+        dir: cleanFolder(str(s.dir) || (type === "gitlab-pages" ? "public" : "")),
+        host: type === "cloudflare-pages" ? "cloudflare-pages" : type,
+        siteUrl: siteUrl2
+      };
+      if (!account && reuse && parseAccount(reuse).type === provider) account = reuse;
+    }
+    if (!account) fail(`hosting.credential is required (${h.credentialTypes.join(" / ")} account).`);
+  }
+  const siteUrl = str(settings.siteUrl).replace(/\/+$/, "");
+  if (type !== "local-folder" && !/^https?:\/\/[^/]+/.test(siteUrl)) fail("hosting.settings.siteUrl must be an http(s) URL.");
+  if (siteUrl) settings.siteUrl = siteUrl;
+  const secrets = account ? credentialValues(account, h.credentialTypes, "hosting") : {};
+  const publicSettings = Object.fromEntries(Object.entries(splitSecretSettings(settings).publicSettings));
+  return {
+    target: { connectorId: h.connectorId, settings: { ...settings, ...secrets } },
+    hosting: { type, connectorId: h.connectorId, settings: publicSettings, folder },
+    adminUrl: siteUrl ? `${siteUrl}/${folder}/` : null,
+    account: account || void 0
+  };
+}
+function resolvePlan(plan, opts = {}) {
+  if (!plan || typeof plan !== "object") fail("The plan must be a JSON object.");
+  const alias = validateAlias(str(plan.alias));
+  const name = str(plan.name) || alias;
+  const ownerEmail = str(plan.owner?.email).toLowerCase();
+  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(ownerEmail)) fail("owner.email (the first CRM admin) is required.", 'e.g. "owner": { "name": "Ada Lovelace", "email": "ada@acme.com" }');
+  const owner = { name: str(plan.owner?.name) || ownerEmail.split("@")[0], email: ownerEmail };
+  const backendId = str(plan.data?.backend);
+  const backend = findBackend(backendId);
+  if (!backend) fail(`Unknown data.backend "${backendId}" (journal, git-json, firebase).`);
+  if (!backend.cli) fail(`Data backend "${backend.id}" can't be set up from the CLI.`, backend.notes.join(" "));
+  const credentials = {};
+  const warnings = [];
+  let runtime;
+  let dataTarget;
+  let dataType;
+  let dataPath;
+  let backendSecrets;
+  let passphraseAccount;
+  let passphrase;
+  if (plan.data.backend === "journal") {
+    const data = plan.data;
+    const loc = resolveLocation(data.location);
+    dataTarget = loc.target;
+    dataType = loc.type;
+    dataPath = loc.path;
+    if (loc.account) credentials.data = loc.account;
+    const root = cleanFolder(str(data.root) || "agentcrm");
+    const encrypted = data.encryption !== false;
+    if (encrypted) {
+      const enc = data.encryption === void 0 ? {} : data.encryption;
+      passphraseAccount = str(enc.credential) || `passphrase:${alias}`;
+      if (parseAccount(passphraseAccount).type !== "passphrase") fail("data.encryption.credential must be a passphrase account.");
+      const stored = getCredential(passphraseAccount)?.values.passphrase;
+      if (!stored && enc.credential) requireCredential(passphraseAccount);
+      passphrase = stored;
+      credentials.passphrase = passphraseAccount;
+    } else {
+      warnings.push("The dataset is NOT encrypted: anyone who can read the storage reads every contact. Keep the location private.");
+    }
+    const publicSettings = splitSecretSettings(dataTarget.settings).publicSettings;
+    delete publicSettings.path;
+    delete publicSettings.siteUrl;
+    runtime = { backend: "journal", name, journal: { connectorId: dataTarget.connectorId, settings: publicSettings, root, encrypted } };
+  } else if (plan.data.backend === "git-json") {
+    const g = plan.data.git ?? {};
+    const provider = str(g.provider);
+    if (provider !== "github" && provider !== "gitlab") fail('data.git.provider must be "github" or "gitlab".');
+    if (provider === "github" && (!str(g.owner) || !str(g.repo))) fail("data.git.owner and data.git.repo are required for GitHub.");
+    if (provider === "gitlab" && !str(g.project)) fail("data.git.project is required for GitLab.");
+    const account = str(plan.data.credential);
+    if (!account) fail("data.credential is required (e.g. github:acme).");
+    backendSecrets = credentialValues(account, [provider], "data");
+    credentials.data = account;
+    runtime = {
+      backend: "git-json",
+      name,
+      git: {
+        provider,
+        ...provider === "github" ? { owner: str(g.owner), repo: str(g.repo) } : { project: str(g.project) },
+        branch: str(g.branch) || "main",
+        ...str(g.apiBaseUrl) ? { apiBaseUrl: str(g.apiBaseUrl) } : {},
+        dir: cleanFolder(str(g.dir))
+      }
+    };
+    warnings.push("git-json keeps every past value in the repository history: deleted records stay readable there. Keep the repository private.");
+  } else {
+    const fb = plan.data.firebase ?? {};
+    for (const k of ["apiKey", "authDomain", "projectId", "appId"]) if (!str(fb[k])) fail(`data.firebase.${k} is required (Firebase console → Project settings → Your apps → config).`);
+    const account = str(plan.data.credential);
+    if (!account) fail("data.credential is required (firebase:<name>, email + password of the first admin).");
+    backendSecrets = credentialValues(account, ["firebase"], "data");
+    credentials.data = account;
+    const methods = Array.isArray(plan.data.signInMethods) ? plan.data.signInMethods.filter((m) => m === "password" || m === "google") : [];
+    runtime = {
+      backend: "firebase",
+      name,
+      firebase: Object.fromEntries(["apiKey", "authDomain", "projectId", "storageBucket", "messagingSenderId", "appId", "measurementId"].filter((k) => str(fb[k])).map((k) => [k, str(fb[k])])),
+      ...methods.length ? { signInMethods: [.../* @__PURE__ */ new Set(["password", ...methods])] } : {}
+    };
+  }
+  let hostingTarget = null;
+  let hosting = null;
+  let adminUrl = null;
+  if (plan.hosting) {
+    const h = resolveHosting(plan.hosting, credentials.data);
+    hostingTarget = h.target;
+    hosting = h.hosting;
+    adminUrl = h.adminUrl;
+    if (h.account) credentials.hosting = h.account;
+    if (adminUrl && !adminUrl.startsWith("https://") && !/^http:\/\/(localhost|127\.0\.0\.1)/.test(adminUrl)) {
+      warnings.push(`${adminUrl} is plain HTTP: browsers only allow the admin's request signing and encryption on HTTPS pages. Put HTTPS (a CDN) in front.`);
+    }
+    if (dataTarget && hostingTarget.connectorId === "s3" && dataTarget.connectorId === "s3" && hostingTarget.settings.bucket === dataTarget.settings.bucket && hostingTarget.settings.endpoint === dataTarget.settings.endpoint) {
+      warnings.push(
+        runtime.backend === "journal" && runtime.journal.encrypted ? "The data lives in the bucket that serves the admin: the encrypted files are downloadable by anyone. Prefer a separate private bucket." : "The data lives UNENCRYPTED in the public bucket that serves the admin: anyone can download every contact. Use a separate private bucket or encryption."
+      );
+    }
+  }
+  return {
+    alias,
+    name,
+    owner,
+    backend: runtime.backend,
+    runtime,
+    dataTarget,
+    dataType,
+    dataPath,
+    backendSecrets,
+    passphraseAccount,
+    passphrase,
+    hostingTarget,
+    hosting,
+    adminUrl,
+    credentials,
+    demo: plan.demo === true,
+    currency: str(plan.currency) || void 0,
+    locale: str(plan.locale) || void 0,
+    warnings
+  };
+}
+const PLAN_EXAMPLE = {
+  alias: "acme-crm",
+  name: "Acme CRM",
+  owner: { name: "Ada Lovelace", email: "ada@acme.com" },
+  data: {
+    backend: "journal",
+    location: { type: "s3", settings: { endpoint: "https://s3.gra.io.cloud.ovh.net", region: "gra", bucket: "acme-crm-data" }, credential: "s3:ovh" },
+    root: "agentcrm"
+  },
+  hosting: { type: "s3", settings: { endpoint: "https://s3.gra.io.cloud.ovh.net", region: "gra", bucket: "acme-crm-admin", siteUrl: "https://crm.acme.com", publicRead: true }, credential: "s3:ovh", folder: "admin" },
+  demo: false
+};
+export {
+  PLAN_EXAMPLE,
+  cleanFolder,
+  resolveHosting,
+  resolveLocation,
+  resolvePlan
+};

package/dist/agent/chunks/pluginRegistry-DyHtlkcr.mjs

@@ -0,0 +1,83 @@
+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 createPluginRegistry(onError = defaultOnError) {
+  const filters = /* @__PURE__ */ new Map();
+  const actions = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const sorted = (list) => [...list].sort((a, b) => a.priority - b.priority || a.order - b.order);
+  const registry = {
+    addFilter(hook, fn, priority = 10) {
+      const list = filters.get(hook) ?? [];
+      list.push({ fn, priority, order: counter++ });
+      filters.set(hook, list);
+      return () => registry.removeFilter(hook, fn);
+    },
+    removeFilter(hook, fn) {
+      const list = filters.get(hook);
+      if (list) filters.set(hook, list.filter((e) => e.fn !== fn));
+    },
+    async applyFilters(hook, value, ...args) {
+      let current = value;
+      for (const e of sorted(filters.get(hook) ?? [])) {
+        try {
+          current = await e.fn(current, ...args);
+        } catch (err) {
+          onError(hook, err);
+        }
+      }
+      return current;
+    },
+    applyFiltersSync(hook, value, ...args) {
+      let current = value;
+      for (const e of sorted(filters.get(hook) ?? [])) {
+        const next = e.fn(current, ...args);
+        if (next instanceof Promise) throw new Error(`Filter "${hook}" must be synchronous; got a Promise.`);
+        current = next;
+      }
+      return current;
+    },
+    addAction(hook, fn, priority = 10) {
+      const list = actions.get(hook) ?? [];
+      list.push({ fn, priority, order: counter++ });
+      actions.set(hook, list);
+      return () => registry.removeAction(hook, fn);
+    },
+    removeAction(hook, fn) {
+      const list = actions.get(hook);
+      if (list) actions.set(hook, list.filter((e) => e.fn !== fn));
+    },
+    async doAction(hook, ...args) {
+      for (const e of sorted(actions.get(hook) ?? [])) {
+        try {
+          await e.fn(...args);
+        } catch (err) {
+          onError(hook, err);
+        }
+      }
+    },
+    hasAction(hook) {
+      return (actions.get(hook)?.length ?? 0) > 0;
+    },
+    reset() {
+      filters.clear();
+      actions.clear();
+      counter = 0;
+    },
+    listHooks() {
+      return { filters: [...filters.keys()], actions: [...actions.keys()] };
+    }
+  };
+  return registry;
+}
+function defaultOnError(hook, err) {
+  console.error(`[plugins] "${hook}" callback failed:`, err);
+}
+const plugins = createPluginRegistry();
+export {
+  createPluginRegistry,
+  plugins
+};