reply-composer.ts (15718B)
1 import { mount, unmount } from 'svelte'; 2 import type { beforeNavigate as KitBeforeNavigate } from '$app/navigation'; 3 type BeforeNavigate = Parameters<Parameters<typeof KitBeforeNavigate>[0]>[0]; 4 import { 5 finalizeEvent, 6 type UnsignedEvent, 7 type NostrEvent 8 } from 'applesauce-core/helpers'; 9 import { renderFixture as renderThread } from './conversation-thread.ts'; 10 import Panel from './reply-composer-panel.svelte'; 11 import { 12 createReplyController, 13 createRuntimeReplyController, 14 replySnapshot, 15 replyText, 16 updateReplyText, 17 sendReply, 18 closeReplyController, 19 requestReplyNavigation, 20 keepReplyEditing, 21 discardReplyNavigation, 22 selectReplyParent 23 } from '../../../src/lib/messaging/reply-controller.ts'; 24 import { 25 inboxListSnapshot, 26 inboxReplyOwnership 27 } from '../../../src/lib/messaging/inbox-view.ts'; 28 import { 29 captureAuthenticatedReplyRumor, 30 rumorPlanSnapshot, 31 stopRumorPlan 32 } from '../../../src/lib/messaging/rumor-plan.ts'; 33 import { 34 createIdentitySession, 35 connectIdentity, 36 probeIdentityMessaging, 37 disconnectIdentity 38 } from '../../../src/lib/runtime/identity-session.ts'; 39 import { 40 inboxSetupViewOwnership, 41 inboxSetupViewSnapshot 42 } from '../../../src/lib/messaging/inbox-setup-view.ts'; 43 import { createInboxResolver } from '../../../src/lib/messaging/resolve-inbox.ts'; 44 import { browserDatabaseTransaction } from '../../../src/lib/persistence/database.ts'; 45 import { 46 createPublicScheduler, 47 createPublicRun, 48 openInboxRequest, 49 closePublicScheduler, 50 type RequestClock 51 } from '../../../src/lib/nostr/request-scope.ts'; 52 import { 53 createPublicRuntimeContext, 54 mountPublicRuntime, 55 closePublicRuntime 56 } from '../../../src/lib/runtime/public-runtime.ts'; 57 58 const navigation: ((event: BeforeNavigate) => void)[] = []; 59 let destinations = Array.from<string>([]); 60 export function beforeNavigate(callback: (event: BeforeNavigate) => void) { 61 navigation.push(callback); 62 } 63 export function goto(destination: string | URL) { 64 destinations = destinations.concat(String(destination)); 65 return Promise.resolve(); 66 } 67 export async function renderReplyFixture(qualified = true, production = false) { 68 navigation.length = 0; 69 destinations = []; 70 const manager = navigator.locks; 71 const originalDescriptor = Object.getOwnPropertyDescriptor( 72 manager, 73 'request' 74 ); 75 const originalRequest = Reflect.get(manager, 'request'); 76 let crossOwnerSecond: string | undefined; 77 let nativeTransactions: { 78 stores: string[]; 79 outcome: 'abort' | 'complete'; 80 }[] = []; 81 let restoreTransaction = () => {}; 82 let commandIds: string[] = []; 83 let lockAttempts: { name: string; ifAvailable: boolean; granted: boolean }[] = 84 []; 85 const observedRequest = ((...args: unknown[]) => { 86 const callbackIndex = args.length - 1; 87 const callback = args[callbackIndex] as (lock: Lock | null) => unknown; 88 const options = args.length === 3 ? (args[1] as LockOptions) : undefined; 89 const forwarded = args.slice(); 90 forwarded[callbackIndex] = (lock: Lock | null) => { 91 lockAttempts = lockAttempts.concat({ 92 name: String(args[0]), 93 ifAvailable: options?.ifAvailable === true, 94 granted: lock !== null 95 }); 96 if (lock && options?.ifAvailable && args[0] === crossOwnerSecond) { 97 crossOwnerSecond = undefined; 98 const capturedSecond = Math.floor(clockSamples.at(-1)!.value / 1000); 99 return (async () => { 100 await new Promise<void>((resolve) => { 101 function forwardAfterBoundary() { 102 if (Math.floor(originalNow() / 1000) === capturedSecond) { 103 window.setTimeout(forwardAfterBoundary, 1); 104 return; 105 } 106 resolve(); 107 } 108 window.setTimeout( 109 forwardAfterBoundary, 110 Math.max(1, (capturedSecond + 1) * 1000 - originalNow() + 1) 111 ); 112 }); 113 return callback(lock); 114 })(); 115 } 116 return callback(lock); 117 }; 118 return Reflect.apply( 119 originalRequest, 120 manager, 121 forwarded 122 ) as Promise<unknown>; 123 }) as typeof manager.request; 124 manager.request = observedRequest; 125 const originalNowDescriptor = Object.getOwnPropertyDescriptor(Date, 'now'); 126 const originalNow = Reflect.get(Date, 'now'); 127 let clockSamples: { value: number; stack: string | undefined }[] = []; 128 const observedNow = () => { 129 const value = originalNow(); 130 clockSamples = clockSamples.concat({ 131 value, 132 stack: new Error().stack?.split('\n').slice(1, 5).join('\n') 133 }); 134 return value; 135 }; 136 Date.now = observedNow; 137 function restoreSendClock() { 138 crossOwnerSecond = undefined; 139 restoreTransaction(); 140 restoreTransaction = () => {}; 141 if (Date.now === observedNow && originalNowDescriptor) 142 Object.defineProperty(Date, 'now', originalNowDescriptor); 143 } 144 145 let clockOffset = 0, 146 alive = true; 147 let nextTimer = 0; 148 const timers = new Map<number, { at: number; callback: () => void }>(); 149 const ownSchedulers: ReturnType<typeof createPublicScheduler>[] = []; 150 const clock: RequestClock = { 151 now: () => clockOffset, 152 schedule(callback, delay) { 153 const id = ++nextTimer; 154 timers.set(id, { at: clockOffset + delay, callback }); 155 return () => timers.delete(id); 156 } 157 }; 158 function advanceClock() { 159 const target = clockOffset + 15_001; 160 for (;;) { 161 const next = [...timers] 162 .filter(([, timer]) => timer.at <= target) 163 .sort((a, b) => a[1].at - b[1].at || a[0] - b[0])[0]; 164 if (!next) break; 165 const [id, timer] = next; 166 timers.delete(id); 167 clockOffset = timer.at; 168 timer.callback(); 169 } 170 clockOffset = target; 171 } 172 const freshOwn: NonNullable<Parameters<typeof renderThread>[3]> = ( 173 owner, 174 policy 175 ) => { 176 const event = finalizeEvent( 177 { 178 kind: 10050, 179 created_at: 100, 180 tags: [['relay', 'wss://archive.example.org']], 181 content: '' 182 }, 183 new Uint8Array(32).fill(83) 184 ); 185 if (event.pubkey !== owner) throw Error('wrong genuine owner'); 186 const scheduler = createPublicScheduler({ 187 now: () => 0, 188 schedule: () => () => {} 189 }); 190 ownSchedulers.push(scheduler); 191 const run = createPublicRun(scheduler, policy); 192 return Promise.resolve( 193 createInboxResolver( 194 run, 195 owner, 196 (next) => 197 openInboxRequest( 198 run, 199 owner, 200 (sink) => { 201 sink({ 202 type: 'EVENT', 203 from: 'wss://discovery.example.org', 204 id: 'fixture', 205 event 206 }); 207 sink({ 208 type: 'EOSE', 209 from: 'wss://discovery.example.org', 210 id: 'fixture' 211 }); 212 return () => {}; 213 }, 214 next 215 ), 216 () => alive 217 ) 218 ); 219 }; 220 const thread = await renderThread( 221 'inbound', 222 undefined, 223 qualified, 224 production ? freshOwn : undefined 225 ); 226 await thread.checkSetup(); 227 if (!(await thread.unlock())) throw Error('no genuine unlocked thread'); 228 let gate = false, 229 lookups = 0; 230 const scope = inboxReplyOwnership( 231 thread.controller, 232 thread.conversationId, 233 thread.firstRumor 234 ); 235 const setup = scope && inboxSetupViewOwnership(scope.setup); 236 const publicContext = production ? createPublicRuntimeContext() : undefined; 237 const runtime = 238 publicContext && 239 setup && 240 mountPublicRuntime(publicContext, setup.policy, clock); 241 if (production && !runtime) throw Error('no genuine public runtime'); 242 const candidate = runtime 243 ? createRuntimeReplyController( 244 thread.controller, 245 thread.conversationId, 246 thread.firstRumor, 247 runtime 248 ) 249 : createReplyController( 250 thread.controller, 251 thread.conversationId, 252 thread.firstRumor, 253 { 254 lookupPeer: (peer) => { 255 lookups++; 256 if (gate) throw Error('controlled same-page setup cancellation'); 257 return Promise.resolve(thread.replyLookup(peer)); 258 } 259 } 260 ); 261 if (!candidate) throw Error('no original reply controller'); 262 const controller = candidate; 263 const target = document.createElement('div'); 264 document.body.append(target); 265 let clicks = 0; 266 target.addEventListener( 267 'click', 268 () => { 269 clicks++; 270 }, 271 { capture: true } 272 ); 273 const mounted = mount(Panel, { target, props: { controller } }); 274 let unmounted = false, 275 held = false, 276 release: (() => void) | undefined; 277 const provider = window.nostr as 278 { signEvent(event: UnsignedEvent): Promise<NostrEvent> } | undefined; 279 if (!provider) throw Error('no actual fixture provider'); 280 const nativeSign = provider.signEvent.bind(provider); 281 provider.signEvent = (event: UnsignedEvent) => 282 held 283 ? new Promise<NostrEvent>((resolve, reject) => { 284 release = () => { 285 held = false; 286 nativeSign(event).then(resolve, reject); 287 }; 288 }) 289 : nativeSign(event); 290 async function closeComposer() { 291 if (unmounted) return; 292 unmounted = true; 293 await unmount(mounted); 294 closeReplyController(controller); 295 target.remove(); 296 } 297 return { 298 owner: thread.owner, 299 peer: thread.peer, 300 parent: thread.firstRumor, 301 conversationId: thread.conversationId, 302 snapshot: () => replySnapshot(controller), 303 diagnostic: async () => ({ 304 setup: inboxSetupViewSnapshot(scope?.setup), 305 locks: await navigator.locks.query(), 306 lockAttempts: lockAttempts.slice(), 307 clicks, 308 clockSamples: clockSamples.slice(), 309 nativeTransactions: nativeTransactions.slice(), 310 commandIds: commandIds.slice() 311 }), 312 resetDiagnostics: () => { 313 lockAttempts = []; 314 clicks = 0; 315 clockSamples = []; 316 nativeTransactions = []; 317 commandIds = []; 318 }, 319 configureSendClock(crossSecond: boolean) { 320 if (!scope) throw Error('no original reply scope'); 321 crossOwnerSecond = crossSecond 322 ? 'harvestcircle:owner:' + scope.owner 323 : undefined; 324 Date.now = observedNow; 325 const db = browserDatabaseTransaction( 326 scope.database, 327 ['private_sends'], 328 'readonly' 329 ).db; 330 const descriptor = Object.getOwnPropertyDescriptor(db, 'transaction'); 331 const original = Reflect.get(db, 'transaction'); 332 const uuidDescriptor = Object.getOwnPropertyDescriptor( 333 crypto, 334 'randomUUID' 335 ); 336 const originalUuid = Reflect.get(crypto, 'randomUUID'); 337 const observedUuid = () => { 338 const id = Reflect.apply(originalUuid, crypto, []); 339 commandIds = commandIds.concat(id); 340 return id; 341 }; 342 crypto.randomUUID = observedUuid; 343 const observed = ((...args: Parameters<IDBDatabase['transaction']>) => { 344 const tx = Reflect.apply(original, db, args); 345 if ( 346 tx.mode === 'readwrite' && 347 tx.objectStoreNames.contains('private_sends') 348 ) { 349 for (const outcome of ['abort', 'complete'] as const) 350 tx.addEventListener(outcome, () => { 351 nativeTransactions = nativeTransactions.concat({ 352 stores: Array.from(tx.objectStoreNames), 353 outcome 354 }); 355 }); 356 } 357 return tx; 358 }) as typeof db.transaction; 359 db.transaction = observed; 360 restoreTransaction = () => { 361 if (db.transaction === observed) { 362 if (descriptor) Object.defineProperty(db, 'transaction', descriptor); 363 else Reflect.deleteProperty(db, 'transaction'); 364 } 365 if (crypto.randomUUID === observedUuid) { 366 if (uuidDescriptor) 367 Object.defineProperty(crypto, 'randomUUID', uuidDescriptor); 368 else Reflect.deleteProperty(crypto, 'randomUUID'); 369 } 370 }; 371 }, 372 restoreSendClock, 373 text: () => replyText(controller), 374 native: thread.native, 375 delta: thread.delta, 376 list: () => inboxListSnapshot(thread.controller), 377 lookups: () => lookups, 378 advance: advanceClock, 379 refreshSetup: thread.checkSetup, 380 gate: (value: boolean) => { 381 gate = value; 382 }, 383 send: (review: unknown = 'reviewed_reply_send') => 384 sendReply(controller, review), 385 update: (text: string, review: unknown = 'reviewed_private_text') => 386 updateReplyText(controller, text, review), 387 selectParent: (parent: string) => 388 selectReplyParent(controller, parent, 'reviewed_reply_parent'), 389 copied: async () => ({ 390 snapshot: replySnapshot({ ...controller }), 391 text: replyText({ ...controller }), 392 update: updateReplyText( 393 { ...controller }, 394 'copied sentinel', 395 'reviewed_private_text' 396 ), 397 send: await sendReply({ ...controller }, 'reviewed_reply_send'), 398 navigation: requestReplyNavigation({ ...controller }), 399 keep: keepReplyEditing({ ...controller }), 400 discard: discardReplyNavigation( 401 { ...controller }, 402 'reviewed_discard_private_text' 403 ) 404 }), 405 async admission() { 406 const scope = inboxReplyOwnership( 407 thread.controller, 408 thread.conversationId, 409 thread.firstRumor 410 ); 411 if (!scope) throw Error('missing actual original room'); 412 const capture = ( 413 identity = scope.identity, 414 session = scope.session, 415 unlocked = scope.unlocked, 416 room = scope.room 417 ) => 418 captureAuthenticatedReplyRumor( 419 identity, 420 session, 421 unlocked, 422 room, 423 'Local admission fixture only', 424 Math.floor(Date.now() / 1000) 425 ); 426 const genuine = capture(); 427 if (!genuine) throw Error('missing genuine plan'); 428 const wire = rumorPlanSnapshot(genuine)?.wire; 429 stopRumorPlan(genuine); 430 const copied = [ 431 capture({ ...scope.identity }), 432 capture(scope.identity, { ...scope.session }), 433 capture(scope.identity, scope.session, { ...scope.unlocked }), 434 capture(scope.identity, scope.session, scope.unlocked, { 435 ...scope.room 436 }) 437 ].map((plan) => !!plan); 438 const other = createIdentitySession(); 439 await connectIdentity(other); 440 await probeIdentityMessaging(other, 'reviewed_self_copy'); 441 const foreign = capture(other); 442 if (foreign) stopRumorPlan(foreign); 443 disconnectIdentity(other); 444 return { wire, copied, foreign: !!foreign }; 445 }, 446 navigate() { 447 let cancelled = false; 448 const event = { 449 cancel: () => { 450 cancelled = true; 451 }, 452 to: { url: new URL('/messages', window.location.origin) }, 453 willUnload: false 454 } as unknown as BeforeNavigate; 455 for (const callback of navigation) callback(event); 456 return cancelled; 457 }, 458 destinations: () => destinations.slice(), 459 holdSigner: () => { 460 held = true; 461 }, 462 pending: () => !!release, 463 settle: () => release?.(), 464 closeComposer, 465 logout: thread.logout, 466 async close() { 467 restoreSendClock(); 468 release?.(); 469 provider.signEvent = nativeSign; 470 await closeComposer(); 471 if (publicContext) closePublicRuntime(publicContext); 472 await thread.close(); 473 if (manager.request === observedRequest) { 474 if (originalDescriptor) 475 Object.defineProperty(manager, 'request', originalDescriptor); 476 else Reflect.deleteProperty(manager, 'request'); 477 } 478 if (Date.now === observedNow && originalNowDescriptor) 479 Object.defineProperty(Date, 'now', originalNowDescriptor); 480 alive = false; 481 for (const scheduler of ownSchedulers) closePublicScheduler(scheduler); 482 timers.clear(); 483 } 484 }; 485 }