inbox-setup-operation.ts (11882B)
1 import { 2 captureInboxSetup, 3 inboxSetupRecordCurrent, 4 type InboxSetupReview 5 } from './inbox-setup.ts'; 6 import { operationEnabled } from '../config/operation-flags.ts'; 7 import type { InboxResolver } from './resolve-inbox.ts'; 8 import { publicRelayTargets, type RelayPolicy } from '../config/relays.ts'; 9 import { canonicalLocalId } from '../private-handles.ts'; 10 import { 11 identityMessagingOwnership, 12 captureIdentityPublicOperation, 13 identityPublicOperationOwnership, 14 signIdentityPublicOperation, 15 stopIdentityPublicOperation, 16 recheckIdentityOwner, 17 subscribeIdentityInvalidation, 18 type IdentitySession, 19 type IdentityPublicOperation 20 } from '../runtime/identity-session.ts'; 21 import { 22 runCapturedPublicEffect, 23 type PublicEffectLease 24 } from '../runtime/effect-ownership.ts'; 25 import { 26 publicRecordSnapshot, 27 decodePublicRecord, 28 type PublicRecordHandle 29 } from '../persistence/records.ts'; 30 import { 31 loadPreferenceOperation, 32 commitPublicOperationTransition, 33 observePublicOperationTransition, 34 publicQuotaOwner, 35 type PublicQuotaRepository 36 } from '../persistence/quota.ts'; 37 import { 38 preparePreferenceSigningTransition, 39 preparePublicArtifactTransition, 40 type PublicOperationTransition 41 } from '../persistence/artifact-records.ts'; 42 import { getPublicPool } from '../nostr/public-pool.ts'; 43 import { 44 authorizeStoredInboxPreference, 45 preferencePolicyFingerprint 46 } from '../nostr/inbox-preference-publication.ts'; 47 import { 48 publishInboxPreference, 49 type PreferencePublicationResult 50 } from '../nostr/inbox-preference-publisher.ts'; 51 declare const actionBrand: unique symbol; 52 export type InboxPreferenceAction = Readonly<{ [actionBrand]: true }>; 53 type Lookup = () => Promise<InboxResolver>; 54 type Saved = Readonly<{ 55 repository: PublicQuotaRepository; 56 identity: IdentitySession; 57 policy: RelayPolicy; 58 original: PublicRecordHandle; 59 operation: IdentityPublicOperation; 60 id: string; 61 actionId: string; 62 lookup: Lookup; 63 retry: boolean; 64 control: AbortController; 65 running(): boolean; 66 markRunning(): void; 67 }>; 68 const actions = new WeakMap<InboxPreferenceAction, Saved>(); 69 type Prepared = 70 | Readonly<{ status: 'prepared'; action: InboxPreferenceAction }> 71 | Readonly<{ status: 'invalid' | 'unavailable' | 'conflict' | 'unknown' }>; 72 function retain( 73 repository: PublicQuotaRepository, 74 identity: IdentitySession, 75 policy: RelayPolicy, 76 original: PublicRecordHandle, 77 id: string, 78 lookup: Lookup, 79 retry: boolean 80 ): Prepared { 81 const operation = captureIdentityPublicOperation( 82 identity, 83 original, 84 id, 85 'reviewed_captured_operation' 86 ); 87 if (!operation || typeof lookup !== 'function') 88 return { status: 'unavailable' }; 89 let used = false; 90 const action = Object.freeze({}) as InboxPreferenceAction; 91 actions.set(action, { 92 repository, 93 identity, 94 policy, 95 original, 96 operation, 97 id, 98 actionId: crypto.randomUUID(), 99 lookup, 100 retry, 101 control: new AbortController(), 102 running: () => used, 103 markRunning: () => { 104 used = true; 105 } 106 }); 107 return { status: 'prepared', action }; 108 } 109 // Original opaque065 review only. This does not auto-run after connect/setup. 110 export async function beginInboxPreferenceOperation( 111 repository: PublicQuotaRepository, 112 identity: IdentitySession, 113 policy: RelayPolicy, 114 review: InboxSetupReview, 115 command: unknown, 116 lookup: Lookup, 117 consent: unknown 118 ): Promise<Prepared> { 119 try { 120 const id = canonicalLocalId(command), 121 owner = identityMessagingOwnership(identity); 122 if (!id || !owner || publicQuotaOwner(repository) !== owner.owner) 123 return { status: 'unavailable' }; 124 const resolver = await lookup(), 125 captured = captureInboxSetup(review, resolver, id, consent); 126 if (captured.status !== 'captured') return captured; 127 if (captured.owner !== owner.owner || !owner.current()) 128 return { status: 'unavailable' }; 129 return retain( 130 repository, 131 identity, 132 policy, 133 captured.record, 134 id, 135 lookup, 136 false 137 ); 138 } catch { 139 return { status: 'unavailable' }; 140 } 141 } 142 // Explicit reload review of the actual stored signed operation, with full 143 // original capture retained. Unsigned uncertainty cannot become a fresh plan. 144 export async function resumeInboxPreferenceOperation( 145 repository: PublicQuotaRepository, 146 identity: IdentitySession, 147 policy: RelayPolicy, 148 command: unknown, 149 lookup: Lookup, 150 consent: unknown 151 ): Promise<Prepared> { 152 try { 153 if (consent !== 'reviewed_stored_inbox_preference') 154 return { status: 'invalid' }; 155 const id = canonicalLocalId(command); 156 await recheckIdentityOwner(identity); 157 const owner = identityMessagingOwnership(identity); 158 if (!id || !owner || publicQuotaOwner(repository) !== owner.owner) 159 return { status: 'unavailable' }; 160 const read = await loadPreferenceOperation(repository, id); 161 if (!read.ok) return { status: 'unavailable' }; 162 const row = publicRecordSnapshot(read.value, owner.owner, id); 163 if (row?.family !== 'preference_operation') return { status: 'invalid' }; 164 if (row.revision < 2 || !row.artifact) return { status: 'unknown' }; 165 const fingerprint = await preferencePolicyFingerprint(policy), 166 resolver = await lookup(); 167 if ( 168 !operationEnabled(policy, 'messaging') || 169 row.capture.policyFingerprint !== fingerprint || 170 JSON.stringify(row.capture.targets) !== 171 JSON.stringify(publicRelayTargets(policy, 'write')) || 172 !inboxSetupRecordCurrent(read.value, owner.owner, id, resolver, policy) || 173 !owner.current() 174 ) 175 return { status: 'conflict' }; 176 // Historical original signing wire for lease matching only; never written 177 // back, never a reset. The effect runner uses the actual stored artifact. 178 const original = decodePublicRecord( 179 JSON.stringify({ ...row, revision: 0, artifact: null, receipts: [] }), 180 owner.owner, 181 id 182 ); 183 return original.ok 184 ? retain(repository, identity, policy, original.value, id, lookup, true) 185 : { status: 'invalid' }; 186 } catch { 187 return { status: 'unavailable' }; 188 } 189 } 190 async function acknowledged( 191 repository: PublicQuotaRepository, 192 transition: PublicOperationTransition 193 ): Promise<boolean> { 194 const result = await commitPublicOperationTransition(repository, transition); 195 return ( 196 result.ok && 197 (await observePublicOperationTransition(repository, transition)).state === 198 'committed' 199 ); 200 } 201 async function knownBase(saved: Saved): Promise<(() => boolean) | undefined> { 202 const owner = identityMessagingOwnership(saved.identity); 203 const operation = identityPublicOperationOwnership( 204 saved.identity, 205 saved.operation 206 ); 207 if (!owner || !operation || saved.control.signal.aborted) return undefined; 208 const stored = await loadPreferenceOperation(saved.repository, saved.id); 209 if (!stored.ok) return undefined; 210 const resolver = await saved.lookup(); 211 const current = () => 212 !saved.control.signal.aborted && 213 operation.current() && 214 owner.current() && 215 inboxSetupRecordCurrent( 216 stored.value, 217 owner.owner, 218 saved.id, 219 resolver, 220 saved.policy 221 ); 222 return current() ? current : undefined; 223 } 224 export async function runInboxPreferenceOperation( 225 action: InboxPreferenceAction 226 ): Promise<PreferencePublicationResult> { 227 const saved = actions.get(action); 228 if (!saved) return { status: 'invalid' }; 229 if (saved.running() || saved.control.signal.aborted) 230 return { status: 'stopped' }; 231 saved.markRunning(); 232 const capture = identityPublicOperationOwnership( 233 saved.identity, 234 saved.operation 235 ); 236 if (!capture) return { status: 'stopped' }; 237 const messagingOwner = identityMessagingOwnership(saved.identity); 238 if ( 239 !messagingOwner || 240 messagingOwner.owner !== capture.owner || 241 messagingOwner.session !== capture.session 242 ) 243 return { status: 'stopped' }; 244 if (!capture.current() || saved.control.signal.aborted) 245 return { status: 'stopped' }; 246 const invalidate = subscribeIdentityInvalidation(saved.identity, () => { 247 // Notifications also describe pending/completed observations. Only actual 248 // owner/capability/generation loss cancels this original explicit action. 249 if (!capture.current() || !messagingOwner.current()) saved.control.abort(); 250 }); 251 try { 252 const result = await runCapturedPublicEffect<PreferencePublicationResult>( 253 saved.repository, 254 saved.original, 255 saved.id, 256 { 257 ...capture, 258 current: () => capture.current() && !saved.control.signal.aborted 259 }, 260 saved.retry 261 ? 'reviewed_stored_preference_retry' 262 : 'reviewed_prepared_preference_operation', 263 async (lease: PublicEffectLease, claimed: PublicRecordHandle) => { 264 if (!(await knownBase(saved))) return { status: 'stopped' }; 265 const row = publicRecordSnapshot(claimed, capture.owner, saved.id); 266 if (row?.family !== 'preference_operation') 267 return { status: 'invalid' }; 268 if ( 269 !operationEnabled(saved.policy, 'messaging') || 270 row.capture.policyFingerprint !== 271 (await preferencePolicyFingerprint(saved.policy)) || 272 JSON.stringify(row.capture.targets) !== 273 JSON.stringify(publicRelayTargets(saved.policy, 'write')) 274 ) 275 return { status: 'stopped' }; 276 if (!capture.current() || saved.control.signal.aborted) 277 return { status: 'stopped' }; 278 if (!row.artifact) { 279 const marker = preparePreferenceSigningTransition( 280 claimed, 281 capture.owner, 282 saved.id 283 ); 284 if ( 285 !marker.ok || 286 !(await acknowledged(saved.repository, marker.value)) 287 ) 288 return { status: 'storage_failed' }; 289 if (!(await knownBase(saved))) return { status: 'stopped' }; 290 const signed = await signIdentityPublicOperation( 291 saved.identity, 292 saved.operation, 293 lease 294 ); 295 if (signed.status !== 'signed') return { status: 'stopped' }; 296 const pending = await loadPreferenceOperation( 297 saved.repository, 298 saved.id 299 ); 300 if (!pending.ok) return { status: 'storage_failed' }; 301 if (!capture.current() || saved.control.signal.aborted) 302 return { status: 'stopped' }; 303 const transition = preparePublicArtifactTransition( 304 pending.value, 305 capture.owner, 306 saved.id, 307 signed.artifact 308 ); 309 if ( 310 !transition.ok || 311 !(await acknowledged(saved.repository, transition.value)) 312 ) 313 return { status: 'storage_failed' }; 314 } 315 if (saved.control.signal.aborted || !capture.current()) 316 return { status: 'stopped' }; 317 const pool = getPublicPool(saved.policy); 318 if (!pool) return { status: 'stopped' }; 319 return await publishInboxPreference( 320 saved.repository, 321 capture.owner, 322 saved.id, 323 saved.actionId, 324 pool, 325 saved.policy, 326 saved.control.signal, 327 () => 328 authorizeStoredInboxPreference( 329 saved.repository, 330 saved.identity, 331 saved.operation, 332 lease, 333 saved.original, 334 saved.id, 335 saved.policy, 336 () => knownBase(saved) 337 ) 338 ); 339 } 340 ); 341 return result.status === 'completed' ? result.value : { status: 'stopped' }; 342 } catch { 343 return { status: 'stopped' }; 344 } finally { 345 invalidate(); 346 } 347 } 348 export function stopInboxPreferenceOperation( 349 action: InboxPreferenceAction 350 ): void { 351 const saved = actions.get(action); 352 if (!saved) return; 353 saved.control.abort(); 354 stopIdentityPublicOperation(saved.identity, saved.operation); 355 }