add a friendly message when a message is already on the pds

src/index.ts

···
       return res.status(401).json({ error: 'Not logged in' })
     }
 
-    const { anmsg, blob, rkey, anhash: providedAnhash, blobhash: providedBlobhash } = req.body ?? {}
+    const {
+      anmsg,
+      blob,
+      anblob: bodyAnblob,
+      rkey,
+      anhash: providedAnhash,
+      blobhash: providedBlobhash,
+    } = req.body ?? {}
+    let computedRkey: string | undefined
     if (typeof anmsg !== 'string' || !anmsg.trim()) {
       return res.status(400).json({ error: 'anmsg is required' })
     }
+    if (blob && blob === anmsg) {
+      return res.status(400).json({ error: 'anmsg must be the signature; blob belongs in the blob field' })
+    }
     const maxAnmsgLen = 20000
     if (anmsg.length > maxAnmsgLen) {
       return res.status(400).json({ error: 'anmsg too large' })
     }
+
+    let agent: Agent | null = null
 
     try {
       const oauthSession = await client.restore(session.did)
···
         return res.status(401).json({ error: 'Session expired' })
       }
 
-      const agent = new Agent(oauthSession)
+      agent = new Agent(oauthSession)
       let finalBlobhash: string | undefined
       let anblob: string | undefined
 
-      if (blob) {
-        if (typeof blob !== 'string') {
-          return res.status(400).json({ error: 'blob must be base64 string' })
-        }
-        const buf = Buffer.from(blob, 'base64')
+      const incomingBlob =
+        typeof bodyAnblob === 'string' && bodyAnblob.trim()
+          ? bodyAnblob
+          : typeof blob === 'string'
+            ? blob
+            : ''
+      if (!incomingBlob) {
+        return res.status(400).json({ error: 'anblob is required' })
+      }
+      if (incomingBlob) {
+        const buf = Buffer.from(incomingBlob)
         if (!buf.length) {
-          return res.status(400).json({ error: 'blob decode failed' })
+          return res.status(400).json({ error: 'anblob decode failed' })
         }
         const maxBlobBytes = 6 * 1024 * 1024
         if (buf.length > maxBlobBytes) {
-          return res.status(400).json({ error: 'blob too large (max 6MB)' })
+          return res.status(400).json({ error: 'anblob too large (max 6MB)' })
         }
-        anblob = blob
-        finalBlobhash = await hashAn(blob)
+        anblob = incomingBlob
+        finalBlobhash = await hashAn(incomingBlob)
       } else if (typeof providedBlobhash === 'string' && providedBlobhash.trim()) {
         finalBlobhash = providedBlobhash.trim()
       }
···
       if (providedAnhash && providedAnhash !== anhash) {
         return res.status(400).json({ error: 'anhash does not match anmsg hash' })
       }
-      const computedRkey = toBase64Url(anhash)
+      computedRkey = toBase64Url(anhash)
       if (typeof rkey === 'string' && rkey.trim() && rkey.trim() !== computedRkey) {
         return res.status(400).json({ error: 'rkey does not match anmsg hash' })
       }
···
 
       res.json({ ok: true, rkey: computedRkey })
     } catch (err) {
-      console.error('Publish failed:', err)
-      res.status(500).json({ error: 'Publish failed', detail: String(err) })
+      let responseData = (err as any)?.response?.data
+      let responseStatus = (err as any)?.response?.status
+      const responseError = typeof responseData?.error === 'string' ? responseData.error : ''
+      const responseMessage =
+        typeof responseData?.message === 'string'
+          ? responseData.message
+          : typeof (err as any)?.message === 'string'
+            ? (err as any).message
+            : ''
+      const isDuplicate =
+        (err as any)?.response?.status === 409 ||
+        responseError === 'RecordAlreadyExists' ||
+        responseError === 'already_exists' ||
+        /already exists/i.test(responseMessage) ||
+        /internal server error/i.test(responseMessage)
+
+      if (!isDuplicate && computedRkey && session.did) {
+        try {
+          const ensureAgent = async () => {
+            if (agent) return agent
+            const oauthSession = await client.restore(session.did!)
+            if (!oauthSession) return null
+            return new Agent(oauthSession)
+          }
+          const fetchAgent = await ensureAgent()
+          if (fetchAgent) {
+            const existing = await fetchAgent.com.atproto.repo.getRecord({
+              repo: session.did!,
+              collection: messageLexUri,
+              rkey: computedRkey,
+            })
+            if (existing?.data) {
+              isDuplicate = true
+              responseStatus = responseStatus || 409
+              responseData = existing.data
+            }
+          }
+        } catch {
+          // ignore fallback duplicate check errors
+        }
+      }
+
+      const status = isDuplicate
+        ? 409
+        : (err as any)?.status || (err as any)?.response?.status || 500
+      const atUri =
+        session.did && computedRkey ? `at://${session.did}/${messageLexUri}/${computedRkey}` : undefined
+      const detail = isDuplicate
+        ? {
+            message: 'Message already on PDS.',
+            ...(computedRkey ? { rkey: computedRkey } : {}),
+            ...(atUri ? { atUri } : {}),
+          }
+        : responseData || responseMessage || String(err)
+      console.error('Publish failed:', {
+        status,
+        detail,
+        duplicate: isDuplicate,
+        stack: (err as any)?.stack,
+        responseData,
+      })
+      res
+        .status(status)
+        .json({
+          code: isDuplicate ? 'already_exists' : 'publish_failed',
+          error: isDuplicate ? 'Message already on PDS.' : 'Publish failed',
+          ...(computedRkey ? { rkey: computedRkey } : {}),
+          ...(atUri ? { atUri } : {}),
+          detail,
+        })
     }
   })
 
···
               return pub
             }
 
+            const resolveSignatureForEntry = async (msg) => {
+              if (msg?.sig) return msg.sig
+              if (msg?.hash) {
+                try {
+                  const maybeSig = await apds.get(msg.hash)
+                  if (maybeSig) {
+                    const opened = await apds.open(maybeSig)
+                    if (opened) return maybeSig
+                  }
+                } catch {
+                  // ignore
+                }
+              }
+              if (msg?.text) {
+                try {
+                  const opened = await apds.open(msg.text)
+                  if (opened) return msg.text
+                } catch {
+                  // ignore
+                }
+              }
+              return null
+            }
+
+            const buildPayloadFromSig = async (sig) => {
+              if (!sig) return null
+              const payload = { anmsg: sig }
+              try {
+                payload.anhash = await apds.hash(sig)
+              } catch {
+                // leave out anhash if it fails
+              }
+              try {
+                const opened = await apds.open(sig)
+                if (opened && opened.length > 13) {
+                  const contentHash = opened.substring(13)
+                  const maybeBlob = await apds.get(contentHash)
+                  if (typeof maybeBlob === 'string' && maybeBlob.length) {
+                    payload.anblob = maybeBlob
+                  } else {
+                    logEvent('Missing blob for ' + contentHash, true)
+                    return null
+                  }
+                }
+              } catch {
+                // ignore blob failures
+              }
+              return payload
+            }
+
+            const publishWithRetry = async (payload, label = 'Publish') => {
+              const isAlreadyExists = (res, data) => {
+                const code = (data?.code || data?.error || '').toString().toLowerCase()
+                const msg = (data?.message || data?.error || data?.detail?.message || '').toString().toLowerCase()
+                return (
+                  res?.status === 409 ||
+                  code === 'already_exists' ||
+                  code === 'recordalreadyexists' ||
+                  msg.includes('already exists') ||
+                  msg.includes('already on pds') ||
+                  msg === 'message already on pds.'
+                )
+              }
+
+              const send = async (body) => {
+                console.log('Publish payload', label, body)
+                try {
+                  const res = await fetch('/publish', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(body),
+                  })
+                  let data = {}
+                  try {
+                    data = await res.json()
+                  } catch {
+                    // ignore parse errors
+                  }
+                  if (!res.ok) {
+                    console.warn('Publish response', label, res.status, res.statusText, data)
+                  }
+                  return { res, data, duplicate: isAlreadyExists(res, data) }
+                } catch (err) {
+                  console.error('Publish fetch failed', label, err)
+                  return { res: null, data: { error: String(err) } }
+                }
+              }
+              const first = await send(payload)
+              if (first.duplicate) {
+                logEvent('Message already on PDS.', false)
+                return first
+              }
+              if (first.res?.ok) return first
+              const reason = first.data?.error || first.res?.statusText || 'rejected'
+              logEvent(label + ' rejected: ' + reason, true)
+              let second = null
+              if (payload?.anmsg) {
+                const rebuilt = await buildPayloadFromSig(payload.anmsg)
+                if (rebuilt) {
+                  second = await send(rebuilt)
+                  if (second.duplicate) {
+                    logEvent('Message already on PDS.', false)
+                    return second
+                  }
+                  if (second.res?.ok) {
+                    logEvent(label + ' retry succeeded', false)
+                    return second
+                  }
+                  const reason2 = second.data?.error || second.res?.statusText || 'retry failed'
+                  logEvent(label + ' retry failed: ' + reason2, true)
+                }
+              }
+              return first
+            }
+
             const syncLocalToPds = async () => {
               if (!loggedIn || syncInFlight) return
               const now = Date.now()
···
                 const entries = sortEntries((await apds.query()) || [])
                 const ours = entries.filter((e) => e.author === pub)
                 for (const msg of ours) {
-                  if (!msg.text) continue
                   if (await hasSynced(msg.hash)) continue
-                  let anhash = ''
-                  try {
-                    anhash = await apds.hash(msg.text)
-                  } catch {
-                    continue
-                  }
+                  const sig = await resolveSignatureForEntry(msg)
+                  if (!sig) continue
+                  const payload = await buildPayloadFromSig(sig)
+                  if (!payload) continue
                   try {
-                    const res = await fetch('/publish', {
-                      method: 'POST',
-                      headers: { 'Content-Type': 'application/json' },
-                      body: JSON.stringify({ anmsg: msg.text, anhash }),
-                    })
-                    const data = await res.json().catch(() => ({}))
-                    if (!res.ok) {
+                    const result = await publishWithRetry(payload, 'Sync')
+                    const { res, data, duplicate } = result || {}
+                    if (!res?.ok && !duplicate) {
                       // If already exists, mark synced to avoid replays.
-                      if (res.status === 409 || String(data?.error || '').toLowerCase().includes('already')) {
+                      if (res?.status === 409 || String(data?.error || '').toLowerCase().includes('already')) {
                         await markSynced(msg.hash)
                         continue
                       }
···
                 return
               }
 
-              let payload = {}
+              let payload = null
               let protocolHash = ''
               let publishOk = false
 
               try {
                 protocolHash = await apds.compose(content)
-                const anmsg = await apds.get(protocolHash)
-                if (!anmsg) {
+                const sig = await apds.get(protocolHash)
+                if (!sig) {
                   logEvent('Could not load signed message', true)
                   return
                 }
-                payload.anmsg = anmsg
-                try {
-                  const anhash = await apds.hash(anmsg)
-                  payload.anhash = anhash
-                } catch (err) {
-                  console.warn('Could not compute anhash', err)
+                payload = await buildPayloadFromSig(sig)
+                if (!payload) {
+                  logEvent('Could not build publish payload', true)
+                  return
                 }
               } catch (err) {
                 logEvent('Signing failed', true)
···
 
               try {
                 if (loggedIn) {
-                  const res = await fetch('/publish', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify(payload),
-                  })
-                  const data = await res.json()
-                  if (!res.ok) {
+                  const result = await publishWithRetry(payload, 'Publish')
+                  const { res, data, duplicate } = result || {}
+                  if (!res?.ok && !duplicate) {
                     throw new Error(data?.error || 'Publish failed')
                   }
                   publishOk = true
-                  logEvent('Saved with rkey ' + data.rkey, false)
+                  if (duplicate) {
+                    logEvent('Message already on PDS.', false)
+                  } else {
+                    logEvent('Saved with rkey ' + data.rkey, false)
+                  }
                 } else {
                   logEvent('Signed locally. Login to publish to PDS.', false)
                 }