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

package/dist/agent/chunks/gitJson-fjr8mcHe.mjs

@@ -0,0 +1,528 @@
+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 { SECRET_SETTING_KEYS, datasetId, getSecret, getGitToken, setSecret, setSecretJson, getSecretJson } from "./runtimeConfig-CCOFg1RM.mjs";
+import { setGitToken } from "./runtimeConfig-CCOFg1RM.mjs";
+import { j as joinRepoPath, G as GitConflictError, c as createRemoteGitTransport } from "./s3-Dz50-NuA.mjs";
+import { b as bytesToBase64, a as base64ToUtf8 } from "./encoding-C9MzdP95.mjs";
+import { w as withFileStore } from "./index-RCmo-uld.mjs";
+import { e as emptySnapshot, n as normalizeDoc, a as splitPath, g as getPath, b as setPath, c as createStoreCore, d as applyMutations } from "./core-Dy7vY9H6.mjs";
+import { COLLECTIONS, isCollectionName, DocConflictError } from "./types-BOy9PUl7.mjs";
+import { a as assertFileId } from "./ids-u-noYcy5.mjs";
+import "./index-BM8qeGOb.mjs";
+import { l as loadFolderHandle, e as ensureFolderPermission, c as createLocalFsTransport } from "./registry-DijAKZ24.mjs";
+import "./http-Bk9ICb7I.mjs";
+import "./index-w03ReRs4.mjs";
+import "./_commonjsHelpers-ClciMIcB.mjs";
+import "stream";
+import "events";
+import "buffer";
+import "util";
+const GIT_JSON_FORMAT = "agentcrm-git-json";
+const GIT_JSON_VERSION = 1;
+const MARKER_FILE = "agentcrm.json";
+function docKey(collection, id) {
+  return `${collection}/${id}`;
+}
+function encodeName(id) {
+  return encodeURIComponent(id).replace(/\./g, "%2E");
+}
+function decodeName(name) {
+  try {
+    return decodeURIComponent(name);
+  } catch {
+    return name;
+  }
+}
+function docPath(collection, doc) {
+  if (collection === "records") {
+    const object = typeof doc.object === "string" && doc.object ? doc.object : "_";
+    return `records/${encodeName(object)}/${encodeName(doc.id)}.json`;
+  }
+  return `${collection}/${encodeName(doc.id)}.json`;
+}
+function parseDocPath(path) {
+  const parts = path.split("/");
+  const [head] = parts;
+  if (!isCollectionName(head)) return null;
+  const file = parts[parts.length - 1];
+  if (!file.endsWith(".json")) return null;
+  if (head === "records" ? parts.length !== 3 : parts.length !== 2) return null;
+  const id = decodeName(file.slice(0, -".json".length));
+  return id ? { collection: head, id } : null;
+}
+function isLayoutFile(path) {
+  return path === MARKER_FILE || parseDocPath(path) !== null;
+}
+function serializeDoc(doc) {
+  return JSON.stringify(doc, null, 2) + "\n";
+}
+function collectSecrets(value, path, out) {
+  if (Array.isArray(value)) return value.map((v, i) => collectSecrets(v, [...path, String(i)], out));
+  if (!value || typeof value !== "object") return value;
+  const clean = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (SECRET_SETTING_KEYS.has(k) && typeof v === "string") {
+      if (v) out[[...path, k].join(".")] = v;
+      continue;
+    }
+    clean[k] = collectSecrets(v, [...path, k], out);
+  }
+  return clean;
+}
+function stripDocSecrets(doc) {
+  const secrets = {};
+  const clean = collectSecrets(doc, [], secrets);
+  return { doc: clean, secrets };
+}
+function mergeDocSecrets(doc, secrets) {
+  if (!secrets) return doc;
+  let out = { ...doc };
+  for (const [path, value] of Object.entries(secrets)) {
+    const p = splitPath(path);
+    if (getPath(out, p.slice(0, -1)) === void 0 && p.length > 1) continue;
+    out = setPath(out, p, value);
+  }
+  return out;
+}
+function filesToSnapshot(files, secrets = {}) {
+  const snapshot = emptySnapshot();
+  const index = /* @__PURE__ */ new Map();
+  const errors = [];
+  for (const [path, text] of files) {
+    const parsed = parseDocPath(path);
+    if (!parsed) continue;
+    let doc;
+    try {
+      const raw = JSON.parse(text);
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) throw new Error("not an object");
+      doc = { ...raw, id: parsed.id };
+    } catch (err) {
+      errors.push(`${path}: ${err.message}`);
+      continue;
+    }
+    if (parsed.collection === "config") doc = mergeDocSecrets(doc, secrets[parsed.id]);
+    snapshot[parsed.collection].set(parsed.id, normalizeDoc(doc));
+    index.set(docKey(parsed.collection, parsed.id), path);
+  }
+  return { snapshot, index, errors };
+}
+function planChanges(keys, target, files, index, secrets) {
+  const nextFiles = new Map(files);
+  const nextIndex = new Map(index);
+  const nextSecrets = { ...secrets };
+  const changes = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const [collection, id] of keys) {
+    const key = docKey(collection, id);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    const oldPath = nextIndex.get(key);
+    const doc = target[collection].get(id);
+    if (!doc) {
+      if (oldPath) {
+        changes.set(oldPath, { type: "delete", path: oldPath });
+        nextFiles.delete(oldPath);
+        nextIndex.delete(key);
+      }
+      if (collection === "config") delete nextSecrets[id];
+      continue;
+    }
+    let stored = doc;
+    if (collection === "config") {
+      const split = stripDocSecrets(doc);
+      stored = split.doc;
+      if (Object.keys(split.secrets).length) nextSecrets[id] = split.secrets;
+      else delete nextSecrets[id];
+    }
+    const path = docPath(collection, stored);
+    const content = serializeDoc(stored);
+    if (oldPath && oldPath !== path) {
+      changes.set(oldPath, { type: "delete", path: oldPath });
+      nextFiles.delete(oldPath);
+    }
+    if (nextFiles.get(path) !== content) changes.set(path, { type: "put", path, content });
+    nextFiles.set(path, content);
+    nextIndex.set(key, path);
+  }
+  return { changes: [...changes.values()], files: nextFiles, index: nextIndex, secrets: nextSecrets };
+}
+function markerContent() {
+  return JSON.stringify({ format: GIT_JSON_FORMAT, version: GIT_JSON_VERSION }, null, 2) + "\n";
+}
+function isCollectionFolder(name) {
+  return COLLECTIONS.includes(name);
+}
+const GIT_JSON_POLL_MS = 3e4;
+const GIT_JSON_LOCAL_POLL_MS = 1e4;
+const MAX_REBASES = 3;
+function isGitJsonStore(store) {
+  return store.kind === "git-json" && typeof store.resetSession === "function";
+}
+function roleFromPermissions(p) {
+  if (p.isAdmin) return "admin";
+  if (p.canWrite) return "member";
+  return "viewer";
+}
+function defaultGitIdentity(p, t, email) {
+  const noreply = t.kind === "github" ? `${p.login}@users.noreply.github.com` : t.kind === "gitlab" ? `${p.login}@users.noreply.gitlab.com` : "local@localhost";
+  return {
+    uid: t.kind === "local" ? "local" : `${t.kind}:${p.login}`,
+    email: email?.trim().toLowerCase() || noreply,
+    displayName: p.login,
+    role: t.kind === "local" ? "admin" : roleFromPermissions(p)
+  };
+}
+const GIT_FILES_DIR = "files";
+const GIT_LARGE_FILE_WARN_BYTES = 5 * 1024 * 1024;
+function keyOf(m) {
+  return [m.collection, m.op === "set" ? m.doc.id : m.id];
+}
+const same = (a, b) => JSON.stringify(a ?? null) === JSON.stringify(b ?? null);
+function checkRebase(mutations, before, remote, message = "Someone else changed this document — reload to see their version.") {
+  for (const m of mutations) {
+    const [collection, id] = keyOf(m);
+    const base = before[collection].get(id);
+    const theirs = remote[collection].get(id);
+    if (same(base, theirs)) continue;
+    if (m.op === "patch") {
+      if (!theirs) throw new DocConflictError(message, collection, id);
+      for (const [path, value] of Object.entries(m.fields)) {
+        const p = splitPath(path);
+        const b = getPath(base, p);
+        const r = getPath(theirs, p);
+        if (!same(b, r) && !same(r, value)) throw new DocConflictError(message, collection, id);
+        for (let i = 1; i < p.length; i++) {
+          const pb = getPath(base, p.slice(0, i));
+          const pr = getPath(theirs, p.slice(0, i));
+          if (pb === void 0 !== (pr === void 0)) throw new DocConflictError(message, collection, id);
+        }
+      }
+      continue;
+    }
+    if (m.op === "set" && same(theirs, m.doc)) continue;
+    if (m.op === "delete" && !theirs) continue;
+    throw new DocConflictError(message, collection, id);
+  }
+}
+function createGitJsonStoreWith(opts) {
+  const dir = opts.dir.replace(/^\/+|\/+$/g, "");
+  const rel = (path) => dir ? path.slice(dir.length + 1) : path;
+  const inDir = (path) => !dir || path.startsWith(dir + "/");
+  const suffix = opts.messageSuffix ?? " — AgentCRM [skip ci]";
+  const secrets = opts.secrets ?? { read: () => ({}), write: () => void 0 };
+  let transport = null;
+  let identityPromise = null;
+  let state = null;
+  let stale = false;
+  async function openTransport() {
+    if (!transport) transport = await opts.openTransport();
+    return transport;
+  }
+  async function requireTransport() {
+    const t = await openTransport();
+    if (!t) throw new Error("Not connected to the data repository on this browser (missing token or folder access).");
+    return t;
+  }
+  async function loadRemote() {
+    const t = await requireTransport();
+    const tree = await t.listTree();
+    const entries = tree.entries.filter((e) => inDir(e.path) && isLayoutFile(rel(e.path)));
+    const texts = await t.readTexts(entries);
+    const files2 = /* @__PURE__ */ new Map();
+    for (const [path, text] of texts) files2.set(rel(path), text);
+    const { snapshot, index, errors } = filesToSnapshot(files2, secrets.read());
+    if (errors.length) console.warn("[git-json] unreadable files:", errors);
+    const blobs = /* @__PURE__ */ new Map();
+    for (const e of tree.entries) {
+      if (!inDir(e.path)) continue;
+      const r = rel(e.path);
+      if (r.startsWith(`${GIT_FILES_DIR}/`) && r.endsWith(".bin")) blobs.set(r, e);
+    }
+    return { head: tree.headSha, blobs, files: files2, index, snapshot, errors };
+  }
+  async function persist(mutations, before, _after, message) {
+    const t = await requireTransport();
+    if (!state) state = await loadRemote();
+    for (let attempt = 0; ; attempt++) {
+      const base = state;
+      checkRebase(mutations, before, base.snapshot);
+      const { next } = applyMutations(base.snapshot, mutations);
+      const plan = planChanges(mutations.map(keyOf), next, base.files, base.index, secrets.read());
+      if (!base.files.has(MARKER_FILE)) {
+        plan.changes.push({ type: "put", path: MARKER_FILE, content: markerContent() });
+        plan.files.set(MARKER_FILE, markerContent());
+      }
+      if (plan.changes.length === 0) return;
+      const changes = plan.changes.map(
+        (c) => c.type === "put" ? { type: "put", path: joinRepoPath(dir, c.path), content: c.content ?? "" } : { type: "delete", path: joinRepoPath(dir, c.path) }
+      );
+      try {
+        const head = await t.commit(changes, { message: `${message}${suffix}`, expectedHeadSha: base.head });
+        secrets.write(plan.secrets);
+        state = { head, blobs: base.blobs, files: plan.files, index: plan.index, snapshot: next, errors: base.errors };
+        if (base.snapshot !== before && attempt > 0) stale = true;
+        return;
+      } catch (err) {
+        if (!(err instanceof GitConflictError) || attempt >= MAX_REBASES) throw err;
+      }
+      state = await loadRemote();
+      stale = true;
+    }
+  }
+  const core = createStoreCore({
+    kind: "git-json",
+    pollIntervalMs: opts.pollIntervalMs ?? GIT_JSON_POLL_MS,
+    async load() {
+      state = await loadRemote();
+      stale = false;
+      return state.snapshot;
+    },
+    persist,
+    async poll() {
+      const t = await openTransport();
+      if (!t || !state) return null;
+      const head = await t.headSha();
+      if (head === state.head && !stale) return null;
+      state = await loadRemote();
+      stale = false;
+      return state.snapshot;
+    },
+    identity() {
+      if (!identityPromise) {
+        identityPromise = (async () => {
+          const t = await openTransport();
+          if (!t) return null;
+          try {
+            const p = await t.permissions();
+            return opts.identityFor ? opts.identityFor(p, t) : defaultGitIdentity(p, t);
+          } catch (err) {
+            console.warn("[git-json] permission check failed:", err);
+            return null;
+          }
+        })();
+        void identityPromise.then((id) => {
+          if (!id) {
+            identityPromise = null;
+            transport = null;
+          }
+        });
+      }
+      return identityPromise;
+    }
+  });
+  const blobPath = (id) => `${GIT_FILES_DIR}/${id}.bin`;
+  async function commitBlobs(changes, message) {
+    const t = await requireTransport();
+    const full = changes.map((c) => ({ ...c, path: joinRepoPath(dir, c.path) }));
+    const msg = `${message}${suffix}`;
+    if (state) {
+      try {
+        const head = await t.commit(full, { message: msg, expectedHeadSha: state.head });
+        const blobs = new Map(state.blobs);
+        for (const c of changes) {
+          if (c.type === "put") blobs.set(c.path, { path: joinRepoPath(dir, c.path), sha: "" });
+          else blobs.delete(c.path);
+        }
+        state = { ...state, head, blobs };
+        return;
+      } catch (err) {
+        if (!(err instanceof GitConflictError)) throw err;
+      }
+    }
+    await t.commit(full, { message: msg });
+    stale = true;
+  }
+  async function findBlob(id) {
+    const p = blobPath(id);
+    let e = state?.blobs.get(p);
+    if (!e || !e.sha) {
+      const t = await requireTransport();
+      const tree = await t.listTree();
+      const full = joinRepoPath(dir, p);
+      e = tree.entries.find((x) => x.path === full);
+      if (e && state) state.blobs.set(p, e);
+    }
+    return e ?? null;
+  }
+  const files = {
+    kind: "git-json",
+    async put(id, bytes) {
+      await files.putMany([{ id, bytes }]);
+    },
+    async putMany(items) {
+      if (!items.length) return;
+      for (const it of items) assertFileId(it.id);
+      const total = items.reduce((n, it) => n + it.bytes.length, 0);
+      if (total > GIT_LARGE_FILE_WARN_BYTES) console.warn(`[git-json] committing ${Math.round(total / 1024)} KB of files: git history keeps them forever and large repos get slow.`);
+      await commitBlobs(
+        items.map((it) => ({ type: "put", path: blobPath(it.id), content: bytesToBase64(it.bytes), encoding: "base64" })),
+        `Upload ${items.length === 1 ? items[0].meta?.name ?? "a file" : `${items.length} files`}`
+      );
+    },
+    async get(id) {
+      assertFileId(id);
+      const entry = await findBlob(id);
+      if (!entry) return null;
+      return (await requireTransport()).readBytes(entry);
+    },
+    async delete(id) {
+      assertFileId(id);
+      if (!await findBlob(id)) return;
+      await commitBlobs([{ type: "delete", path: blobPath(id) }], "Purge a file");
+    },
+    async list() {
+      const t = await requireTransport();
+      const tree = await t.listTree();
+      const prefix = joinRepoPath(dir, `${GIT_FILES_DIR}/`);
+      return tree.entries.filter((e) => e.path.startsWith(prefix) && e.path.endsWith(".bin")).map((e) => e.path.slice(prefix.length, -".bin".length)).filter((id) => !id.includes("/")).sort();
+    }
+  };
+  withFileStore(core, files);
+  return Object.assign(core, {
+    resetSession() {
+      transport = null;
+      identityPromise = null;
+      state = null;
+      stale = false;
+    },
+    loadErrors: () => state?.errors ?? [],
+    headSha: () => state?.head ?? null
+  });
+}
+async function inspectGitJsonFolder(t, dir) {
+  const d = dir.replace(/^\/+|\/+$/g, "");
+  const tree = await t.listTree();
+  const relPaths = tree.entries.map((e) => d ? e.path.startsWith(d + "/") ? e.path.slice(d.length + 1) : null : e.path).filter((p) => p !== null);
+  const docs = relPaths.filter((p) => p !== MARKER_FILE && isLayoutFile(p));
+  const exists = relPaths.includes(MARKER_FILE) || docs.some((p) => p.startsWith("objects/"));
+  let name;
+  const settingsEntry = tree.entries.find((e) => e.path === joinRepoPath(d, "settings/general.json"));
+  if (settingsEntry) {
+    const text = (await t.readTexts([settingsEntry])).get(settingsEntry.path);
+    try {
+      name = text ? JSON.parse(text).name : void 0;
+    } catch {
+    }
+  }
+  return { exists, documents: docs.length, hasUsers: docs.some((p) => p.startsWith("users/")), name };
+}
+function createMemoryRepo(files = {}) {
+  return { head: "c0", files: new Map(Object.entries(files)), commits: [] };
+}
+function shaOf(text) {
+  let h = 2166136261;
+  for (let i = 0; i < text.length; i++) {
+    h ^= text.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return `b${(h >>> 0).toString(16)}-${text.length}`;
+}
+function createMemoryGitTransport(repo, opts = {}) {
+  const t = {
+    kind: opts.kind ?? "github",
+    label: "memory/repo@main",
+    reads: 0,
+    async headSha() {
+      return repo.head;
+    },
+    async listTree() {
+      const entries = [...repo.files.entries()].map(([path, text]) => ({ path, sha: shaOf(text), size: text.length })).sort((a, b) => a.path.localeCompare(b.path));
+      return { headSha: repo.head, entries };
+    },
+    async readTexts(entries) {
+      t.reads++;
+      const out = /* @__PURE__ */ new Map();
+      for (const e of entries) {
+        const text = repo.files.get(e.path);
+        if (text !== void 0) out.set(e.path, text);
+      }
+      return out;
+    },
+    async readBytes(entry) {
+      return new TextEncoder().encode(repo.files.get(entry.path) ?? "");
+    },
+    async commit(changes, o) {
+      opts.beforeCommit?.(repo);
+      if (o.expectedHeadSha && o.expectedHeadSha !== repo.head) throw new GitConflictError("Branch moved", repo.head);
+      for (const c of changes) {
+        if (c.type === "delete") repo.files.delete(c.path);
+        else repo.files.set(c.path, c.encoding === "base64" ? base64ToUtf8(c.content) : c.content);
+      }
+      const sha = `c${repo.commits.length + 1}`;
+      repo.commits.push({ sha, message: o.message, changes });
+      repo.head = sha;
+      return sha;
+    },
+    async permissions() {
+      return { login: "octocat", canWrite: true, isAdmin: true, visibility: "private", ...opts.permissions };
+    }
+  };
+  return t;
+}
+const LOCAL_GIT_HANDLE_KEY = "git-json-folder";
+async function openGitJsonTransport(git, token) {
+  if (git.provider === "local") {
+    const handle = await loadFolderHandle(LOCAL_GIT_HANDLE_KEY);
+    if (!handle || !await ensureFolderPermission(handle)) return null;
+    return createLocalFsTransport(handle);
+  }
+  const tok = token ?? getGitToken(git);
+  if (!tok) return null;
+  return git.provider === "github" ? createRemoteGitTransport({ provider: "github", owner: git.owner ?? "", repo: git.repo ?? "", branch: git.branch, token: tok, apiBaseUrl: git.apiBaseUrl }) : createRemoteGitTransport({ provider: "gitlab", project: git.project ?? "", branch: git.branch, token: tok, apiBaseUrl: git.apiBaseUrl });
+}
+function getGitUserEmail(config) {
+  return getSecret(`gitEmail:${datasetId(config)}`);
+}
+function setGitUserEmail(config, email) {
+  setSecret(`gitEmail:${datasetId(config)}`, email?.trim().toLowerCase() || null);
+}
+function createGitJsonStore(config, opts = {}) {
+  const cfg = config.git;
+  const explicitToken = typeof opts.secrets?.token === "string" ? opts.secrets.token : null;
+  const explicitEmail = typeof opts.secrets?.email === "string" ? opts.secrets.email : null;
+  const bagKey = `gitSecrets:${datasetId(config)}`;
+  return createGitJsonStoreWith({
+    dir: cfg.dir,
+    openTransport: () => openGitJsonTransport(cfg, explicitToken),
+    identityFor: (p, t) => defaultGitIdentity(p, t, explicitEmail ?? getGitUserEmail(config)),
+    secrets: {
+      read: () => getSecretJson(bagKey) ?? {},
+      write: (bag) => setSecretJson(bagKey, bag)
+    },
+    pollIntervalMs: opts.pollIntervalMs ?? (cfg.provider === "local" ? GIT_JSON_LOCAL_POLL_MS : GIT_JSON_POLL_MS)
+  });
+}
+export {
+  GIT_JSON_FORMAT,
+  GIT_JSON_VERSION,
+  LOCAL_GIT_HANDLE_KEY,
+  MARKER_FILE,
+  checkRebase,
+  createGitJsonStore,
+  createGitJsonStoreWith,
+  createMemoryGitTransport,
+  createMemoryRepo,
+  docKey,
+  docPath,
+  filesToSnapshot,
+  getGitToken,
+  getGitUserEmail,
+  inspectGitJsonFolder,
+  isCollectionFolder,
+  isGitJsonStore,
+  isLayoutFile,
+  markerContent,
+  mergeDocSecrets,
+  openGitJsonTransport,
+  parseDocPath,
+  planChanges,
+  roleFromPermissions,
+  serializeDoc,
+  setGitToken,
+  setGitUserEmail,
+  stripDocSecrets
+};

package/dist/agent/chunks/hosting-Bme7LxPc.mjs

@@ -0,0 +1,144 @@
+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 { statSync, rmSync, existsSync, unlinkSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from "node:fs";
+import { resolve, dirname, sep, join, relative } from "node:path";
+import { buildConfigJsSource } from "./runtimeConfig-CCOFg1RM.mjs";
+import { a as createGitPagesConnector, b as createS3Connector } from "./s3-Dz50-NuA.mjs";
+import { C as CliError, r as readVersionInfo, i as distRoot } from "../agentcrm.mjs";
+import { pathToFileURL } from "node:url";
+import "./index-BM8qeGOb.mjs";
+import "./http-Bk9ICb7I.mjs";
+import "./encoding-C9MzdP95.mjs";
+import "node:util";
+import "node:crypto";
+import "node:os";
+import "node:child_process";
+import "node:http";
+function createFsConnector(settings) {
+  const raw = typeof settings.path === "string" ? settings.path.trim() : "";
+  if (!raw) throw new Error("local-folder: settings.path (absolute folder) is required.");
+  const root = resolve(raw);
+  const abs = (p) => {
+    const file = resolve(root, p.replace(/^\/+/, ""));
+    if (file !== root && !file.startsWith(root + sep)) throw new Error(`Path escapes the folder: ${p}`);
+    return file;
+  };
+  const walk = (dir) => existsSync(dir) ? readdirSync(dir).flatMap((name) => {
+    const p = join(dir, name);
+    return statSync(p).isDirectory() ? walk(p) : [p];
+  }) : [];
+  const rel = (file) => relative(root, file).split(sep).join("/");
+  const connector = {
+    id: settings.id ?? "local-folder",
+    model: "files",
+    capabilities: { list: true, rename: false, renameFolder: false, folders: true, deletePrefix: true },
+    async put(input) {
+      const file = abs(input.path);
+      mkdirSync(dirname(file), { recursive: true });
+      writeFileSync(file, input.encoding === "base64" ? Buffer.from(input.content, "base64") : input.content);
+    },
+    async get(path) {
+      return readFileSync(abs(path), "utf8");
+    },
+    async getBytes(path) {
+      const file = abs(path);
+      return existsSync(file) ? new Uint8Array(readFileSync(file)) : null;
+    },
+    async delete(path) {
+      const file = abs(path);
+      if (existsSync(file)) unlinkSync(file);
+    },
+    async deletePrefix(path) {
+      rmSync(abs(path), { recursive: true, force: true });
+    },
+    async list(page, perPage) {
+      const all = walk(root).map((f) => ({ path: rel(f), type: "file", size: statSync(f).size })).sort((a, b) => a.path.localeCompare(b.path));
+      return { items: all.slice((page - 1) * perPage, page * perPage), page, per_page: perPage, total: all.length };
+    },
+    async listPrefix(prefix) {
+      const p = prefix.replace(/^\/+/, "");
+      return walk(root).map(rel).filter((f) => f.startsWith(p)).sort();
+    },
+    async publicUrl(path) {
+      return pathToFileURL(abs(path)).href;
+    },
+    async commitBatch(ops) {
+      for (const op of ops) {
+        if (op.type === "put") await connector.put(op);
+        else if (op.type === "delete") await connector.delete(op.path);
+        else await connector.deletePrefix(op.path);
+      }
+    }
+  };
+  return connector;
+}
+function buildConnector(target) {
+  switch (target.connectorId) {
+    case "s3":
+      return createS3Connector(target.settings);
+    case "git-pages":
+      return createGitPagesConnector({ token: "", ...target.settings });
+    case "local-folder":
+      return createFsConnector({ path: target.settings.path });
+    default:
+      throw new CliError("unsupported-storage", `The "${target.connectorId}" storage can't be used from the CLI.`, "Use an S3 bucket, a GitHub / GitLab repo or a local folder.");
+  }
+}
+function adminDir() {
+  return join(distRoot(), "admin");
+}
+function adminFiles() {
+  const root = adminDir();
+  if (!existsSync(join(root, "index.html"))) {
+    throw new CliError("admin-missing", `No admin build at ${root}.`, "Use the npm package (`npx -y @fleox-agent-crm/agentcrm …`), or run `npm run build` in a clone.");
+  }
+  const manifest = join(root, "admin-files.json");
+  if (existsSync(manifest)) {
+    try {
+      const files = JSON.parse(readFileSync(manifest, "utf8")).files;
+      if (Array.isArray(files) && files.every((f) => typeof f === "string")) {
+        return [.../* @__PURE__ */ new Set([...files.filter((f) => f !== "config.js" && f !== "version.json" && existsSync(join(root, f))), "admin-files.json"])];
+      }
+    } catch {
+    }
+  }
+  const walk = (dir) => readdirSync(dir).flatMap((name) => {
+    const abs = join(dir, name);
+    return statSync(abs).isDirectory() ? walk(abs) : [abs];
+  });
+  return walk(root).map((abs) => relative(root, abs).split(sep).join("/")).filter((f) => f !== "config.js" && f !== "version.json" && !f.endsWith(".DS_Store")).sort();
+}
+const putBytes = (path, bytes) => ({ type: "put", path, content: Buffer.from(bytes).toString("base64"), encoding: "base64" });
+function adminOps(folder, runtime) {
+  const root = adminDir();
+  const files = adminFiles();
+  const ordered = [...files.filter((f) => f !== "index.html"), "index.html"];
+  const info = readVersionInfo();
+  const prefix = folder ? `${folder.replace(/^\/+|\/+$/g, "")}/` : "";
+  const ops = ordered.map((f) => putBytes(`${prefix}${f}`, readFileSync(join(root, f))));
+  ops.splice(ops.length - 1, 0, { type: "put", path: `${prefix}version.json`, content: JSON.stringify(info, null, 2) + "\n" });
+  ops.splice(ops.length - 1, 0, { type: "put", path: `${prefix}config.js`, content: buildConfigJsSource(runtime) });
+  return { ops, version: info.version };
+}
+async function applyOps(connector, ops) {
+  if (connector.commitBatch) {
+    await connector.commitBatch(ops);
+    return;
+  }
+  for (const op of ops) {
+    if (op.type === "put") await connector.put(op);
+    else if (op.type === "delete") await connector.delete(op.path);
+    else if (connector.deletePrefix) await connector.deletePrefix(op.path);
+  }
+}
+export {
+  adminDir,
+  adminFiles,
+  adminOps,
+  applyOps,
+  buildConnector
+};