@profullstack/builtindie 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@profullstack/builtindie",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "built.indie: launch your indie product with one URL. We fetch the logo, screenshots, videos, llms.txt, OpenSite and OpenProfile from your homepage; people upvote; you get a badge. Web (PWA), API, CLI, TUI and MCP.",
   "license": "MIT",
   "type": "module",

package/src/cli.ts

@@ -28,7 +28,8 @@ export const HELP = `builtindie ${VERSION}: launch your indie product with one U
   builtindie vote <slug>
   builtindie preview <url>            what we read from a site; nothing is saved
   builtindie search <words>
-  builtindie claim <slug>             the DNS TXT record that proves it is yours, then checks it
+  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 me                       your launches
   builtindie edit <slug> [--name --tagline --description --tags a,b --video URL]
   builtindie refetch <slug>           read the homepage again
@@ -53,7 +54,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'].includes(k)) flags[k] = argv[++i]!
+      else if (argv[i + 1] !== undefined && !argv[i + 1]!.startsWith('--') && !['json', 'draft', 'md'].includes(k)) flags[k] = argv[++i]!
       else flags[k] = true
     } else words.push(a)
   }
@@ -172,6 +173,11 @@ export async function main(argv = process.argv.slice(2), out: Out = console, cli
       }
       case 'claim': {
         const slug = rest[0] ?? ''
+        if (flags.md) {
+          const r = await client.claimRecord(slug)
+          out.log(json ? JSON.stringify(r, null, 2) : r.markdown)
+          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(', ')})`)

package/src/client.ts

@@ -89,11 +89,11 @@ export class BuiltIndieClient {
     return k
   }
 
-  claimRecord(slug: string): Promise<{ owner: boolean; record: ClaimRecord }> {
+  claimRecord(slug: string): Promise<{ owner: boolean; record: ClaimRecord; 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 }> {
+  claim(slug: string): Promise<{ claimed: boolean; looked: string[]; record: ClaimRecord; markdown?: string }> {
     return this.call('POST', `/api/v1/products/${encodeURIComponent(slug)}/claim`, {}, this.needKey())
   }
 

package/src/html.ts

@@ -330,8 +330,52 @@ ${d.error ? `<p class="note error" role="alert">${esc(d.error.message)}</p>` : '
   })
 }
 
+/**
+ * The claim as Markdown: a prompt to hand an AI agent (or a person) that has
+ * access to the domain's DNS. Everything it needs is in it: the exact record,
+ * where it goes, how to check it took, and how to finish the claim.
+ */
+export function claimMarkdown(origin: string, p: Product, record: { name: string; value: string }): string {
+  const bare = p.domain.replace(/^www\./, '')
+  const label = record.name.slice(0, -(bare.length + 1))
+  return `# Claim ${p.name} on built.indie: add one DNS TXT record
+
+Prove control of \`${bare}\` so the listing ${origin}/p/${p.slug} can be claimed and edited.
+
+## The record
+
+| Field | Value |
+| --- | --- |
+| Type | \`TXT\` |
+| Name / host | \`${record.name}\` (many DNS hosts want only \`${label}\`, relative to the zone) |
+| Value / content | \`${record.value}\` |
+| TTL | 300, or the host's default |
+
+The same TXT value on \`${bare}\` itself also works, if a \`${label}\` name is not possible.
+
+## Steps
+
+1. Find the DNS zone that serves \`${bare}\`. It is the zone of the registered domain (for \`a.b.example.com\` that is usually \`example.com\`): check with \`dig +short NS ${bare}\`.
+2. In that zone, add the TXT record above. Add it; do not replace or delete any existing TXT records (SPF, DKIM, other verifications).
+3. Wait for it to be served, then check it from public resolvers (built.indie asks 1.1.1.1 and 9.9.9.9):
+
+   \`\`\`sh
+   dig +short TXT ${record.name} @1.1.1.1
+   # expect: "${record.value}"
+   \`\`\`
+
+4. Finish the claim, any one of:
+   - open ${origin}/p/${p.slug}/claim (signed in as the same account) and press **Check DNS**
+   - \`BUILTINDIE_KEY=bi_… builtindie claim ${p.slug}\`
+   - \`curl -X POST ${origin}/api/v1/products/${p.slug}/claim -H 'authorization: Bearer bi_…'\` (answers \`{"claimed": true}\`)
+
+The value is tied to one built.indie account: a record made for another account will not claim it for this one. The record can be removed once the claim succeeds.
+`
+}
+
 export function claimPage(ctx: Ctx, d: { product: Product; record: { name: string; value: string }; owner: boolean; result?: { ok: boolean; looked: string[] } }): string {
   const p = d.product
+  const md = claimMarkdown(ctx.origin, p, d.record)
   const done = d.owner || d.result?.ok
   return layout({
     ctx,
@@ -351,6 +395,12 @@ ${d.result && !d.result.ok ? `<p class="note error" role="alert">We did not find
   <p class="small muted">Value</p><div class="address"><code>${esc(d.record.value)}</code><button class="copy" data-copy="${esc(d.record.value)}">Copy</button></div>
   <p class="small muted">A TXT record on ${esc(p.domain.replace(/^www\./, ''))} itself with the same value works too. You can remove it once claimed.</p>
   <form method="post" action="/p/${esc(p.slug)}/claim" data-busy="Asking DNS…"><button class="btn">Check DNS</button></form>
+</div>
+<div class="card">
+  <h2 class="mini-h">${icon('terminal')} Have an AI do the DNS</h2>
+  <p class="muted small">Copy these instructions as Markdown and paste them to an agent (or a person) with access to your DNS. They hold your record, how to check it, and how to finish the claim.</p>
+  <div class="row"><button class="chip" data-copy="${esc(md)}">Copy as Markdown for AI</button><a class="chip" href="/p/${esc(p.slug)}/claim.md">Open as .md</a></div>
+  <details><summary class="small">Preview</summary><pre><code>${esc(md)}</code></pre></details>
 </div>`}`,
   })
 }

package/src/mcp.ts

@@ -66,7 +66,7 @@ export function createMcpServer(client = new BuiltIndieClient()): McpServer {
   )
   server.tool(
     'claim_product',
-    'Claim a listing for its domain owner (needs BUILTINDIE_KEY). Returns the DNS TXT record to add; call again once it is in DNS and claimed comes back true.',
+    'Claim a listing for its domain owner (needs BUILTINDIE_KEY). Returns the DNS TXT record to add, plus `markdown`: step-by-step instructions for whoever has DNS access. Call again once it is in DNS and claimed comes back true.',
     { slug },
     wrap((a: { slug: string }) => client.claim(a.slug)),
   )

package/src/server.ts

@@ -12,7 +12,7 @@ import { deleteCookie, getCookie, setCookie } from 'hono/cookie'
 import { Auth, consoleMailer, resendMailer, safeNext, SESSION_COOKIE, validEmail } from './auth.js'
 import { Store, type Product, type User, type Window } from './db.js'
 import { privateAddress } from './fetch.js'
-import { badgeSvg, boardPage, cardImage, claimPage, editPage, esc, helpPage, homePage, loginPage, makerPage, mePage, messagePage, productPage, submitPage, type Ctx } from './html.js'
+import { badgeSvg, boardPage, cardImage, claimMarkdown, claimPage, editPage, esc, helpPage, homePage, loginPage, makerPage, mePage, messagePage, productPage, submitPage, type Ctx } from './html.js'
 import { IMAGE_TYPES, Media } from './media.js'
 import { RING_PLACEHOLDER, ringBar, startRingRefresh, visitorOnMoshpit } from './ring.js'
 import { BuiltIndie, CLAIM_LABEL, CLAIM_PREFIX, DEFAULT_CHAINS, InputError, type Config, type Edit } from './service.js'
@@ -236,6 +236,14 @@ export function createApp(deps: Deps) {
   const claimRecord = (p: Product, user: User) => ({ type: 'TXT', name: `${CLAIM_LABEL}.${p.domain.replace(/^www\./, '')}`, value: `${CLAIM_PREFIX}${service.claimToken(p, user)}` })
   const claimView = (c: Context<Env>, p: Product, user: User, extra: { result?: { ok: boolean; looked: string[] } } = {}, status = 200) =>
     page(c, claimPage(ctxOf(c), { product: p, record: claimRecord(p, user), owner: p.ownerId === user.id, ...extra }), status)
+  // The same instructions as Markdown, to paste to an AI agent with DNS access.
+  app.get('/p/:slug/claim.md', (c) => {
+    const user = sessionUser(c)
+    if (!user) return c.redirect(`/login?next=${encodeURIComponent(c.req.path)}`)
+    const p = store.bySlug(c.req.param('slug'))
+    if (!p || p.status === 'hidden') return c.text('not found', 404)
+    return c.body(claimMarkdown(origin, p, claimRecord(p, user)), 200, { 'content-type': 'text/markdown; charset=utf-8', 'cache-control': 'private, no-store' })
+  })
   app.get('/p/:slug/claim', (c) => {
     const user = sessionUser(c)
     if (!user) return toLogin(c)
@@ -531,7 +539,7 @@ export function createApp(deps: Deps) {
     if (!user) return c.json(NEEDS_ACCOUNT, 401)
     const p = store.bySlug(c.req.param('slug'))
     if (!p || p.status === 'hidden') return c.json({ error: 'no such product' }, 404)
-    return c.json({ owner: p.ownerId === user.id, record: claimRecord(p, user) })
+    return c.json({ owner: p.ownerId === user.id, record: claimRecord(p, user), markdown: claimMarkdown(origin, p, claimRecord(p, user)) })
   })
   app.post('/api/v1/products/:slug/claim', async (c) => {
     const user = apiUser(c)
@@ -540,7 +548,7 @@ export function createApp(deps: Deps) {
     if (!p || p.status === 'hidden') return c.json({ error: 'no such product' }, 404)
     if (!readLimit.allow(`read:${ip(c)}`)) return c.json({ error: 'too many checks; wait a few minutes' }, 429)
     const r = await service.claim(p, user)
-    return c.json({ claimed: r.ok, looked: r.looked, record: claimRecord(p, user) })
+    return c.json({ claimed: r.ok, looked: r.looked, record: claimRecord(p, user), ...(r.ok ? {} : { markdown: claimMarkdown(origin, p, claimRecord(p, user)) }) })
   })
   app.get('/api/v1/me', (c) => {
     const user = apiUser(c)

package/src/service.ts

@@ -47,9 +47,20 @@ export type Config = {
 export const CLAIM_LABEL = '_built-indie'
 export const CLAIM_PREFIX = 'built-indie-verify='
 
-const resolver = new Resolver({ timeout: 4000, tries: 2 })
-resolver.setServers(['1.1.1.1', '9.9.9.9'])
-const publicTxt = (name: string) => resolver.resolveTxt(name)
+/**
+ * TXT records as public resolvers see them: every answer from 1.1.1.1 and 9.9.9.9, merged.
+ * One Resolver per server on purpose: Bun 1.4's node:dns Resolver given two servers
+ * answers ENOTFOUND for a record each of them serves alone, so no claim could succeed.
+ */
+const PUBLIC_DNS = ['1.1.1.1', '9.9.9.9'].map((server) => {
+  const r = new Resolver({ timeout: 4000, tries: 2 })
+  r.setServers([server])
+  return r
+})
+export async function publicTxt(name: string, resolvers: Pick<Resolver, 'resolveTxt'>[] = PUBLIC_DNS): Promise<string[][]> {
+  const answers = await Promise.all(resolvers.map((r) => r.resolveTxt(name).catch(() => [] as string[][])))
+  return answers.flat()
+}
 
 export const CHAIN_LABELS: Record<string, string> = {
   USDC_POL: 'USDC on Polygon', USDC_SOL: 'USDC on Solana', USDC_ETH: 'USDC on Ethereum', USDT_POL: 'USDT on Polygon',

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.1.2'
+export const VERSION = '0.1.4'