@profullstack/builtindie 0.1.4 → 0.6.0

package/src/cli.ts

@@ -7,9 +7,20 @@
  *   builtindie show <slug>
  *   builtindie vote <slug>
  *   builtindie preview <url>           what we would read from a site, nothing saved
- *   builtindie search <words>
- *   builtindie claim <slug>            prove you own the domain (DNS TXT), BUILTINDIE_KEY
+ *   builtindie tags [tag]              every tag, or the launches with one
+ *   builtindie search [words] [--category k] [--tag t] [--has h] [--sort top|new|name]
+ *   builtindie categories              every category and tag, with counts
+ *   builtindie claim <slug>            prove you own the domain (the badge or DNS TXT), BUILTINDIE_KEY
  *   builtindie me                      your launches, BUILTINDIE_KEY
+ *   builtindie invite                  your invite link and free Featured credits, BUILTINDIE_KEY
+ *   builtindie credit <slug>           spend a credit: feature a listing you own, BUILTINDIE_KEY
+ *   builtindie feature <slug>          pay to feature it: a CoinPay checkout link (any coin or PayPal), BUILTINDIE_KEY
+ *   builtindie karma                   your karma, history, next free Featured week, BUILTINDIE_KEY
+ *   builtindie leaderboard [karma|invites] [--period week|month|all]
+ *   builtindie comment <slug> "text"   comment on a launch (--reply <id>), BUILTINDIE_KEY
+ *   builtindie comments <slug>         read the comments
+ *   builtindie review <slug> <1-5> "text"   review a launch, BUILTINDIE_KEY
+ *   builtindie reviews <slug>          read the reviews
  *   builtindie edit <slug> --tagline … (BUILTINDIE_KEY)
  *   builtindie refetch <slug>          (BUILTINDIE_KEY)
  *   builtindie mcp                     MCP server on stdio
@@ -27,10 +38,25 @@ export const HELP = `builtindie ${VERSION}: launch your indie product with one U
   builtindie show <slug>
   builtindie vote <slug>
   builtindie preview <url>            what we read from a site; nothing is saved
-  builtindie search <words>
-  builtindie claim <slug> [--md]      the DNS TXT record that proves it is yours, then checks it;
-                                      --md prints the steps as Markdown to paste to an AI with DNS access
+  builtindie tags [tag]               every tag with its count, or the launches tagged <tag>
+  builtindie search [words]           search; narrow with --category developer-tools --tag ai
+        [--has verified,video] [--stack Bun] [--maker "Name"] [--launched today|week|month|year]
+        [--sort relevance|top|new|name] [--page N] [--facets]
+  builtindie categories               every category and tag, with how many launches each
+  builtindie claim <slug> [--md]      your badge for the homepage (or the DNS TXT record) that proves
+                                      it is yours, then checks both; --md prints the steps as Markdown
+                                      to paste to an AI with DNS or site access
   builtindie me                       your launches
+  builtindie invite                   your invite link; each maker it brings in who launches = a free Featured week
+  builtindie credit <slug>            spend a credit to feature a listing you own
+  builtindie feature <slug> [--email you@x]  pay to feature it: prints a CoinPay checkout link (any coin or PayPal)
+  builtindie karma                    your karma, history and how far to the next free Featured week
+  builtindie leaderboard [karma|invites] [--period week|month|all]
+  builtindie comment <slug> "text"    comment on a launch (+2 karma); --reply <comment id> to answer one
+  builtindie comments <slug>          read a launch's comments
+  builtindie uncomment <id>           delete your comment (its karma goes back)
+  builtindie review <slug> <1-5> "text"   stars and words (+5 karma for 30+ characters)
+  builtindie reviews <slug>           read a launch's reviews
   builtindie edit <slug> [--name --tagline --description --tags a,b --video URL]
   builtindie refetch <slug>           read the homepage again
   builtindie publish <slug>           put a draft live
@@ -54,7 +80,7 @@ export function parseArgs(argv: string[]): { words: string[]; flags: Record<stri
     if (a.startsWith('--')) {
       const [k, v] = a.slice(2).split(/=(.*)/s) as [string, string | undefined]
       if (v !== undefined) flags[k] = v
-      else if (argv[i + 1] !== undefined && !argv[i + 1]!.startsWith('--') && !['json', 'draft', 'md'].includes(k)) flags[k] = argv[++i]!
+      else if (argv[i + 1] !== undefined && !argv[i + 1]!.startsWith('--') && !['json', 'draft', 'md', 'facets'].includes(k)) flags[k] = argv[++i]!
       else flags[k] = true
     } else words.push(a)
   }
@@ -135,8 +161,26 @@ export async function main(argv = process.argv.slice(2), out: Out = console, cli
         return 0
       }
       case 'search': {
-        const r = await client.search(rest.join(' '))
-        show(r, r.products.map((p) => line(p)).join('\n') || 'Nothing matches.')
+        const many = (k: string) => (typeof flags[k] === 'string' ? String(flags[k]).split(',').map((v) => v.trim()).filter(Boolean) : undefined)
+        const r = await client.search(rest.join(' '), { category: many('category'), tag: many('tag'), has: many('has'), stack: many('stack'), maker: typeof flags.maker === 'string' ? [flags.maker] : undefined, launched: str('launched'), sort: str('sort'), page: Number(str('page') ?? 1) || 1, limit: Number(str('limit') ?? 30) || 30 })
+        const facets = flags.facets && r.facets ? `\n\n${Object.entries(r.facets).filter(([, v]) => v.length).map(([k, v]) => `${k}: ${v.map((f) => `${f.value} (${f.count})`).join(', ')}`).join('\n')}` : ''
+        show(r, `${r.products.map((p) => line(p)).join('\n') || 'Nothing matches.'}\n\n${r.total} match${r.total === 1 ? '' : 'es'}${r.pages > 1 ? `, page ${r.page} of ${r.pages}` : ''} · ${r.web}${facets}`)
+        return 0
+      }
+      case 'categories': {
+        const r = await client.categories()
+        show(r, `${r.categories.map((c) => `${String(c.count).padStart(4)}  ${c.label} (${c.key})`).join('\n')}\n\nTags: ${r.tags.map((t) => `${t.tag} (${t.count})`).join(', ')}`)
+        return 0
+      }
+      case 'tags':
+      case 'tag': {
+        if (rest.length) {
+          const r = await client.tagged(rest.join(' '), Number(str('limit') ?? 30))
+          show(r, r.products.map((p, i) => line(p, i + 1)).join('\n') || `Nothing tagged ${r.tag} yet.`)
+        } else {
+          const r = await client.tags()
+          show(r, r.tags.map((t) => `${String(t.count).padStart(4)}  ${t.tag}`).join('\n') || 'No tags yet.')
+        }
         return 0
       }
       case 'show': {
@@ -179,8 +223,8 @@ export async function main(argv = process.argv.slice(2), out: Out = console, cli
           return 0
         }
         const r = await client.claim(slug)
-        if (r.claimed) return show(r, `${slug} is yours ✓. Edit it: builtindie edit ${slug} --tagline "…"`), 0
-        show(r, `Add this DNS record, wait a minute, then run builtindie claim ${slug} again:\n\n  type   TXT\n  name   ${r.record.name}\n  value  ${r.record.value}\n\n(not found yet at ${r.looked.join(', ')})`)
+        if (r.claimed) return show(r, `${slug} is yours ✓${r.method === 'badge' ? ' (we found your badge)' : r.method === 'dns' ? ' (we found your DNS record)' : ''}. Edit it: builtindie edit ${slug} --tagline "…"`), 0
+        show(r, `Prove it either way, then run builtindie claim ${slug} again:\n\n1. Easiest: put this badge on your homepage and deploy (its id is yours; it also earns the followed link and the ✓):\n\n  ${r.badge}\n\n2. Or add this DNS record (wait a minute for it to show):\n\n  type   TXT\n  name   ${r.record.name}\n  value  ${r.record.value}\n\n(not found yet at ${r.looked.join(', ')})`)
         return 1
       }
       case 'me': {
@@ -188,6 +232,62 @@ export async function main(argv = process.argv.slice(2), out: Out = console, cli
         show(r, `${r.email}\n${r.products.map((p) => `${line(p)}  ${p.owner ? 'claimed ✓' : p.status === 'draft' ? 'draft' : 'not claimed'}`).join('\n') || 'No launches yet.'}`)
         return 0
       }
+      case 'invite':
+      case 'invites': {
+        const r = await client.invites()
+        show(r, `Your invite link: ${r.link}\n${r.invited} joined · ${r.launched} launched · ${r.credits} free Featured week${r.credits === 1 ? '' : 's'} to use (${r.feature_days} days each)${r.credits ? '\nUse one: builtindie credit <slug>' : ''}`)
+        return 0
+      }
+      case 'credit': {
+        const r = await client.credit(rest[0] ?? '')
+        show(r, `${rest[0]} is Featured until ${r.featured_until.slice(0, 10)} ★  (${r.credits} credit${r.credits === 1 ? '' : 's'} left)`)
+        return 0
+      }
+      case 'feature': {
+        const r = await client.feature(rest[0] ?? '', str('email'))
+        show(r, `Pay $${r.usd} for ${r.days} days Featured (${r.methods.join(', ')}):\n${r.checkout_url}`)
+        return 0
+      }
+      case 'karma': {
+        const r = await client.karma()
+        show(r, `${r.total} karma (${r.week >= 0 ? '+' : ''}${r.week} this week) · ${r.next_credit_in} to your next free Featured week · ${r.credits.earned} earned from karma\n\n${r.events.map((e) => `${(e.points > 0 ? '+' : '') + e.points}`.padStart(4) + `  ${e.label}  ${e.at.slice(0, 10)}`).join('\n') || 'No karma yet. How to earn:\n' + r.how_to_earn.map((h) => `  +${h.points}  ${h.action}: ${h.rule}`).join('\n')}`)
+        return 0
+      }
+      case 'leaderboard':
+      case 'board': {
+        const r = await client.leaderboard(rest[0] ?? 'karma', str('period') ?? 'week', Number(str('limit') ?? 25))
+        show(r, `${r.board === 'invites' ? 'Top inviters' : 'Top karma'} (${r.period})\n${r.rows.map((x) => `${String(x.rank ?? '').padStart(3)}. ${String(x.value).padStart(5)}  ${x.name} ${x.badges.map((b) => b.emoji).join('')}`).join('\n') || 'Nobody yet.'}\n${r.web}`)
+        return 0
+      }
+      case 'comment': {
+        const [slug, ...text] = rest
+        if (!slug || !text.length) throw new Error('builtindie comment <slug> "text" [--reply <comment id>]')
+        const r = await client.comment(slug, text.join(' '), str('reply'))
+        show(r, `Posted: ${r.comment.url}  (you have ${r.karma} karma)`)
+        return 0
+      }
+      case 'comments': {
+        const r = await client.comments(rest[0] ?? '')
+        show(r, r.comments.map((x) => `${x.parent ? '    ↳ ' : ''}${x.deleted ? '[deleted]' : `${x.author} (${x.karma} karma)${x.maker ? ' [maker]' : ''} ${x.at.slice(0, 10)}  #${x.id}\n${x.parent ? '      ' : '  '}${x.body}`}`).join('\n') || 'No comments yet.')
+        return 0
+      }
+      case 'uncomment': {
+        const r = await client.deleteComment(rest[0] ?? '')
+        show(r, 'Deleted.')
+        return 0
+      }
+      case 'review': {
+        const [slug, stars, ...text] = rest
+        if (!slug || !stars) throw new Error('builtindie review <slug> <1-5> "text"')
+        const r = await client.review(slug, Number(stars), text.join(' '))
+        show(r, `${'★'.repeat(r.review.rating)} saved. ${slug} is rated ${r.product.rating} from ${r.product.count}. You have ${r.karma} karma.`)
+        return 0
+      }
+      case 'reviews': {
+        const r = await client.reviews(rest[0] ?? '')
+        show(r, `${r.rating === null ? 'No reviews yet.' : `★ ${r.rating} from ${r.count}`}\n${r.reviews.map((x) => `${'★'.repeat(x.rating)}  ${x.author} (${x.karma} karma) ${x.at.slice(0, 10)}\n  ${x.body}`).join('\n')}`)
+        return 0
+      }
       case 'verify': {
         const r = await client.verify(rest[0] ?? '')
         show(r, r.verified ? 'Verified ✓: we found the badge.' : 'Not found yet: add the badge HTML to your homepage and deploy.')

package/src/client.ts

@@ -3,6 +3,10 @@
  * BUILTINDIE_URL points it at another instance; BUILTINDIE_KEY (bi_…) is your
  * account's API key (built.indie/me), for claiming and editing your products.
  */
+export type SearchFilters = Partial<{ category: string[]; tag: string[]; has: string[]; stack: string[]; maker: string[]; launched: string; sort: string; page: number; limit: number }>
+export type FacetValue = { value: string; label: string; count: number }
+export type SearchResult = { total: number; page: number; pages: number; products: (ApiProduct & { categories: string[] })[]; facets?: Record<string, FacetValue[]>; web: string }
+
 export type ApiProduct = {
   slug: string
   name: string
@@ -12,6 +16,8 @@ export type ApiProduct = {
   domain: string
   status: string
   votes: number
+  reviews?: number
+  rating?: number | null
   tags: string[]
   logo: string | null
   card_image: string | null
@@ -32,6 +38,13 @@ export type ApiProduct = {
   award?: { day: string; rank: number } | null
 }
 
+export type Invites = { link: string; code: string; invited: number; launched: number; credits: number; karma_credits?: number; used: number; feature_days: number }
+
+export type KarmaInfo = { total: number; week: number; per_credit: number; next_credit_in: number; credits: { earned: number; used: number }; events: { action: string; label: string; ref: string; points: number; at: string }[]; how_to_earn: { action: string; points: number; rule: string }[]; leaderboard: string }
+export type BoardRows = { board: string; period: string; total: number; rows: { rank: number | null; id: string; name: string; value: number; badges: { emoji: string; label: string }[]; url: string }[]; web: string }
+export type ApiComment = { id: string; parent: string | null; body: string | null; deleted: boolean; author: string | null; karma: number; maker: boolean; at: string; url: string; mine?: boolean }
+export type ApiReview = { rating: number; body: string; author: string; karma: number; at: string }
+
 export type Launched = { product: ApiProduct; claim_url?: string; existing?: boolean }
 export type ClaimRecord = { type: string; name: string; value: string }
 
@@ -71,8 +84,27 @@ export class BuiltIndieClient {
     return this.call('GET', `/api/v1/products?window=${encodeURIComponent(window)}&limit=${limit}`)
   }
 
-  search(q: string): Promise<{ products: ApiProduct[] }> {
-    return this.call('GET', `/api/v1/products?q=${encodeURIComponent(q)}`)
+  tags(): Promise<{ tags: { tag: string; count: number }[] }> {
+    return this.call('GET', '/api/v1/tags')
+  }
+
+  tagged(tag: string, limit = 30): Promise<{ tag: string; products: ApiProduct[] }> {
+    return this.call('GET', `/api/v1/products?tag=${encodeURIComponent(tag)}&limit=${limit}`)
+  }
+
+  /** Search with filters; the answer carries the facets (counts per category, tag, stack…) to narrow further. */
+  search(q: string, filters: SearchFilters = {}): Promise<SearchResult> {
+    const p = new URLSearchParams()
+    if (q) p.set('q', q)
+    for (const k of ['category', 'tag', 'has', 'stack', 'maker'] as const) for (const v of filters[k] ?? []) p.append(k, v)
+    for (const k of ['launched', 'sort'] as const) if (filters[k]) p.set(k, filters[k]!)
+    if (filters.page) p.set('page', String(filters.page))
+    if (filters.limit) p.set('limit', String(filters.limit))
+    return this.call('GET', `/api/v1/search?${p}`)
+  }
+
+  categories(): Promise<{ categories: { key: string; label: string; count: number; page: string }[]; tags: { tag: string; count: number; page: string }[] }> {
+    return this.call('GET', '/api/v1/categories')
   }
 
   product(slug: string): Promise<ApiProduct> {
@@ -89,18 +121,33 @@ export class BuiltIndieClient {
     return k
   }
 
-  claimRecord(slug: string): Promise<{ owner: boolean; record: ClaimRecord; markdown: string }> {
+  claimRecord(slug: string): Promise<{ owner: boolean; record: ClaimRecord; badge: string; markdown: string }> {
     return this.call('GET', `/api/v1/products/${encodeURIComponent(slug)}/claim`, undefined, this.needKey())
   }
 
-  claim(slug: string): Promise<{ claimed: boolean; looked: string[]; record: ClaimRecord; markdown?: string }> {
+  claim(slug: string): Promise<{ claimed: boolean; method?: 'dns' | 'badge'; looked: string[]; record: ClaimRecord; badge: string; markdown?: string }> {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/claim`, {}, this.needKey())
   }
 
-  me(): Promise<{ email: string; products: (ApiProduct & { owner: boolean })[] }> {
+  me(): Promise<{ email: string; products: (ApiProduct & { owner: boolean })[]; invite: Invites }> {
     return this.call('GET', '/api/v1/me', undefined, this.needKey())
   }
 
+  /** Your invite link and credits: each new member it brings in who launches earns a free Featured week. */
+  invites(): Promise<Invites> {
+    return this.call('GET', '/api/v1/invites', undefined, this.needKey())
+  }
+
+  /** Spend one invite credit to feature a listing you own. */
+  credit(slug: string): Promise<{ featured_until: string; credits: number }> {
+    return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/credit`, {}, this.needKey())
+  }
+
+  /** Pay to feature a listing you own: opens a CoinPay checkout session (any coin or PayPal); send the buyer to checkout_url. */
+  feature(slug: string, email?: string): Promise<{ checkout_url: string; checkout_session_id: string; methods: string[]; payment: string; usd: number; days: number }> {
+    return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/feature`, email ? { email } : {}, this.needKey())
+  }
+
   edit(slug: string, patch: Record<string, unknown>, key?: string): Promise<ApiProduct> {
     return this.call('PATCH', `/api/v1/products/${encodeURIComponent(slug)}`, patch, this.needKey(key))
   }
@@ -109,6 +156,35 @@ export class BuiltIndieClient {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/${action}`, {}, this.needKey(key))
   }
 
+  /** Your karma: total, this week, history, and how far to the next free Featured week. */
+  karma(): Promise<KarmaInfo> {
+    return this.call('GET', '/api/v1/karma', undefined, this.needKey())
+  }
+
+  leaderboard(board = 'karma', period = 'week', limit = 25): Promise<BoardRows> {
+    return this.call('GET', `/api/v1/leaderboard?board=${encodeURIComponent(board)}&period=${encodeURIComponent(period)}&limit=${limit}`)
+  }
+
+  comments(slug: string): Promise<{ slug: string; comments: ApiComment[] }> {
+    return this.call('GET', `/api/v1/products/${encodeURIComponent(slug)}/comments`)
+  }
+
+  comment(slug: string, body: string, parent?: string): Promise<{ comment: ApiComment; karma: number }> {
+    return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/comments`, { body, ...(parent ? { parent } : {}) }, this.needKey())
+  }
+
+  deleteComment(id: string): Promise<{ deleted: boolean }> {
+    return this.call('DELETE', `/api/v1/comments/${encodeURIComponent(id)}`, undefined, this.needKey())
+  }
+
+  reviews(slug: string): Promise<{ slug: string; rating: number | null; count: number; reviews: ApiReview[] }> {
+    return this.call('GET', `/api/v1/products/${encodeURIComponent(slug)}/reviews`)
+  }
+
+  review(slug: string, rating: number, body: string): Promise<{ review: { rating: number; body: string }; product: { rating: number | null; count: number }; karma: number }> {
+    return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/reviews`, { rating, body }, this.needKey())
+  }
+
   verify(slug: string): Promise<{ verified: boolean }> {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/verify`, {})
   }

package/src/coinpay-signin.ts

@@ -0,0 +1,118 @@
+/**
+ * Sign in with CoinPay: the house identity provider (OIDC at coinpayportal.com,
+ * authorization code + PKCE S256), through the shared @profullstack/stack/coinpay
+ * helpers. Same flow as pwamart.com, so one CoinPay account is a member of both.
+ *
+ * Linking is by CoinPay `sub` only (user_identities), never by email: CoinPay
+ * does not verify emails (email_verified is always false). So:
+ *   - a returning sub signs in as the member it is linked to;
+ *   - a signed-in member who connects (from /me) gets the sub attached;
+ *   - anyone else gets a new member, with their CoinPay name as the display name
+ *     and a placeholder address (…@coinpay.invalid): the CoinPay email is never
+ *     used as the account's email, or it would let a CoinPay account sign in as
+ *     whoever owns that address here. An address that already has an account
+ *     is refused: that person signs in by email and connects CoinPay from /me.
+ *
+ * The state and PKCE verifier ride in a short HttpOnly cookie scoped to
+ * /api/v1/coinpay. Off (buttons hidden, routes redirect) without a client id and secret.
+ */
+import { createHash, randomBytes } from 'node:crypto'
+import { exchangeCoinPayCode, fetchCoinPayUserinfo, generateCoinPayPkcePair, getCoinPayAuthorizeUrl, validateCoinPayState } from '@profullstack/stack/coinpay'
+import type { Context, Hono } from 'hono'
+import { getCookie, setCookie } from 'hono/cookie'
+import { safeNext, SESSION_COOKIE, type Auth } from './auth.js'
+import type { Store, User } from './db.js'
+
+export type CoinPayOAuth = { clientId: string; clientSecret: string; issuer: string; /** Tests pass a fake CoinPay. */ fetch?: typeof fetch }
+
+export const PROVIDER = 'coinpay'
+const COOKIE = 'bi_cp'
+const PATH = '/api/v1/coinpay'
+const SCOPES = 'openid profile email'
+
+export function coinpayOAuthFromEnv(env: Record<string, string | undefined> = process.env): CoinPayOAuth | null {
+  const clientId = env.COINPAY_OAUTH_CLIENT_ID?.trim()
+  const clientSecret = env.COINPAY_OAUTH_CLIENT_SECRET?.trim()
+  return clientId && clientSecret ? { clientId, clientSecret, issuer: (env.COINPAY_OAUTH_ISSUER ?? 'https://coinpayportal.com').replace(/\/+$/, '') } : null
+}
+
+/** The address a CoinPay-only member is kept under: unique, and never deliverable. */
+export const placeholderEmail = (sub: string) => `cp-${createHash('sha256').update(sub).digest('hex').slice(0, 20)}@coinpay.invalid`
+export const isPlaceholder = (email: string) => email.endsWith('@coinpay.invalid')
+
+export function mountCoinPaySignin(
+  app: Hono<any>,
+  o: { store: Store; auth: Auth; origin: string; oauth: CoinPayOAuth | null; secure: (c: Context) => boolean; sessionUser: (c: Context) => User | null; onNewMember?: (c: Context, user: User) => void },
+): void {
+  const redirectUri = `${o.origin}${PATH}/callback`
+  const cookie = (c: Context, value: string, maxAge: number) => setCookie(c, COOKIE, value, { httpOnly: true, secure: o.secure(c), sameSite: 'Lax', path: PATH, maxAge })
+
+  app.get(`${PATH}/login`, (c) => {
+    if (!o.oauth) return c.redirect('/login?error=coinpay-off')
+    const state = randomBytes(24).toString('base64url')
+    const { codeVerifier, codeChallenge } = generateCoinPayPkcePair()
+    const next = safeNext(c.req.query('next')) ?? '/me'
+    cookie(c, Buffer.from(JSON.stringify({ state, codeVerifier, next })).toString('base64url'), 600)
+    return c.redirect(getCoinPayAuthorizeUrl({ issuer: o.oauth.issuer, clientId: o.oauth.clientId, redirectUri, state, codeChallenge, scopes: SCOPES }))
+  })
+
+  app.get(`${PATH}/callback`, async (c) => {
+    const fail = (why: string) => c.redirect(`/login?error=${encodeURIComponent(why)}`)
+    if (!o.oauth) return fail('coinpay-off')
+    let saved: { state?: string; codeVerifier?: string; next?: string } | null = null
+    try {
+      saved = JSON.parse(Buffer.from(getCookie(c, COOKIE) ?? '', 'base64url').toString())
+    } catch {}
+    cookie(c, '', 0)
+    if (!saved?.state || !saved.codeVerifier) return fail('coinpay-expired')
+    if (c.req.query('error')) return fail('coinpay-denied')
+    if (!validateCoinPayState(c.req.query('state'), saved.state)) return fail('coinpay-state')
+    const code = c.req.query('code')
+    if (!code) return fail('coinpay-failed')
+
+    let claims: { sub?: string; email?: string; name?: string }
+    try {
+      const tokens = await exchangeCoinPayCode({ issuer: o.oauth.issuer, code, redirectUri, clientId: o.oauth.clientId, clientSecret: o.oauth.clientSecret, codeVerifier: saved.codeVerifier, fetch: o.oauth.fetch })
+      claims = await fetchCoinPayUserinfo({ issuer: o.oauth.issuer, accessToken: tokens.access_token, fetch: o.oauth.fetch })
+    } catch (e) {
+      console.error(`[coinpay-signin] ${(e as Error).message}`)
+      return fail('coinpay-failed')
+    }
+    const sub = String(claims.sub ?? '')
+    if (!sub) return fail('coinpay-failed')
+    const email = String(claims.email ?? '').trim().toLowerCase() || null
+    const name = String(claims.name ?? '').replace(/\s+/g, ' ').trim().slice(0, 40) || null
+    const next = safeNext(saved.next) ?? '/me'
+
+    // Connecting CoinPay to the member who is signed in.
+    const current = o.sessionUser(c)
+    if (current) {
+      if (!o.store.linkIdentity({ provider: PROVIDER, subject: sub, userId: current.id, email, name })) return c.redirect('/me?coinpay=taken#signin')
+      return c.redirect('/me?coinpay=connected#signin')
+    }
+
+    let user = o.store.identityUser(PROVIDER, sub)
+    let created = false
+    if (!user) {
+      if (email && o.store.userByEmail(email)) return fail('coinpay-email-exists')
+      user = o.store.findOrCreateUser(placeholderEmail(sub))
+      created = true
+      o.store.linkIdentity({ provider: PROVIDER, subject: sub, userId: user.id, email, name })
+      if (name && !user.displayName) o.store.setDisplayName(user.id, name)
+      user = o.store.user(user.id)!
+      o.onNewMember?.(c, user)
+    }
+    setCookie(c, SESSION_COOKIE, o.auth.createSession(user.id), { httpOnly: true, secure: o.secure(c), sameSite: 'Lax', path: '/', maxAge: 90 * 86400 })
+    return c.redirect(created && next === '/me' ? '/me?coinpay=welcome' : next)
+  })
+}
+
+/** What /login says for each ?error= the flow can end with. */
+export const COINPAY_ERRORS: Record<string, string> = {
+  'coinpay-off': 'Sign in with CoinPay is not set up on this server. Use your email instead.',
+  'coinpay-expired': 'That CoinPay sign-in took too long. Try again.',
+  'coinpay-denied': 'CoinPay sign-in was cancelled.',
+  'coinpay-state': 'That CoinPay sign-in did not match this browser. Try again.',
+  'coinpay-failed': 'CoinPay did not confirm who you are. Try again in a moment.',
+  'coinpay-email-exists': 'That email already has a built.indie account. Sign in with your email, then connect CoinPay on your page.',
+}