app

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

identity-session.ts (11873B)


      1 import {
      2   createExtensionAdapter,
      3   extensionSnapshot,
      4   connectExtensionAdapter,
      5   recheckExtensionAdapter,
      6   probeExtensionAdapter,
      7   disconnectExtensionAdapter,
      8   extensionOwnershipCapture,
      9   extensionMessagingOwnershipCapture,
     10   subscribeExtensionInvalidation,
     11   signApprovedExtensionAdapter,
     12   markApprovedSigningWaitExpired,
     13   type ApprovedSignResult,
     14   type ExtensionAdapter,
     15   type ExtensionSnapshot,
     16   type ExtensionGuestReason
     17 } from '../nostr/extension.ts';
     18 import { approveCapturedPublicSigning } from '../nostr/approved-signing.ts';
     19 import {
     20   publicRecordSnapshot,
     21   publicRecordWire,
     22   type PublicRecordHandle
     23 } from '../persistence/records.ts';
     24 import {
     25   stopPublicEffect,
     26   type PublicEffectLease,
     27   type PublicEffectCapture
     28 } from './effect-ownership.ts';
     29 import {
     30   bindLatePublicResponse,
     31   latePublicResultIdentity,
     32   reviewLatePublicArtifact,
     33   type LatePublicArtifact
     34 } from './late-results.ts';
     35 import {
     36   capturedArtifactSnapshot,
     37   type CapturedArtifact
     38 } from '../persistence/artifact-records.ts';
     39 
     40 declare const sessionBrand: unique symbol;
     41 export type IdentitySession = Readonly<{ [sessionBrand]: true }>;
     42 export type IdentitySnapshot = (
     43   | Readonly<{ state: 'guest'; reason: ExtensionGuestReason }>
     44   | Readonly<{ state: 'pending'; action: 'connect' | 'recheck' | 'probe' }>
     45   | Readonly<{
     46       state: 'connected' | 'signing_only' | 'messaging_capable';
     47       publicKey: string;
     48       messaging: 'not_probed' | 'unsupported' | 'refused' | 'capable';
     49     }>
     50 ) &
     51   Readonly<{ admission?: 'busy' }>;
     52 // Per-client opaque session, never a module-global server user. A public key is
     53 // an extension observation, not installed-account or publishing authorization.
     54 const sessions = new WeakMap<IdentitySession, ExtensionAdapter>();
     55 type ViewController = { stamp(): symbol; invalidate(): void };
     56 const views = new WeakMap<IdentitySession, ViewController>();
     57 declare const operationBrand: unique symbol;
     58 export type IdentityPublicOperation = Readonly<{ [operationBrand]: true }>;
     59 type OperationController = {
     60   session: IdentitySession;
     61   ownership(): PublicEffectCapture | undefined;
     62   sign(lease: PublicEffectLease): Promise<ApprovedSignResult>;
     63   stop(expired: boolean): void;
     64   snapshot(): Readonly<{
     65     owner: string;
     66     id: string;
     67     revision: number;
     68     hash: string;
     69     current: boolean;
     70     lateAvailable: boolean;
     71     outcome: ApprovedSignResult['status'] | 'not_started' | 'pending';
     72   }>;
     73   review(
     74     record: PublicRecordHandle,
     75     review: unknown
     76   ): CapturedArtifact | undefined;
     77 };
     78 const operations = new WeakMap<IdentityPublicOperation, OperationController>();
     79 export function createIdentitySession(): IdentitySession {
     80   const session = Object.freeze({}) as IdentitySession;
     81   sessions.set(session, createExtensionAdapter());
     82   let stamp = Symbol();
     83   views.set(session, {
     84     stamp: () => stamp,
     85     invalidate() {
     86       stamp = Symbol();
     87     }
     88   });
     89   return session;
     90 }
     91 function mapIdentitySnapshot(snapshot: ExtensionSnapshot): IdentitySnapshot {
     92   if (snapshot.state !== 'connected') return { ...snapshot };
     93   const state: IdentitySnapshot = {
     94     state:
     95       snapshot.messaging === 'capable' && snapshot.signingCandidate
     96         ? 'messaging_capable'
     97         : snapshot.signingCandidate
     98           ? 'signing_only'
     99           : 'connected',
    100     publicKey: snapshot.publicKey,
    101     messaging: snapshot.messaging
    102   };
    103   return snapshot.admission === 'busy'
    104     ? { ...state, admission: 'busy' }
    105     : state;
    106 }
    107 export function identitySessionSnapshot(
    108   session: IdentitySession
    109 ): IdentitySnapshot {
    110   const adapter = sessions.get(session);
    111   return adapter
    112     ? mapIdentitySnapshot(extensionSnapshot(adapter))
    113     : { state: 'guest', reason: 'unavailable' };
    114 }
    115 export async function connectIdentity(
    116   session: IdentitySession
    117 ): Promise<IdentitySnapshot> {
    118   const adapter = sessions.get(session);
    119   if (adapter)
    120     return mapIdentitySnapshot(await connectExtensionAdapter(adapter));
    121   return identitySessionSnapshot(session);
    122 }
    123 export async function recheckIdentityOwner(
    124   session: IdentitySession
    125 ): Promise<IdentitySnapshot> {
    126   const adapter = sessions.get(session);
    127   if (adapter)
    128     return mapIdentitySnapshot(await recheckExtensionAdapter(adapter));
    129   return identitySessionSnapshot(session);
    130 }
    131 export async function probeIdentityMessaging(
    132   session: IdentitySession,
    133   review: unknown
    134 ): Promise<IdentitySnapshot> {
    135   const adapter = sessions.get(session);
    136   if (adapter)
    137     return mapIdentitySnapshot(await probeExtensionAdapter(adapter, review));
    138   return identitySessionSnapshot(session);
    139 }
    140 export function disconnectIdentity(session: IdentitySession): void {
    141   views.get(session)?.invalidate();
    142   const adapter = sessions.get(session);
    143   if (adapter) disconnectExtensionAdapter(adapter);
    144 }
    145 // Internal messaging lifecycle ports. Captured observation is not an inbox
    146 // configuration, AUTH, private store or publication permission.
    147 export function identityMessagingOwnership(
    148   session: IdentitySession
    149 ): PublicEffectCapture | undefined {
    150   const adapter = sessions.get(session);
    151   return adapter && extensionMessagingOwnershipCapture(adapter);
    152 }
    153 // Local account metadata uses the original observed extension generation. This
    154 // grants no signing, messaging, installed account or network effect authority.
    155 export function identityLocalOwnership(session: IdentitySession) {
    156   const observed = identitySessionSnapshot(session);
    157   if (!('publicKey' in observed)) return;
    158   const adapter = sessions.get(session);
    159   const captured = adapter && extensionOwnershipCapture(adapter);
    160   return (
    161     captured && {
    162       owner: captured.owner,
    163       session: captured.session,
    164       current: () => {
    165         const state = identitySessionSnapshot(session);
    166         return (
    167           captured.current() &&
    168           'publicKey' in state &&
    169           state.publicKey === captured.owner
    170         );
    171       }
    172     }
    173   );
    174 }
    175 export function subscribeIdentityInvalidation(
    176   session: IdentitySession,
    177   listener: () => void
    178 ): () => void {
    179   const adapter = sessions.get(session);
    180   return adapter ? subscribeExtensionInvalidation(adapter, listener) : () => {};
    181 }
    182 // Explicit route/input lifecycle event. No draft, DB, reconnect or SDK effect.
    183 export function invalidateIdentityOperations(session: IdentitySession): void {
    184   views.get(session)?.invalidate();
    185 }
    186 // Internal public operation capability, never an unrestricted UI template signer.
    187 // Current-head/inbox/IDB preparation and publication retain their typed owners.
    188 export function captureIdentityPublicOperation(
    189   session: IdentitySession,
    190   record: PublicRecordHandle,
    191   id: unknown,
    192   review: unknown
    193 ): IdentityPublicOperation | undefined {
    194   const adapter = sessions.get(session),
    195     view = views.get(session);
    196   const captured = adapter && extensionOwnershipCapture(adapter);
    197   if (!adapter || !view || !captured) return undefined;
    198   const row = publicRecordSnapshot(record, captured.owner, id),
    199     recordWire = publicRecordWire(record, captured.owner, id);
    200   const approval = approveCapturedPublicSigning(
    201     record,
    202     captured.owner,
    203     id,
    204     review
    205   );
    206   if (
    207     !row ||
    208     !recordWire ||
    209     !approval ||
    210     row.family === 'public_draft' ||
    211     row.revision !== 0
    212   )
    213     return undefined;
    214   const owner = row.owner,
    215     command = row.id,
    216     epoch = view.stamp(),
    217     originalSession = captured.session;
    218   let stopped = false,
    219     pending = false;
    220   let lease: PublicEffectLease | undefined,
    221     late: LatePublicArtifact | undefined;
    222   let outcome: ApprovedSignResult['status'] | 'not_started' | 'pending' =
    223     'not_started';
    224   const current = () =>
    225     !stopped && view.stamp() === epoch && captured.current();
    226   const token = Object.freeze({}) as IdentityPublicOperation;
    227   operations.set(token, {
    228     session,
    229     ownership: () =>
    230       current() ? { owner, session: originalSession, current } : undefined,
    231     async sign(originalLease) {
    232       if (pending) return { status: 'busy' };
    233       if (!current()) return { status: 'stale' };
    234       pending = true;
    235       lease = originalLease;
    236       outcome = 'pending';
    237       try {
    238         let result = await signApprovedExtensionAdapter(
    239           adapter,
    240           approval,
    241           originalLease
    242         );
    243         // The adapter's promise can settle before this continuation runs.
    244         // Recheck this view before disclosing a normal signed result.
    245         if (result.status === 'signed' && !current()) {
    246           const artifact = capturedArtifactSnapshot(result.artifact);
    247           const originalLate =
    248             artifact &&
    249             bindLatePublicResponse(
    250               approval,
    251               JSON.parse(artifact.wire),
    252               originalSession
    253             );
    254           result = originalLate
    255             ? { status: 'unknown', late: originalLate }
    256             : { status: 'unknown' };
    257         }
    258         outcome = result.status;
    259         if (result.status === 'unknown' && result.late) {
    260           const original = latePublicResultIdentity(result.late);
    261           if (
    262             original?.owner === owner &&
    263             original.id === command &&
    264             original.recordWire === recordWire &&
    265             original.session === originalSession
    266           )
    267             late = result.late;
    268         }
    269         // Only disclosure/explicit original-operation review can obtain a late
    270         // artifact. A normal signing result never returns it after invalidation.
    271         return result.status === 'unknown' ? { status: 'unknown' } : result;
    272       } finally {
    273         pending = false;
    274         lease = undefined;
    275       }
    276     },
    277     stop(expired) {
    278       stopped = true;
    279       if (lease) {
    280         if (expired) markApprovedSigningWaitExpired(adapter, approval, lease);
    281         stopPublicEffect(lease);
    282       }
    283     },
    284     snapshot: () => ({
    285       owner,
    286       id: command,
    287       revision: row.revision,
    288       hash: row.capture.hash,
    289       current: current(),
    290       lateAvailable: late !== undefined,
    291       outcome
    292     }),
    293     review(original, consent) {
    294       const observed = extensionSnapshot(adapter);
    295       return late &&
    296         observed.state === 'connected' &&
    297         observed.publicKey === owner
    298         ? reviewLatePublicArtifact(late, original, owner, command, consent)
    299         : undefined;
    300     }
    301   });
    302   return token;
    303 }
    304 function operationOf(session: IdentitySession, token: IdentityPublicOperation) {
    305   const operation = operations.get(token);
    306   return operation?.session === session ? operation : undefined;
    307 }
    308 export function identityPublicOperationOwnership(
    309   session: IdentitySession,
    310   operation: IdentityPublicOperation
    311 ): PublicEffectCapture | undefined {
    312   return operationOf(session, operation)?.ownership();
    313 }
    314 export function identityPublicOperationSnapshot(
    315   session: IdentitySession,
    316   operation: IdentityPublicOperation
    317 ) {
    318   return operationOf(session, operation)?.snapshot();
    319 }
    320 export function signIdentityPublicOperation(
    321   session: IdentitySession,
    322   operation: IdentityPublicOperation,
    323   lease: PublicEffectLease
    324 ): Promise<ApprovedSignResult> {
    325   return (
    326     operationOf(session, operation)?.sign(lease) ??
    327     Promise.resolve({ status: 'invalid_approval' })
    328   );
    329 }
    330 export function stopIdentityPublicOperation(
    331   session: IdentitySession,
    332   operation: IdentityPublicOperation
    333 ): void {
    334   operationOf(session, operation)?.stop(false);
    335 }
    336 // UI supplies expiry; existing scheduler owns its actual pending promise.
    337 export function expireIdentityPublicOperationWait(
    338   session: IdentitySession,
    339   operation: IdentityPublicOperation
    340 ): void {
    341   operationOf(session, operation)?.stop(true);
    342 }
    343 // Pure same-author original review, not fresh author/CAS/resume/publish proof.
    344 export function reviewIdentityLatePublicArtifact(
    345   session: IdentitySession,
    346   operation: IdentityPublicOperation,
    347   original: PublicRecordHandle,
    348   review: unknown
    349 ): CapturedArtifact | undefined {
    350   return operationOf(session, operation)?.review(original, review);
    351 }