app

Local-first trade for farms and co-ops
git clone https://radroots.dev/git/app.git
Log | Files | Refs | README | LICENSE

private-session.ts (6627B)


      1 import {
      2   identityMessagingOwnership,
      3   recheckIdentityOwner,
      4   subscribeIdentityInvalidation,
      5   disconnectIdentity,
      6   type IdentitySession
      7 } from './identity-session.ts';
      8 import type { PublicEffectCapture } from './effect-ownership.ts';
      9 import {
     10   browserExtensionScheduler,
     11   runExtensionAction
     12 } from '../nostr/extension-scheduler.ts';
     13 declare const privateBrand: unique symbol;
     14 export type PrivateSession = Readonly<{ [privateBrand]: true }>;
     15 type Controller = {
     16   identity: IdentitySession;
     17   capture: PublicEffectCapture;
     18   current(): boolean;
     19   close(): boolean;
     20   cleanupRequired(): boolean;
     21   subscribe(listener: () => void): () => void;
     22 };
     23 const sessions = new WeakMap<PrivateSession, Controller>();
     24 const currentSessions = new WeakMap<IdentitySession, PrivateSession>();
     25 // No sockets, decryption, stores or readiness on construction. Only an explicit
     26 // capability action may perform the fresh owner recheck through the page SDK
     27 // scheduler. The generation is the real adapter's, not a caller-supplied key.
     28 export async function createPrivateSession(
     29   identity: IdentitySession,
     30   review: unknown
     31 ): Promise<PrivateSession | undefined> {
     32   if (typeof window === 'undefined' || review !== 'reviewed_private_session')
     33     return undefined;
     34   // Retire unresolved old resources before any new provider observation. A new
     35   // author/generation cannot replace failed authenticated socket ownership.
     36   const previous = currentSessions.get(identity);
     37   const prior = previous && sessions.get(previous);
     38   if (prior && !prior.current() && !prior.close()) return undefined;
     39   const before = identityMessagingOwnership(identity);
     40   if (!before) return undefined;
     41   const checked = await recheckIdentityOwner(identity);
     42   const capture = identityMessagingOwnership(identity);
     43   if (
     44     !before.current() ||
     45     checked.state !== 'messaging_capable' ||
     46     checked.admission === 'busy' ||
     47     !capture ||
     48     capture.owner !== before.owner ||
     49     capture.session !== before.session
     50   )
     51     return undefined;
     52   const existing = currentSessions.get(identity);
     53   if (existing && sessions.get(existing)?.current()) return existing;
     54   if (existing && !sessions.get(existing)?.close()) return undefined;
     55   const token = Object.freeze({}) as PrivateSession;
     56   const listeners = new Map<symbol, () => void>();
     57   let closed = false;
     58   let closing = false;
     59   let unsubscribe = () => {};
     60   const current = () => !closed && capture.current();
     61   function close() {
     62     closed = true;
     63     if (closing) return false;
     64     closing = true;
     65     try {
     66       unsubscribe();
     67       for (const [id, listener] of listeners) {
     68         try {
     69           listener();
     70           listeners.delete(id);
     71         } catch {
     72           // Keep only failed cleanup registrations for an actual retry. Drain
     73           // other resources now; passive invalidation never leaks exceptions.
     74         }
     75       }
     76     } finally {
     77       closing = false;
     78     }
     79     return listeners.size === 0;
     80   }
     81   sessions.set(token, {
     82     identity,
     83     capture,
     84     current,
     85     close,
     86     cleanupRequired: () => closed && listeners.size !== 0,
     87     subscribe(listener) {
     88       const id = Symbol();
     89       listeners.set(id, listener);
     90       if (!current()) close();
     91       return () => {
     92         listeners.delete(id);
     93       };
     94     }
     95   });
     96   unsubscribe = subscribeIdentityInvalidation(identity, () => {
     97     if (!current()) close();
     98   });
     99   // Observe again after registering: no missed invalidation/acquisition seam.
    100   if (!current()) {
    101     close();
    102     return undefined;
    103   }
    104   currentSessions.set(identity, token);
    105   return token;
    106 }
    107 export function privateSessionOwnership(
    108   token: PrivateSession
    109 ): PublicEffectCapture | undefined {
    110   const state = sessions.get(token);
    111   if (!state?.current()) {
    112     state?.close();
    113     return undefined;
    114   }
    115   return {
    116     owner: state.capture.owner,
    117     session: state.capture.session,
    118     current: () => state.current()
    119   };
    120 }
    121 export function privateSessionSnapshot(
    122   token: PrivateSession
    123 ): Readonly<{ owner: string; current: boolean }> | undefined {
    124   const state = sessions.get(token);
    125   return (
    126     state && {
    127       owner: state.capture.owner,
    128       current: state.current()
    129     }
    130   );
    131 }
    132 export function privateSessionCleanupRequired(token: PrivateSession): boolean {
    133   return sessions.get(token)?.cleanupRequired() ?? false;
    134 }
    135 export function subscribePrivateSessionClose(
    136   token: PrivateSession,
    137   listener: () => void
    138 ): () => void {
    139   const state = sessions.get(token);
    140   if (!state) throw new Error('private_session_invalid');
    141   return state.subscribe(listener);
    142 }
    143 export function closePrivateSession(token: PrivateSession): boolean {
    144   return sessions.get(token)?.close() ?? false;
    145 }
    146 // A trusted private owner has actually observed key/capability loss. Invalidate
    147 // synchronously inside its occupied permission job without a second provider
    148 // request. The original captured generation must still be current: a late old
    149 // callback cannot disconnect a newly connected generation of this identity.
    150 export function invalidatePrivateSessionGeneration(
    151   token: PrivateSession
    152 ): boolean {
    153   const state = sessions.get(token);
    154   if (!state?.current()) return false;
    155   disconnectIdentity(state.identity);
    156   state.close();
    157   return true;
    158 }
    159 // Every new finite network action gets a fresh SDK owner observation; neither
    160 // a remembered key nor a still-current presentation snapshot substitutes.
    161 export async function recheckPrivateSession(
    162   token: PrivateSession
    163 ): Promise<boolean> {
    164   const state = sessions.get(token);
    165   if (!state?.current()) return false;
    166   const checked = await recheckIdentityOwner(state.identity);
    167   return (
    168     state.current() &&
    169     checked.state === 'messaging_capable' &&
    170     checked.publicKey === state.capture.owner &&
    171     checked.admission !== 'busy'
    172   );
    173 }
    174 
    175 // A short local-storage action reserves the actual shared SDK slot without
    176 // invoking the provider. No permission/network work belongs inside this job.
    177 export async function withIdlePrivateLocalStorage<T>(
    178   token: PrivateSession,
    179   work: (this: void) => Promise<T>
    180 ): Promise<Readonly<{ ok: true; value: T }> | Readonly<{ ok: false }>> {
    181   const state = sessions.get(token),
    182     scheduler = browserExtensionScheduler();
    183   if (!state?.current() || !scheduler) return { ok: false };
    184   const result = await runExtensionAction(
    185     scheduler,
    186     {
    187       owner: state.capture.owner,
    188       session: state.capture.session,
    189       operation: Symbol()
    190     },
    191     () => state.current(),
    192     () => work()
    193   );
    194   return result.status === 'completed' && 'value' in result && state.current()
    195     ? { ok: true, value: result.value as T }
    196     : { ok: false };
    197 }