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

package/dist/agent/chunks/s3-Dz50-NuA.mjs

@@ -0,0 +1,903 @@
+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";
+import { g as gitFetch, m as mapLimit, S as StorageError, t as toast, p as performRequest } from "./http-Bk9ICb7I.mjs";
+import { getRuntimeConfig, getGitToken } from "./runtimeConfig-CCOFg1RM.mjs";
+import { d as base64ToBytes, a as base64ToUtf8, u as utf8ToBase64 } from "./encoding-C9MzdP95.mjs";
+const DB_NAME = "agentcrm-git-blobs";
+const STORE = "texts";
+const memory = /* @__PURE__ */ new Map();
+let dbPromise = null;
+function openDb() {
+  if (dbPromise) return dbPromise;
+  dbPromise = new Promise((resolve) => {
+    try {
+      if (typeof indexedDB === "undefined") return resolve(null);
+      const req = indexedDB.open(DB_NAME, 1);
+      req.onupgradeneeded = () => req.result.createObjectStore(STORE);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve(null);
+      req.onblocked = () => resolve(null);
+    } catch {
+      resolve(null);
+    }
+  });
+  return dbPromise;
+}
+async function getCachedTexts(shas) {
+  const out = /* @__PURE__ */ new Map();
+  const missing = [];
+  for (const sha of shas) {
+    const hit = memory.get(sha);
+    if (hit !== void 0) out.set(sha, hit);
+    else missing.push(sha);
+  }
+  if (missing.length === 0) return out;
+  const db = await openDb();
+  if (!db) return out;
+  await new Promise((resolve) => {
+    try {
+      const tx = db.transaction(STORE, "readonly");
+      const store = tx.objectStore(STORE);
+      for (const sha of missing) {
+        const req = store.get(sha);
+        req.onsuccess = () => {
+          if (typeof req.result === "string") {
+            out.set(sha, req.result);
+            memory.set(sha, req.result);
+          }
+        };
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+      tx.onabort = () => resolve();
+    } catch {
+      resolve();
+    }
+  });
+  return out;
+}
+async function putCachedTexts(entries) {
+  for (const [sha, text] of entries) memory.set(sha, text);
+  const db = await openDb();
+  if (!db || entries.size === 0) return;
+  await new Promise((resolve) => {
+    try {
+      const tx = db.transaction(STORE, "readwrite");
+      const store = tx.objectStore(STORE);
+      for (const [sha, text] of entries) store.put(text, sha);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+      tx.onabort = () => resolve();
+    } catch {
+      resolve();
+    }
+  });
+}
+class GitConflictError extends Error {
+  constructor(message, currentHeadSha) {
+    super(message);
+    this.currentHeadSha = currentHeadSha;
+    this.name = "GitConflictError";
+  }
+}
+const TREE_CHUNK = 300;
+const GRAPHQL_BATCH = 50;
+const MAX_REF_RETRIES = 3;
+function createGitHubTransport(cfg) {
+  const api = (cfg.apiBaseUrl || "https://api.github.com").replace(/\/+$/, "");
+  const graphqlUrl = api.endsWith("/api/v3") ? api.replace(/\/api\/v3$/, "/api/graphql") : `${api}/graphql`;
+  const repoUrl = `${api}/repos/${encodeURIComponent(cfg.owner)}/${encodeURIComponent(cfg.repo)}`;
+  const refPath = `heads/${cfg.branch.split("/").map(encodeURIComponent).join("/")}`;
+  const headers = {
+    Authorization: `Bearer ${cfg.token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28"
+  };
+  const jsonHeaders = { ...headers, "Content-Type": "application/json" };
+  async function getJson(url, action = "get") {
+    const res = await gitFetch(action, url, { headers, cache: "no-store" });
+    return await res.json();
+  }
+  async function postJson(url, body, method = "POST") {
+    const res = await gitFetch("commit", url, { method, headers: jsonHeaders, body: JSON.stringify(body) });
+    return await res.json();
+  }
+  async function headSha() {
+    const res = await gitFetch("get", `${repoUrl}/git/ref/${refPath}`, { headers, cache: "no-store" }, [404, 409]);
+    if (!res.ok) return "";
+    const data = await res.json();
+    if (Array.isArray(data)) return "";
+    return data.object?.sha ?? "";
+  }
+  async function treeShaOf(commitSha) {
+    const commit2 = await getJson(`${repoUrl}/git/commits/${commitSha}`);
+    return commit2.tree.sha;
+  }
+  async function walk(treeSha, prefix, out) {
+    const data = await getJson(`${repoUrl}/git/trees/${treeSha}`, "list");
+    for (const item of data.tree) {
+      const path = prefix + item.path;
+      if (item.type === "blob") out.push({ path, sha: item.sha, size: item.size });
+      else if (item.type === "tree") await walk(item.sha, path + "/", out);
+    }
+  }
+  async function listTreeAt(head) {
+    if (!head) return { headSha: "", entries: [] };
+    const treeSha = await treeShaOf(head);
+    const data = await getJson(
+      `${repoUrl}/git/trees/${treeSha}?recursive=1`,
+      "list"
+    );
+    if (!data.truncated) {
+      return {
+        headSha: head,
+        entries: data.tree.filter((t) => t.type === "blob").map((t) => ({ path: t.path, sha: t.sha, size: t.size }))
+      };
+    }
+    const entries = [];
+    await walk(treeSha, "", entries);
+    return { headSha: head, entries };
+  }
+  async function readBlobBase64(sha) {
+    const blob = await getJson(`${repoUrl}/git/blobs/${sha}`);
+    return blob.content;
+  }
+  async function graphqlTexts(shas) {
+    const out = /* @__PURE__ */ new Map();
+    for (let i = 0; i < shas.length; i += GRAPHQL_BATCH) {
+      const batch = shas.slice(i, i + GRAPHQL_BATCH);
+      const fields = batch.map((sha, j) => `b${j}: object(oid: "${sha}") { ... on Blob { text isBinary isTruncated } }`).join("\n");
+      const query = `query($owner: String!, $name: String!) { repository(owner: $owner, name: $name) { ${fields} } }`;
+      try {
+        const res = await fetch(graphqlUrl, {
+          method: "POST",
+          headers: jsonHeaders,
+          body: JSON.stringify({ query, variables: { owner: cfg.owner, name: cfg.repo } })
+        });
+        if (!res.ok) continue;
+        const json = await res.json();
+        const repo = json.data?.repository;
+        if (!repo) continue;
+        batch.forEach((sha, j) => {
+          const blob = repo[`b${j}`];
+          if (blob && !blob.isBinary && !blob.isTruncated && typeof blob.text === "string") {
+            out.set(sha, blob.text);
+          }
+        });
+      } catch {
+      }
+    }
+    return out;
+  }
+  async function readTexts(entries) {
+    const shas = [...new Set(entries.map((e) => e.sha))];
+    const bySha = await getCachedTexts(shas);
+    const missing = shas.filter((sha) => !bySha.has(sha));
+    const fetched = /* @__PURE__ */ new Map();
+    if (missing.length > 0) {
+      const viaGraphql = await graphqlTexts(missing);
+      for (const [sha, text] of viaGraphql) fetched.set(sha, text);
+      const rest = missing.filter((sha) => !fetched.has(sha));
+      await mapLimit(rest, 6, async (sha) => {
+        fetched.set(sha, base64ToUtf8(await readBlobBase64(sha)));
+      });
+      await putCachedTexts(fetched);
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const text = bySha.get(e.sha) ?? fetched.get(e.sha);
+      if (text !== void 0) out.set(e.path, text);
+    }
+    return out;
+  }
+  async function readBytes(entry) {
+    return base64ToBytes(await readBlobBase64(entry.sha));
+  }
+  async function bootstrapBranch(message) {
+    const repo = await getJson(repoUrl);
+    const defaultRes = repo.default_branch ? await gitFetch(
+      "get",
+      `${repoUrl}/git/ref/heads/${encodeURIComponent(repo.default_branch)}`,
+      { headers, cache: "no-store" },
+      [404, 409]
+    ) : null;
+    if (!defaultRes || !defaultRes.ok) {
+      const created = await postJson(
+        `${repoUrl}/contents/.gitkeep`,
+        { message, content: "", branch: cfg.branch },
+        "PUT"
+      );
+      return created.commit.sha;
+    }
+    const tree = await postJson(`${repoUrl}/git/trees`, {
+      tree: [{ path: ".gitkeep", mode: "100644", type: "blob", content: "" }]
+    });
+    const commit2 = await postJson(`${repoUrl}/git/commits`, {
+      message,
+      tree: tree.sha,
+      parents: []
+    });
+    await postJson(`${repoUrl}/git/refs`, { ref: `refs/heads/${cfg.branch}`, sha: commit2.sha });
+    return commit2.sha;
+  }
+  async function commit(changes, opts) {
+    const blobShas = /* @__PURE__ */ new Map();
+    for (let attempt = 0; ; attempt++) {
+      let head = await headSha();
+      if (opts.expectedHeadSha !== void 0 && head !== opts.expectedHeadSha) {
+        throw new GitConflictError(`Branch ${cfg.branch} moved`, head);
+      }
+      if (!head) head = await bootstrapBranch("Initialize branch — AgentCRM");
+      for (const change of changes) {
+        if (change.type === "put" && change.encoding === "base64" && !blobShas.has(change.path)) {
+          const blob = await postJson(`${repoUrl}/git/blobs`, {
+            content: change.content,
+            encoding: "base64"
+          });
+          blobShas.set(change.path, blob.sha);
+        }
+      }
+      const baseTree = await treeShaOf(head);
+      let existing = null;
+      if (changes.some((c) => c.type === "delete")) {
+        existing = new Set((await listTreeAt(head)).entries.map((e) => e.path));
+      }
+      const items = [];
+      for (const change of changes) {
+        if (change.type === "delete") {
+          if (existing?.has(change.path)) {
+            items.push({ path: change.path, mode: "100644", type: "blob", sha: null });
+          }
+        } else if (change.encoding === "base64") {
+          items.push({ path: change.path, mode: "100644", type: "blob", sha: blobShas.get(change.path) });
+        } else {
+          items.push({ path: change.path, mode: "100644", type: "blob", content: change.content });
+        }
+      }
+      let tree = baseTree;
+      for (let i = 0; i < items.length; i += TREE_CHUNK) {
+        const res = await postJson(`${repoUrl}/git/trees`, {
+          base_tree: tree,
+          tree: items.slice(i, i + TREE_CHUNK)
+        });
+        tree = res.sha;
+      }
+      if (tree === baseTree) return head;
+      const created = await postJson(`${repoUrl}/git/commits`, {
+        message: opts.message,
+        tree,
+        parents: [head]
+      });
+      const update = await gitFetch(
+        "commit",
+        `${repoUrl}/git/refs/${refPath}`,
+        { method: "PATCH", headers: jsonHeaders, body: JSON.stringify({ sha: created.sha, force: false }) },
+        [409, 422]
+      );
+      if (update.ok) return created.sha;
+      if (opts.expectedHeadSha !== void 0) {
+        throw new GitConflictError(`Branch ${cfg.branch} moved`, await headSha());
+      }
+      if (attempt >= MAX_REF_RETRIES) {
+        throw new GitConflictError(`Branch ${cfg.branch} kept moving`, await headSha());
+      }
+    }
+  }
+  async function resetBranch(files, opts) {
+    const items = [];
+    for (const f of files) {
+      const blob = await postJson(`${repoUrl}/git/blobs`, { content: f.content, encoding: "base64" });
+      items.push({ path: f.path, mode: "100644", type: "blob", sha: blob.sha });
+    }
+    const tree = await postJson(`${repoUrl}/git/trees`, { tree: items });
+    const created = await postJson(`${repoUrl}/git/commits`, { message: opts.message, tree: tree.sha, parents: [] });
+    const head = await headSha();
+    if (head !== opts.expectedHeadSha) throw new GitConflictError(`Branch ${cfg.branch} moved`, head);
+    await gitFetch("commit", `${repoUrl}/git/refs/${refPath}`, {
+      method: "PATCH",
+      headers: jsonHeaders,
+      body: JSON.stringify({ sha: created.sha, force: true })
+    });
+    return created.sha;
+  }
+  async function permissions() {
+    const [user, repo] = await Promise.all([
+      getJson(`${api}/user`),
+      getJson(repoUrl)
+    ]);
+    const p = repo.permissions ?? {};
+    const visibility = repo.visibility === "public" || repo.visibility === "private" || repo.visibility === "internal" ? repo.visibility : typeof repo.private === "boolean" ? repo.private ? "private" : "public" : void 0;
+    return { login: user.login, canWrite: !!(p.push || p.maintain || p.admin), isAdmin: !!(p.admin || p.maintain), visibility };
+  }
+  return {
+    kind: "github",
+    label: `${cfg.owner}/${cfg.repo}@${cfg.branch}`,
+    headSha,
+    listTree: async () => listTreeAt(await headSha()),
+    readTexts,
+    readBytes,
+    commit,
+    permissions,
+    resetBranch
+  };
+}
+const MAX_RETRIES = 3;
+const WRITE_LEVEL = 30;
+const ADMIN_LEVEL = 40;
+function createGitLabTransport(cfg) {
+  const api = (cfg.apiBaseUrl || "https://gitlab.com/api/v4").replace(/\/+$/, "");
+  const projectUrl = `${api}/projects/${encodeURIComponent(cfg.project)}`;
+  const headers = { Authorization: `Bearer ${cfg.token}` };
+  const jsonHeaders = { ...headers, "Content-Type": "application/json" };
+  const pathsByHead = /* @__PURE__ */ new Map();
+  async function getJson(url, action = "get") {
+    const res = await gitFetch(action, url, { headers, cache: "no-store" });
+    return await res.json();
+  }
+  async function headSha() {
+    const res = await gitFetch(
+      "get",
+      `${projectUrl}/repository/branches/${encodeURIComponent(cfg.branch)}`,
+      { headers, cache: "no-store" },
+      [404]
+    );
+    if (!res.ok) return "";
+    const data = await res.json();
+    return data.commit?.id ?? "";
+  }
+  async function listTreeAt(head) {
+    if (!head) return { headSha: "", entries: [] };
+    const entries = [];
+    for (let page = 1; ; page++) {
+      const url = `${projectUrl}/repository/tree?${new URLSearchParams({
+        ref: head,
+        recursive: "true",
+        per_page: "100",
+        page: String(page)
+      })}`;
+      const res = await gitFetch("list", url, { headers, cache: "no-store" });
+      const items = await res.json();
+      for (const item of items) {
+        if (item.type === "blob") entries.push({ path: item.path, sha: item.id });
+      }
+      const nextPage = res.headers.get("x-next-page");
+      if (!nextPage || items.length === 0) break;
+    }
+    pathsByHead.set(head, new Set(entries.map((e) => e.path)));
+    return { headSha: head, entries };
+  }
+  async function rawBlob(sha) {
+    return gitFetch("get", `${projectUrl}/repository/blobs/${sha}/raw`, { headers });
+  }
+  async function readTexts(entries) {
+    const shas = [...new Set(entries.map((e) => e.sha))];
+    const bySha = await getCachedTexts(shas);
+    const missing = shas.filter((sha) => !bySha.has(sha));
+    const fetched = /* @__PURE__ */ new Map();
+    await mapLimit(missing, 6, async (sha) => {
+      fetched.set(sha, await (await rawBlob(sha)).text());
+    });
+    await putCachedTexts(fetched);
+    const out = /* @__PURE__ */ new Map();
+    for (const e of entries) {
+      const text = bySha.get(e.sha) ?? fetched.get(e.sha);
+      if (text !== void 0) out.set(e.path, text);
+    }
+    return out;
+  }
+  async function readBytes(entry) {
+    return new Uint8Array(await (await rawBlob(entry.sha)).arrayBuffer());
+  }
+  async function existingPaths(head) {
+    if (!head) return /* @__PURE__ */ new Set();
+    return pathsByHead.get(head) ?? new Set((await listTreeAt(head)).entries.map((e) => e.path));
+  }
+  async function defaultBranch() {
+    const project = await getJson(projectUrl);
+    return project.default_branch || void 0;
+  }
+  async function commit(changes, opts) {
+    for (let attempt = 0; ; attempt++) {
+      const head = await headSha();
+      if (opts.expectedHeadSha !== void 0 && head !== opts.expectedHeadSha) {
+        throw new GitConflictError(`Branch ${cfg.branch} moved`, head);
+      }
+      const existing = await existingPaths(head);
+      const actions = [];
+      const after = new Set(existing);
+      for (const change of changes) {
+        if (change.type === "delete") {
+          if (!existing.has(change.path)) continue;
+          actions.push({ action: "delete", file_path: change.path });
+          after.delete(change.path);
+        } else {
+          actions.push({
+            action: existing.has(change.path) ? "update" : "create",
+            file_path: change.path,
+            encoding: "base64",
+            content: change.encoding === "base64" ? change.content : utf8ToBase64(change.content)
+          });
+          after.add(change.path);
+        }
+      }
+      if (actions.length === 0) return head;
+      const body = {
+        branch: cfg.branch,
+        commit_message: opts.message,
+        actions
+      };
+      if (!head) {
+        const base = await defaultBranch();
+        if (base && base !== cfg.branch) body.start_branch = base;
+      }
+      const res = await gitFetch(
+        "commit",
+        `${projectUrl}/repository/commits`,
+        { method: "POST", headers: jsonHeaders, body: JSON.stringify(body) },
+        // 400 = create/update mismatch: someone added / removed a file
+        // since our listing. Refresh and retry.
+        [400]
+      );
+      if (res.ok) {
+        const created = await res.json();
+        pathsByHead.set(created.id, after);
+        return created.id;
+      }
+      pathsByHead.delete(head);
+      if (opts.expectedHeadSha !== void 0 || attempt >= MAX_RETRIES) {
+        throw new GitConflictError(`Commit on ${cfg.branch} rejected: ${await res.text()}`, await headSha());
+      }
+    }
+  }
+  async function permissions() {
+    const [user, project] = await Promise.all([
+      getJson(`${api}/user`),
+      getJson(projectUrl)
+    ]);
+    const level = Math.max(
+      project.permissions?.project_access?.access_level ?? 0,
+      project.permissions?.group_access?.access_level ?? 0
+    );
+    const v = project.visibility;
+    const visibility = v === "public" || v === "private" || v === "internal" ? v : void 0;
+    return { login: user.username, canWrite: level >= WRITE_LEVEL, isAdmin: level >= ADMIN_LEVEL, visibility };
+  }
+  return {
+    kind: "gitlab",
+    label: `${cfg.project}@${cfg.branch}`,
+    headSha,
+    listTree: async () => listTreeAt(await headSha()),
+    readTexts,
+    readBytes,
+    commit,
+    permissions
+  };
+}
+function createRemoteGitTransport(cfg) {
+  return cfg.provider === "github" ? createGitHubTransport(cfg) : createGitLabTransport(cfg);
+}
+function joinRepoPath(dir, path) {
+  const d = dir.replace(/^\/+|\/+$/g, "");
+  const p = path.replace(/^\/+/, "");
+  return d ? `${d}/${p}` : p;
+}
+function gitlabCi(dir, branch) {
+  const copy = dir === "public" ? '    - echo "Publishing public/"' : `    - rm -rf public && cp -r ${dir} public`;
+  return [
+    "# Generated by AgentCRM — publishes the static files with GitLab Pages.",
+    "# Safe to edit: AgentCRM only creates this file when the repo has none.",
+    "pages:",
+    "  stage: deploy",
+    "  script:",
+    copy,
+    "  artifacts:",
+    "    paths:",
+    "      - public",
+    "  rules:",
+    `    - if: $CI_COMMIT_BRANCH == "${branch}"`,
+    ""
+  ].join("\n");
+}
+function resolveGitPagesToken(settings) {
+  if (settings.token) return settings.token;
+  const runtime = getRuntimeConfig();
+  if (runtime?.backend === "git-json" && runtime.git.provider === settings.provider) {
+    return getGitToken(runtime.git) ?? "";
+  }
+  return "";
+}
+const pagesChecks = /* @__PURE__ */ new Map();
+function ensureGithubPages(settings, token, dir) {
+  const key = `${settings.owner}/${settings.repo}`;
+  let check = pagesChecks.get(key);
+  if (!check) {
+    check = enableGithubPages(settings, token, dir, key);
+    pagesChecks.set(key, check);
+  }
+  return check;
+}
+async function enableGithubPages(settings, token, dir, key) {
+  const api = (settings.apiBaseUrl || "https://api.github.com").replace(/\/+$/, "");
+  const url = `${api}/repos/${encodeURIComponent(settings.owner ?? "")}/${encodeURIComponent(settings.repo ?? "")}/pages`;
+  const headers = { Authorization: `Bearer ${token}`, Accept: "application/vnd.github+json" };
+  try {
+    const current = await fetch(url, { headers, cache: "no-store" });
+    if (current.ok) return;
+    const created = await fetch(url, {
+      method: "POST",
+      headers: { ...headers, "Content-Type": "application/json" },
+      body: JSON.stringify({ source: { branch: settings.branch, path: dir === "docs" ? "/docs" : "/" } })
+    });
+    if (created.ok) {
+      toast.success(instance.t("connectors.pages.enabled"));
+      return;
+    }
+  } catch {
+  }
+  toast.info(
+    instance.t("connectors.pages.enableHint", {
+      repo: key,
+      branch: settings.branch,
+      folder: dir === "docs" ? "/docs" : "/ (root)"
+    })
+  );
+}
+function createGitPagesConnector(settings) {
+  const token = resolveGitPagesToken(settings);
+  let dir = String(settings.dir ?? "").replace(/^\/+|\/+$/g, "");
+  if (settings.host === "gitlab-pages" && !dir) dir = "public";
+  const transport = createRemoteGitTransport(
+    settings.provider === "github" ? {
+      provider: "github",
+      owner: settings.owner ?? "",
+      repo: settings.repo ?? "",
+      branch: settings.branch,
+      token,
+      apiBaseUrl: settings.apiBaseUrl
+    } : {
+      provider: "gitlab",
+      project: settings.project ?? "",
+      branch: settings.branch,
+      token,
+      apiBaseUrl: settings.apiBaseUrl
+    }
+  );
+  const siteUrl = (settings.siteUrl ?? "").replace(/\/+$/, "");
+  const repoPath = (path) => joinRepoPath(dir, path);
+  const sitePath = (path) => dir ? path.slice(dir.length + 1) : path;
+  const inSite = (path) => !dir || path.startsWith(dir + "/");
+  let cache = null;
+  async function tree() {
+    const head = await transport.headSha();
+    if (cache && cache.head === head) return cache;
+    const listed = await transport.listTree();
+    cache = { head: listed.headSha, files: new Map(listed.entries.map((e) => [e.path, e])) };
+    return cache;
+  }
+  function hostExtras(files) {
+    if (settings.host === "github-pages") {
+      const marker = repoPath(".nojekyll");
+      return files.has(marker) ? [] : [{ type: "put", path: marker, content: "" }];
+    }
+    if (settings.host === "gitlab-pages") {
+      return files.has(".gitlab-ci.yml") ? [] : [{ type: "put", path: ".gitlab-ci.yml", content: gitlabCi(dir, settings.branch) }];
+    }
+    return [];
+  }
+  async function commitBatch(ops) {
+    const { files } = await tree();
+    const changes = [];
+    let count = 0;
+    for (const op of ops) {
+      if (op.type === "deletePrefix") {
+        const prefix = repoPath(op.path) + "/";
+        for (const path of files.keys()) {
+          if (path.startsWith(prefix)) changes.push({ type: "delete", path });
+        }
+      } else if (op.type === "delete") {
+        if (files.has(repoPath(op.path))) changes.push({ type: "delete", path: repoPath(op.path) });
+      } else {
+        changes.push({ type: "put", path: repoPath(op.path), content: op.content, encoding: op.encoding });
+        count++;
+      }
+    }
+    changes.push(...hostExtras(files));
+    const deleted = changes.filter((c) => c.type === "delete").length;
+    const summary = [count && `${count} updated`, deleted && `${deleted} removed`].filter(Boolean).join(", ");
+    const skipCi = settings.branch === "agentcrm-data" || !settings.host ? " [skip ci]" : "";
+    const verb = settings.host ? "Publish files" : "Update data";
+    await transport.commit(changes, { message: `${verb}${summary ? ` (${summary})` : ""} — AgentCRM${skipCi}` });
+    cache = null;
+    if (settings.host === "github-pages" && settings.provider === "github") {
+      void ensureGithubPages(settings, token, dir);
+    }
+  }
+  return {
+    id: "git-pages",
+    model: "commit",
+    capabilities: {
+      list: true,
+      rename: false,
+      renameFolder: false,
+      folders: false,
+      deletePrefix: true
+    },
+    // Outside a batch every write is its own commit — correct, just noisy.
+    put: (input) => commitBatch([{ type: "put", ...input }]),
+    delete: (path) => commitBatch([{ type: "delete", path }]),
+    deletePrefix: (path) => commitBatch([{ type: "deletePrefix", path }]),
+    commitBatch,
+    async get(path) {
+      const { files } = await tree();
+      const entry = files.get(repoPath(path));
+      if (!entry) throw new StorageError(`File not found: ${path}`, 404);
+      const texts = await transport.readTexts([entry]);
+      const text = texts.get(entry.path);
+      if (text === void 0) throw new StorageError(`File not found: ${path}`, 404);
+      return text;
+    },
+    async getBytes(path) {
+      const { files } = await tree();
+      const entry = files.get(repoPath(path));
+      return entry ? transport.readBytes(entry) : null;
+    },
+    async list(page, perPage) {
+      const { files } = await tree();
+      const all = [...files.values()].filter((e) => inSite(e.path)).map((e) => ({ path: sitePath(e.path), type: "file", size: e.size, url: `${siteUrl}/${sitePath(e.path)}` })).sort((a, b) => a.path < b.path ? -1 : 1);
+      return { items: all.slice((page - 1) * perPage, page * perPage), page, per_page: perPage, total: all.length };
+    },
+    async listPrefix(under) {
+      const { files } = await tree();
+      const want = repoPath(under.replace(/^\/+/, ""));
+      return [...files.keys()].filter((p) => inSite(p) && p.startsWith(want)).map(sitePath).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    },
+    async publicUrl(path) {
+      return `${siteUrl}/${path.replace(/^\/+/, "")}`;
+    }
+  };
+}
+const gitPagesFactory = {
+  id: "git-pages",
+  create: createGitPagesConnector
+};
+const TYPES = {
+  html: "text/html; charset=utf-8",
+  htm: "text/html; charset=utf-8",
+  css: "text/css; charset=utf-8",
+  js: "text/javascript; charset=utf-8",
+  mjs: "text/javascript; charset=utf-8",
+  json: "application/json; charset=utf-8",
+  webmanifest: "application/manifest+json; charset=utf-8",
+  xml: "application/xml; charset=utf-8",
+  xsl: "application/xslt+xml; charset=utf-8",
+  txt: "text/plain; charset=utf-8",
+  md: "text/markdown; charset=utf-8",
+  svg: "image/svg+xml",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  pdf: "application/pdf",
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mp3: "audio/mpeg",
+  zip: "application/zip"
+};
+function contentTypeFor(path) {
+  const ext = path.split(".").pop()?.toLowerCase() ?? "";
+  return TYPES[ext] ?? "application/octet-stream";
+}
+function cacheControlFor(path) {
+  return /\.(html?|json|xml|xsl|txt|css|js|mjs|webmanifest)$/i.test(path) ? "no-cache" : "public, max-age=86400";
+}
+const enc = new TextEncoder();
+function hex(buffer) {
+  return [...new Uint8Array(buffer)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha256Hex(data) {
+  return hex(await crypto.subtle.digest("SHA-256", enc.encode(data)));
+}
+async function hmac(key, data) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return crypto.subtle.sign("HMAC", cryptoKey, enc.encode(data));
+}
+function rfc3986(value) {
+  return encodeURIComponent(value).replace(/[!'()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+}
+function amzDates(date) {
+  const amzDate = date.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  return { amzDate, dateStamp: amzDate.slice(0, 8) };
+}
+async function signRequest(args) {
+  const url = new URL(args.url);
+  const { amzDate, dateStamp } = amzDates(args.date ?? /* @__PURE__ */ new Date());
+  const headers = { ...args.headers, "x-amz-date": amzDate };
+  const signed = { host: url.host };
+  for (const [k, v] of Object.entries(headers)) signed[k.toLowerCase()] = String(v).trim().replace(/\s+/g, " ");
+  const names = Object.keys(signed).sort();
+  const canonicalHeaders = names.map((n) => `${n}:${signed[n]}
+`).join("");
+  const signedHeaders = names.join(";");
+  const query = [...url.searchParams.entries()].map(([k, v]) => [rfc3986(k), rfc3986(v)]).sort(([a, av], [b, bv]) => a < b ? -1 : a > b ? 1 : av < bv ? -1 : av > bv ? 1 : 0).map(([k, v]) => `${k}=${v}`).join("&");
+  const canonicalRequest = [
+    args.method.toUpperCase(),
+    url.pathname || "/",
+    query,
+    canonicalHeaders,
+    signedHeaders,
+    args.payloadHash
+  ].join("\n");
+  const { accessKeyId, secretAccessKey, region, service } = args.credentials;
+  const scope = `${dateStamp}/${region}/${service}/aws4_request`;
+  const stringToSign = ["AWS4-HMAC-SHA256", amzDate, scope, await sha256Hex(canonicalRequest)].join("\n");
+  let key = await hmac(enc.encode(`AWS4${secretAccessKey}`), dateStamp);
+  key = await hmac(key, region);
+  key = await hmac(key, service);
+  key = await hmac(key, "aws4_request");
+  const signature = hex(await hmac(key, stringToSign));
+  return {
+    ...headers,
+    Authorization: `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`
+  };
+}
+const UNSIGNED = "UNSIGNED-PAYLOAD";
+function encodeKey(key) {
+  return key.split("/").map(rfc3986).join("/");
+}
+function decodeXml(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function createS3Connector(settings) {
+  const endpoint = (settings.endpoint || `https://s3.${settings.region}.amazonaws.com`).replace(/\/+$/, "");
+  let endpointUrl;
+  try {
+    endpointUrl = new URL(endpoint);
+  } catch {
+    throw new StorageError(`Invalid S3 endpoint: ${endpoint}`, 400);
+  }
+  const pathStyle = settings.forcePathStyle ?? !endpointUrl.hostname.endsWith("amazonaws.com");
+  const bucketBase = pathStyle ? `${endpoint}/${rfc3986(settings.bucket)}` : `${endpointUrl.protocol}//${settings.bucket}.${endpointUrl.host}`;
+  const prefix = (settings.prefix ?? "").replace(/^\/+|\/+$/g, "");
+  const siteUrl = (settings.siteUrl ?? "").replace(/\/+$/, "");
+  const credentials = {
+    accessKeyId: settings.accessKeyId,
+    secretAccessKey: settings.secretAccessKey,
+    region: settings.region || "us-east-1",
+    service: "s3"
+  };
+  const keyFor = (path) => prefix ? `${prefix}/${path.replace(/^\/+/, "")}` : path.replace(/^\/+/, "");
+  const pathFor = (key) => prefix ? key.slice(prefix.length + 1) : key;
+  async function send(action, method, url, init = {}) {
+    const headers = await signRequest({
+      method,
+      url,
+      headers: { "x-amz-content-sha256": UNSIGNED, ...init.headers ?? {} },
+      payloadHash: UNSIGNED,
+      credentials
+    });
+    return performRequest(
+      action,
+      () => fetch(url, { method, headers, body: init.body, signal: init.signal, cache: init.cache })
+    );
+  }
+  async function listKeys(under) {
+    const out = [];
+    let token;
+    do {
+      const params = new URLSearchParams({ "list-type": "2", "max-keys": "1000" });
+      if (under) params.set("prefix", under);
+      if (token) params.set("continuation-token", token);
+      const res = await send("list", "GET", `${bucketBase}/?${params}`, { cache: "no-store" });
+      const xml = await res.text();
+      for (const block of xml.match(/<Contents>[\s\S]*?<\/Contents>/g) ?? []) {
+        const key = block.match(/<Key>([\s\S]*?)<\/Key>/)?.[1];
+        const size = Number(block.match(/<Size>(\d+)<\/Size>/)?.[1] ?? 0);
+        if (key) out.push({ key: decodeXml(key), size });
+      }
+      const truncated = /<IsTruncated>true<\/IsTruncated>/.test(xml);
+      token = truncated ? decodeXml(xml.match(/<NextContinuationToken>([\s\S]*?)<\/NextContinuationToken>/)?.[1] ?? "") : void 0;
+    } while (token);
+    return out;
+  }
+  async function deleteKey(key, signal) {
+    try {
+      await send("delete", "DELETE", `${bucketBase}/${encodeKey(key)}`, { signal });
+    } catch (err) {
+      if (err instanceof StorageError && err.status === 404) return;
+      throw err;
+    }
+  }
+  return {
+    id: "s3",
+    model: "files",
+    capabilities: {
+      list: true,
+      rename: false,
+      renameFolder: false,
+      folders: false,
+      deletePrefix: true
+    },
+    async put(input, signal) {
+      const body = input.encoding === "base64" ? base64ToBytes(input.content) : input.content;
+      await send("upload", "PUT", `${bucketBase}/${encodeKey(keyFor(input.path))}`, {
+        headers: {
+          "content-type": contentTypeFor(input.path),
+          "cache-control": cacheControlFor(input.path),
+          ...settings.publicRead ? { "x-amz-acl": "public-read" } : {}
+        },
+        body,
+        signal
+      });
+    },
+    async get(path) {
+      const res = await send("get", "GET", `${bucketBase}/${encodeKey(keyFor(path))}`, { cache: "no-store" });
+      return res.text();
+    },
+    async getBytes(path) {
+      const url = `${bucketBase}/${encodeKey(keyFor(path))}`;
+      const headers = await signRequest({
+        method: "GET",
+        url,
+        headers: { "x-amz-content-sha256": UNSIGNED },
+        payloadHash: UNSIGNED,
+        credentials
+      });
+      const res = await fetch(url, { headers, cache: "no-store" }).catch(
+        (err) => performRequest("get", () => Promise.reject(err))
+      );
+      if (res.status === 404 || res.status === 403) {
+        return null;
+      }
+      const ok = res.ok ? res : await performRequest("get", async () => res);
+      return new Uint8Array(await ok.arrayBuffer());
+    },
+    delete: (path, signal) => deleteKey(keyFor(path), signal),
+    async deletePrefix(path) {
+      const keys = await listKeys(keyFor(path).replace(/\/+$/, "") + "/");
+      await mapLimit(keys, 6, (k) => deleteKey(k.key));
+    },
+    async list(page, perPage) {
+      const all = (await listKeys(prefix ? `${prefix}/` : "")).map((k) => ({ path: pathFor(k.key), type: "file", size: k.size, url: `${siteUrl}/${pathFor(k.key)}` }));
+      return { items: all.slice((page - 1) * perPage, page * perPage), page, per_page: perPage, total: all.length };
+    },
+    async listPrefix(under) {
+      const clean = under.replace(/^\/+/, "");
+      return (await listKeys(keyFor(clean))).map((k) => pathFor(k.key)).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    },
+    async publicUrl(path) {
+      return `${siteUrl}/${path.replace(/^\/+/, "")}`;
+    }
+  };
+}
+const s3Factory = {
+  id: "s3",
+  create: createS3Connector
+};
+export {
+  GitConflictError as G,
+  createGitPagesConnector as a,
+  createS3Connector as b,
+  createRemoteGitTransport as c,
+  gitPagesFactory as g,
+  joinRepoPath as j,
+  resolveGitPagesToken as r,
+  s3Factory as s
+};