inbox-sync.ts (6902B)
1 import { 2 captureUnlockedSession, 3 closeUnlockedSession 4 } from '../../../src/lib/messaging/unlocked-session.ts'; 5 import { identitySessionSnapshot } from '../../../src/lib/runtime/identity-session.ts'; 6 import { 7 browserExtensionScheduler, 8 extensionSchedulerSnapshot 9 } from '../../../src/lib/nostr/extension-scheduler.ts'; 10 import { makeFixture as makeRecoveryFixture } from './resume-preparation.ts'; 11 import { 12 validateRelayPolicy, 13 readRelayPolicy 14 } from '../../../src/lib/config/relays.ts'; 15 import { 16 createPrivateSession, 17 closePrivateSession, 18 privateSessionOwnership 19 } from '../../../src/lib/runtime/private-session.ts'; 20 import { 21 captureInboxSync, 22 startInboxSync, 23 stopInboxSync, 24 inboxSyncSnapshot, 25 type InboxSync 26 } from '../../../src/lib/messaging/inbox-sync.ts'; 27 import { loadPrivateRecord } from '../../../src/lib/persistence/private-storage.ts'; 28 import { privateRecordSnapshot } from '../../../src/lib/persistence/private-records.ts'; 29 import { 30 getPublicStore, 31 publicStoreEnvelope 32 } from '../../../src/lib/nostr/public-store.ts'; 33 export async function makeFixture() { 34 const f = await makeRecoveryFixture(); 35 const policy = validateRelayPolicy( 36 JSON.stringify({ 37 ...readRelayPolicy(f.context.policy), 38 messagingEnabled: true 39 }) 40 ); 41 if (!policy) throw Error('fixture policy unavailable'); 42 const session = await createPrivateSession( 43 f.identity, 44 'reviewed_private_session' 45 ); 46 if (!session) throw Error('missing genuine session'); 47 const capturedSession = session; 48 const capture = privateSessionOwnership(session)!; 49 const unlocked = captureUnlockedSession(session, 'reviewed_messages_unlock'); 50 if (!unlocked) throw Error('missing genuine unlock'); 51 const publicStore = getPublicStore()!; 52 const self = (await f.row())!.record.self; 53 let ingress: InboxSync | undefined; 54 async function retireOriginalSync() { 55 for (;;) { 56 let incomplete = false; 57 try { 58 if (ingress) stopInboxSync(ingress); 59 } catch (error) { 60 if ( 61 !(error instanceof Error) || 62 error.message !== 'private_inbox_cleanup_required' 63 ) 64 throw error; 65 incomplete = true; 66 } 67 const sessionClean = closePrivateSession(capturedSession); 68 if (!incomplete && sessionClean) { 69 if (ingress && inboxSyncSnapshot(ingress)?.cleanupRequired) 70 throw Error('actual original sync cleanup remains incomplete'); 71 return; 72 } 73 // Retry exact original disposal after its actual SDK close observers; 74 // this wait starts no retrieval, permission or replacement session. 75 await new Promise<void>((resolve) => setTimeout(resolve, 0)); 76 } 77 } 78 79 let authorized = true; 80 let restoreFault = () => {}; 81 let releaseKey: (() => void) | undefined; 82 let restoreKey = () => {}; 83 return { 84 ...f, 85 outer: self.wire, 86 outerId: self.eventId, 87 capture(access = true, review: unknown = 'reviewed_foreground_inbox') { 88 const candidate = captureInboxSync( 89 f.repository, 90 session, 91 policy, 92 f.context.own, 93 unlocked, 94 access 95 ? (context) => ({ 96 ...context, 97 receive: 'qualified_exercised', 98 archive: 'qualified_exercised', 99 current: () => authorized && capture.current() 100 }) 101 : undefined, 102 review 103 ); 104 if (candidate) ingress = candidate; 105 return !!candidate; 106 }, 107 start(review: unknown = 'reviewed_foreground_inbox') { 108 if (!ingress) return false; 109 return startInboxSync(ingress, review); 110 }, 111 stop: retireOriginalSync, 112 snapshot: () => ingress && inboxSyncSnapshot(ingress), 113 async stored(id = self.eventId) { 114 const row = await loadPrivateRecord( 115 f.repository, 116 'received_envelopes', 117 id 118 ); 119 return row.ok ? privateRecordSnapshot(row.value, f.owner, id) : undefined; 120 }, 121 publicContains: (id = self.eventId) => 122 !!publicStoreEnvelope(publicStore, id), 123 countsValue: () => f.counts(), 124 closeUnlock() { 125 closeUnlockedSession(unlocked); 126 }, 127 navigateAway: retireOriginalSync, 128 changeKey() { 129 f.mode('changed_key'); 130 }, 131 holdNextKey() { 132 const provider = window.nostr as 133 { getPublicKey: () => Promise<string> } | undefined; 134 if (!provider) throw Error('missing genuine fixture provider'); 135 const original = provider.getPublicKey; 136 provider.getPublicKey = async () => { 137 const owner = await original.call(provider); 138 return await new Promise<string>((resolve) => { 139 releaseKey = () => resolve(owner); 140 }); 141 }; 142 restoreKey = () => { 143 provider.getPublicKey = original; 144 }; 145 }, 146 pendingKey: () => !!releaseKey, 147 keyJobOccupied() { 148 const scheduler = browserExtensionScheduler(); 149 const slot = scheduler && extensionSchedulerSnapshot(scheduler); 150 return slot?.state === 'active' && slot.pending === 'key'; 151 }, 152 identityState: () => identitySessionSnapshot(f.identity).state, 153 settleKey() { 154 const release = releaseKey; 155 releaseKey = undefined; 156 restoreKey(); 157 release?.(); 158 }, 159 revokeAccess() { 160 authorized = false; 161 }, 162 logout() { 163 closePrivateSession(session); 164 }, 165 logoutIdentity() { 166 f.disconnect(); 167 closePrivateSession(session); 168 }, 169 restoreFault() { 170 restoreFault(); 171 }, 172 faultRetention(kind: 'abort' | 'readback') { 173 const put = Reflect.get<IDBObjectStore, 'put'>( 174 IDBObjectStore.prototype, 175 'put' 176 ); 177 const cursor = Reflect.get<IDBIndex, 'openCursor'>( 178 IDBIndex.prototype, 179 'openCursor' 180 ); 181 let written = false; 182 IDBObjectStore.prototype.put = function ( 183 ...args: Parameters<IDBObjectStore['put']> 184 ) { 185 const request = put.apply(this, args); 186 if (this.name === 'received_envelopes') { 187 written = true; 188 if (kind === 'abort') this.transaction.abort(); 189 } 190 return request; 191 }; 192 IDBIndex.prototype.openCursor = function ( 193 ...args: Parameters<IDBIndex['openCursor']> 194 ) { 195 if ( 196 kind === 'readback' && 197 written && 198 this.objectStore.name === 'received_envelopes' && 199 this.objectStore.transaction.mode === 'readonly' 200 ) 201 throw Error('actual post-put inbox readback failure'); 202 return cursor.apply(this, args); 203 }; 204 restoreFault = () => { 205 IDBObjectStore.prototype.put = put; 206 IDBIndex.prototype.openCursor = cursor; 207 }; 208 }, 209 async close() { 210 const release = releaseKey; 211 releaseKey = undefined; 212 restoreKey(); 213 release?.(); 214 restoreFault(); 215 await retireOriginalSync(); 216 closePrivateSession(session); 217 f.close(); 218 } 219 }; 220 }