@drakkar.software/starfish-client 2.2.0 → 3.0.0-alpha.0

package/dist/index.js

@@ -1,6 +1,13 @@
 // src/index.ts
 import { configurePlatform } from "@drakkar.software/starfish-protocol";
-import { stableStringify as stableStringify2, computeHash } from "@drakkar.software/starfish-protocol";
+import { stableStringify as stableStringify3, computeHash } from "@drakkar.software/starfish-protocol";
+import { buildRevocationList, revocationListCanonicalSigningInput } from "@drakkar.software/starfish-protocol";
+
+// src/client.ts
+import {
+  signRequest,
+  stableStringify
+} from "@drakkar.software/starfish-protocol";
 
 // src/types.ts
 var ConflictError = class extends Error {
@@ -20,34 +27,109 @@ var StarfishHttpError = class extends Error {
 
 // src/client.ts
 var APPEND_DEFAULT_FIELD = "items";
+function encodeCapAuth(cap) {
+  const json = stableStringify(cap);
+  if (typeof btoa === "function") {
+    return btoa(json);
+  }
+  const bufCtor = globalThis.Buffer;
+  if (bufCtor) return bufCtor.from(json, "utf-8").toString("base64");
+  throw new Error("No base64 encoder available");
+}
 var StarfishClient = class {
   baseUrl;
-  auth;
+  capProvider;
   fetch;
+  /**
+   * Installed client-side plugins. Currently stored as inert data; no
+   * hooks fire yet. Extensions can inspect this list if needed.
+   */
+  plugins;
   constructor(options) {
     this.baseUrl = options.baseUrl.replace(/\/$/, "");
-    this.auth = options.auth;
+    this.capProvider = options.capProvider;
     this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.plugins = options.plugins ? [...options.plugins] : [];
+  }
+  /**
+   * Resolve the host portion of the URL the client will send to. The host
+   * is folded into the signed canonical input as the `h` field so the
+   * server can refuse a signature that was minted against a different
+   * Starfish host (replay-across-servers defence).
+   *
+   * When `baseUrl` is relative — e.g. the consumer passed a custom `fetch`
+   * that resolves relative URLs in its own context — there is no parseable
+   * host; we return `""` so signing still proceeds. The server-side
+   * verifier will also reconstruct host from its inbound URL, so the
+   * empty-host case still verifies symmetrically when both sides agree.
+   */
+  signingHost() {
+    try {
+      return new URL(this.baseUrl).host;
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Build auth headers for a request. When a `capProvider` is set, signs the
+   * request with the device's Ed25519 private key and returns the v3 header
+   * set (`Authorization: Cap …`, `X-Starfish-Sig`, `X-Starfish-Ts`,
+   * `X-Starfish-Nonce`). Empty when no provider is configured (public reads).
+   *
+   * Body bytes signed MUST equal the bytes sent on the wire — callers pass
+   * the already-serialized body string here so signing and transmission agree.
+   * The host bound into the signature is derived from `baseUrl` once per call.
+   */
+  async buildAuthHeaders(method, pathAndQuery, body) {
+    if (this.capProvider) {
+      const { cap, devEdPrivHex } = await this.capProvider.getCap();
+      const req = {
+        method,
+        pathAndQuery,
+        body,
+        host: this.signingHost()
+      };
+      const { sig, ts, nonce } = await signRequest(req, devEdPrivHex);
+      return {
+        Authorization: `Cap ${encodeCapAuth(cap)}`,
+        "X-Starfish-Sig": sig,
+        "X-Starfish-Ts": String(ts),
+        "X-Starfish-Nonce": nonce
+      };
+    }
+    return {};
   }
   async pull(path, checkpointOrOptions) {
-    let url = `${this.baseUrl}${path}`;
+    let pathAndQuery = path;
     let appendField;
     if (typeof checkpointOrOptions === "number") {
-      if (checkpointOrOptions) url += `?checkpoint=${checkpointOrOptions}`;
+      if (checkpointOrOptions) pathAndQuery += `?checkpoint=${checkpointOrOptions}`;
     } else if (checkpointOrOptions != null) {
-      appendField = checkpointOrOptions.appendField ?? APPEND_DEFAULT_FIELD;
+      const opts = checkpointOrOptions;
+      const isPullOptions = opts.withKeyring !== void 0 || opts.checkpoint !== void 0;
       const params = new URLSearchParams();
-      if (checkpointOrOptions.since != null) {
-        if (checkpointOrOptions.since < 0) throw new Error("since must be non-negative");
-        params.set("checkpoint", String(checkpointOrOptions.since));
-      }
-      if (checkpointOrOptions.last != null) {
-        if (checkpointOrOptions.last < 0) throw new Error("last must be non-negative");
-        params.set("last", String(checkpointOrOptions.last));
+      if (isPullOptions) {
+        if (opts.checkpoint != null && opts.checkpoint > 0) {
+          params.set("checkpoint", String(opts.checkpoint));
+        }
+        if (opts.withKeyring) {
+          params.set("withKeyring", "1");
+        }
+      } else {
+        appendField = opts.appendField ?? APPEND_DEFAULT_FIELD;
+        if (opts.since != null) {
+          if (opts.since < 0) throw new Error("since must be non-negative");
+          params.set("checkpoint", String(opts.since));
+        }
+        if (opts.last != null) {
+          if (opts.last < 0) throw new Error("last must be non-negative");
+          params.set("last", String(opts.last));
+        }
       }
-      if (params.size > 0) url += `?${params.toString()}`;
+      if (params.size > 0) pathAndQuery += `?${params.toString()}`;
     }
-    const authHeaders = this.auth ? await this.auth({ method: "GET", path, body: null }) : {};
+    const url = `${this.baseUrl}${pathAndQuery}`;
+    const authHeaders = await this.buildAuthHeaders("GET", pathAndQuery, void 0);
     const res = await this.fetch(url, {
       method: "GET",
       headers: { Accept: "application/json", ...authHeaders }
@@ -67,16 +149,17 @@ var StarfishClient = class {
    * @param path - The push endpoint path (e.g. "/push/users/abc/settings")
    * @param data - The full document data to push
    * @param baseHash - Hash of the document this push is based on (null for first push)
-   * @param authorSignature - Optional author signature for provenance
+   *
+   * v3 author fields (`authorPubkey` + `authorSignature`) live inside `data`
+   * and are produced by `SyncManager` when a `signer` is configured.
    * @throws {ConflictError} if the server detects a hash mismatch (409)
    */
-  async push(path, data, baseHash, authorSignature) {
+  async push(path, data, baseHash) {
     const body = JSON.stringify({
       data,
-      baseHash,
-      ...authorSignature && { authorSignature }
+      baseHash
     });
-    const authHeaders = this.auth ? await this.auth({ method: "POST", path, body }) : {};
+    const authHeaders = await this.buildAuthHeaders("POST", path, body);
     const res = await this.fetch(`${this.baseUrl}${path}`, {
       method: "POST",
       headers: {
@@ -99,7 +182,7 @@ var StarfishClient = class {
    * Returns raw bytes with the content hash from the ETag header.
    */
   async pullBlob(path) {
-    const authHeaders = this.auth ? await this.auth({ method: "GET", path, body: null }) : {};
+    const authHeaders = await this.buildAuthHeaders("GET", path, void 0);
     const res = await this.fetch(`${this.baseUrl}${path}`, {
       method: "GET",
       headers: { Accept: "*/*", ...authHeaders }
@@ -117,7 +200,7 @@ var StarfishClient = class {
    * Binary collections use last-write-wins (no conflict detection).
    */
   async pushBlob(path, data, contentType) {
-    const authHeaders = this.auth ? await this.auth({ method: "POST", path, body: null }) : {};
+    const authHeaders = await this.buildAuthHeaders("POST", path, void 0);
     const res = await this.fetch(`${this.baseUrl}${path}`, {
       method: "POST",
       headers: {
@@ -135,51 +218,7 @@ var StarfishClient = class {
 };
 
 // src/sync.ts
-import { deepMerge, stableStringify } from "@drakkar.software/starfish-protocol";
-
-// src/crypto.ts
-import { getCrypto, getBase64, IV_BYTES, ENCRYPTED_KEY, deriveKey } from "@drakkar.software/starfish-protocol";
-var ALGO = "AES-GCM";
-function createEncryptor(secret, salt, info = "starfish-e2e") {
-  if (!secret) throw new Error("encryptionSecret must not be empty");
-  if (!salt) throw new Error("encryptionSalt must not be empty");
-  const keyPromise = deriveKey(secret, salt, info);
-  return {
-    async encrypt(data) {
-      const key = await keyPromise;
-      const c = getCrypto();
-      const b64 = getBase64();
-      const plaintext = new TextEncoder().encode(JSON.stringify(data));
-      const iv = c.getRandomValues(new Uint8Array(IV_BYTES));
-      const ciphertext = await c.subtle.encrypt({ name: ALGO, iv }, key, plaintext);
-      const combined = new Uint8Array(iv.length + ciphertext.byteLength);
-      combined.set(iv);
-      combined.set(new Uint8Array(ciphertext), iv.length);
-      return { [ENCRYPTED_KEY]: b64.encode(combined) };
-    },
-    async decrypt(wrapper) {
-      const encoded = wrapper[ENCRYPTED_KEY];
-      if (typeof encoded !== "string") {
-        throw new Error("Expected encrypted data but received unencrypted document");
-      }
-      const key = await keyPromise;
-      const c = getCrypto();
-      const b64 = getBase64();
-      const combined = b64.decode(encoded);
-      if (combined.length < IV_BYTES) {
-        throw new Error("Encrypted data is too short");
-      }
-      const iv = combined.slice(0, IV_BYTES);
-      const ciphertext = combined.slice(IV_BYTES);
-      try {
-        const plaintext = await c.subtle.decrypt({ name: ALGO, iv }, key, ciphertext);
-        return JSON.parse(new TextDecoder().decode(plaintext));
-      } catch (err) {
-        throw new Error("Decryption failed: data may be tampered or key is incorrect", { cause: err });
-      }
-    }
-  };
-}
+import { deepMerge, getBase64, stableStringify as stableStringify2 } from "@drakkar.software/starfish-protocol";
 
 // src/validate.ts
 var ValidationError = class extends Error {
@@ -211,7 +250,7 @@ var SyncManager = class {
   onConflict;
   maxRetries;
   encryptor;
-  signData;
+  signer;
   logger;
   loggerName;
   validate;
@@ -225,11 +264,11 @@ var SyncManager = class {
     this.pushPath = options.pushPath;
     this.onConflict = options.onConflict ?? deepMerge;
     this.maxRetries = options.maxRetries ?? 3;
-    this.signData = options.signData;
+    this.signer = options.signer;
     this.logger = options.logger;
     this.loggerName = options.loggerName ?? options.pullPath.split("/").filter(Boolean).pop() ?? options.pullPath;
     this.validate = options.validate;
-    this.encryptor = options.encryptor ?? (options.encryptionSecret && options.encryptionSalt ? createEncryptor(options.encryptionSecret, options.encryptionSalt, options.encryptionInfo) : null);
+    this.encryptor = options.encryptor ?? null;
   }
   abort() {
     this.aborted = true;
@@ -289,15 +328,25 @@ var SyncManager = class {
     let pendingData = data;
     while (attempt <= this.maxRetries) {
       try {
-        const payload = this.encryptor ? await this.encryptor.encrypt(pendingData) : pendingData;
-        if (this.aborted) throw new AbortError();
-        const sig = this.signData ? await this.signData(stableStringify(payload)) : void 0;
+        const sealed = this.encryptor ? await this.encryptor.encrypt(pendingData) : pendingData;
         if (this.aborted) throw new AbortError();
+        let payload = sealed;
+        if (this.signer) {
+          const { devEdPubHex, sign } = await this.signer.getSigner();
+          if (this.aborted) throw new AbortError();
+          const canonical = stableStringify2(sealed);
+          const sigBytes = await sign(new TextEncoder().encode(canonical));
+          if (this.aborted) throw new AbortError();
+          payload = {
+            ...sealed,
+            authorPubkey: devEdPubHex,
+            authorSignature: getBase64().encode(sigBytes)
+          };
+        }
         const result = await this.client.push(
           this.pushPath,
           payload,
-          this.lastHash,
-          sig
+          this.lastHash
         );
         if (this.aborted) throw new AbortError();
         this.lastHash = result.hash;
@@ -339,6 +388,9 @@ var SyncManager = class {
   }
 };
 
+// src/index.ts
+import { ENCRYPTED_KEY } from "@drakkar.software/starfish-protocol";
+
 // src/logger.ts
 var consoleSyncLogger = {
   pullStart: (s) => console.log(`[starfish:${s}] pull started`),
@@ -1171,170 +1223,6 @@ function createMultiStoreSync(options) {
   }
   return { serialize, restore, version };
 }
-
-// src/group-crypto.ts
-import { x25519 } from "@noble/curves/ed25519.js";
-import { getCrypto as getCrypto2, getBase64 as getBase642, IV_BYTES as IV_BYTES2, deriveKey as deriveKey2 } from "@drakkar.software/starfish-protocol";
-function bytesToHex(bytes) {
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-function hexToBytes(hex) {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < bytes.length; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-}
-var ALGO2 = "AES-GCM";
-var GROUP_WRAP_SALT = "starfish-group-wrap";
-var GROUP_WRAP_INFO = "starfish-group-wrap";
-var GROUP_ECDH_DOMAIN = "starfish-group-ecdh";
-var GROUP_DATA_INFO = "starfish-group";
-var GEK_BYTES = 32;
-async function deriveGroupKeyPair(passphrase, userId) {
-  const c = getCrypto2();
-  const enc = new TextEncoder();
-  const input = enc.encode(`${passphrase}:${userId}:${GROUP_ECDH_DOMAIN}`);
-  const hash = await c.subtle.digest("SHA-256", input);
-  const privateKeyBytes = new Uint8Array(hash);
-  const publicKeyBytes = x25519.getPublicKey(privateKeyBytes);
-  return { privateKey: bytesToHex(privateKeyBytes), publicKey: bytesToHex(publicKeyBytes) };
-}
-function generateGroupKey() {
-  const c = getCrypto2();
-  return bytesToHex(c.getRandomValues(new Uint8Array(GEK_BYTES)));
-}
-async function wrapGroupKey(gek, memberPublicKey, wrapperPrivateKey) {
-  const sharedSecret = x25519.getSharedSecret(hexToBytes(wrapperPrivateKey), hexToBytes(memberPublicKey));
-  const wrappingKey = await deriveKey2(bytesToHex(sharedSecret), GROUP_WRAP_SALT, GROUP_WRAP_INFO);
-  const c = getCrypto2();
-  const b64 = getBase642();
-  const iv = c.getRandomValues(new Uint8Array(IV_BYTES2));
-  const encrypted = await c.subtle.encrypt({ name: ALGO2, iv }, wrappingKey, hexToBytes(gek).buffer);
-  const combined = new Uint8Array(IV_BYTES2 + encrypted.byteLength);
-  combined.set(iv);
-  combined.set(new Uint8Array(encrypted), IV_BYTES2);
-  return b64.encode(combined);
-}
-async function unwrapGroupKey(wrapped, memberPrivateKey, adminPublicKey) {
-  const sharedSecret = x25519.getSharedSecret(hexToBytes(memberPrivateKey), hexToBytes(adminPublicKey));
-  const wrappingKey = await deriveKey2(bytesToHex(sharedSecret), GROUP_WRAP_SALT, GROUP_WRAP_INFO);
-  const b64 = getBase642();
-  const c = getCrypto2();
-  const combined = b64.decode(wrapped);
-  const iv = combined.slice(0, IV_BYTES2);
-  const ciphertext = combined.slice(IV_BYTES2);
-  try {
-    const decrypted = await c.subtle.decrypt({ name: ALGO2, iv }, wrappingKey, ciphertext);
-    return bytesToHex(new Uint8Array(decrypted));
-  } catch {
-    throw new Error("Failed to unwrap group key: decryption failed (wrong keys or corrupted data)");
-  }
-}
-async function createGroupKeyring(adminKeyPair, members, gek) {
-  const resolvedGek = gek ?? generateGroupKey();
-  const wrappedKeys = {};
-  for (const [memberId, memberPublicKey] of Object.entries(members)) {
-    wrappedKeys[memberId] = await wrapGroupKey(resolvedGek, memberPublicKey, adminKeyPair.privateKey);
-  }
-  const keyring = {
-    currentEpoch: 1,
-    epochs: {
-      "1": { adminPublicKey: adminKeyPair.publicKey, wrappedKeys }
-    }
-  };
-  return { keyring, gek: resolvedGek };
-}
-async function addGroupMember(keyring, adminKeyPair, currentGek, newMemberId, newMemberPublicKey) {
-  const epochKey = String(keyring.currentEpoch);
-  const epochKeyring = keyring.epochs[epochKey];
-  if (!epochKeyring) throw new Error(`Epoch ${keyring.currentEpoch} not found in keyring`);
-  if (epochKeyring.adminPublicKey !== adminKeyPair.publicKey) {
-    throw new Error(`Provided key pair does not match the admin public key stored in epoch ${keyring.currentEpoch}`);
-  }
-  const wrapped = await wrapGroupKey(currentGek, newMemberPublicKey, adminKeyPair.privateKey);
-  return {
-    ...keyring,
-    epochs: {
-      ...keyring.epochs,
-      [epochKey]: {
-        ...epochKeyring,
-        wrappedKeys: { ...epochKeyring.wrappedKeys, [newMemberId]: wrapped }
-      }
-    }
-  };
-}
-async function rotateGroupKey(keyring, adminKeyPair, remainingMembers, newGek) {
-  const epochKey = String(keyring.currentEpoch);
-  const epochKeyring = keyring.epochs[epochKey];
-  if (epochKeyring && epochKeyring.adminPublicKey !== adminKeyPair.publicKey) {
-    throw new Error(
-      `Provided key pair does not match the admin public key stored in epoch ${keyring.currentEpoch}`
-    );
-  }
-  const resolvedGek = newGek ?? generateGroupKey();
-  const newEpoch = keyring.currentEpoch + 1;
-  const wrappedKeys = {};
-  for (const [memberId, memberPublicKey] of Object.entries(remainingMembers)) {
-    wrappedKeys[memberId] = await wrapGroupKey(resolvedGek, memberPublicKey, adminKeyPair.privateKey);
-  }
-  const newKeyring = {
-    currentEpoch: newEpoch,
-    epochs: {
-      ...keyring.epochs,
-      [String(newEpoch)]: { adminPublicKey: adminKeyPair.publicKey, wrappedKeys }
-    }
-  };
-  return { keyring: newKeyring, gek: resolvedGek };
-}
-async function createGroupEncryptor(keyring, myIdentity, myPrivateKey) {
-  const epochEncryptors = /* @__PURE__ */ new Map();
-  for (const [epochStr, epochKeyring] of Object.entries(keyring.epochs)) {
-    const epoch = parseInt(epochStr, 10);
-    const wrapped = epochKeyring.wrappedKeys[myIdentity];
-    if (!wrapped) continue;
-    const gek = await unwrapGroupKey(wrapped, myPrivateKey, epochKeyring.adminPublicKey);
-    epochEncryptors.set(epoch, createEncryptor(gek, `epoch-${epoch}`, GROUP_DATA_INFO));
-  }
-  const currentEpoch = keyring.currentEpoch;
-  const currentEncryptor = epochEncryptors.get(currentEpoch);
-  if (!currentEncryptor) {
-    throw new Error(
-      `No wrapped key found for identity "${myIdentity}" in epoch ${currentEpoch}. Ensure the admin has added this member to the keyring.`
-    );
-  }
-  return {
-    async encrypt(data) {
-      const encrypted = await currentEncryptor.encrypt(data);
-      return { ...encrypted, _epoch: currentEpoch };
-    },
-    async decrypt(wrapper) {
-      const epoch = typeof wrapper._epoch === "number" ? wrapper._epoch : currentEpoch;
-      const encryptor = epochEncryptors.get(epoch);
-      if (!encryptor) {
-        throw new Error(
-          `No key available for epoch ${epoch}. This document was encrypted in a different epoch. Ensure your keyring is up to date.`
-        );
-      }
-      return encryptor.decrypt(wrapper);
-    }
-  };
-}
-
-// src/entitlements.ts
-async function pullEntitlements(client, userId, opts) {
-  const path = (opts?.path ?? "/pull/users/{userId}/entitlements").replace("{userId}", userId);
-  const field = opts?.field ?? "features";
-  try {
-    const result = await client.pull(path);
-    const list = result.data?.[field];
-    if (!Array.isArray(list)) return [];
-    return list.filter((s) => typeof s === "string");
-  } catch (err) {
-    if (err instanceof StarfishHttpError && err.status === 404) return [];
-    throw err;
-  }
-}
 export {
   AbortError,
   ConflictError,
@@ -1344,7 +1232,7 @@ export {
   StarfishHttpError,
   SyncManager,
   ValidationError,
-  addGroupMember,
+  buildRevocationList,
   classifyError,
   computeHash,
   configurePlatform,
@@ -1352,9 +1240,6 @@ export {
   createDebouncedPush,
   createDebouncedSync,
   createDedupFetch,
-  createEncryptor,
-  createGroupEncryptor,
-  createGroupKeyring,
   createIndexedDBStorage,
   createMetricsCollector,
   createMigrator,
@@ -1364,27 +1249,22 @@ export {
   createSoftDeleteResolver,
   createSuspenseResource,
   createUnionMerge,
-  deriveGroupKeyPair,
   exportData,
   exportToBlob,
   fetchServerConfig,
-  generateGroupKey,
   importData,
   isBackgroundSyncSupported,
   isServiceWorkerSupported,
   noopSyncLogger,
   pruneTombstones,
-  pullEntitlements,
   registerBackgroundSync,
   registerServiceWorker,
-  rotateGroupKey,
-  stableStringify2 as stableStringify,
+  revocationListCanonicalSigningInput,
+  stableStringify3 as stableStringify,
   startAdaptivePolling,
   startPolling,
   timestampWinner,
   unregisterServiceWorkers,
-  unwrapGroupKey,
-  withConflictMeta,
-  wrapGroupKey
+  withConflictMeta
 };
 //# sourceMappingURL=index.js.map