@brandfine/client 0.11.0 → 0.14.0

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # @brandfine/client
 
+## 0.14.0
+
+### Minor Changes
+
+- 966879a: Appointments grows the authenticated half it was missing — book as a known person, read your own status back, and cancel, mirroring Live Chat's identity model:
+  - **Verified visitor identity on `createRequest`** — optional `visitor: { externalId, name?, email?, attributes?, identityToken }`, signed with the SAME `liveChat.identityToken(externalId)` you already use for chat (one signature, both plugins). Valid → the booking is attributed (verified name/email take precedence, `identityVerified: true` in the response, and the booking links to the person's chat threads via the shared `externalId`). Invalid or absent → the booking proceeds anonymously; it is never rejected.
+  - **Identity-scoped read-back** — `appointments.list({ externalId, identityToken })` returns the verified person's appointments (status, requestedAt, `scheduledAt` once confirmed, `declineReason` on rejection, timezone), newest first; `appointments.get(id, identity)` fetches one, 404ing identically for missing and foreign ids. POST under the hood so the identityToken never lands in URLs or logs. Bad signature → hard 401 (reads require proof).
+  - **`appointments.cancel(cancellationToken)`** — spends the one-time token `createRequest` already returned; no more hand-rolled HTTP call.
+  - **Publishable-key availability** — the workspace's scoped `brandfine_pk_…` key (minted/upgraded on Appointments activation, shown in the config) can now call `getAvailability` read-only, so fully-static sites render slots without a proxy. Booking, read-back and cancel stay on the broad workspace key.
+  - **Export fix** — `AppointmentAvailability`, `AppointmentSlot`, `CreateAppointmentRequestInput`, `CreatedAppointmentRequest` (plus the new `Appointment`, `AppointmentStatus`, `AppointmentIdentity`, `VerifiedVisitor`) are now exported from the package root; previously they were declared but unexported.
+
+- 966879a: Live Chat gets a realtime transport — messages arrive in ~ms instead of on the 5-second tick, with **zero consumer code changes**:
+  - `createSession()` upgrades itself to a WebSocket when the API advertises `realtimeUrl` (new optional field on `LiveChatBootstrap` and the runtime config — older SDKs ignore it; this SDK against an older API simply polls). Same `subscribe`/`getSnapshot`/`send`/`reset`/`close` surface; a consumer never has to ask which transport is live.
+  - **Polling is the automatic, invisible fallback**: no `realtimeUrl`, no `WebSocket` in the runtime, a socket that won't open, or 5 consecutive reconnect failures → the session polls exactly as before. During reconnect backoff (1s→30s with jitter) polling covers the gap from the first millisecond.
+  - **Resume by `eventId`**: every message now carries a monotonic per-conversation `eventId`; reconnects replay everything after the last one seen — a laptop waking from sleep gets the missed replies, no gaps and no duplicates (also fixes a rare equal-millisecond drop window in the polling cursor via the new `afterEvent` history param).
+  - **Idempotent sends**: `send()` attaches a generated `clientId`; a retry after a dropped response returns the original message instead of duplicating.
+  - Socket auth mirrors REST exactly (publishable key + conversation token, sent in the first frame — never in the URL) and grants nothing REST wouldn't. `reset()` tears the socket down before switching threads (shared-browser guarantee); unknown frame types are ignored by both ends so typing/presence/read receipts can ship later without a breaking change.
+  - Workspaces can optionally restrict socket origins via the new `allowedOrigins` Live Chat setting (unset = any origin, matching the REST posture).
+
+## 0.13.0
+
+### Minor Changes
+
+- 6c8f190: Headless Live Chat — build your own chat UI:
+  - `liveChat.createSession({ config, visitor, locale, pollIntervalMs })` exposes the conversation as typed, subscribable state (`messages`, `status`, `online`, localized `greeting`/`offlineMessage`, `sending`, `error`) with `send()`, `subscribe()` (shaped for `useSyncExternalStore`), `close()` and `reset()`. Shares the floating widget's storage, threading and identity semantics — same conversation everywhere; the widget remains unchanged.
+  - Raw wire methods for full control: `liveChat.runtimeConfig()`, `startConversation()`, `sendMessage()`, `history()`. In browsers, construct the client with the publishable key.
+  - New root exports: `ChatMessage`, `ChatMessageSender`, `ConversationStatus`, `LiveChatSession`, `LiveChatSessionSnapshot`, `LiveChatSessionState`, `LiveChatCreateSessionOptions`, `LiveChatRuntimeConfig`, `StartConversationResult` — with a root-export test so gaps can't regress again.
+  - Transport is polling (default 5000 ms, `pollIntervalMs` option); a future realtime upgrade keeps this API with polling as fallback.
+
+## 0.12.0
+
+### Minor Changes
+
+- 0e6c7c9: Live Chat localization + zero-config identity signing (code already on main, changeset restored after a merge dropped it):
+  - `liveChat.install({ config, locale })` pins the widget's language (falls back to the page's `<html lang>`, then the browser). Greeting/away-message translations are configured per locale in the CMS and resolved server-side; the visitor's page language is stored on the conversation.
+  - `liveChat.identityToken()` no longer requires a configured secret: by default it derives the signing secret from the client's API key (domain-separated HMAC; the API verifies against the same derivation). `{ secret }` / `BRANDFINE_LIVE_CHAT_IDENTITY_SECRET` still override for decoupled signers and legacy workspaces. The missing-secret throw is gone — only the in-browser guard remains.
+
 ## 0.11.0
 
 ### Minor Changes

package/README.md

@@ -62,6 +62,17 @@ await bf.appointments.createRequest({
   visitorName: 'Alex',
   visitorEmail: 'alex@example.com',
   requestedAt: slots[0].start,
+  // Optional: book as a KNOWN person — same signature Live Chat
+  // uses, so one identityToken serves both plugins. Unlocks
+  // list()/get() read-back for that person.
+  visitor: {
+    externalId: 'user:42',
+    identityToken: await bf.liveChat.identityToken('user:42'),
+  },
+})
+const mine = await bf.appointments.list({
+  externalId: 'user:42',
+  identityToken: await bf.liveChat.identityToken('user:42'),
 })
 ```
 
@@ -106,16 +117,13 @@ bf.liveChat.install({ config })
 
 ### Verified visitors
 
-On signed-in pages, tell the inbox **who** is chatting. Sign the
-identity on your server with the workspace's identity secret (CMS:
-Plugins → Live Chat → Manage settings → Integrate), then pass it to
-`install()`:
+On signed-in pages, tell the inbox **who** is chatting. Signing
+needs **no extra configuration** — `identityToken()` derives the
+signing secret from the API key the client already holds:
 
 ```ts
 // Server — never in a browser:
-const identityToken = await bf.liveChat.identityToken(user.id, {
-  secret: process.env.BRANDFINE_LIVE_CHAT_IDENTITY_SECRET,
-})
+const identityToken = await bf.liveChat.identityToken(user.id)
 const visitor = {
   externalId: user.id,
   name: user.name,
@@ -133,11 +141,13 @@ the Brandfine inbox and continue across devices/sessions (same
 `externalId` = same person). An invalid or missing token silently
 downgrades to anonymous chat — never a blocked visitor.
 
-> **Security:** never ship the identity secret to a browser and
-> never compute the HMAC client-side — either would let anyone
-> impersonate any visitor. `identityToken()` enforces this: it
-> throws in browser contexts and when the secret is missing. Rotate
-> the secret in the CMS if it ever leaks.
+> **Security:** never compute the HMAC client-side — the signing
+> secret (derived from your API key, or an explicit one) must never
+> reach a browser, or anyone could impersonate any visitor.
+> `identityToken()` enforces this by throwing in browser contexts.
+> An explicit secret (`{ secret }` / `BRANDFINE_LIVE_CHAT_IDENTITY_SECRET`)
+> overrides the derived default — only needed when the signer
+> shouldn't hold the broad API key.
 
 Full reference: [docs.brandfine.co/docs/sdk/live-chat](https://docs.brandfine.co/docs/sdk/live-chat).
 

package/dist/index.cjs

@@ -4,6 +4,356 @@ var chunkXJFKL2HU_cjs = require('./chunk-XJFKL2HU.cjs');
 var chunkFCK7QJBC_cjs = require('./chunk-FCK7QJBC.cjs');
 var chunkKHHMR2NX_cjs = require('./chunk-KHHMR2NX.cjs');
 
+// src/live-chat-session.ts
+var SESSION_STORAGE_KEY = "bf-live-chat-session";
+function tokenStorageKey(publishableKey) {
+  return `bf-live-chat-token:${publishableKey.slice(-12)}`;
+}
+function getVisitorSessionId() {
+  try {
+    const existing = localStorage.getItem(SESSION_STORAGE_KEY);
+    if (existing) return existing;
+    const generated = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID().replace(/-/g, "") : `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+    localStorage.setItem(SESSION_STORAGE_KEY, generated);
+    return generated;
+  } catch {
+    return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+  }
+}
+function readStoredToken(publishableKey) {
+  try {
+    return localStorage.getItem(tokenStorageKey(publishableKey)) ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+function writeStoredToken(publishableKey, token) {
+  try {
+    if (token === null) localStorage.removeItem(tokenStorageKey(publishableKey));
+    else localStorage.setItem(tokenStorageKey(publishableKey), token);
+  } catch {
+  }
+}
+function resolvePageLocale(explicit) {
+  if (explicit) return explicit;
+  if (typeof document === "undefined") return void 0;
+  const htmlLang = document.documentElement.lang?.trim();
+  if (htmlLang) return htmlLang;
+  return typeof navigator !== "undefined" ? navigator.language || void 0 : void 0;
+}
+async function createLiveChatSession(wire, opts) {
+  if (typeof window === "undefined") {
+    throw new Error(
+      "liveChat.createSession() is browser-only \u2014 build the transcript UI client-side; fetch the bootstrap with getConfig() on the server."
+    );
+  }
+  const publishableKey = opts.config.enabled ? opts.config.publishableKey : void 0;
+  const locale = resolvePageLocale(opts.locale);
+  const pollMs = Math.max(1e3, opts.pollIntervalMs ?? 5e3);
+  let snapshot = {
+    messages: [],
+    status: "CONNECTING",
+    online: false,
+    greeting: null,
+    offlineMessage: null,
+    sending: false,
+    error: null
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  let cursor;
+  let lastEventId = 0;
+  let token;
+  let timer;
+  let closed = false;
+  let ticking = false;
+  const aborter = new AbortController();
+  let realtimeUrl = opts.config.realtimeUrl;
+  let ws;
+  let wsLive = false;
+  let wsFailures = 0;
+  let wsGivenUp = false;
+  let reconnectTimer;
+  let pingTimer;
+  function emit(patch) {
+    snapshot = { ...snapshot, ...patch };
+    for (const listener of listeners) listener(snapshot);
+  }
+  function appendMessages(incoming) {
+    const fresh = incoming.filter((m) => !seen.has(m.id));
+    if (fresh.length === 0) {
+      for (const m of incoming) {
+        if (typeof m.eventId === "number" && m.eventId > lastEventId) {
+          lastEventId = m.eventId;
+        }
+      }
+      return;
+    }
+    for (const m of fresh) {
+      seen.add(m.id);
+      if (typeof m.eventId === "number" && m.eventId > lastEventId) {
+        lastEventId = m.eventId;
+      }
+    }
+    const messages = [...snapshot.messages, ...fresh];
+    cursor = messages[messages.length - 1].createdAt;
+    emit({ messages });
+  }
+  function markClosed() {
+    if (snapshot.status !== "CLOSED") emit({ status: "CLOSED" });
+    stopPolling();
+    teardownRealtime();
+    wsGivenUp = true;
+  }
+  async function tick() {
+    if (ticking || closed || !token) return;
+    ticking = true;
+    try {
+      const result = await wire.history(
+        token,
+        // The eventId cursor is exact (no equal-millisecond drop
+        // window); the timestamp cursor remains for old APIs that
+        // never sent eventIds.
+        lastEventId > 0 ? { afterEvent: lastEventId } : { after: cursor }
+      );
+      if (closed) return;
+      appendMessages(result.messages);
+      if (result.status === "CLOSED") markClosed();
+    } catch {
+    } finally {
+      ticking = false;
+    }
+  }
+  function startPolling() {
+    stopPolling();
+    timer = setInterval(() => void tick(), pollMs);
+  }
+  function stopPolling() {
+    if (timer !== void 0) clearInterval(timer);
+    timer = void 0;
+  }
+  function teardownRealtime() {
+    if (reconnectTimer !== void 0) clearTimeout(reconnectTimer);
+    reconnectTimer = void 0;
+    if (pingTimer !== void 0) clearInterval(pingTimer);
+    pingTimer = void 0;
+    wsLive = false;
+    if (ws) {
+      const socket = ws;
+      ws = void 0;
+      try {
+        socket.onopen = socket.onmessage = socket.onclose = socket.onerror = null;
+        socket.close();
+      } catch {
+      }
+    }
+  }
+  function scheduleReconnect() {
+    if (closed || wsGivenUp || reconnectTimer !== void 0) return;
+    if (wsFailures >= 5) {
+      wsGivenUp = true;
+      return;
+    }
+    const base = Math.min(3e4, 1e3 * 2 ** wsFailures);
+    const delay = base / 2 + Math.random() * (base / 2);
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = void 0;
+      startRealtime();
+    }, delay);
+  }
+  function handleSocketDown() {
+    teardownRealtime();
+    if (closed || wsGivenUp || snapshot.status === "CLOSED") return;
+    startPolling();
+    wsFailures += 1;
+    scheduleReconnect();
+  }
+  function startRealtime() {
+    if (closed || wsGivenUp || wsLive || ws !== void 0 || !realtimeUrl || !token || !publishableKey || typeof WebSocket === "undefined" || snapshot.status === "CLOSED") {
+      return;
+    }
+    let socket;
+    try {
+      socket = new WebSocket(realtimeUrl);
+    } catch {
+      wsFailures += 1;
+      scheduleReconnect();
+      return;
+    }
+    ws = socket;
+    socket.onopen = () => {
+      try {
+        socket.send(
+          JSON.stringify({
+            type: "auth",
+            publishableKey,
+            conversationToken: token,
+            lastEventId
+          })
+        );
+      } catch {
+        handleSocketDown();
+      }
+    };
+    socket.onmessage = (event) => {
+      let frame;
+      try {
+        frame = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      switch (frame.type) {
+        case "ready": {
+          wsLive = true;
+          wsFailures = 0;
+          stopPolling();
+          if (pingTimer === void 0) {
+            pingTimer = setInterval(() => {
+              try {
+                socket.send(JSON.stringify({ type: "ping" }));
+              } catch {
+              }
+            }, 3e4);
+          }
+          break;
+        }
+        case "message": {
+          const m = frame.message;
+          if (m && typeof m.id === "string") {
+            appendMessages([
+              {
+                ...m,
+                eventId: typeof frame.eventId === "number" ? frame.eventId : m.eventId
+              }
+            ]);
+          }
+          break;
+        }
+        case "status": {
+          if (frame.status === "CLOSED") markClosed();
+          break;
+        }
+        case "error": {
+          wsGivenUp = true;
+          teardownRealtime();
+          if (!closed && snapshot.status !== "CLOSED") startPolling();
+          break;
+        }
+      }
+    };
+    socket.onclose = () => handleSocketDown();
+    socket.onerror = () => {
+    };
+  }
+  async function connect(resumeToken) {
+    if (!publishableKey) {
+      emit({ status: "CLOSED" });
+      return;
+    }
+    try {
+      const cfg = await wire.runtimeConfig(locale);
+      if (closed) return;
+      if (!cfg.enabled) {
+        emit({ status: "CLOSED" });
+        return;
+      }
+      emit({
+        greeting: cfg.greeting,
+        offlineMessage: cfg.offlineMessage,
+        online: cfg.online !== false
+      });
+      if (cfg.realtimeUrl !== void 0) realtimeUrl = cfg.realtimeUrl;
+    } catch (error) {
+      if (closed) return;
+      emit({ status: "ERROR", error });
+      return;
+    }
+    try {
+      const started = await wire.startConversation({
+        visitorSessionId: getVisitorSessionId(),
+        conversationToken: resumeToken,
+        pageUrl: opts.pageUrl ?? (typeof location !== "undefined" ? location.href.slice(0, 2048) : void 0),
+        referrer: opts.referrer,
+        locale,
+        visitor: opts.visitor
+      });
+      if (closed) return;
+      if (!started.enabled) {
+        emit({ status: "CLOSED" });
+        return;
+      }
+      token = started.conversationToken;
+      writeStoredToken(publishableKey, token);
+      if (started.online !== void 0) emit({ online: started.online });
+      emit({ status: "OPEN" });
+      await tick();
+      if (!closed) {
+        startPolling();
+        startRealtime();
+      }
+    } catch (error) {
+      if (closed) return;
+      emit({ status: "ERROR", error });
+    }
+  }
+  const session = {
+    get messages() {
+      return snapshot.messages;
+    },
+    get state() {
+      return snapshot.status;
+    },
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    async send(body) {
+      const trimmed = body.trim();
+      if (!trimmed) throw new Error("send(): message body is empty");
+      if (!token) throw new Error("send(): session is not connected");
+      if (snapshot.status === "CLOSED") {
+        throw new Error("send(): conversation is closed \u2014 call reset()");
+      }
+      emit({ sending: true });
+      try {
+        const clientId = typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 12)}`;
+        const message = await wire.sendMessage(token, {
+          body: trimmed,
+          clientId
+        });
+        appendMessages([message]);
+        return message;
+      } finally {
+        emit({ sending: false });
+      }
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      stopPolling();
+      teardownRealtime();
+      aborter.abort();
+      listeners.clear();
+    },
+    async reset() {
+      teardownRealtime();
+      wsFailures = 0;
+      wsGivenUp = false;
+      if (publishableKey) writeStoredToken(publishableKey, null);
+      token = void 0;
+      cursor = void 0;
+      lastEventId = 0;
+      seen.clear();
+      stopPolling();
+      emit({ messages: [], status: "CONNECTING", error: null });
+      await connect(void 0);
+    }
+  };
+  await connect(publishableKey ? readStoredToken(publishableKey) : void 0);
+  return session;
+}
+
 // src/client.ts
 var BrandfineApiError = class extends Error {
   name = "BrandfineApiError";
@@ -23,6 +373,23 @@ var BrandfineApiError = class extends Error {
 };
 var INSTALLED_MARKER = "data-brandfine-analytics";
 var LIVE_CHAT_MARKER = "data-brandfine-live-chat";
+var LIVE_CHAT_IDENTITY_CONTEXT = "brandfine:live-chat:identity:v1";
+async function hmacHex(key, message) {
+  const enc = new TextEncoder();
+  const cryptoKey = await globalThis.crypto.subtle.importKey(
+    "raw",
+    enc.encode(key),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const sig = await globalThis.crypto.subtle.sign(
+    "HMAC",
+    cryptoKey,
+    enc.encode(message)
+  );
+  return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
 var GTAG_MARKER = "data-brandfine-gtag";
 function injectGoogleTag(measurementId) {
   if (typeof document === "undefined") return;
@@ -170,6 +537,28 @@ function createBrandfineClient(config) {
       return { installed: true, websiteId: cfg.websiteId };
     }
   };
+  async function liveChatWireRequest(key, method, path, body) {
+    const url = `${baseUrl}${path}`;
+    const res = await fetchImpl(url, {
+      method,
+      headers: {
+        Accept: "application/json",
+        ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+        ...key ? { "X-Api-Key": key } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new BrandfineApiError({
+        status: res.status,
+        statusText: res.statusText,
+        body: text,
+        url
+      });
+    }
+    return await res.json();
+  }
   const liveChat = {
     getConfig() {
       return get("/external/live-chat/bootstrap");
@@ -194,6 +583,9 @@ function createBrandfineClient(config) {
       if (opts.visitor?.externalId && opts.visitor.identityToken) {
         host.setAttribute("data-visitor", JSON.stringify(opts.visitor));
       }
+      if (opts.locale) {
+        host.setAttribute("data-locale", opts.locale);
+      }
       if (cfg.theme) {
         for (const [key, value] of Object.entries(cfg.theme)) {
           if (key.startsWith("--bf-chat-")) {
@@ -209,35 +601,67 @@ function createBrandfineClient(config) {
       document.head.appendChild(script);
       return { installed: true };
     },
+    createSession(opts) {
+      const pk = opts.config.enabled ? opts.config.publishableKey : void 0;
+      const wire = {
+        runtimeConfig: (locale) => liveChatWireRequest(
+          pk,
+          "GET",
+          `/external/live-chat/config${locale ? `?locale=${encodeURIComponent(locale)}` : ""}`
+        ),
+        startConversation: (input) => liveChatWireRequest(pk, "POST", "/external/live-chat/conversations", input),
+        sendMessage: (conversationToken, input) => liveChatWireRequest(
+          void 0,
+          "POST",
+          `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages`,
+          input
+        ),
+        history: (conversationToken, o = {}) => liveChatWireRequest(
+          void 0,
+          "GET",
+          `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages${o.afterEvent !== void 0 ? `?afterEvent=${encodeURIComponent(String(o.afterEvent))}` : o.after ? `?after=${encodeURIComponent(o.after)}` : ""}`
+        )
+      };
+      return createLiveChatSession(wire, opts);
+    },
+    runtimeConfig(locale) {
+      return liveChatWireRequest(
+        apiKey,
+        "GET",
+        `/external/live-chat/config${locale ? `?locale=${encodeURIComponent(locale)}` : ""}`
+      );
+    },
+    startConversation(input) {
+      return liveChatWireRequest(apiKey, "POST", "/external/live-chat/conversations", input);
+    },
+    sendMessage(conversationToken, input) {
+      return liveChatWireRequest(
+        void 0,
+        "POST",
+        `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages`,
+        input
+      );
+    },
+    history(conversationToken, o = {}) {
+      const qs = o.afterEvent !== void 0 ? `?afterEvent=${encodeURIComponent(String(o.afterEvent))}` : o.after ? `?after=${encodeURIComponent(o.after)}` : "";
+      return liveChatWireRequest(
+        void 0,
+        "GET",
+        `/external/live-chat/conversations/${encodeURIComponent(conversationToken)}/messages${qs}`
+      );
+    },
     async identityToken(externalId, opts = {}) {
       if (typeof document !== "undefined" || typeof window !== "undefined") {
         throw new Error(
           "liveChat.identityToken() is server-only \u2014 never compute identity tokens in a browser. Sign the visitor on your server and pass the result to install({ visitor })."
         );
       }
-      const secret = opts.secret ?? (typeof process !== "undefined" ? process.env.BRANDFINE_LIVE_CHAT_IDENTITY_SECRET : void 0);
-      if (!secret) {
-        throw new Error(
-          "liveChat.identityToken(): identity secret missing. Pass { secret } or set BRANDFINE_LIVE_CHAT_IDENTITY_SECRET. Generate one in the CMS: Plugins \u2192 Live Chat \u2192 Integrate."
-        );
-      }
       if (!externalId) {
         throw new Error("liveChat.identityToken(): externalId is required.");
       }
-      const enc = new TextEncoder();
-      const key = await globalThis.crypto.subtle.importKey(
-        "raw",
-        enc.encode(secret),
-        { name: "HMAC", hash: "SHA-256" },
-        false,
-        ["sign"]
-      );
-      const sig = await globalThis.crypto.subtle.sign(
-        "HMAC",
-        key,
-        enc.encode(externalId)
-      );
-      return Array.from(new Uint8Array(sig)).map((b) => b.toString(16).padStart(2, "0")).join("");
+      const explicit = opts.secret ?? (typeof process !== "undefined" ? process.env.BRANDFINE_LIVE_CHAT_IDENTITY_SECRET : void 0);
+      const secret = explicit ?? await hmacHex(apiKey, LIVE_CHAT_IDENTITY_CONTEXT);
+      return hmacHex(secret, externalId);
     }
   };
   const submissions = {
@@ -305,6 +729,35 @@ function createBrandfineClient(config) {
         "/external/appointments/requests",
         input
       );
+    },
+    async list(identity) {
+      const res = await post(
+        "/external/appointments/requests/lookup",
+        identity
+      );
+      return res.appointments;
+    },
+    async get(id, identity) {
+      const res = await post(
+        "/external/appointments/requests/lookup",
+        { ...identity, id }
+      );
+      const row = res.appointments[0];
+      if (!row) {
+        throw new BrandfineApiError({
+          status: 404,
+          statusText: "Not Found",
+          body: "Appointment not found.",
+          url: "/external/appointments/requests/lookup"
+        });
+      }
+      return row;
+    },
+    cancel(cancellationToken) {
+      return post(
+        `/external/appointments/requests/${encodeURIComponent(cancellationToken)}/cancel`,
+        {}
+      );
     }
   };
   return {