cursedbelt 4.7.0 → 5.0.0

package/src/react/media/privateClient.ts

@@ -1,82 +0,0 @@
-// ── Private-media client helpers (hook-free) ────────────────────────────────────
-// The fetch/URL logic for the private-media routes, usable OUTSIDE React state — the unlock
-// token is held by one component (an unlock plugin) and handed to others (files/gallery
-// plugins) via a cross-plugin port, so consumers of a passed-in token need these standalone
-// helpers rather than their own usePrivateUnlock state. usePrivateUnlock delegates here:
-// one source of truth for the endpoints' shapes.
-
-/** A clear index row — non-sensitive facts only (matches the server's PrivateIndexRow). */
-export type PrivateIndexRow = {
-  id: string;
-  sizeBytes: number;
-  createdAt: number;
-  status: 'pending' | 'processing' | 'ready' | 'failed';
-};
-
-export type RevealedItem = { id: string; meta: Record<string, unknown> };
-
-export interface PrivateClientConfig {
-  /** Origin+prefix for the private routes. '' = same-origin; an absolute API origin for a
-   * split-origin deploy. */
-  apiBase?: string;
-  /** Route mount prefix (must match mountPrivateRoutes basePath). Default '/_private'. */
-  basePath?: string;
-  /** Extra headers for the GUARDED calls (unlock/index/reveal) — e.g. the app's Bearer. The
-   * token-embedded byte/key URLs need no header. */
-  authHeaders?: () => Record<string, string>;
-}
-
-export const privateBaseUrl = (cfg: PrivateClientConfig): string =>
-  `${cfg.apiBase ?? ''}${cfg.basePath ?? '/_private'}`;
-
-const guardedHeaders = (cfg: PrivateClientConfig): Record<string, string> => ({
-  'content-type': 'application/json',
-  ...(cfg.authHeaders?.() ?? {}),
-});
-
-const postForItems = async (
-  cfg: PrivateClientConfig,
-  path: string,
-  body: Record<string, unknown>,
-): Promise<RevealedItem[]> => {
-  const res = await fetch(`${privateBaseUrl(cfg)}${path}`, {
-    method: 'POST',
-    headers: guardedHeaders(cfg),
-    body: JSON.stringify(body),
-    // Split-origin hosts (SPA on the apex, API on a subdomain) authenticate these
-    // guarded calls with the app's httpOnly session cookie.
-    credentials: 'include',
-  });
-  if (!res.ok) return [];
-  return ((await res.json()) as { items: RevealedItem[] }).items ?? [];
-};
-
-/** Try `password` against every item; returns the ones it decrypts (with their metadata). */
-export const revealPrivateWithPassword = (
-  cfg: PrivateClientConfig,
-  password: string,
-): Promise<RevealedItem[]> => postForItems(cfg, '/reveal', { password });
-
-/** Reveal the items an UNLOCK TOKEN opens — no password re-entry. The token must belong to the
- * session caller (the server enforces it). */
-export const revealPrivateWithToken = (
-  cfg: PrivateClientConfig,
-  token: string,
-): Promise<RevealedItem[]> => postForItems(cfg, '/reveal-unlocked', { token });
-
-/** The token-embedded HLS master URL for a private video — same shape usePrivateUnlock.hlsUrl
- * builds. Needs no auth header (the token IS the authorization). */
-export const privateHlsUrlWithToken = (
-  cfg: PrivateClientConfig,
-  token: string,
-  sourceId: string,
-  videoId: string,
-): string => `${privateBaseUrl(cfg)}/u/${token}/hls/${sourceId}/${videoId}/master.m3u8`;
-
-/** The token-embedded URL for a private NON-video file (photo/doc) stored as an encrypted
- * blob — served decrypted by the gated blob route. Needs no auth header. */
-export const privateFileUrlWithToken = (
-  cfg: PrivateClientConfig,
-  token: string,
-  fileId: string,
-): string => `${privateBaseUrl(cfg)}/u/${token}/file/${fileId}`;

package/src/react/media/usePrivateUnlock.ts

@@ -1,132 +0,0 @@
-import React from 'react';
-import {
-  type PrivateClientConfig,
-  type PrivateIndexRow,
-  privateBaseUrl,
-  privateHlsUrlWithToken,
-  type RevealedItem,
-  revealPrivateWithPassword,
-  revealPrivateWithToken,
-} from './privateClient.js';
-
-// ── usePrivateUnlock ────────────────────────────────────────────────────────────
-// The client state machine for encrypted private media. It drives the cursedbelt-server
-// private-media routes: unlock (get a token sealing the set key), the clear index (sizes only,
-// for cleanup), try-a-password reveal, and building the token-embedded HLS URL a player loads.
-// UI-agnostic — a modal / index view / gallery toggle all consume this one hook. The fetch/URL
-// shapes live in ./privateClient (hook-free) so a component holding a PASSED-IN token (via a
-// cross-plugin port) can call the same endpoints without this hook's state.
-
-export type { PrivateIndexRow, RevealedItem } from './privateClient.js';
-
-export type UsePrivateUnlockOptions = PrivateClientConfig;
-
-export type PrivateUnlock = {
-  token: string | null;
-  mode: 'standard' | 'deniable' | null;
-  busy: boolean;
-  error: string | null;
-  /** Unlock: pass a password for a deniable set, or omit for the standard (server-key) set.
-   * Returns true on success. */
-  unlock(password?: string): Promise<boolean>;
-  /** Drop the token (re-lock). */
-  lock(): void;
-  /** Fetch the clear index (sizes + created-at) for the cleanup view. */
-  loadIndex(): Promise<PrivateIndexRow[]>;
-  /** Try a password against every item; returns the ones it decrypts (with their metadata). */
-  reveal(password: string): Promise<RevealedItem[]>;
-  /** Reveal the items the CURRENT unlock token opens — no password re-entry. Throws when
-   * locked (no token). */
-  revealUnlocked(): Promise<RevealedItem[]>;
-  /** Build the token-embedded HLS master URL for a private video (null when locked). */
-  hlsUrl(sourceId: string, videoId: string): string | null;
-};
-
-export function usePrivateUnlock(opts: UsePrivateUnlockOptions = {}): PrivateUnlock {
-  const { apiBase, basePath, authHeaders } = opts;
-  const cfg = React.useMemo<PrivateClientConfig>(
-    () => ({ apiBase, basePath, authHeaders }),
-    [apiBase, basePath, authHeaders],
-  );
-  const base = privateBaseUrl(cfg);
-  const [token, setToken] = React.useState<string | null>(null);
-  const [mode, setMode] = React.useState<'standard' | 'deniable' | null>(null);
-  const [busy, setBusy] = React.useState(false);
-  const [error, setError] = React.useState<string | null>(null);
-
-  const guarded = React.useCallback(
-    (extra?: Record<string, string>): Record<string, string> => ({
-      'content-type': 'application/json',
-      ...(authHeaders?.() ?? {}),
-      ...extra,
-    }),
-    [authHeaders],
-  );
-
-  const unlock = React.useCallback(
-    async (password?: string): Promise<boolean> => {
-      setBusy(true);
-      setError(null);
-      try {
-        const res = await fetch(`${base}/unlock`, {
-          method: 'POST',
-          headers: guarded(),
-          body: JSON.stringify(password ? { password } : {}),
-          // Split-origin hosts authenticate via the app's httpOnly session cookie —
-          // matches postForItems in ./privateClient and createServiceClient.
-          credentials: 'include',
-        });
-        if (!res.ok) {
-          setError('Unlock failed');
-          return false;
-        }
-        const data = (await res.json()) as { token: string; mode: 'standard' | 'deniable' };
-        setToken(data.token);
-        setMode(data.mode);
-        return true;
-      } catch {
-        setError('Unlock failed');
-        return false;
-      } finally {
-        setBusy(false);
-      }
-    },
-    [base, guarded],
-  );
-
-  const lock = React.useCallback(() => {
-    setToken(null);
-    setMode(null);
-  }, []);
-
-  const loadIndex = React.useCallback(async (): Promise<PrivateIndexRow[]> => {
-    const res = await fetch(`${base}/index`, { headers: guarded(), credentials: 'include' });
-    if (!res.ok) return [];
-    return ((await res.json()) as { items: PrivateIndexRow[] }).items ?? [];
-  }, [base, guarded]);
-
-  const reveal = React.useCallback(
-    (password: string): Promise<RevealedItem[]> => revealPrivateWithPassword(cfg, password),
-    [cfg],
-  );
-
-  const revealUnlocked = React.useCallback((): Promise<RevealedItem[]> => {
-    if (!token) return Promise.reject(new Error('locked — unlock first'));
-    return revealPrivateWithToken(cfg, token);
-  }, [cfg, token]);
-
-  const hlsUrl = React.useCallback(
-    (sourceId: string, videoId: string): string | null =>
-      token ? privateHlsUrlWithToken(cfg, token, sourceId, videoId) : null,
-    [cfg, token],
-  );
-
-  // Memoise the returned object so it's a STABLE reference across renders (the callbacks are
-  // already useCallback-stable; only real state changes flip it). Without this, consumers doing
-  // `useEffect(() => { unlock.loadIndex()… }, [unlock])` would loop — a new object every render
-  // re-runs the effect → setState → re-render → "Maximum update depth exceeded".
-  return React.useMemo(
-    () => ({ token, mode, busy, error, unlock, lock, loadIndex, reveal, revealUnlocked, hlsUrl }),
-    [token, mode, busy, error, unlock, lock, loadIndex, reveal, revealUnlocked, hlsUrl],
-  );
-}