${body}

`;\n}\n\nfunction msg(text: string | null, isError: boolean): string {\n return text\n ? `

${escapeHtml(text)}

`\n : \"\";\n}\n\n// ── job queue ────────────────────────────────────────────────────────\n\n// Atomic claim: the UPDATE...WHERE...RETURNING is one SQLite statement, so\n// concurrent pollers/streamers can never claim the same row.\nasync function claimOne(\n channel: string,\n): Promise<\n { id: string; method: string; params: Record } | null\n> {\n const { rows } = await sqlite.execute({\n sql: `UPDATE mcp_bridge_requests SET status = 'claimed'\n WHERE id = (SELECT id FROM mcp_bridge_requests WHERE channel = ? AND status = 'pending' ORDER BY created_at LIMIT 1)\n RETURNING id, method, params`,\n args: [channel],\n });\n if (rows.length === 0) return null;\n const row = rows[0] as any as { id: string; method: string; params: string };\n return { id: row.id, method: row.method, params: JSON.parse(row.params) };\n}\n\nasync function enqueue(\n channel: string,\n method: string,\n params: Record,\n): Promise {\n const id = crypto.randomUUID();\n await sqlite.execute({\n sql:\n `INSERT INTO mcp_bridge_requests (id, channel, method, params, status, created_at) VALUES (?, ?, ?, ?, 'pending', ?)`,\n args: [id, channel, method, JSON.stringify(params), Date.now()],\n });\n return id;\n}\n\n// Blocks until the row lands in 'done' or CLIENT_MAX_WAIT_MS elapses.\nasync function dispatch(\n channel: string,\n method: string,\n params: Record,\n) {\n const id = await enqueue(channel, method, params);\n const deadline = Date.now() + CLIENT_MAX_WAIT_MS;\n\n while (Date.now() < deadline) {\n const { rows } = await sqlite.execute({\n sql:\n `SELECT result, error FROM mcp_bridge_requests WHERE id = ? AND status = 'done'`,\n args: [id],\n });\n if (rows.length > 0) {\n const row = rows[0] as any as {\n result: string | null;\n error: string | null;\n };\n await sqlite.execute({\n sql: `DELETE FROM mcp_bridge_requests WHERE id = ?`,\n args: [id],\n });\n return {\n result: row.result != null ? JSON.parse(row.result) : undefined,\n error: row.error ?? undefined,\n };\n }\n await sleep(CLIENT_POLL_INTERVAL_MS);\n }\n await sqlite.execute({\n sql: `DELETE FROM mcp_bridge_requests WHERE id = ?`,\n args: [id],\n });\n return null;\n}\n\ninterface JsonRpcRequest {\n jsonrpc: \"2.0\";\n id?: string | number | null;\n method: string;\n params?: Record;\n}\n\nasync function handleRpc(\n channel: string,\n req: JsonRpcRequest,\n tokenFingerprint: string,\n) {\n const { id, method, params = {} } = req;\n\n if (method === \"notifications/initialized\") {\n await enqueue(channel, method, params); // fire-and-forget: no response expected\n return null;\n }\n\n const outcome = await dispatch(channel, method, params);\n await logCall(\n tokenFingerprint,\n channel,\n method,\n outcome !== null && !outcome.error,\n );\n\n if (outcome === null) {\n return rpcError(\n id,\n -32001,\n `Timed out waiting for the local agent on channel '${channel}' to answer '${method}'.`,\n );\n }\n return outcome.error\n ? rpcError(id, -32000, outcome.error)\n : rpcResult(id, outcome.result);\n}\n\nconst app = new Hono();\n\nasync function handleMcpPost(c: any, channel: string) {\n const token = bearer(c.req.raw);\n if (!(await resolveToken(token))) {\n const origin = new URL(c.req.url).origin;\n c.header(\n \"WWW-Authenticate\",\n `Bearer resource_metadata=\"${origin}/.well-known/oauth-protected-resource\"`,\n );\n return c.json(rpcError(null, -32000, \"Unauthorized\"), 401);\n }\n await purgeExpired();\n\n const fingerprint = await sha256Base64Url(token!);\n if (await isRateLimited(fingerprint)) {\n return c.json(\n rpcError(\n null,\n -32029,\n `Rate limit exceeded: ${MCP_RATE_LIMIT_MAX} calls per ${\n MCP_RATE_LIMIT_WINDOW_MS / 1000\n }s.`,\n ),\n 429,\n );\n }\n\n let body: JsonRpcRequest | JsonRpcRequest[];\n try {\n body = await c.req.json();\n } catch {\n return c.json(rpcError(null, -32700, \"Parse error\"), 400);\n }\n\n const batch = Array.isArray(body) ? body : [body];\n const responses =\n (await Promise.all(batch.map((r) => handleRpc(channel, r, fingerprint))))\n .filter((r) => r !== null);\n\n if (responses.length === 0) return c.body(null, 202);\n return c.json(Array.isArray(body) ? responses : responses[0]);\n}\n\napp.post(\"/mcp\", (c) => handleMcpPost(c, DEFAULT_CHANNEL));\napp.post(\"/mcp/:channel\", (c) => handleMcpPost(c, c.req.param(\"channel\")));\napp.get(\n \"/mcp\",\n (c) => c.json({ error: \"POST only — no SSE client transport.\" }, 405),\n);\n\nasync function handlePoll(c: any, channel: string) {\n if (bearer(c.req.raw) !== WORKER_TOKEN) return c.body(null, 401);\n const deadline = Date.now() + WORKER_POLL_WINDOW_MS;\n while (Date.now() < deadline) {\n const job = await claimOne(channel);\n if (job) return c.json(job);\n await sleep(WORKER_POLL_INTERVAL_MS);\n }\n return c.body(null, 204);\n}\napp.get(\"/poll\", (c) => handlePoll(c, DEFAULT_CHANNEL));\napp.get(\"/poll/:channel\", (c) => handlePoll(c, c.req.param(\"channel\")));\n\nfunction handleStream(c: any, channel: string) {\n if (bearer(c.req.raw) !== WORKER_TOKEN) return c.body(null, 401);\n\n const stream = new ReadableStream({\n async start(controller) {\n const encoder = new TextEncoder();\n const deadline = Date.now() + STREAM_MAX_MS;\n let lastHeartbeat = Date.now();\n try {\n while (Date.now() < deadline) {\n const job = await claimOne(channel);\n if (job) {\n controller.enqueue(encoder.encode(JSON.stringify(job) + \"\\n\"));\n continue;\n }\n if (Date.now() - lastHeartbeat > STREAM_HEARTBEAT_INTERVAL_MS) {\n controller.enqueue(encoder.encode(\"\\n\")); // keeps intermediaries from buffering the whole stream\n lastHeartbeat = Date.now();\n }\n await sleep(STREAM_CHECK_INTERVAL_MS);\n }\n } catch {\n // client disconnected — no job was left half-claimed, nothing to clean up\n } finally {\n controller.close();\n }\n },\n });\n\n return new Response(stream, {\n headers: {\n \"content-type\": \"application/x-ndjson\",\n \"cache-control\": \"no-store\",\n },\n });\n}\napp.get(\"/stream\", (c) => handleStream(c, DEFAULT_CHANNEL));\napp.get(\"/stream/:channel\", (c) => handleStream(c, c.req.param(\"channel\")));\n\napp.post(\"/respond\", async (c) => {\n if (bearer(c.req.raw) !== WORKER_TOKEN) return c.body(null, 401);\n const { id, result, error } = await c.req.json() as {\n id: string;\n result?: unknown;\n error?: string;\n };\n await sqlite.execute({\n sql:\n `UPDATE mcp_bridge_requests SET status = 'done', result = ?, error = ? WHERE id = ?`,\n args: [\n result !== undefined ? JSON.stringify(result) : null,\n error ?? null,\n id,\n ],\n });\n return c.body(null, 204);\n});\n\napp.get(\"/health\", async (c) => {\n await purgeExpired();\n const { rows } = await sqlite.execute(\n `SELECT channel, COUNT(*) as stuck FROM mcp_bridge_requests WHERE status != 'done' GROUP BY channel`,\n );\n return c.json({ ok: rows.length === 0, stuck: rows });\n});\n\n// ── OAuth 2.1 authorization server ──────────────────────────────────\n\napp.get(\"/.well-known/oauth-authorization-server\", (c) => {\n const origin = new URL(c.req.url).origin;\n return c.json({\n issuer: origin,\n authorization_endpoint: `${origin}/authorize`,\n token_endpoint: `${origin}/token`,\n registration_endpoint: `${origin}/register`,\n response_types_supported: [\"code\"],\n grant_types_supported: [\"authorization_code\", \"refresh_token\"],\n code_challenge_methods_supported: [\"S256\"],\n token_endpoint_auth_methods_supported: [\"none\"],\n });\n});\n\napp.get(\"/.well-known/oauth-protected-resource\", (c) => {\n const origin = new URL(c.req.url).origin;\n return c.json({\n resource: origin,\n authorization_servers: [origin],\n bearer_methods_supported: [\"header\"],\n });\n});\n\n// DCR: client_id isn't a security boundary for this AS (PKCE is), so\n// registration always succeeds and nothing is persisted.\napp.post(\"/register\", async (c) => {\n let body: Record = {};\n try {\n body = await c.req.json();\n } catch { /* empty registration request is fine */ }\n return c.json({\n client_id: crypto.randomUUID(),\n client_id_issued_at: Math.floor(Date.now() / 1000),\n redirect_uris: body.redirect_uris ?? [],\n token_endpoint_auth_method: \"none\",\n grant_types: [\"authorization_code\", \"refresh_token\"],\n response_types: [\"code\"],\n }, 201);\n});\n\nconst AUTHORIZE_FIELDS = [\n \"response_type\",\n \"client_id\",\n \"redirect_uri\",\n \"code_challenge\",\n \"code_challenge_method\",\n \"state\",\n \"resource\",\n] as const;\n\nfunction renderAuthorizePage(\n q: Record,\n error: string | null,\n): string {\n const hidden = AUTHORIZE_FIELDS\n .map((\n k,\n ) => (q[k] !== undefined\n ? ``\n : \"\")\n )\n .join(\"\\n\");\n return layout(\n \"Authorize — valtown-mcp-bridge\",\n `\n

Authorize access

Enter your access key to connect this client.

\n ${msg(error, true)}\n \n `,\n );\n}\n\napp.get(\"/authorize\", (c) => c.html(renderAuthorizePage(c.req.query(), null)));\n\napp.post(\"/authorize\", async (c) => {\n const body = await c.req.parseBody() as Record;\n\n if (!(await resolveToken(body.key))) {\n return c.html(\n renderAuthorizePage(body, \"Incorrect or unapproved key.\"),\n 401,\n );\n }\n if (body.response_type !== \"code\") {\n return c.html(\n renderAuthorizePage(body, \"Only response_type=code is supported.\"),\n 400,\n );\n }\n if (body.code_challenge_method !== \"S256\") {\n return c.html(\n renderAuthorizePage(body, \"Only PKCE S256 is supported.\"),\n 400,\n );\n }\n\n const redirectUri = body.redirect_uri ?? \"\";\n if (\n !/^https:\\/\\//.test(redirectUri) &&\n !/^http:\\/\\/(localhost|127\\.0\\.0\\.1)(:\\d+)?\\//.test(redirectUri)\n ) {\n return c.html(renderAuthorizePage(body, \"Unrecognized redirect_uri.\"), 400);\n }\n if (!body.code_challenge) {\n return c.html(renderAuthorizePage(body, \"Missing code_challenge.\"), 400);\n }\n\n const code = crypto.randomUUID();\n await sqlite.execute({\n sql:\n `INSERT INTO oauth_codes (code, redirect_uri, code_challenge, granted_token, created_at) VALUES (?, ?, ?, ?, ?)`,\n args: [code, redirectUri, body.code_challenge, body.key, Date.now()],\n });\n\n const dest = new URL(redirectUri);\n dest.searchParams.set(\"code\", code);\n if (body.state) dest.searchParams.set(\"state\", body.state);\n return c.redirect(dest.toString(), 302);\n});\n\napp.post(\"/token\", async (c) => {\n let params: Record = {};\n try {\n params = await c.req.parseBody() as Record;\n } catch {\n try {\n params = await c.req.json();\n } catch {\n return c.json({ error: \"invalid_request\" }, 400);\n }\n }\n\n if (params.grant_type === \"authorization_code\") {\n const { rows } = await sqlite.execute({\n sql:\n `SELECT redirect_uri, code_challenge, granted_token, created_at FROM oauth_codes WHERE code = ?`,\n args: [params.code ?? \"\"],\n });\n if (rows.length === 0) {\n return c.json({\n error: \"invalid_grant\",\n error_description: \"unknown or already-used code\",\n }, 400);\n }\n\n const row = rows[0] as any as {\n redirect_uri: string;\n code_challenge: string;\n granted_token: string;\n created_at: number;\n };\n await sqlite.execute({\n sql: `DELETE FROM oauth_codes WHERE code = ?`,\n args: [params.code],\n }); // one-time use\n\n if (Date.now() - row.created_at > OAUTH_CODE_TTL_MS) {\n return c.json({\n error: \"invalid_grant\",\n error_description: \"code expired\",\n }, 400);\n }\n if (params.redirect_uri && params.redirect_uri !== row.redirect_uri) {\n return c.json({\n error: \"invalid_grant\",\n error_description: \"redirect_uri mismatch\",\n }, 400);\n }\n const computed = await sha256Base64Url(params.code_verifier ?? \"\");\n if (computed !== row.code_challenge) {\n return c.json({\n error: \"invalid_grant\",\n error_description: \"PKCE verification failed\",\n }, 400);\n }\n\n return c.json({\n access_token: row.granted_token,\n token_type: \"bearer\",\n expires_in: 3600,\n refresh_token: row.granted_token,\n });\n }\n\n if (params.grant_type === \"refresh_token\") {\n if (!(await resolveToken(params.refresh_token))) {\n return c.json({ error: \"invalid_grant\" }, 400);\n }\n return c.json({\n access_token: params.refresh_token,\n token_type: \"bearer\",\n expires_in: 3600,\n refresh_token: params.refresh_token,\n });\n }\n\n return c.json({ error: \"unsupported_grant_type\" }, 400);\n});\n\n// ── registration: request-access site ───────────────────────────────\n\ninterface ApplyValues {\n name?: string;\n email?: string;\n reason?: string;\n}\n\n// Two arrows, both pointing INTO the bridge — that's the entire argument\n// this diagram exists to make. No arrow ever touches the local-agent box\n// from the outside, because nothing is allowed to reach it from outside.\nfunction renderArchitectureDiagram(): string {\n return `\n `;\n}\n\nfunction renderApplyForm(values: ApplyValues): string {\n return `\n `;\n}\n\nfunction renderApplyPage(\n values: ApplyValues,\n note: string | null,\n isError: boolean,\n): string {\n return layout(\n \"valtown-mcp-bridge\",\n `\n

A front door for tools that were never meant to have one

\n This bridges MCP clients to an MCP server running on a machine behind NAT,\n with no forwarded ports, no tunnel software trusted with your traffic, and\n no one getting in who wasn't manually approved.\n

\n\n

Why this exists

\n An MCP server that's actually useful — one wired into a real filesystem,\n a real Roslyn workspace, a real local toolchain — has to run on the\n machine that has those things. MCP clients like Claude run somewhere\n else entirely, and a home network behind NAT has no public address for\n them to reach. The usual fixes make that worse, not better:\n

Port forwarding puts a listening service directly on the open internet, permanently.
Tunnel services (ngrok and similar) fix the reachability problem by routing your traffic through a third party's infrastructure.
Static bearer tokens don't satisfy the OAuth 2.1 + PKCE flow modern MCP clients expect from a connector, so a bare API key doesn't even work as a shortcut.

\n The only direction of connection NAT actually allows is outbound. So\n that's the only direction this uses.\n

\n\n

How it works

\n ${renderArchitectureDiagram()}\n

\n A client's request lands in a SQLite-backed queue on this always-on,\n publicly reachable relay. Your local agent — which never listens for\n anything — polls or streams from the relay to claim the job, runs it\n against your real MCP server, and posts the result back. The relay\n holds no tool registry of its own, so it can never drift out of sync\n with what your local server actually implements.\n

\n\n

Access is manual, on purpose

\n This isn't a public service — it's a front door onto one person's\n machine. Every request below is written to a database before an email\n ever goes out, and nothing gets through until it's approved by hand.\n If that's still what you're after, here's the form.\n

\n\n ${msg(note, isError)}\n ${renderApplyForm(values)}\n `,\n );\n}\n\napp.get(\"/\", (c) => {\n if (wantsHtml(c)) return c.html(renderApplyPage({}, null, false));\n return c.json({\n name: \"valtown-mcp-bridge\",\n endpoints: {\n client: [\"POST /mcp[/:channel]\"],\n agent: [\n \"GET /poll[/:channel]\",\n \"GET /stream[/:channel]\",\n \"POST /respond\",\n ],\n oauth: [\n \"GET /.well-known/oauth-authorization-server\",\n \"GET /.well-known/oauth-protected-resource\",\n \"POST /register\",\n \"GET|POST /authorize\",\n \"POST /token\",\n ],\n access: [\n \"GET / (browser: request-access form)\",\n \"POST /apply\",\n \"GET /admin (browser: admin panel)\",\n ],\n },\n });\n});\n\napp.post(\"/apply\", async (c) => {\n const body = await c.req.parseBody() as Record;\n const ip = clientIp(c);\n const ua = c.req.header(\"user-agent\") ?? \"unknown\";\n\n // Honeypot: real users never populate a visually hidden field. Respond as\n // if successful — telling a bot it was rejected only teaches it to adapt —\n // but write nothing to the database or the owner's inbox.\n if (body.company) {\n return c.html(\n renderApplyPage(\n {},\n \"Request received. You'll hear back once it's reviewed.\",\n false,\n ),\n );\n }\n\n const applicantEmail = (body.email ?? \"\").trim().toLowerCase();\n const name = (body.name ?? \"\").trim();\n const reason = (body.reason ?? \"\").trim();\n\n const errors: string[] = [];\n if (\n !/^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/.test(applicantEmail) ||\n applicantEmail.length > 320\n ) errors.push(\"Enter a valid email address.\");\n if (name.length < 2 || name.length > 200) errors.push(\"Enter your name.\");\n if (reason.length < 10 || reason.length > 2000) {\n errors.push(\"Say a bit more about what you need access for.\");\n }\n if (errors.length > 0) {\n return c.html(\n renderApplyPage(\n { name, email: applicantEmail, reason },\n errors.join(\" \"),\n true,\n ),\n 400,\n );\n }\n\n await purgeExpired();\n\n const { rows: existing } = await sqlite.execute({\n sql:\n `SELECT status FROM registrations WHERE email = ? AND status IN ('pending','approved') ORDER BY created_at DESC LIMIT 1`,\n args: [applicantEmail],\n });\n if (existing.length > 0) {\n const status = (existing[0] as any as { status: string }).status;\n return c.html(\n renderApplyPage(\n {},\n status === \"approved\"\n ? \"This email already has approved access.\"\n : \"This email already has a pending request.\",\n false,\n ),\n );\n }\n\n const { rows: recent } = await sqlite.execute({\n sql:\n `SELECT COUNT(*) as n FROM registrations WHERE ip = ? AND created_at > ?`,\n args: [ip, Date.now() - APPLY_RATE_LIMIT_WINDOW_MS],\n });\n if (((recent[0] as any as { n: number }).n) >= APPLY_RATE_LIMIT_MAX) {\n return c.html(\n renderApplyPage(\n {},\n \"Too many requests from this network — try again later.\",\n true,\n ),\n 429,\n );\n }\n\n const id = crypto.randomUUID();\n await sqlite.execute({\n sql:\n `INSERT INTO registrations (id, email, name, reason, status, ip, user_agent, created_at) VALUES (?, ?, ?, ?, 'pending', ?, ?, ?)`,\n args: [id, applicantEmail, name, reason, ip, ua, Date.now()],\n });\n\n const origin = new URL(c.req.url).origin;\n await email({\n subject: `[mcp-bridge] access request: ${name}`,\n text: [\n `Name: ${name}`,\n `Email: ${applicantEmail}`,\n `Reason: ${reason}`,\n `IP: ${ip}`,\n `User-Agent: ${ua}`,\n ``,\n `Approve: ${origin}/admin/approve?id=${id}&key=${ADMIN_KEY}`,\n `Deny: ${origin}/admin/deny?id=${id}&key=${ADMIN_KEY}`,\n `Dashboard: ${origin}/admin?key=${ADMIN_KEY}`,\n ].join(\"\\n\"),\n }).catch((err) =>\n console.error(\"registration notification email failed:\", err)\n );\n\n return c.html(\n renderApplyPage(\n {},\n \"Request received. You'll hear back once it's reviewed.\",\n false,\n ),\n );\n});\n\n// ── admin: approve / deny / revoke / dashboard ──────────────────────\n\nfunction adminLoginPage(c: any, error?: string): string {\n const params = new URLSearchParams(c.req.query());\n params.delete(\"key\");\n const hidden = [...params.entries()].map(([k, v]) =>\n ``\n ).join(\"\\n\");\n return layout(\n \"Admin — valtown-mcp-bridge\",\n `\n

Admin

Enter the admin key to continue.

\n ${msg(error ?? null, true)}\n `,\n );\n}\n\nfunction requireAdmin(c: any): Response | null {\n if (c.req.query(\"key\") !== ADMIN_KEY) {\n return c.html(\n adminLoginPage(c, c.req.query(\"key\") ? \"Incorrect key.\" : undefined),\n 401,\n );\n }\n return null;\n}\n\napp.get(\"/admin/approve\", async (c) => {\n const denied = requireAdmin(c);\n if (denied) return denied;\n\n const token = randomToken();\n const fingerprint = await sha256Base64Url(token);\n const expiresAt = Date.now() + ACCESS_TOKEN_TTL_MS;\n const { rows } = await sqlite.execute({\n sql:\n `UPDATE registrations SET status = 'approved', access_token = ?, token_fingerprint = ?, expires_at = ?, decided_at = ?\n WHERE id = ? AND status = 'pending' RETURNING name, email`,\n args: [token, fingerprint, expiresAt, Date.now(), c.req.query(\"id\") ?? \"\"],\n });\n if (rows.length === 0) {\n return c.html(\n layout(\n \"Admin\",\n `

Not found

No pending request with that id.

← Dashboard

`,\n ),\n 404,\n );\n }\n\n const row = rows[0] as any as { name: string; email: string };\n return c.html(layout(\n \"Approved — valtown-mcp-bridge\",\n `\n

Approved

\n ${msg(`${row.name} <${row.email}>`, false)}\n

Send them this access key — it's shown once here, and always visible on the dashboard.\n Expires ${escapeHtml(new Date(expiresAt).toLocaleDateString())} (${\n ACCESS_TOKEN_TTL_MS / 86_400_000\n } days).

${escapeHtml(token)}

← Dashboard

`,\n ));\n});\n\napp.get(\"/admin/deny\", async (c) => {\n const denied = requireAdmin(c);\n if (denied) return denied;\n\n const { rows } = await sqlite.execute({\n sql:\n `UPDATE registrations SET status = 'denied', decided_at = ? WHERE id = ? AND status = 'pending' RETURNING name, email`,\n args: [Date.now(), c.req.query(\"id\") ?? \"\"],\n });\n if (rows.length === 0) {\n return c.html(\n layout(\n \"Admin\",\n `

Not found

No pending request with that id.

← Dashboard

`,\n ),\n 404,\n );\n }\n\n const row = rows[0] as any as { name: string; email: string };\n return c.html(layout(\n \"Denied — valtown-mcp-bridge\",\n `\n

Denied

\n ${msg(`${row.name} <${row.email}>`, true)}\n

← Dashboard

`,\n ));\n});\n\napp.get(\"/admin/revoke\", async (c) => {\n const denied = requireAdmin(c);\n if (denied) return denied;\n\n await sqlite.execute({\n sql:\n `UPDATE registrations SET status = 'revoked', decided_at = ? WHERE id = ? AND status = 'approved'`,\n args: [Date.now(), c.req.query(\"id\") ?? \"\"],\n });\n return c.redirect(`/admin?key=${ADMIN_KEY}`, 302);\n});\n\napp.get(\"/admin\", async (c) => {\n const denied = requireAdmin(c);\n if (denied) return denied;\n\n await purgeExpired();\n const { rows } = await sqlite.execute(\n `SELECT id, email, name, reason, status, access_token, expires_at, ip, user_agent, created_at FROM registrations ORDER BY created_at DESC LIMIT 200`,\n );\n const counts = { pending: 0, approved: 0, denied: 0, revoked: 0 } as Record<\n string,\n number\n >;\n for (const r of rows as any[]) counts[r.status] = (counts[r.status] ?? 0) + 1;\n\n const renderRow = (r: any) => {\n const when = new Date(r.created_at).toLocaleString();\n const actions = r.status === \"pending\"\n ? `approve · deny`\n : r.status === \"approved\"\n ? `${\n escapeHtml((r.access_token ?? \"\").slice(0, 16))\n }…\n
expires ${\n escapeHtml(new Date(r.expires_at).toLocaleDateString())\n }\n · revoke`\n : `—`;\n return `\n ${escapeHtml(when)}\n ${escapeHtml(r.name)}
${\n escapeHtml(r.email)\n }\n ${escapeHtml(r.reason)}\n ${escapeHtml(r.ip)}\n ${r.status}\n ${actions}\n `;\n };\n\n const body = `\n

Registrations

${counts.pending} pending · ${counts.approved} approved · ${counts.denied} denied · ${counts.revoked} revoked

\n ${\n rows.length === 0 ? `

No registrations yet.

` : `\n \n \n ${(rows as any[]).map(renderRow).join(\"\\n\")}\n

When	Who	Reason	IP	Status	Actions

`\n }\n `;\n\n return c.html(\n layout(\"Admin — valtown-mcp-bridge\", body).replace(\n 'class=\"wrap\"',\n 'class=\"wrap wide\"',\n ),\n );\n});\n\n// ── fallbacks ─────────────────────────────────────────────────────\n\napp.get(\"/favicon.ico\", (c) => c.body(null, 204));\n\napp.notFound((c) => {\n if (wantsHtml(c)) {\n return c.html(\n layout(\n \"Not found\",\n `

404

Nothing at this address.

← Home

`,\n ),\n 404,\n );\n }\n return c.json({ error: \"Not found\" }, 404);\n});\n\napp.onError((err) => Promise.reject(err));\n\nexport default app.fetch;",[140],"c10d8cd9-0f64-4353-9325-76cd3874f427","main.ts",11,["D",1784231469679],10,"// local-agent.ts — runs on YOUR machine. Opens zero listening ports.\n//\n// Every call here is outbound to the bridge val — the only direction NAT\n// permits. One loop per configured local service (\"channel\"): each prefers\n// the bridge's streaming push endpoint and falls back to bounded polling\n// if streaming errors out repeatedly.\n//\n// Run: deno run --allow-net --allow-env local-agent.ts\n//\n// Required:\n// BRIDGE_URL https://your-username-yourval.web.val.run\n// BRIDGE_WORKER_TOKEN must match BRIDGE_WORKER_TOKEN on the val\n//\n// Local services — one of:\n// MCP_SERVICES \"name:port[:path],name:port[:path],...\"\n// e.g. \"rojs:5057:/mcp,studio:5058:/mcp\"\n// LOCAL_MCP_PORT (+ optional LOCAL_MCP_PATH, default /mcp) single service, channel \"default\"\n// LOCAL_MCP_URL single service, full URL, channel \"default\"\n//\n// Optional:\n// AGENT_TRANSPORT \"stream\" (default) or \"poll\"\n// STREAM_FAILURE_THRESHOLD consecutive stream errors before fallback (default 3)\n// STREAM_COOLDOWN_MS time spent polling before retrying stream (default 30000)\n\ninterface Service {\n channel: string;\n url: string;\n}\n\ninterface Job {\n id: string;\n method: string;\n params: Record;\n}\n\nfunction requireEnv(key: string): string {\n const v = Deno.env.get(key);\n if (!v) throw new Error(`Missing required environment variable: ${key}`);\n return v;\n}\n\nfunction loadServices(): Service[] {\n const multi = Deno.env.get(\"MCP_SERVICES\");\n if (multi) {\n return multi.split(\",\").map((entry) => {\n const [name, port, path = \"/mcp\"] = entry.trim().split(\":\");\n if (!name || !port) {\n throw new Error(\n `Malformed MCP_SERVICES entry '${entry}' — expected name:port[:path]`,\n );\n }\n return { channel: name, url: `http://localhost:${port}${path}` };\n });\n }\n const url = Deno.env.get(\"LOCAL_MCP_URL\");\n if (url) return [{ channel: \"default\", url }];\n\n const port = Deno.env.get(\"LOCAL_MCP_PORT\");\n if (port) {\n return [{\n channel: \"default\",\n url: `http://localhost:${port}${\n Deno.env.get(\"LOCAL_MCP_PATH\") ?? \"/mcp\"\n }`,\n }];\n }\n\n throw new Error(\"Set MCP_SERVICES, or LOCAL_MCP_URL, or LOCAL_MCP_PORT.\");\n}\n\nconst BRIDGE_URL = requireEnv(\"BRIDGE_URL\").replace(/\\/$/, \"\");\nconst WORKER_TOKEN = requireEnv(\"BRIDGE_WORKER_TOKEN\");\nconst SERVICES = loadServices();\nconst TRANSPORT = Deno.env.get(\"AGENT_TRANSPORT\") ?? \"stream\";\nconst STREAM_FAILURE_THRESHOLD = Number(\n Deno.env.get(\"STREAM_FAILURE_THRESHOLD\") ?? \"3\",\n);\nconst STREAM_COOLDOWN_MS = Number(\n Deno.env.get(\"STREAM_COOLDOWN_MS\") ?? \"30000\",\n);\n\nconst sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\nconst authHeaders = (channel: string, mode: string) => ({\n authorization: `Bearer ${WORKER_TOKEN}`,\n \"x-worker-id\": `${channel}-${mode}`,\n});\n\nasync function executeLocally(\n service: Service,\n job: Job,\n): Promise<{ result?: unknown; error?: string }> {\n const resp = await fetch(service.url, {\n method: \"POST\",\n headers: { \"content-type\": \"application/json\" },\n body: JSON.stringify({\n jsonrpc: \"2.0\",\n id: job.id,\n method: job.method,\n params: job.params,\n }),\n });\n if (!resp.ok) {\n return {\n error: `Local MCP server returned HTTP ${resp.status}: ${await resp\n .text()}`,\n };\n }\n const body = await resp.json() as {\n result?: unknown;\n error?: { message: string };\n };\n return body.error ? { error: body.error.message } : { result: body.result };\n}\n\nasync function respond(\n job: Job,\n outcome: { result?: unknown; error?: string },\n) {\n await fetch(`${BRIDGE_URL}/respond`, {\n method: \"POST\",\n headers: {\n authorization: `Bearer ${WORKER_TOKEN}`,\n \"content-type\": \"application/json\",\n },\n body: JSON.stringify({ id: job.id, ...outcome }),\n });\n}\n\nasync function handleJob(service: Service, job: Job) {\n console.log(`[${service.channel}] ${job.id} ${job.method}`);\n const outcome = await executeLocally(service, job).catch((err) => ({\n error: `Local execution threw: ${err}`,\n }));\n await respond(job, outcome);\n}\n\nasync function pollOnce(service: Service): Promise {\n const resp = await fetch(`${BRIDGE_URL}/poll/${service.channel}`, {\n headers: authHeaders(service.channel, \"poll\"),\n });\n if (resp.status === 204) return null;\n if (!resp.ok) {\n throw new Error(\n `/poll/${service.channel} → ${resp.status}: ${await resp.text()}`,\n );\n }\n return await resp.json() as Job;\n}\n\nasync function runPollLoop(service: Service, until: number | null) {\n while (until === null || Date.now() < until) {\n try {\n const job = await pollOnce(service);\n if (job) await handleJob(service, job);\n } catch (err) {\n console.error(`[${service.channel}] poll error: ${err}`);\n await sleep(2000);\n }\n }\n}\n\n// Newline-delimited JSON job announcements over a chunked response.\n// Blank lines are heartbeats. Jobs execute concurrently with the read loop\n// so one slow tool call can't stall receipt of the next pushed job.\nasync function runStreamLoop(service: Service) {\n let failures = 0;\n\n while (true) {\n if (failures >= STREAM_FAILURE_THRESHOLD) {\n console.warn(\n `[${service.channel}] streaming failed ${failures}x — polling for ${STREAM_COOLDOWN_MS}ms`,\n );\n await runPollLoop(service, Date.now() + STREAM_COOLDOWN_MS);\n failures = 0;\n continue;\n }\n\n try {\n const resp = await fetch(`${BRIDGE_URL}/stream/${service.channel}`, {\n headers: authHeaders(service.channel, \"stream\"),\n });\n if (!resp.ok || !resp.body) {\n throw new Error(`/stream/${service.channel} → ${resp.status}`);\n }\n\n const reader = resp.body.pipeThrough(new TextDecoderStream()).getReader();\n let buffer = \"\";\n for (;;) {\n const { value, done } = await reader.read();\n if (done) break;\n buffer += value;\n let cut: number;\n while ((cut = buffer.indexOf(\"\\n\")) >= 0) {\n const line = buffer.slice(0, cut).trim();\n buffer = buffer.slice(cut + 1);\n if (line) {\n handleJob(service, JSON.parse(line)).catch((err) =>\n console.error(`[${service.channel}] job failed: ${err}`)\n );\n }\n }\n }\n failures = 0; // clean close (server-side max lifetime) — reconnect immediately\n } catch (err) {\n failures++;\n console.error(`[${service.channel}] stream error (${failures}): ${err}`);\n await sleep(Math.min(10_000, 1000 * 2 ** failures));\n }\n }\n}\n\nconsole.log(\n `[agent] ${SERVICES.map((s) => `${s.channel} -> ${s.url}`).join(\", \")}`,\n);\nawait Promise.all(\n SERVICES.map((\n s,\n ) => (TRANSPORT === \"poll\" ? runPollLoop(s, null) : runStreamLoop(s))),\n);",[148],"pulls","branches",1,"forks","envVars",{"_162":136,"_164":42},"connections",{"_162":42,"_163":42},"count","unfilledCount","emptyCount",{"_18":147,"_20":148,"_116":36,"_118":-5,"_119":71,"_120":149,"_121":38,"_22":179,"_68":151,"_124":125,"_126":152,"_128":26,"_129":21,"_170":180,"_88":181},{"_18":139,"_20":140,"_116":141,"_118":-5,"_119":71,"_120":142,"_121":38,"_22":176,"_68":144,"_124":125,"_126":145,"_128":26,"_129":-5,"_170":177,"_88":178},{"_18":131,"_20":132,"_116":133,"_118":-5,"_119":71,"_120":134,"_121":38,"_22":173,"_68":136,"_124":125,"_126":137,"_128":26,"_129":-5,"_170":174,"_88":175},{"_18":114,"_20":115,"_116":117,"_118":-5,"_119":71,"_120":69,"_121":38,"_22":169,"_68":123,"_124":125,"_126":127,"_128":26,"_129":-5,"_170":171,"_88":172},["D",1784446152771],"children",[],[115],["D",1784262697344],[],[132],["D",1784234996982],[],[140],["D",1784231469679],[],[148],["D",1784117326079],["D",1789558275908],{"_16":17,"_86":82},{"_16":17,"_80":-5,"_81":82,"_33":34,"_83":84,"_85":26},{"_68":69,"_20":70,"_18":71,"_72":19,"_73":-5,"_74":-5,"_75":-5,"_76":-5,"_77":-5,"_78":21,"_79":17},"ctx",{"_61":-5,"_107":220,"_221":222,"_223":224,"_225":26,"_226":26,"_227":26,"_228":38,"_229":-5,"_230":-7,"_231":-7,"_232":42,"_233":26,"_234":26,"_235":-5,"_236":26,"_237":26,"_238":26,"_239":-5},"ENV",{"_191":192,"_193":194,"_195":70,"_196":197,"_198":199,"_200":201,"_202":203,"_204":205,"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]