selfstore 1.8.20 → 1.8.21

package/dist/chunk-TKWU52LK.js

@@ -1,607 +0,0 @@
-import { lifeLine, boundedSignal } from './chunk-J5MFXJU6.js';
-import { seal, isEnvelope, unseal, newDeviceKey } from './chunk-QBCU7OOP.js';
-import { AuthExpiredError, SelfstoreError } from './chunk-3OBJOMQ2.js';
-
-// src/persistence/targets/desktop.ts
-var PATH_KEY = "desktopFilePath";
-var bridge = null;
-function useDesktopFiles(b) {
-  bridge = b;
-}
-function hasDesktopFiles() {
-  return bridge != null;
-}
-var FILTERS = [{ name: "Backup", extensions: ["zip"] }];
-function baseName(path) {
-  const parts = path.split(/[\\/]/);
-  return parts[parts.length - 1] || path;
-}
-async function markerOf(b, path) {
-  try {
-    const info = await b.stat(path);
-    const mtime = info?.mtime;
-    if (mtime == null) return null;
-    const ms = mtime instanceof Date ? mtime.getTime() : Number(mtime);
-    return Number.isFinite(ms) ? String(ms) : null;
-  } catch {
-    return null;
-  }
-}
-function firstPath(picked) {
-  if (picked == null) return null;
-  return Array.isArray(picked) ? picked[0] ?? null : picked;
-}
-function fromPath(path, b, kv) {
-  let current = path;
-  return {
-    kind: "file",
-    get label() {
-      return baseName(current);
-    },
-    async save(blob) {
-      try {
-        await b.writeFile(current, new Uint8Array(await blob.arrayBuffer()));
-      } catch (e) {
-        throw new SelfstoreError("TARGET_WRITE_FAILED", `File write failed: ${String(e)}`);
-      }
-      return markerOf(b, current);
-    },
-    async load() {
-      try {
-        const bytes = await b.readFile(current);
-        return new Blob([new Uint8Array(bytes)]);
-      } catch {
-        return null;
-      }
-    },
-    async stat() {
-      return markerOf(b, current);
-    },
-    async isReady() {
-      return true;
-    },
-    async reconnect() {
-      const picked = await b.save({ defaultPath: current, filters: FILTERS });
-      if (!picked) return false;
-      current = picked;
-      await kv.set(PATH_KEY, picked);
-      return true;
-    },
-    async disconnect() {
-      await kv.del(PATH_KEY);
-    }
-  };
-}
-async function connect(opts) {
-  if (!bridge) return null;
-  const picked = await bridge.save({ defaultPath: opts.fileName, filters: FILTERS });
-  if (!picked) return null;
-  await opts.kv.set(PATH_KEY, picked);
-  return fromPath(picked, bridge, opts.kv);
-}
-async function openExisting(opts) {
-  if (!bridge) return null;
-  const picked = firstPath(await bridge.open({ multiple: false, filters: FILTERS }));
-  if (!picked) return null;
-  await opts.kv.set(PATH_KEY, picked);
-  return fromPath(picked, bridge, opts.kv);
-}
-async function fromSession(opts) {
-  if (!bridge) return null;
-  const path = await opts.kv.get(PATH_KEY);
-  return path ? fromPath(path, bridge, opts.kv) : null;
-}
-
-// src/persistence/targets/file.ts
-var HANDLE_KEY = "fileHandle";
-var refused = false;
-function insideGesture() {
-  const ua = typeof navigator !== "undefined" ? navigator.userActivation : void 0;
-  return ua ? ua.isActive : true;
-}
-function isSupported() {
-  if (hasDesktopFiles()) return true;
-  return !refused && typeof window !== "undefined" && "showSaveFilePicker" in window;
-}
-function isOpenSupported() {
-  if (hasDesktopFiles()) return true;
-  return !refused && typeof window !== "undefined" && "showOpenFilePicker" in window;
-}
-async function ask(open) {
-  const asked = insideGesture();
-  try {
-    return await open();
-  } catch (e) {
-    if (e instanceof DOMException && e.name === "AbortError") return null;
-    refused = asked;
-    return null;
-  }
-}
-function asTargetError(e, transient, what) {
-  const name = e instanceof DOMException ? e.name : "";
-  if (name === "NotAllowedError" || name === "SecurityError") {
-    return new AuthExpiredError("File permission was revoked.");
-  }
-  if (name === "NotFoundError") {
-    return new SelfstoreError("TARGET_GONE", `${what}: the backup file is no longer there.`);
-  }
-  return new SelfstoreError(transient, `${what}: ${String(e)}`);
-}
-function fromHandle(handle, kv) {
-  return {
-    kind: "file",
-    label: handle.name,
-    async save(blob) {
-      try {
-        const writable = await handle.createWritable();
-        await writable.write(blob);
-        await writable.close();
-      } catch (e) {
-        throw asTargetError(e, "TARGET_WRITE_FAILED", "File write failed");
-      }
-      try {
-        return String((await handle.getFile()).lastModified);
-      } catch {
-        return null;
-      }
-    },
-    async load() {
-      try {
-        return await handle.getFile();
-      } catch (e) {
-        throw asTargetError(e, "TARGET_UNAVAILABLE", "File read failed");
-      }
-    },
-    async stat() {
-      try {
-        return String((await handle.getFile()).lastModified);
-      } catch {
-        return null;
-      }
-    },
-    async isReady() {
-      return await handle.queryPermission({ mode: "readwrite" }) === "granted";
-    },
-    async reconnect() {
-      return await handle.requestPermission({ mode: "readwrite" }) === "granted";
-    },
-    async disconnect() {
-      await kv.del(HANDLE_KEY);
-    }
-  };
-}
-async function connect2(opts) {
-  if (hasDesktopFiles()) return connect(opts);
-  const picker = window.showSaveFilePicker;
-  if (!picker) return null;
-  const handle = await ask(
-    () => picker({
-      suggestedName: opts.fileName,
-      types: [{ description: "Backup", accept: { "application/zip": [".zip"] } }]
-    })
-  );
-  if (!handle) return null;
-  await opts.kv.set(HANDLE_KEY, handle);
-  return fromHandle(handle, opts.kv);
-}
-async function openExisting2(opts) {
-  if (hasDesktopFiles()) return openExisting(opts);
-  const picker = window.showOpenFilePicker;
-  if (!picker) return null;
-  const picked = await ask(
-    () => picker({
-      multiple: false,
-      types: [{ description: "Backup", accept: { "application/zip": [".zip"] } }]
-    })
-  );
-  const handle = picked?.[0];
-  if (!handle) return null;
-  try {
-    await handle.requestPermission({ mode: "readwrite" });
-  } catch {
-  }
-  await opts.kv.set(HANDLE_KEY, handle);
-  return fromHandle(handle, opts.kv);
-}
-async function fromSession2(opts) {
-  if (hasDesktopFiles()) return fromSession(opts);
-  const handle = await opts.kv.get(HANDLE_KEY);
-  return handle ? fromHandle(handle, opts.kv) : null;
-}
-
-// src/persistence/targets/webdav.ts
-var CONFIG_KEY = "webdavConfig";
-var KEY_KEY = "webdavKey";
-var DATA_DEADLINE_MS = 3e4;
-var META_DEADLINE_MS = 15e3;
-async function configKey(kv) {
-  const existing = await kv.get(KEY_KEY);
-  if (existing) return existing;
-  const fresh = await newDeviceKey();
-  await kv.set(KEY_KEY, fresh);
-  return fresh;
-}
-async function saveConfig(kv, c) {
-  const bytes = new TextEncoder().encode(JSON.stringify(c));
-  await kv.set(CONFIG_KEY, await seal(await configKey(kv), bytes));
-}
-async function loadConfig(kv) {
-  const stored = await kv.get(CONFIG_KEY);
-  if (!isEnvelope(stored)) return null;
-  const bytes = await unseal(await configKey(kv), stored);
-  return JSON.parse(new TextDecoder().decode(bytes));
-}
-function labelOf(url) {
-  try {
-    return new URL(url).host;
-  } catch {
-    return "WebDAV";
-  }
-}
-function assertSecureUrl(url) {
-  let u;
-  try {
-    u = new URL(url);
-  } catch {
-    throw new TypeError(`webdavTarget: invalid URL "${url}".`);
-  }
-  const loopback = u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]";
-  if (u.protocol !== "https:" && !(u.protocol === "http:" && loopback)) {
-    throw new TypeError(
-      `webdavTarget: refusing "${u.protocol}" - Basic-auth credentials need https (http is allowed only for localhost).`
-    );
-  }
-}
-function versionOf(res) {
-  return res.headers.get("ETag") ?? res.headers.get("Last-Modified") ?? null;
-}
-function fromConfig(c, kv) {
-  const headers = { Authorization: "Basic " + btoa(`${c.username}:${c.password}`) };
-  const life = lifeLine();
-  const bounded = (ms) => boundedSignal(ms, life.current());
-  async function probe() {
-    try {
-      return await fetch(c.url, {
-        method: "HEAD",
-        headers,
-        signal: bounded(META_DEADLINE_MS)
-      });
-    } catch {
-      return null;
-    }
-  }
-  async function stat() {
-    const res = await probe();
-    return res && res.ok ? versionOf(res) : null;
-  }
-  async function ready() {
-    const res = await probe();
-    if (!res) return false;
-    if (res.status === 401 || res.status === 403) {
-      throw new AuthExpiredError(`WebDAV rejected the credentials (${res.status}).`);
-    }
-    return res.ok || res.status === 404;
-  }
-  async function reconnectProbe() {
-    const res = await probe();
-    return !!res && (res.ok || res.status === 404);
-  }
-  return {
-    kind: "webdav",
-    label: labelOf(c.url),
-    abortInFlight: life.cut,
-    async save(blob) {
-      const res = await fetch(c.url, {
-        method: "PUT",
-        headers,
-        body: blob,
-        signal: bounded(DATA_DEADLINE_MS)
-      });
-      if (res.status === 401 || res.status === 403) {
-        throw new AuthExpiredError(`WebDAV rejected the credentials (${res.status}).`);
-      }
-      if (!res.ok)
-        throw new SelfstoreError("TARGET_WRITE_FAILED", `WebDAV PUT failed: ${res.status}`);
-      return versionOf(res) ?? await stat();
-    },
-    async load() {
-      const res = await fetch(c.url, {
-        method: "GET",
-        headers,
-        signal: bounded(DATA_DEADLINE_MS)
-      });
-      if (res.status === 404) return null;
-      if (res.status === 401 || res.status === 403) {
-        throw new AuthExpiredError(`WebDAV rejected the credentials (${res.status}).`);
-      }
-      if (!res.ok)
-        throw new SelfstoreError("TARGET_UNAVAILABLE", `WebDAV GET failed: ${res.status}`);
-      return res.blob();
-    },
-    stat,
-    isReady: ready,
-    reconnect: reconnectProbe,
-    // stored credentials: re-check reachability, no gesture
-    async disconnect() {
-      await kv.del(CONFIG_KEY);
-      await kv.del(KEY_KEY);
-    }
-  };
-}
-function peer(opts) {
-  if (opts.username !== void 0) assertSecureUrl(opts.url);
-  const headers = opts.username !== void 0 ? { Authorization: "Basic " + btoa(`${opts.username}:${opts.password ?? ""}`) } : void 0;
-  return {
-    label: opts.label ?? labelOf(opts.url),
-    async load() {
-      const res = await fetch(opts.url, {
-        method: "GET",
-        headers,
-        signal: AbortSignal.timeout(DATA_DEADLINE_MS)
-      });
-      if (res.status === 404) return null;
-      if (res.status === 401 || res.status === 403) {
-        throw new AuthExpiredError(`WebDAV peer rejected the credentials (${res.status}).`);
-      }
-      if (!res.ok) {
-        throw new SelfstoreError("TARGET_UNAVAILABLE", `WebDAV peer GET failed: ${res.status}`);
-      }
-      return res.blob();
-    },
-    async stat() {
-      try {
-        const res = await fetch(opts.url, {
-          method: "HEAD",
-          headers,
-          signal: AbortSignal.timeout(META_DEADLINE_MS)
-        });
-        return res.ok ? versionOf(res) : null;
-      } catch {
-        return null;
-      }
-    }
-  };
-}
-async function connect3(opts) {
-  assertSecureUrl(opts.config.url);
-  const target = fromConfig(opts.config, opts.kv);
-  let ok;
-  try {
-    ok = await target.isReady();
-  } catch {
-    ok = false;
-  }
-  if (!ok) return null;
-  await saveConfig(opts.kv, opts.config);
-  return target;
-}
-async function fromSession3(opts) {
-  const config = await loadConfig(opts.kv);
-  return config ? fromConfig(config, opts.kv) : null;
-}
-
-// src/persistence/targets/sigv4.ts
-var encoder = new TextEncoder();
-function hex(bytes) {
-  let out = "";
-  for (const b of bytes) out += b.toString(16).padStart(2, "0");
-  return out;
-}
-async function sha256Hex(bytes) {
-  return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)));
-}
-var EMPTY_PAYLOAD_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
-async function hmac(key, data) {
-  const k = await crypto.subtle.importKey(
-    "raw",
-    key,
-    { name: "HMAC", hash: "SHA-256" },
-    false,
-    ["sign"]
-  );
-  return new Uint8Array(await crypto.subtle.sign("HMAC", k, data));
-}
-function encodeSegment(s) {
-  return encodeURIComponent(s).replace(
-    /[!*'()]/g,
-    (c) => "%" + c.charCodeAt(0).toString(16).toUpperCase()
-  );
-}
-function encodeS3Path(path) {
-  return path.split("/").map((seg) => encodeSegment(seg)).join("/");
-}
-function basicAmzDate() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/[:-]|\.\d{3}/g, "");
-}
-async function signS3(input) {
-  const service = input.service ?? "s3";
-  const amzDate = input.amzDate ?? basicAmzDate();
-  const dateStamp = amzDate.slice(0, 8);
-  const { host } = new URL(input.origin);
-  const canonicalUri = encodeS3Path(input.path);
-  const headers = {
-    host,
-    "x-amz-content-sha256": input.payloadHashHex,
-    "x-amz-date": amzDate
-  };
-  for (const [name, value] of Object.entries({})) {
-    headers[name.toLowerCase()] = value;
-  }
-  const signedNames = Object.keys(headers).sort();
-  const canonicalHeaders = signedNames.map((n) => `${n}:${headers[n].trim()}
-`).join("");
-  const signedHeaders = signedNames.join(";");
-  const canonicalRequest = [
-    input.method,
-    canonicalUri,
-    "",
-    // no query string on any of our single-object requests
-    canonicalHeaders,
-    signedHeaders,
-    input.payloadHashHex
-  ].join("\n");
-  const scope = `${dateStamp}/${input.region}/${service}/aws4_request`;
-  const stringToSign = [
-    "AWS4-HMAC-SHA256",
-    amzDate,
-    scope,
-    await sha256Hex(encoder.encode(canonicalRequest))
-  ].join("\n");
-  const kDate = await hmac(
-    encoder.encode("AWS4" + input.secretAccessKey),
-    encoder.encode(dateStamp)
-  );
-  const kRegion = await hmac(kDate, encoder.encode(input.region));
-  const kService = await hmac(kRegion, encoder.encode(service));
-  const kSigning = await hmac(kService, encoder.encode("aws4_request"));
-  const signature = hex(await hmac(kSigning, encoder.encode(stringToSign)));
-  const authorization = `AWS4-HMAC-SHA256 Credential=${input.accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`;
-  const sendHeaders = { authorization };
-  for (const n of signedNames) if (n !== "host") sendHeaders[n] = headers[n];
-  return { url: input.origin.replace(/\/$/, "") + canonicalUri, headers: sendHeaders };
-}
-
-// src/persistence/targets/s3.ts
-var CONFIG_KEY2 = "s3Config";
-var KEY_KEY2 = "s3Key";
-var DATA_DEADLINE_MS2 = 3e4;
-var META_DEADLINE_MS2 = 15e3;
-async function configKey2(kv) {
-  const existing = await kv.get(KEY_KEY2);
-  if (existing) return existing;
-  const fresh = await newDeviceKey();
-  await kv.set(KEY_KEY2, fresh);
-  return fresh;
-}
-async function saveConfig2(kv, c) {
-  const bytes = new TextEncoder().encode(JSON.stringify(c));
-  await kv.set(CONFIG_KEY2, await seal(await configKey2(kv), bytes));
-}
-async function loadConfig2(kv) {
-  const stored = await kv.get(CONFIG_KEY2);
-  if (!isEnvelope(stored)) return null;
-  const bytes = await unseal(await configKey2(kv), stored);
-  return JSON.parse(new TextDecoder().decode(bytes));
-}
-function assertSecureEndpoint(endpoint) {
-  let u;
-  try {
-    u = new URL(endpoint);
-  } catch {
-    throw new TypeError(`s3Target: invalid endpoint "${endpoint}".`);
-  }
-  const loopback = u.hostname === "localhost" || u.hostname === "127.0.0.1" || u.hostname === "[::1]";
-  if (u.protocol !== "https:" && !(u.protocol === "http:" && loopback)) {
-    throw new TypeError(
-      `s3Target: refusing "${u.protocol}" - S3 requests need https (http is allowed only for localhost).`
-    );
-  }
-  return u;
-}
-function labelOf2(c) {
-  try {
-    return `${c.bucket} (${new URL(c.endpoint).host})`;
-  } catch {
-    return c.bucket || "S3";
-  }
-}
-function versionOf2(res) {
-  return res.headers.get("ETag") ?? res.headers.get("Last-Modified") ?? null;
-}
-function fromConfig2(c, kv) {
-  const endpointUrl = assertSecureEndpoint(c.endpoint);
-  const pathStyle = c.forcePathStyle ?? true;
-  const origin = pathStyle ? `${endpointUrl.protocol}//${endpointUrl.host}` : `${endpointUrl.protocol}//${c.bucket}.${endpointUrl.host}`;
-  const objectPath = pathStyle ? `/${c.bucket}/${c.key}` : `/${c.key}`;
-  const life = lifeLine();
-  async function request(method, payloadHashHex, body, extraHeaders, deadlineMs = DATA_DEADLINE_MS2) {
-    const signed = await signS3({
-      method,
-      origin,
-      path: objectPath,
-      region: c.region,
-      accessKeyId: c.accessKeyId,
-      secretAccessKey: c.secretAccessKey,
-      payloadHashHex});
-    return fetch(signed.url, {
-      method,
-      headers: signed.headers,
-      body,
-      signal: boundedSignal(deadlineMs, life.current())
-    });
-  }
-  async function probe() {
-    try {
-      return await request("HEAD", EMPTY_PAYLOAD_SHA256, void 0, void 0, META_DEADLINE_MS2);
-    } catch {
-      return null;
-    }
-  }
-  async function stat() {
-    const res = await probe();
-    return res && res.ok ? versionOf2(res) : null;
-  }
-  async function ready() {
-    const res = await probe();
-    if (!res) return false;
-    if (res.status === 403) {
-      throw new AuthExpiredError("S3 rejected the credentials (403).");
-    }
-    return res.ok || res.status === 404;
-  }
-  async function reconnectProbe() {
-    const res = await probe();
-    return !!res && (res.ok || res.status === 404);
-  }
-  return {
-    kind: "s3",
-    label: labelOf2(c),
-    abortInFlight: life.cut,
-    async save(blob) {
-      const bytes = new Uint8Array(await blob.arrayBuffer());
-      const res = await request("PUT", await sha256Hex(bytes), bytes);
-      if (res.status === 403) {
-        throw new AuthExpiredError("S3 rejected the credentials (403).");
-      }
-      if (!res.ok) throw new SelfstoreError("TARGET_WRITE_FAILED", `S3 PUT failed: ${res.status}`);
-      return versionOf2(res) ?? await stat();
-    },
-    async load() {
-      const res = await request("GET", EMPTY_PAYLOAD_SHA256);
-      if (res.status === 404) return null;
-      if (res.status === 403) {
-        throw new AuthExpiredError("S3 rejected the credentials (403).");
-      }
-      if (!res.ok) throw new SelfstoreError("TARGET_UNAVAILABLE", `S3 GET failed: ${res.status}`);
-      return res.blob();
-    },
-    stat,
-    isReady: ready,
-    reconnect: reconnectProbe,
-    async disconnect() {
-      await kv.del(CONFIG_KEY2);
-      await kv.del(KEY_KEY2);
-    }
-  };
-}
-async function connect4(opts) {
-  assertSecureEndpoint(opts.config.endpoint);
-  const target = fromConfig2(opts.config, opts.kv);
-  let ok;
-  try {
-    ok = await target.isReady();
-  } catch {
-    ok = false;
-  }
-  if (!ok) return null;
-  await saveConfig2(opts.kv, opts.config);
-  return target;
-}
-async function fromSession4(opts) {
-  const config = await loadConfig2(opts.kv);
-  return config ? fromConfig2(config, opts.kv) : null;
-}
-
-export { connect2 as connect, connect3 as connect2, connect4 as connect3, fromSession2 as fromSession, fromSession3 as fromSession2, fromSession4 as fromSession3, hasDesktopFiles, isOpenSupported, isSupported, openExisting2 as openExisting, peer, useDesktopFiles };
-//# sourceMappingURL=chunk-TKWU52LK.js.map
-//# sourceMappingURL=chunk-TKWU52LK.js.map