zen-fs-config 0.1.2 → 0.2.0

package/dist/index.js

@@ -316,59 +316,385 @@ function hasBackend(type) {
 function listBackends() {
   return Array.from(registry.keys());
 }
-function syncToAsync(backend) {
-  return {
-    readFile(path, ...args) {
-      const result = backend.readFile(path, ...args);
-      return Promise.resolve(result);
+var inMemoryCounter = 0;
+registerBackend("InMemory", async (options) => {
+  const zenfs = await import("@zenfs/core");
+  const { InMemory } = zenfs;
+  const maxSize = options.maxSize ?? 100 * 1024 * 1024;
+  const label = options.label ?? `zen-fs-config-${++inMemoryCounter}`;
+  await zenfs.configureSingle({ backend: InMemory, maxSize, label });
+  const pfs = zenfs.fs.promises;
+  const backend = {
+    async readFile(path, ...args) {
+      if (args.length > 0) {
+        return pfs.readFile(path, ...args);
+      }
+      return pfs.readFile(path);
     },
-    writeFile(path, data, options) {
-      backend.writeFile(path, data, options);
-      return Promise.resolve();
+    async writeFile(path, data, options2) {
+      return pfs.writeFile(path, data, options2);
     },
-    readdir(path) {
-      const entries = backend.readdir(path);
-      return Promise.resolve(entries.map((e) => typeof e === "string" ? e : e.name));
+    async readdir(path) {
+      const entries = await pfs.readdir(path);
+      return entries.map((e) => typeof e === "string" ? e : e.name);
     },
-    stat(path, ...args) {
-      return Promise.resolve(backend.stat(path, ...args));
+    async stat(path, ...args) {
+      return pfs.stat(path, ...args);
     },
-    exists(path) {
+    async exists(path) {
       try {
-        backend.stat(path);
-        return Promise.resolve(true);
+        await pfs.stat(path);
+        return true;
       } catch {
-        return Promise.resolve(false);
+        return false;
       }
     },
-    mkdir(path, options) {
-      backend.mkdir(path, options);
-      return Promise.resolve();
+    async mkdir(path, options2) {
+      return pfs.mkdir(path, options2);
+    },
+    async unlink(path) {
+      return pfs.unlink(path);
+    },
+    async rmdir(path) {
+      return pfs.rmdir(path);
+    },
+    async rename(oldPath, newPath) {
+      return pfs.rename(oldPath, newPath);
+    }
+  };
+  return backend;
+});
+registerBackend("GitHub", async (options) => {
+  const token = options.token ?? "";
+  const owner = options.owner ?? "";
+  const repo = options.repo ?? "";
+  const branch = options.branch ?? "main";
+  const baseUrl = options.baseUrl ?? "https://api.github.com";
+  if (!owner || !repo) throw new Error('GitHub backend requires "owner" and "repo" options');
+  const headers = {
+    "Accept": "application/vnd.github.v3+json",
+    "User-Agent": "zen-fs-config"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  const apiUrl = (path) => {
+    const p = path.startsWith("/") ? path.slice(1) : path;
+    return `${baseUrl}/repos/${owner}/${repo}/contents/${p}?ref=${branch}`;
+  };
+  const treeUrl = () => `${baseUrl}/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+  const ghStat = (item) => ({
+    isFile: () => item.type === "file",
+    isDirectory: () => item.type === "dir",
+    size: item.size ?? 0
+  });
+  const fetchJson = async (url) => {
+    const res = await fetch(url, { headers });
+    if (!res.ok) throw new Error(`GitHub API ${res.status}: ${url}`);
+    return res.json();
+  };
+  const backend = {
+    async readFile(path, ...args) {
+      const data = await fetchJson(apiUrl(path));
+      if (data.encoding === "base64") {
+        const raw = Uint8Array.from(atob(data.content), (c) => c.charCodeAt(0));
+        if (args[0] === "utf-8") return new TextDecoder().decode(raw);
+        return raw;
+      }
+      return data;
+    },
+    async writeFile(path, data, options2) {
+      const message = options2?.message || `Update ${path}`;
+      const content = typeof data === "string" ? btoa(unescape(encodeURIComponent(data))) : btoa(String.fromCharCode(...new Uint8Array(data)));
+      const sha = await (async () => {
+        try {
+          const d = await fetchJson(apiUrl(path));
+          return d.sha;
+        } catch {
+          return void 0;
+        }
+      })();
+      await fetch(apiUrl(path), {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ message, content, sha, branch })
+      });
+    },
+    async readdir(path) {
+      const data = await fetchJson(apiUrl(path));
+      return data.map((item) => item.name);
     },
-    unlink(path) {
-      backend.unlink(path);
-      return Promise.resolve();
+    async stat(path, ...args) {
+      try {
+        const data = await fetchJson(apiUrl(path));
+        if (Array.isArray(data)) {
+          return { isFile: () => false, isDirectory: () => true, size: 0 };
+        }
+        return ghStat(data);
+      } catch {
+        throw new Error(`ENOENT: ${path}`);
+      }
     },
-    rmdir(path) {
-      if (typeof backend.rmdir === "function") {
-        backend.rmdir(path);
+    async exists(path) {
+      try {
+        await fetchJson(apiUrl(path));
+        return true;
+      } catch {
+        return false;
       }
-      return Promise.resolve();
     },
-    rename(oldPath, newPath) {
-      if (typeof backend.rename === "function") {
-        backend.rename(oldPath, newPath);
+    async mkdir(path, options2) {
+      const dirPath = path.replace(/\/$/, "");
+      const keepPath = `${dirPath}/.gitkeep`;
+      const message = options2?.message || `Create directory ${dirPath}`;
+      const content = btoa("");
+      await fetch(apiUrl(keepPath), {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ message, content, branch })
+      });
+    },
+    async unlink(path) {
+      const data = await fetchJson(apiUrl(path));
+      await fetch(apiUrl(path), {
+        method: "DELETE",
+        headers,
+        body: JSON.stringify({ message: `Delete ${path}`, sha: data.sha, branch })
+      });
+    },
+    async rmdir(path) {
+      const items = await fetchJson(apiUrl(path));
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          const itemPath = `${path}/${item.name}`;
+          if (item.type === "dir") {
+            await backend.rmdir(itemPath);
+          } else {
+            await backend.unlink(itemPath);
+          }
+        }
       }
-      return Promise.resolve();
+    },
+    async rename(oldPath, newPath) {
+      const content = await backend.readFile(oldPath);
+      await backend.writeFile(newPath, content);
+      await backend.unlink(oldPath);
     }
   };
-}
-registerBackend("InMemory", async (options) => {
-  const { InMemory } = await import("@zenfs/core");
-  const maxSize = options.maxSize ?? 100 * 1024 * 1024;
-  const label = options.label ?? "zen-fs-config";
-  const fs = InMemory.create({ maxSize, label });
-  return syncToAsync(fs);
+  return backend;
+});
+registerBackend("Gitee", async (options) => {
+  const token = options.token ?? "";
+  const owner = options.owner ?? "";
+  const repo = options.repo ?? "";
+  const branch = options.branch ?? "master";
+  const baseUrl = options.baseUrl ?? "https://gitee.com/api/v5";
+  if (!owner || !repo) throw new Error('Gitee backend requires "owner" and "repo" options');
+  const fetchJson = async (url) => {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Gitee API ${res.status}: ${url}`);
+    return res.json();
+  };
+  const apiUrl = (path) => {
+    const p = path.startsWith("/") ? path.slice(1) : path;
+    const params = new URLSearchParams({ access_token: token, ref: branch, path: p });
+    return `${baseUrl}/repos/${owner}/${repo}/contents?${params}`;
+  };
+  const ghStat = (item) => ({
+    isFile: () => item.type === "file",
+    isDirectory: () => item.type === "dir",
+    size: item.size ?? 0
+  });
+  const backend = {
+    async readFile(path, ...args) {
+      const data = await fetchJson(apiUrl(path));
+      if (data.content) {
+        const raw = Uint8Array.from(atob(data.content), (c) => c.charCodeAt(0));
+        if (args[0] === "utf-8") return new TextDecoder().decode(raw);
+        return raw;
+      }
+      return data;
+    },
+    async writeFile(path, data, options2) {
+      const message = options2?.message || `Update ${path}`;
+      const content = typeof data === "string" ? btoa(unescape(encodeURIComponent(data))) : btoa(String.fromCharCode(...new Uint8Array(data)));
+      const sha = await (async () => {
+        try {
+          const d = await fetchJson(apiUrl(path));
+          return d.sha;
+        } catch {
+          return void 0;
+        }
+      })();
+      await fetch(apiUrl(path), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message, content, sha, branch })
+      });
+    },
+    async readdir(path) {
+      const data = await fetchJson(apiUrl(path));
+      return Array.isArray(data) ? data.map((i) => i.name) : [];
+    },
+    async stat(path) {
+      try {
+        const data = await fetchJson(apiUrl(path));
+        if (Array.isArray(data)) return ghStat({ type: "dir", size: 0 });
+        return ghStat(data);
+      } catch {
+        throw new Error(`ENOENT: ${path}`);
+      }
+    },
+    async exists(path) {
+      try {
+        await fetchJson(apiUrl(path));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async mkdir(path, options2) {
+      const dirPath = path.replace(/\/$/, "");
+      const keepPath = `${dirPath}/.gitkeep`;
+      const message = options2?.message || `Create directory ${dirPath}`;
+      await fetch(apiUrl(keepPath), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message, content: btoa(""), branch })
+      });
+    },
+    async unlink(path) {
+      const data = await fetchJson(apiUrl(path));
+      await fetch(apiUrl(path), {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message: `Delete ${path}`, sha: data.sha, branch })
+      });
+    },
+    async rmdir(path) {
+      const items = await fetchJson(apiUrl(path));
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          const itemPath = `${path}/${item.name}`;
+          if (item.type === "dir") await backend.rmdir(itemPath);
+          else await backend.unlink(itemPath);
+        }
+      }
+    },
+    async rename(oldPath, newPath) {
+      const content = await backend.readFile(oldPath);
+      await backend.writeFile(newPath, content);
+      await backend.unlink(oldPath);
+    }
+  };
+  return backend;
+});
+registerBackend("WebDAV", async (options) => {
+  const url = options.url ?? "";
+  const username = options.username ?? "";
+  const password = options.password ?? "";
+  const rootPath = options.rootPath ?? "/";
+  if (!url) throw new Error('WebDAV backend requires "url" option');
+  const authHeader = username ? `Basic ${btoa(`${username}:${password}`)}` : "";
+  const davUrl = (path) => {
+    const cleanRoot = rootPath.replace(/\/$/, "");
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    return `${url.replace(/\/$/, "")}${cleanRoot}${cleanPath}`;
+  };
+  const davFetch = async (path, method, body) => {
+    const headers = {};
+    if (authHeader) headers["Authorization"] = authHeader;
+    if (body) headers["Content-Type"] = "application/xml";
+    const res = await fetch(davUrl(path), { method, headers, body });
+    if (!res.ok && res.status !== 404) throw new Error(`WebDAV ${res.status} ${method} ${davUrl(path)}`);
+    return res;
+  };
+  const parseMultiStatus = async (res) => {
+    const text = await res.text();
+    const results = [];
+    const responses = text.match(/<D:response[^>]*>[\s\S]*?<\/D:response>/gi) || [];
+    for (const resp of responses) {
+      const href = (resp.match(/<D:href>([^<]+)<\/D:href>/i) || [])[1] || "";
+      const isDir = /<D:collection\s*\/>/i.test(resp) || /<D:resourcetype>.*<D:collection/.test(resp);
+      const sizeMatch = resp.match(/<D:getcontentlength>([^<]+)<\/D:getcontentlength>/i);
+      const size = sizeMatch ? parseInt(sizeMatch[1]) : 0;
+      const decoded = decodeURIComponent(href);
+      results.push({ path: decoded, isDir, size });
+    }
+    return results;
+  };
+  const exists = async (path) => {
+    const res = await davFetch(path, "PROPFIND");
+    return res.ok;
+  };
+  const backend = {
+    async readFile(path, ...args) {
+      const res = await davFetch(path, "GET");
+      if (!res.ok) throw new Error(`ENOENT: ${path}`);
+      if (args[0] === "utf-8") return res.text();
+      const buf = await res.arrayBuffer();
+      return new Uint8Array(buf);
+    },
+    async writeFile(path, data, _options) {
+      const headers = { "Content-Type": "application/octet-stream" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      await fetch(davUrl(path), {
+        method: "PUT",
+        headers,
+        body: data instanceof ArrayBuffer ? data : data instanceof Uint8Array ? new Uint8Array(data).buffer : new TextEncoder().encode(data)
+      });
+    },
+    async readdir(path) {
+      const headers = { Depth: "1" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+      if (!res.ok) throw new Error(`WebDAV PROPFIND failed: ${res.status}`);
+      const items = await parseMultiStatus(res);
+      const prefix = davUrl(path);
+      return items.filter((i) => i.path !== prefix && i.path !== `${prefix}/`).map((i) => i.path.split("/").filter(Boolean).pop() || "");
+    },
+    async stat(path) {
+      const headers = { Depth: "0" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+      if (!res.ok) throw new Error(`ENOENT: ${path}`);
+      const items = await parseMultiStatus(res);
+      const item = items[0];
+      return { isFile: () => !item.isDir, isDirectory: () => item.isDir, size: item.size };
+    },
+    async exists(path) {
+      return exists(path);
+    },
+    async mkdir(path) {
+      const headers = {};
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "MKCOL", headers });
+      if (!res.ok && res.status !== 405) throw new Error(`WebDAV MKCOL failed: ${res.status}`);
+    },
+    async unlink(path) {
+      await davFetch(path, "DELETE");
+    },
+    async rmdir(path) {
+      const items = await (async () => {
+        const headers = { Depth: "1" };
+        if (authHeader) headers["Authorization"] = authHeader;
+        const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+        if (!res.ok) return [];
+        const parsed = await parseMultiStatus(res);
+        const prefix = davUrl(path);
+        return parsed.filter((i) => i.path !== prefix && i.path !== `${prefix}/`);
+      })();
+      for (const item of items) {
+        if (item.isDir) await backend.rmdir(item.path);
+        else await backend.unlink(item.path);
+      }
+      await davFetch(path, "DELETE");
+    },
+    async rename(oldPath, newPath) {
+      const headers = { Destination: davUrl(newPath) };
+      if (authHeader) headers["Authorization"] = authHeader;
+      await fetch(davUrl(oldPath), { method: "MOVE", headers });
+    }
+  };
+  return backend;
 });
 
 // src/version.ts

package/dist/index.mjs

@@ -269,59 +269,385 @@ function hasBackend(type) {
 function listBackends() {
   return Array.from(registry.keys());
 }
-function syncToAsync(backend) {
-  return {
-    readFile(path, ...args) {
-      const result = backend.readFile(path, ...args);
-      return Promise.resolve(result);
+var inMemoryCounter = 0;
+registerBackend("InMemory", async (options) => {
+  const zenfs = await import("@zenfs/core");
+  const { InMemory } = zenfs;
+  const maxSize = options.maxSize ?? 100 * 1024 * 1024;
+  const label = options.label ?? `zen-fs-config-${++inMemoryCounter}`;
+  await zenfs.configureSingle({ backend: InMemory, maxSize, label });
+  const pfs = zenfs.fs.promises;
+  const backend = {
+    async readFile(path, ...args) {
+      if (args.length > 0) {
+        return pfs.readFile(path, ...args);
+      }
+      return pfs.readFile(path);
     },
-    writeFile(path, data, options) {
-      backend.writeFile(path, data, options);
-      return Promise.resolve();
+    async writeFile(path, data, options2) {
+      return pfs.writeFile(path, data, options2);
     },
-    readdir(path) {
-      const entries = backend.readdir(path);
-      return Promise.resolve(entries.map((e) => typeof e === "string" ? e : e.name));
+    async readdir(path) {
+      const entries = await pfs.readdir(path);
+      return entries.map((e) => typeof e === "string" ? e : e.name);
     },
-    stat(path, ...args) {
-      return Promise.resolve(backend.stat(path, ...args));
+    async stat(path, ...args) {
+      return pfs.stat(path, ...args);
     },
-    exists(path) {
+    async exists(path) {
       try {
-        backend.stat(path);
-        return Promise.resolve(true);
+        await pfs.stat(path);
+        return true;
       } catch {
-        return Promise.resolve(false);
+        return false;
       }
     },
-    mkdir(path, options) {
-      backend.mkdir(path, options);
-      return Promise.resolve();
+    async mkdir(path, options2) {
+      return pfs.mkdir(path, options2);
+    },
+    async unlink(path) {
+      return pfs.unlink(path);
+    },
+    async rmdir(path) {
+      return pfs.rmdir(path);
+    },
+    async rename(oldPath, newPath) {
+      return pfs.rename(oldPath, newPath);
+    }
+  };
+  return backend;
+});
+registerBackend("GitHub", async (options) => {
+  const token = options.token ?? "";
+  const owner = options.owner ?? "";
+  const repo = options.repo ?? "";
+  const branch = options.branch ?? "main";
+  const baseUrl = options.baseUrl ?? "https://api.github.com";
+  if (!owner || !repo) throw new Error('GitHub backend requires "owner" and "repo" options');
+  const headers = {
+    "Accept": "application/vnd.github.v3+json",
+    "User-Agent": "zen-fs-config"
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  const apiUrl = (path) => {
+    const p = path.startsWith("/") ? path.slice(1) : path;
+    return `${baseUrl}/repos/${owner}/${repo}/contents/${p}?ref=${branch}`;
+  };
+  const treeUrl = () => `${baseUrl}/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+  const ghStat = (item) => ({
+    isFile: () => item.type === "file",
+    isDirectory: () => item.type === "dir",
+    size: item.size ?? 0
+  });
+  const fetchJson = async (url) => {
+    const res = await fetch(url, { headers });
+    if (!res.ok) throw new Error(`GitHub API ${res.status}: ${url}`);
+    return res.json();
+  };
+  const backend = {
+    async readFile(path, ...args) {
+      const data = await fetchJson(apiUrl(path));
+      if (data.encoding === "base64") {
+        const raw = Uint8Array.from(atob(data.content), (c) => c.charCodeAt(0));
+        if (args[0] === "utf-8") return new TextDecoder().decode(raw);
+        return raw;
+      }
+      return data;
+    },
+    async writeFile(path, data, options2) {
+      const message = options2?.message || `Update ${path}`;
+      const content = typeof data === "string" ? btoa(unescape(encodeURIComponent(data))) : btoa(String.fromCharCode(...new Uint8Array(data)));
+      const sha = await (async () => {
+        try {
+          const d = await fetchJson(apiUrl(path));
+          return d.sha;
+        } catch {
+          return void 0;
+        }
+      })();
+      await fetch(apiUrl(path), {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ message, content, sha, branch })
+      });
+    },
+    async readdir(path) {
+      const data = await fetchJson(apiUrl(path));
+      return data.map((item) => item.name);
     },
-    unlink(path) {
-      backend.unlink(path);
-      return Promise.resolve();
+    async stat(path, ...args) {
+      try {
+        const data = await fetchJson(apiUrl(path));
+        if (Array.isArray(data)) {
+          return { isFile: () => false, isDirectory: () => true, size: 0 };
+        }
+        return ghStat(data);
+      } catch {
+        throw new Error(`ENOENT: ${path}`);
+      }
     },
-    rmdir(path) {
-      if (typeof backend.rmdir === "function") {
-        backend.rmdir(path);
+    async exists(path) {
+      try {
+        await fetchJson(apiUrl(path));
+        return true;
+      } catch {
+        return false;
       }
-      return Promise.resolve();
     },
-    rename(oldPath, newPath) {
-      if (typeof backend.rename === "function") {
-        backend.rename(oldPath, newPath);
+    async mkdir(path, options2) {
+      const dirPath = path.replace(/\/$/, "");
+      const keepPath = `${dirPath}/.gitkeep`;
+      const message = options2?.message || `Create directory ${dirPath}`;
+      const content = btoa("");
+      await fetch(apiUrl(keepPath), {
+        method: "PUT",
+        headers,
+        body: JSON.stringify({ message, content, branch })
+      });
+    },
+    async unlink(path) {
+      const data = await fetchJson(apiUrl(path));
+      await fetch(apiUrl(path), {
+        method: "DELETE",
+        headers,
+        body: JSON.stringify({ message: `Delete ${path}`, sha: data.sha, branch })
+      });
+    },
+    async rmdir(path) {
+      const items = await fetchJson(apiUrl(path));
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          const itemPath = `${path}/${item.name}`;
+          if (item.type === "dir") {
+            await backend.rmdir(itemPath);
+          } else {
+            await backend.unlink(itemPath);
+          }
+        }
       }
-      return Promise.resolve();
+    },
+    async rename(oldPath, newPath) {
+      const content = await backend.readFile(oldPath);
+      await backend.writeFile(newPath, content);
+      await backend.unlink(oldPath);
     }
   };
-}
-registerBackend("InMemory", async (options) => {
-  const { InMemory } = await import("@zenfs/core");
-  const maxSize = options.maxSize ?? 100 * 1024 * 1024;
-  const label = options.label ?? "zen-fs-config";
-  const fs = InMemory.create({ maxSize, label });
-  return syncToAsync(fs);
+  return backend;
+});
+registerBackend("Gitee", async (options) => {
+  const token = options.token ?? "";
+  const owner = options.owner ?? "";
+  const repo = options.repo ?? "";
+  const branch = options.branch ?? "master";
+  const baseUrl = options.baseUrl ?? "https://gitee.com/api/v5";
+  if (!owner || !repo) throw new Error('Gitee backend requires "owner" and "repo" options');
+  const fetchJson = async (url) => {
+    const res = await fetch(url);
+    if (!res.ok) throw new Error(`Gitee API ${res.status}: ${url}`);
+    return res.json();
+  };
+  const apiUrl = (path) => {
+    const p = path.startsWith("/") ? path.slice(1) : path;
+    const params = new URLSearchParams({ access_token: token, ref: branch, path: p });
+    return `${baseUrl}/repos/${owner}/${repo}/contents?${params}`;
+  };
+  const ghStat = (item) => ({
+    isFile: () => item.type === "file",
+    isDirectory: () => item.type === "dir",
+    size: item.size ?? 0
+  });
+  const backend = {
+    async readFile(path, ...args) {
+      const data = await fetchJson(apiUrl(path));
+      if (data.content) {
+        const raw = Uint8Array.from(atob(data.content), (c) => c.charCodeAt(0));
+        if (args[0] === "utf-8") return new TextDecoder().decode(raw);
+        return raw;
+      }
+      return data;
+    },
+    async writeFile(path, data, options2) {
+      const message = options2?.message || `Update ${path}`;
+      const content = typeof data === "string" ? btoa(unescape(encodeURIComponent(data))) : btoa(String.fromCharCode(...new Uint8Array(data)));
+      const sha = await (async () => {
+        try {
+          const d = await fetchJson(apiUrl(path));
+          return d.sha;
+        } catch {
+          return void 0;
+        }
+      })();
+      await fetch(apiUrl(path), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message, content, sha, branch })
+      });
+    },
+    async readdir(path) {
+      const data = await fetchJson(apiUrl(path));
+      return Array.isArray(data) ? data.map((i) => i.name) : [];
+    },
+    async stat(path) {
+      try {
+        const data = await fetchJson(apiUrl(path));
+        if (Array.isArray(data)) return ghStat({ type: "dir", size: 0 });
+        return ghStat(data);
+      } catch {
+        throw new Error(`ENOENT: ${path}`);
+      }
+    },
+    async exists(path) {
+      try {
+        await fetchJson(apiUrl(path));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    async mkdir(path, options2) {
+      const dirPath = path.replace(/\/$/, "");
+      const keepPath = `${dirPath}/.gitkeep`;
+      const message = options2?.message || `Create directory ${dirPath}`;
+      await fetch(apiUrl(keepPath), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message, content: btoa(""), branch })
+      });
+    },
+    async unlink(path) {
+      const data = await fetchJson(apiUrl(path));
+      await fetch(apiUrl(path), {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ access_token: token, message: `Delete ${path}`, sha: data.sha, branch })
+      });
+    },
+    async rmdir(path) {
+      const items = await fetchJson(apiUrl(path));
+      if (Array.isArray(items)) {
+        for (const item of items) {
+          const itemPath = `${path}/${item.name}`;
+          if (item.type === "dir") await backend.rmdir(itemPath);
+          else await backend.unlink(itemPath);
+        }
+      }
+    },
+    async rename(oldPath, newPath) {
+      const content = await backend.readFile(oldPath);
+      await backend.writeFile(newPath, content);
+      await backend.unlink(oldPath);
+    }
+  };
+  return backend;
+});
+registerBackend("WebDAV", async (options) => {
+  const url = options.url ?? "";
+  const username = options.username ?? "";
+  const password = options.password ?? "";
+  const rootPath = options.rootPath ?? "/";
+  if (!url) throw new Error('WebDAV backend requires "url" option');
+  const authHeader = username ? `Basic ${btoa(`${username}:${password}`)}` : "";
+  const davUrl = (path) => {
+    const cleanRoot = rootPath.replace(/\/$/, "");
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    return `${url.replace(/\/$/, "")}${cleanRoot}${cleanPath}`;
+  };
+  const davFetch = async (path, method, body) => {
+    const headers = {};
+    if (authHeader) headers["Authorization"] = authHeader;
+    if (body) headers["Content-Type"] = "application/xml";
+    const res = await fetch(davUrl(path), { method, headers, body });
+    if (!res.ok && res.status !== 404) throw new Error(`WebDAV ${res.status} ${method} ${davUrl(path)}`);
+    return res;
+  };
+  const parseMultiStatus = async (res) => {
+    const text = await res.text();
+    const results = [];
+    const responses = text.match(/<D:response[^>]*>[\s\S]*?<\/D:response>/gi) || [];
+    for (const resp of responses) {
+      const href = (resp.match(/<D:href>([^<]+)<\/D:href>/i) || [])[1] || "";
+      const isDir = /<D:collection\s*\/>/i.test(resp) || /<D:resourcetype>.*<D:collection/.test(resp);
+      const sizeMatch = resp.match(/<D:getcontentlength>([^<]+)<\/D:getcontentlength>/i);
+      const size = sizeMatch ? parseInt(sizeMatch[1]) : 0;
+      const decoded = decodeURIComponent(href);
+      results.push({ path: decoded, isDir, size });
+    }
+    return results;
+  };
+  const exists = async (path) => {
+    const res = await davFetch(path, "PROPFIND");
+    return res.ok;
+  };
+  const backend = {
+    async readFile(path, ...args) {
+      const res = await davFetch(path, "GET");
+      if (!res.ok) throw new Error(`ENOENT: ${path}`);
+      if (args[0] === "utf-8") return res.text();
+      const buf = await res.arrayBuffer();
+      return new Uint8Array(buf);
+    },
+    async writeFile(path, data, _options) {
+      const headers = { "Content-Type": "application/octet-stream" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      await fetch(davUrl(path), {
+        method: "PUT",
+        headers,
+        body: data instanceof ArrayBuffer ? data : data instanceof Uint8Array ? new Uint8Array(data).buffer : new TextEncoder().encode(data)
+      });
+    },
+    async readdir(path) {
+      const headers = { Depth: "1" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+      if (!res.ok) throw new Error(`WebDAV PROPFIND failed: ${res.status}`);
+      const items = await parseMultiStatus(res);
+      const prefix = davUrl(path);
+      return items.filter((i) => i.path !== prefix && i.path !== `${prefix}/`).map((i) => i.path.split("/").filter(Boolean).pop() || "");
+    },
+    async stat(path) {
+      const headers = { Depth: "0" };
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+      if (!res.ok) throw new Error(`ENOENT: ${path}`);
+      const items = await parseMultiStatus(res);
+      const item = items[0];
+      return { isFile: () => !item.isDir, isDirectory: () => item.isDir, size: item.size };
+    },
+    async exists(path) {
+      return exists(path);
+    },
+    async mkdir(path) {
+      const headers = {};
+      if (authHeader) headers["Authorization"] = authHeader;
+      const res = await fetch(davUrl(path), { method: "MKCOL", headers });
+      if (!res.ok && res.status !== 405) throw new Error(`WebDAV MKCOL failed: ${res.status}`);
+    },
+    async unlink(path) {
+      await davFetch(path, "DELETE");
+    },
+    async rmdir(path) {
+      const items = await (async () => {
+        const headers = { Depth: "1" };
+        if (authHeader) headers["Authorization"] = authHeader;
+        const res = await fetch(davUrl(path), { method: "PROPFIND", headers });
+        if (!res.ok) return [];
+        const parsed = await parseMultiStatus(res);
+        const prefix = davUrl(path);
+        return parsed.filter((i) => i.path !== prefix && i.path !== `${prefix}/`);
+      })();
+      for (const item of items) {
+        if (item.isDir) await backend.rmdir(item.path);
+        else await backend.unlink(item.path);
+      }
+      await davFetch(path, "DELETE");
+    },
+    async rename(oldPath, newPath) {
+      const headers = { Destination: davUrl(newPath) };
+      if (authHeader) headers["Authorization"] = authHeader;
+      await fetch(davUrl(oldPath), { method: "MOVE", headers });
+    }
+  };
+  return backend;
 });
 
 // src/version.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zen-fs-config",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Distributed config management library built on ZenFS, zen-fs-cache, and zen-fs-sync",
   "main": "dist/index.js",
   "module": "dist/index.mjs",