libp2r2p 0.11.27 → 0.11.28

package/README.md

@@ -1257,3 +1257,10 @@ The 0.11.27 session publishes independently of local event-store persistence aft
 its initial durable intent and exact-envelope checkpoint. `deliveryConfirmed`
 and the copied `localPersistence` summary distinguish relay acceptance from
 local storage. See `private-messenger/session/README.md` for retry and cleanup.
+
+The 0.11.28 private messenger preserves classified publication failures for
+seeder recovery asks. Diagnostics include the logical ask ID, channel, seeder
+and range, plus report and relay classifications; arbitrary relay text is not
+logged. Native report causes remain available privately to recovery retry
+policy. Required publication coverage, first-ACK semantics and range recovery
+behavior are unchanged.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2r2p",
-  "version": "0.11.27",
+  "version": "0.11.28",
   "description": "Peer-to-relay-to-peer",
   "keywords": [
     "p2r2p",

package/private-messenger/helpers/publication.js

@@ -1,5 +1,96 @@
 import { getEventHash } from '../../event/index.js'
 
+const safeTokenPattern = /^[A-Za-z0-9][A-Za-z0-9:_-]{0,159}$/
+const safeToken = value => typeof value === 'string' && safeTokenPattern.test(value) ? value : undefined
+const safeRelay = value => {
+  if (typeof value !== 'string') return undefined
+  try {
+    const url = new URL(value)
+    if (url.protocol !== 'ws:' && url.protocol !== 'wss:') return undefined
+    return `${url.protocol}//${url.host}`
+  } catch {
+    return undefined
+  }
+}
+
+function reasonDiagnostic (reason) {
+  if (typeof reason === 'string') {
+    const prefix = /^([a-z][a-z0-9-]{0,31}):/i.exec(reason)?.[1]
+    return { code: safeToken(reason) ?? safeToken(prefix ? `${prefix}:` : undefined) ?? 'UNKNOWN' }
+  }
+  const prefix = typeof reason?.message === 'string' && /^([a-z][a-z0-9-]{0,31}):/i.exec(reason.message)?.[1]
+  const category = safeToken(reason?.category)
+  return {
+    code: safeToken(reason?.code) ?? safeToken(prefix ? `${prefix}:` : undefined) ?? category ?? 'UNKNOWN',
+    ...(category ? { category } : {}),
+    ...(safeToken(reason?.name) ? { name: safeToken(reason.name) } : {}),
+    ...(Number.isSafeInteger(reason?.retryAt) ? { retryAt: reason.retryAt } : {}),
+    ...(Number.isSafeInteger(reason?.retryAfterMs) ? { retryAfterMs: reason.retryAfterMs } : {})
+  }
+}
+
+function sanitizedReport (report, index) {
+  return {
+    index,
+    ...(Number.isSafeInteger(report?.total) ? { total: report.total } : {}),
+    ...(Number.isSafeInteger(report?.fulfilled) ? { fulfilled: report.fulfilled } : {}),
+    ...(report?.retryWhenAvailable === true ? { retryWhenAvailable: true } : {}),
+    ...(report?.retryWhenOnline === true ? { retryWhenOnline: true } : {}),
+    errors: (Array.isArray(report?.errors) ? report.errors : []).map(entry => {
+      const relay = safeRelay(entry?.relay)
+      const detail = reasonDiagnostic(entry?.reason ?? entry)
+      return {
+        ...(relay ? { relay } : {}),
+        ...(safeToken(entry?.code) ? { ...detail, code: entry.code } : detail)
+      }
+    })
+  }
+}
+
+const contextFields = ['operation', 'channelPubkey', 'seederPubkey', 'receiverPubkey', 'eventId']
+const contextNumbers = ['eventKind', 'since', 'until']
+
+export function sanitizePublicationError (error, context = {}) {
+  const source = error instanceof Error ? error : new Error('PRIVATE_MESSAGE_NOT_PUBLISHED')
+  const reports = Array.isArray(source.reports) ? source.reports : []
+  const retryReasons = reports.flatMap(report => (Array.isArray(report?.errors) ? report.errors : [])
+    .map(entry => entry?.reason).filter(Boolean))
+  if (source.code !== 'MESSAGE_NOT_PUBLISHED' && !reports.length) {
+    for (const key of contextFields) if (safeToken(context[key])) source[key] = context[key]
+    for (const key of contextNumbers) if (Number.isSafeInteger(context[key])) source[key] = context[key]
+    return source
+  }
+
+  const sanitized = new Error('PRIVATE_MESSAGE_NOT_PUBLISHED')
+  if (source.stack) sanitized.stack = source.stack
+  Object.assign(sanitized, {
+    code: safeToken(source.code) ?? 'MESSAGE_NOT_PUBLISHED',
+    ...(safeToken(source.reason) ? { reason: source.reason } : {}),
+    ...(safeToken(source.eventId) ? { eventId: source.eventId } : {}),
+    ...(Number.isSafeInteger(source.eventKind) ? { eventKind: source.eventKind } : {}),
+    ...(source.retryWhenAvailable === true ? { retryWhenAvailable: true } : {}),
+    ...(source.retryWhenOnline === true ? { retryWhenOnline: true } : {}),
+    reports: reports.map(sanitizedReport)
+  })
+  for (const key of contextFields) if (safeToken(context[key])) sanitized[key] = context[key]
+  for (const key of contextNumbers) if (Number.isSafeInteger(context[key])) sanitized[key] = context[key]
+  Object.defineProperty(sanitized, 'retryReasons', { value: retryReasons })
+  return sanitized
+}
+
+export function publicationFailureDiagnostic (error) {
+  const result = {}
+  for (const key of [...contextFields, ...contextNumbers]) {
+    const value = error?.[key]
+    if (safeToken(value) && contextFields.includes(key)) result[key] = value
+    else if (Number.isSafeInteger(value) && contextNumbers.includes(key)) result[key] = value
+  }
+  for (const key of ['code', 'reason', 'eventId']) if (safeToken(error?.[key])) result[key] = error[key]
+  for (const key of ['retryWhenAvailable', 'retryWhenOnline']) if (error?.[key] === true) result[key] = true
+  result.reports = (Array.isArray(error?.reports) ? error.reports : []).map(sanitizedReport)
+  return result
+}
+
 // A report describes one outer event, not one relay. Each outer event needs
 // accepted publication covering its routed recipients. Keep the successful fast
 // path immediate; a partially covered multi-recipient report remains a failure.

package/private-messenger/helpers/recovery-retry.js

@@ -19,6 +19,11 @@ export function recoveryRetryDelay (errors, delay) {
       if (['timeout', 'cutoff', 'closed'].includes(entry.status)) retry = true
       visit(entry.error)
     }
+    for (const report of error.reports || []) {
+      if (report.retryWhenAvailable || report.retryWhenOnline) retry = true
+      for (const entry of report.errors || []) visit(entry.reason ?? entry.error)
+    }
+    for (const reason of error.retryReasons || []) visit(reason)
     visit(error.cause)
   }
   errors.forEach(visit)
@@ -36,6 +41,10 @@ export function isPermanentRecoveryError (error) {
         /^(auth-required:|restricted:|blocked:|invalid:|pow:)/.test(value.message || '')) return true
     for (const child of value.errors || []) if (visit(child)) return true
     for (const entry of value.relays || []) if (visit(entry.error)) return true
+    for (const report of value.reports || []) {
+      for (const entry of report.errors || []) if (visit(entry.reason ?? entry.error)) return true
+    }
+    for (const reason of value.retryReasons || []) if (visit(reason)) return true
     return visit(value.cause)
   }
   return visit(error)

package/private-messenger/index.js

@@ -52,6 +52,7 @@ import { backgroundSigner } from './helpers/background-signer.js'
 import { createSendRelayRouting, normalizeFallbackRelays, normalizeFallbackDelay } from './helpers/send-routing.js'
 import { incompleteFetchError } from '../private-channel/helpers/fetch-error.js'
 import { recoveryRetryDelay, isPermanentRecoveryError } from './helpers/recovery-retry.js'
+import { assertMessagePublished, publicationFailureDiagnostic, sanitizePublicationError } from './helpers/publication.js'
 import { normalizeRelayUrl } from '../url/index.js'
 import { deliveryInfo } from '../private-channel/helpers/rumor.js'
 import { migrateMessageQueue } from './services/migrate-message-queue.js'
@@ -2755,13 +2756,17 @@ export class PrivateMessenger {
           payload: { since, until }
         })
         asks.push(ask)
-        const reports = ask?.delivery?.reports
-        if (!Array.isArray(reports) || !reports.length || reports.some(report => report?.success !== true)) {
-          throw new Error('PRIVATE_MESSAGE_NOT_PUBLISHED')
-        }
+        await assertMessagePublished(ask, ask.question)
       } catch (err) {
-        failures.push({ seeder, error: err })
-        console.warn('private-messenger seeder recovery ask failed', seeder, err?.message ?? err)
+        const error = sanitizePublicationError(err, {
+          operation: 'seeder-recovery-ask',
+          channelPubkey,
+          seederPubkey: seeder,
+          since,
+          until
+        })
+        failures.push({ seeder, error })
+        console.warn('private-messenger seeder recovery ask failed', JSON.stringify(publicationFailureDiagnostic(error)))
       }
     }
     return { asks, failures }