[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_196":197,"_198":199},"routes/_app.x.$handle.$name",{"_99":98,"_32":45,"_107":89,"_27":108,"_13":14,"_109":-5,"_11":110,"_111":112,"_113":114,"_115":116,"_117":118,"_20":-5,"_119":-5,"_120":-5,"_121":25,"_122":123,"_124":59,"_125":-5,"_126":-5,"_127":128},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_43":44,"_32":45,"_38":46,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":57,"_58":59,"_60":-5,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69,"_70":71,"_72":-5,"_73":74,"_75":74,"_76":77,"_78":77,"_79":77,"_80":74,"_81":74,"_82":83,"_84":85,"_86":87,"_88":25},"version",26,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":28,"_33":37,"_35":36,"_38":39,"_40":14,"_41":42,"_24":25},"previous",{"_30":31,"_32":28,"_33":34,"_35":36},"deleted",false,"deletedHere","path","test_fake_server.ts","latestPath","fileId","51a5018c-8198-11f1-b319-1607ee4eb77e","name","fileType","script","content","// test_fake_server.js — NOT part of the shipped app. Stands in for a real\n// MCP server transport so Part 2's Ink test can exercise real connect\n// success/failure/re-render behavior without needing an actual fsmcp/vecdb/\n// wordnetmcp process, which this container has no access to (no real\n// servers.json, no spawnable server binaries here). This tests Ink's\n// reaction to state changes; it does not and cannot test mcpClient.js's\n// correctness against a genuine MCP server -- that's a separate, already-\n// existing claim this thread never touched.\nexport function makeFakeConnectServer({ failNames = [] } = {}) {\n return async function fakeConnectServer(name, entry) {\n await new Promise((r) => setTimeout(r, 150 + Math.random() * 200)); // simulate real connect latency\n if (failNames.includes(name)) {\n throw new Error(\n `Failed to connect to server \"${name}\" (simulated failure for test)`,\n );\n }\n return {\n __fakeClient: true,\n name,\n listTools: async () => ({\n tools: [\n {\n name: `${name}_tool_a`,\n description: \"fake tool a\",\n inputSchema: { type: \"object\", properties: {} },\n },\n {\n name: `${name}_tool_b`,\n description: \"fake tool b\",\n inputSchema: { type: \"object\", properties: {} },\n },\n ],\n }),\n callTool: async ({ name: toolName, arguments: args }) => ({\n content: [{\n type: \"text\",\n text: `[fake] ${toolName} called with ${JSON.stringify(args)}`,\n }],\n }),\n close: async () => {},\n };\n };\n}","http","createdAt",["D",1784446152771],"branchVersion","branchId","cdeeab9b-e3e2-475e-80fa-97ce96faf35a","id","3b1bbab8-3df4-4b1c-8719-adcf265363c5","mcp-bridge",["D",1784117326079],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","mcp bridge to local host","imageUrl","2c6d46b0-54dd-11f0-a86c-6fbc2b29331a","pinnedFileId","ee1b71f8-8045-11f1-b556-1607ee4eb77e","pinPreview",true,"pinMigrated","screenshotVersion","likeCount",0,"orgId","850db142-aa5e-4914-bceb-1e2e085ae4c5","tursoName","3b1bbab83df44b1c8719adcf265363c5","tursoHostname","3b1bbab83df44b1c8719adcf265363c5-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789558275908],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_99":98,"_106":102},"org",{"_99":98,"_100":-5,"_101":102,"_18":55,"_103":104,"_105":25},"branch",{"_13":14,"_32":89,"_43":42,"_90":44,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":45,"_97":98},"isOwned","main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","ziggyware","handle","displayName","avatar","https://img.clerk.com/eyJ0eXBlIjoicHJveHkiLCJzcmMiOiJodHRwczovL2ltYWdlcy5jbGVyay5kZXYvb2F1dGhfZ2l0aHViL2ltZ18yekJHRDE5SGVoUHUzUENQaXY2MTRkT3h0cncifQ","tier","free","canRestrictVals","profileImageUrl","branchName","","adoptOrgId",{"_43":44,"_32":45,"_38":191,"_47":-5,"_48":25,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":57,"_58":59,"_60":-5,"_61":-5,"_62":63,"_64":65,"_66":67,"_68":69,"_70":192,"_72":-5,"_73":74,"_75":74,"_76":77,"_78":77,"_79":77,"_80":74,"_81":74,"_82":193,"_84":194,"_86":195,"_88":25},"tree",[174,175,176,177],"files",[174,175,176,177],"counts",{"_163":63,"_164":165,"_166":63,"_167":168,"_169":170},"contents",[129,130,131,132],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_43":156,"_32":157,"_30":57,"_134":-5,"_41":42,"_40":158,"_135":59,"_38":159,"_13":160,"_33":37,"_35":161,"_24":25,"_138":45,"_27":162},{"_43":148,"_32":149,"_30":150,"_134":-5,"_41":42,"_40":151,"_135":59,"_38":152,"_13":153,"_33":37,"_35":154,"_24":25,"_138":-5,"_27":155},{"_43":140,"_32":141,"_30":142,"_134":-5,"_41":42,"_40":143,"_135":59,"_38":144,"_13":145,"_33":37,"_35":146,"_24":25,"_138":-5,"_27":147},{"_43":133,"_32":28,"_30":31,"_134":-5,"_41":42,"_40":14,"_135":59,"_38":136,"_13":137,"_33":37,"_35":36,"_24":25,"_138":-5,"_27":139},"3c131039-7c15-4126-bd73-bb15696cceca","parentId","latest",["D",1784446152771],3,"label",[28],"23366ec8-071e-4052-a3be-cc9ec7baf7d7","new-file-1116.ts","ede5564c-8197-11f1-848c-1607ee4eb77e",25,["D",1784262697344],4,"// test_ink_input.js — Part 3 execution proof. Real useInput-driven keypress\n// handling, not a fixed useEffect sequence like Part 2. Tab and Enter both\n// submit the highlighted match -- this is the direct successor to\n// searchSubmitOnTab.js (@inquirer/core fork, five turns back): same\n// requirement, rebuilt on Ink's primitives instead of imported, since\n// @inquirer/core's search() and Ink's useInput are different, non-\n// interoperable input models (confirmed: search() drives its own readline\n// loop and blocks; useInput hands raw keys to a component that's already\n// part of Ink's persistent render tree). searchSubmitOnTab.js is confirmed\n// dead code under this design, not ported.\nimport React, { useCallback, useState } from \"npm:react\";\nimport { Box, render, Text, useApp, useInput } from \"npm:ink\";\nimport { makeFakeConnectServer } from \"./test_fake_server.ts\";\nimport { ResultBuffer } from \"./src/resultBuffer.js\";\n\nconst h = React.createElement;\nconst buffer = new ResultBuffer();\n\n// Fake tool catalog standing in for what would come from real toolCache\n// (mcpClient.js's listTools() results) -- this test is about input/\n// selection/submit mechanics, not tool discovery, which Part 2 already\n// exercised via the fake connect flow.\nconst FAKE_TOOLS = [\n { server: \"fsmcp\", name: \"read_file\", description: \"read a file\" },\n { server: \"fsmcp\", name: \"list_dir\", description: \"list a directory\" },\n { server: \"vecdb\", name: \"search\", description: \"vector search\" },\n { server: \"vecdb\", name: \"embed\", description: \"embed text\" },\n];\n\nfunction filterTools(query) {\n const needle = query.toLowerCase();\n if (!needle) return FAKE_TOOLS;\n return FAKE_TOOLS.filter(\n (t) =>\n t.name.toLowerCase().includes(needle) ||\n t.server.toLowerCase().includes(needle),\n );\n}\n\nfunction ToolPane({ matches, activeIndex }) {\n return h(\n Box,\n { flexDirection: \"column\", borderStyle: \"single\", paddingX: 1, width: 40 },\n matches.length === 0\n ? h(Text, { dimColor: true }, \"no matches\")\n : matches.map((t, i) =>\n h(\n Text,\n {\n key: `${t.server}/${t.name}`,\n color: i === activeIndex ? \"cyan\" : undefined,\n inverse: i === activeIndex,\n },\n `${t.server}/${t.name}`,\n )\n ),\n );\n}\n\nfunction LogPane({ entries }) {\n return h(\n Box,\n {\n flexDirection: \"column\",\n borderStyle: \"single\",\n paddingX: 1,\n marginTop: 1,\n flexGrow: 1,\n },\n entries.length === 0\n ? h(Text, { dimColor: true }, \"(no results yet)\")\n : entries.map((e) =>\n h(\n Box,\n { key: e.index, flexDirection: \"column\" },\n h(\n Text,\n null,\n h(Text, { color: \"magenta\" }, `#${e.index} `),\n h(Text, { color: \"blue\" }, e.server),\n \"/\",\n h(Text, { bold: true }, e.tool),\n ),\n h(Text, { dimColor: true }, \" \" + e.text),\n )\n ),\n );\n}\n\nfunction InputLine({ query, submitted }) {\n return h(\n Box,\n { borderStyle: \"single\", paddingX: 1, marginTop: 1 },\n h(\n Text,\n null,\n \"> \",\n query,\n submitted ? \"\" : h(Text, { inverse: true }, \" \"),\n ),\n );\n}\n\nfunction App({ connectServerFn, onDone }) {\n const { exit } = useApp();\n const [query, setQuery] = useState(\"\");\n const [activeIndex, setActiveIndex] = useState(0);\n const [entries, setEntries] = useState([]);\n const [submittedCount, setSubmittedCount] = useState(0);\n const [log, setLog] = useState([]);\n\n const matches = filterTools(query);\n const clampedActive = Math.min(activeIndex, Math.max(matches.length - 1, 0));\n\n const [isSubmitting, setIsSubmitting] = useState(false);\n\n const submit = useCallback(\n async (tool) => {\n if (!tool) return;\n setIsSubmitting(true);\n try {\n const client = await connectServerFn(tool.server, {});\n const result = await client.callTool({\n name: tool.name,\n arguments: {},\n });\n buffer.push({\n server: tool.server,\n tool: tool.name,\n args: {},\n mcpResult: result,\n });\n setEntries(buffer.list());\n setSubmittedCount((c) => c + 1);\n setQuery(\"\");\n setActiveIndex(0);\n setLog((\n l,\n ) => [...l, `submitted via keypress: ${tool.server}/${tool.name}`]);\n } finally {\n setIsSubmitting(false);\n }\n },\n [connectServerFn],\n );\n\n useInput((input, key) => {\n // Guard: while a submit is in-flight (real async work -- a real MCP\n // tool call, not instant), ignore further input entirely rather than\n // let it accumulate against a query that's about to be reset out from\n // under it. Fix for a confirmed race: an async submit() resetting\n // query to \"\" can complete *after* a subsequent keystroke's\n // setQuery(q => q + input) already captured the pre-reset `q`,\n // silently dropping that keystroke. Blocking input during the async\n // window is simpler and safer than trying to queue/replay it.\n if (isSubmitting) return;\n if (key.upArrow) {\n setActiveIndex((i) => Math.max(0, i - 1));\n return;\n }\n if (key.downArrow) {\n setActiveIndex((i) => Math.min(matches.length - 1, i + 1));\n return;\n }\n if (key.return || key.tab) {\n // Tab/Enter parity: identical submit path for both, matching the\n // requirement from earlier in this thread (\"pressing tab needs to\n // function the same as enter\").\n submit(matches[clampedActive]);\n return;\n }\n if (key.backspace || key.delete) {\n setQuery((q) => q.slice(0, -1));\n setActiveIndex(0);\n return;\n }\n if (key.escape) {\n exit();\n return;\n }\n if (input && !key.ctrl && !key.meta) {\n setQuery((q) => q + input);\n setActiveIndex(0);\n }\n });\n\n // Test driver: once two tools have been \"typed and submitted\" via the\n // scripted stdin writes below, report done so the harness can assert and\n // exit -- this replaces a human at the keyboard for headless execution.\n React.useEffect(() => {\n if (submittedCount >= 2) {\n onDone({ entries: buffer.list(), log });\n }\n }, [submittedCount, log, onDone]);\n\n return h(\n Box,\n { flexDirection: \"column\" },\n h(InputLine, { query, submitted: false }),\n h(ToolPane, { matches, activeIndex: clampedActive }),\n h(LogPane, { entries }),\n );\n}\n\nimport { PassThrough } from \"node:stream\";\n\nfunction makeFakeTTYStdin() {\n const stream = new PassThrough();\n stream.isTTY = true;\n stream.setRawMode = () => stream; // no-op, matches tty.ReadStream's signature\n stream.ref = () => stream;\n stream.unref = () => stream;\n return stream;\n}\n\nasync function main() {\n const fakeConnect = makeFakeConnectServer({});\n let resolveDone;\n const donePromise = new Promise((r) => (resolveDone = r));\n const fakeStdin = makeFakeTTYStdin();\n const submittedSoFar = () => buffer.list().length;\n\n const { unmount } = render(\n h(App, { connectServerFn: fakeConnect, onDone: resolveDone }),\n {\n stdin: fakeStdin,\n stdout: process.stdout,\n },\n );\n\n // Scripted keypress sequence on the synthetic TTY stream, simulating a\n // human: type \"read\", press Tab (should submit fsmcp/read_file, the sole\n // match) -- then type \"search\", press Enter (should submit vecdb/search).\n // This exercises Tab-submits and Enter-submits through the exact same\n // useInput callback, which is the actual claim under test. Unlike the\n // prior attempt against process.stdin, this stream satisfies Ink's\n // isRawModeSupported check (stdin.isTTY === true), confirmed via App.js\n // source, so useInput's real keypress-parsing logic actually runs here\n // instead of throwing before any handler fires.\n await new Promise((r) => setTimeout(r, 100));\n fakeStdin.write(\"read\");\n await new Promise((r) => setTimeout(r, 100));\n fakeStdin.write(\"\\t\"); // Tab\n\n // Wait for the first submission to actually complete (isSubmitting fix\n // means input sent before this would be correctly ignored, not queued --\n // so the driver must wait, same as a real user watching for the tool\n // call to finish before typing the next request) rather than assume a\n // fixed duration.\n const firstSubmitDeadline = Date.now() + 3000;\n while (submittedSoFar() < 1 && Date.now() < firstSubmitDeadline) {\n await new Promise((r) => setTimeout(r, 20));\n }\n\n fakeStdin.write(\"search\");\n await new Promise((r) => setTimeout(r, 100));\n fakeStdin.write(\"\\r\"); // Enter\n\n const result = await Promise.race([\n donePromise,\n new Promise((resolve) => setTimeout(() => resolve(\"__TIMEOUT__\"), 4000)),\n ]);\n\n unmount();\n\n if (result === \"__TIMEOUT__\") {\n console.log(\"\\n[test] FAIL: did not reach 2 submissions within timeout.\");\n process.exit(1);\n }\n\n console.log(\n \"\\n[test] entries:\",\n JSON.stringify(result.entries.map((e) => `${e.server}/${e.tool}`)),\n );\n console.log(\"[test] log:\", JSON.stringify(result.log));\n\n const expectedOrder = [\"fsmcp/read_file\", \"vecdb/search\"];\n const actualOrder = result.entries.map((e) => `${e.server}/${e.tool}`);\n const tabWorked = actualOrder[0] === expectedOrder[0];\n const enterWorked = actualOrder[1] === expectedOrder[1];\n\n console.log(\n tabWorked\n ? \"PASS: Tab submitted the correct highlighted match.\"\n : \"FAIL: Tab did not submit correctly.\",\n );\n console.log(\n enterWorked\n ? \"PASS: Enter submitted the correct highlighted match.\"\n : \"FAIL: Enter did not submit correctly.\",\n );\n process.exit(tabWorked && enterWorked ? 0 : 1);\n}\n\nmain().catch((err) => {\n console.log(\"[test] FAIL: threw.\");\n console.error(err);\n process.exit(1);\n});",[141],"dbe2d214-ce33-4706-8c12-77c1c5ce4819","main2.ts","331ee7e6-8152-11f1-aba0-1607ee4eb77e",17,["D",1784234996982],5,"// bridge.ts — Val Town HTTP val. Public MCP relay over a SQLite job queue.\n//\n// Neither side can accept an inbound connection: the local machine is\n// behind NAT with no forwarded ports, and Val Town has no persistent\n// process to hold a socket open. So the queue is the protocol. MCP clients\n// POST to /mcp/:channel and block until a local agent — which only ever\n// makes outbound calls — claims the row and posts a result back.\n//\n// No tool registry lives here. Every method except the initialized\n// notification is forwarded verbatim; the local agent's backend is the\n// only source of truth for what tools exist.\n//\n// OAUTH LAYER: claude.ai's custom-connector flow requires the target to\n// behave as an OAuth 2.1 authorization server with PKCE and Dynamic Client\n// Registration — a bare static bearer token isn't an accepted auth mode\n// for connectors added by URL. /register (DCR) always succeeds — client_id\n// isn't a security boundary here, PKCE is. /authorize is a one-field form\n// gated by a key that must resolve to either the admin CLIENT_TOKEN or an\n// approved registrant's personal access token. /token exchanges a\n// PKCE-verified code for whichever of those keys was actually authorized,\n// so /mcp's bearer check just has to look that token up.\n//\n// REGISTRATION LAYER: Val Town Free can only email the account owner, not\n// arbitrary registrants, so this can't be self-serve. Visiting / in a\n// browser shows a request-access form; submissions are validated\n// server-side, written to SQLite regardless of outcome, and emailed to the\n// owner with one-click approve/deny links. Approval mints a per-registrant\n// token; there is no path that hands out access without a database row\n// documenting who asked, when, from what IP, and why.\n\nimport { Hono } from \"npm:hono\";\nimport { sqlite } from \"https://esm.town/v/std/sqlite/main.ts\";\nimport { email } from \"https://esm.town/v/std/email\";\n\nconst CLIENT_TOKEN = requireEnv(\"BRIDGE_CLIENT_TOKEN\"); // admin/master key\nconst WORKER_TOKEN = requireEnv(\"BRIDGE_WORKER_TOKEN\"); // local agent key\nconst ADMIN_KEY = requireEnv(\"ADMIN_KEY\"); // gates /admin/*\n\nconst DEFAULT_CHANNEL = \"default\";\nconst REQUEST_TTL_MS = 120_000;\nconst OAUTH_CODE_TTL_MS = 60_000;\nconst APPLY_RATE_LIMIT_WINDOW_MS = 60 * 60_000;\nconst APPLY_RATE_LIMIT_MAX = 5;\n\n// Val Town execution timeout: 60s (Free) / 600s (Pro) per single val run.\n// Held under the shorter ceiling so requests always resolve cleanly.\nconst CLIENT_MAX_WAIT_MS = 55_000;\nconst CLIENT_POLL_INTERVAL_MS = 250;\n\nconst WORKER_POLL_WINDOW_MS = 25_000;\nconst WORKER_POLL_INTERVAL_MS = 500;\n\n// Streaming push is self-bounded well under the execution ceiling because\n// it's undocumented whether that ceiling applies to a chunked response the\n// same way it applies to a normal one — this is safe either way.\nconst STREAM_MAX_MS = 50_000;\nconst STREAM_CHECK_INTERVAL_MS = 200;\nconst STREAM_HEARTBEAT_INTERVAL_MS = 10_000;\n\n// Feature: per-token rate limiting on /mcp. A compromised or runaway client\n// can otherwise hammer the local agent as fast as the queue will let it.\nconst MCP_RATE_LIMIT_WINDOW_MS = 60_000;\nconst MCP_RATE_LIMIT_MAX = 120;\n\n// Feature: registrant access tokens expire. An approval made once and\n// forgotten shouldn't be a standing credential forever; the admin master\n// key (CLIENT_TOKEN) is exempt — you don't need to re-approve yourself.\nconst ACCESS_TOKEN_TTL_MS = 90 * 24 * 60 * 60_000; // 90 days\n\n// Feature: audit log retention for /admin/activity.\nconst CALL_LOG_RETENTION_MS = 7 * 24 * 60 * 60_000; // 7 days\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\nawait sqlite.execute(`\n CREATE TABLE IF NOT EXISTS mcp_bridge_requests (\n id TEXT PRIMARY KEY,\n channel TEXT NOT NULL DEFAULT 'default',\n method TEXT NOT NULL,\n params TEXT NOT NULL,\n status TEXT NOT NULL DEFAULT 'pending', -- pending | claimed | done\n result TEXT,\n error TEXT,\n created_at INTEGER NOT NULL\n )\n`);\nawait sqlite.execute(\n `CREATE INDEX IF NOT EXISTS idx_bridge_channel_status ON mcp_bridge_requests(channel, status, created_at)`,\n);\n\nawait sqlite.execute(`\n CREATE TABLE IF NOT EXISTS oauth_codes (\n code TEXT PRIMARY KEY,\n redirect_uri TEXT NOT NULL,\n code_challenge TEXT NOT NULL,\n granted_token TEXT NOT NULL,\n created_at INTEGER NOT NULL\n )\n`);\n\nawait sqlite.execute(`\n CREATE TABLE IF NOT EXISTS registrations (\n id TEXT PRIMARY KEY,\n email TEXT NOT NULL,\n name TEXT NOT NULL,\n reason TEXT NOT NULL,\n status TEXT NOT NULL DEFAULT 'pending', -- pending | approved | denied | revoked\n access_token TEXT,\n token_fingerprint TEXT,\n expires_at INTEGER,\n ip TEXT NOT NULL,\n user_agent TEXT NOT NULL,\n created_at INTEGER NOT NULL,\n decided_at INTEGER\n )\n`);\n// Idempotent migration for tables created before token_fingerprint/expires_at\n// existed: SQLite has no \"ADD COLUMN IF NOT EXISTS\", so failure here just\n// means the column is already present.\nfor (\n const stmt of [\n `ALTER TABLE registrations ADD COLUMN token_fingerprint TEXT`,\n `ALTER TABLE registrations ADD COLUMN expires_at INTEGER`,\n ]\n) {\n await sqlite.execute(stmt).catch(() => {});\n}\nawait sqlite.execute(\n `CREATE INDEX IF NOT EXISTS idx_registrations_email_status ON registrations(email, status)`,\n);\nawait sqlite.execute(\n `CREATE INDEX IF NOT EXISTS idx_registrations_fingerprint ON registrations(token_fingerprint)`,\n);\n\n// Feature: audit log + rate-limit source of truth. Stores a fingerprint\n// (sha256 of the token) rather than the token itself — this table is\n// readable from the admin activity page, and a log is the wrong place for\n// a live credential to sit in plaintext even behind an admin key.\nawait sqlite.execute(`\n CREATE TABLE IF NOT EXISTS mcp_calls (\n id TEXT PRIMARY KEY,\n token_fingerprint TEXT NOT NULL,\n channel TEXT NOT NULL,\n method TEXT NOT NULL,\n ok INTEGER NOT NULL,\n created_at INTEGER NOT NULL\n )\n`);\nawait sqlite.execute(\n `CREATE INDEX IF NOT EXISTS idx_mcp_calls_fingerprint_time ON mcp_calls(token_fingerprint, created_at)`,\n);\n\nconst sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));\nconst rpcResult = (id: unknown, result: unknown) => ({\n jsonrpc: \"2.0\",\n id,\n result,\n});\nconst rpcError = (id: unknown, code: number, message: string) => ({\n jsonrpc: \"2.0\",\n id,\n error: { code, message },\n});\nconst bearer = (req: Request) =>\n (req.headers.get(\"authorization\") ?? \"\").match(/^Bearer (.+)$/)?.[1] ?? null;\nconst clientIp = (c: any) =>\n (c.req.header(\"x-forwarded-for\") ?? \"unknown\").split(\",\")[0].trim();\nconst wantsHtml = (c: any) =>\n (c.req.header(\"accept\") ?? \"\").includes(\"text/html\");\n\nfunction escapeHtml(s: string): string {\n return s.replace(\n /[&<>\"']/g,\n (\n ch,\n ) => ({\n \"&\": \"&\",\n \"<\": \"<\",\n \">\": \">\",\n '\"': \""\",\n \"'\": \"'\",\n }[ch]!),\n );\n}\n\nasync function sha256Base64Url(input: string): Promise {\n const digest = await crypto.subtle.digest(\n \"SHA-256\",\n new TextEncoder().encode(input),\n );\n return btoa(String.fromCharCode(...new Uint8Array(digest))).replace(\n /\\+/g,\n \"-\",\n ).replace(/\\//g, \"_\").replace(/=+$/, \"\");\n}\n\nfunction randomToken(): string {\n const bytes = crypto.getRandomValues(new Uint8Array(32));\n return btoa(String.fromCharCode(...bytes)).replace(/\\+/g, \"-\").replace(\n /\\//g,\n \"_\",\n ).replace(/=+$/, \"\");\n}\n\nasync function purgeExpired() {\n await sqlite.execute({\n sql:\n `DELETE FROM mcp_bridge_requests WHERE status != 'done' AND created_at < ?`,\n args: [Date.now() - REQUEST_TTL_MS],\n });\n await sqlite.execute({\n sql: `DELETE FROM oauth_codes WHERE created_at < ?`,\n args: [Date.now() - OAUTH_CODE_TTL_MS],\n });\n await sqlite.execute({\n sql: `DELETE FROM mcp_calls WHERE created_at < ?`,\n args: [Date.now() - CALL_LOG_RETENTION_MS],\n });\n // Expired approvals flip to 'revoked' rather than silently failing\n // resolveToken — the dashboard should show *why* access stopped working.\n await sqlite.execute({\n sql:\n `UPDATE registrations SET status = 'revoked' WHERE status = 'approved' AND expires_at IS NOT NULL AND expires_at < ?`,\n args: [Date.now()],\n });\n}\n\n// A key is valid if it's the admin master key, or it's an approved,\n// unexpired registrant's personal token. Revoking or expiring a\n// registration takes effect immediately because this is a live lookup.\nasync function resolveToken(key: string | null): Promise {\n if (!key) return false;\n if (key === CLIENT_TOKEN) return true;\n const { rows } = await sqlite.execute({\n sql:\n `SELECT 1 FROM registrations WHERE access_token = ? AND status = 'approved' AND (expires_at IS NULL OR expires_at > ?)`,\n args: [key, Date.now()],\n });\n return rows.length > 0;\n}\n\nconst CLIENT_TOKEN_FINGERPRINT = await sha256Base64Url(CLIENT_TOKEN);\n\nasync function logCall(\n tokenFingerprint: string,\n channel: string,\n method: string,\n ok: boolean,\n) {\n await sqlite.execute({\n sql:\n `INSERT INTO mcp_calls (id, token_fingerprint, channel, method, ok, created_at) VALUES (?, ?, ?, ?, ?, ?)`,\n args: [\n crypto.randomUUID(),\n tokenFingerprint,\n channel,\n method,\n ok ? 1 : 0,\n Date.now(),\n ],\n });\n}\n\nasync function isRateLimited(tokenFingerprint: string): Promise {\n const { rows } = await sqlite.execute({\n sql:\n `SELECT COUNT(*) as n FROM mcp_calls WHERE token_fingerprint = ? AND created_at > ?`,\n args: [tokenFingerprint, Date.now() - MCP_RATE_LIMIT_WINDOW_MS],\n });\n return (rows[0] as any as { n: number }).n >= MCP_RATE_LIMIT_MAX;\n}\n\n// ── shared page shell ────────────────────────────────────────────────\n\nfunction layout(title: string, body: string): string {\n return `\n\n\n\n${escapeHtml(title)}\n\n

${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;",[149],"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);",[157],"pulls","branches",1,"forks","envVars",{"_171":145,"_173":63},"connections",{"_171":63,"_172":63},"count","unfilledCount","emptyCount",{"_43":156,"_32":157,"_30":57,"_134":-5,"_41":42,"_40":158,"_135":59,"_38":188,"_13":160,"_33":37,"_35":161,"_24":25,"_138":45,"_179":189,"_27":190},{"_43":148,"_32":149,"_30":150,"_134":-5,"_41":42,"_40":151,"_135":59,"_38":185,"_13":153,"_33":37,"_35":154,"_24":25,"_138":-5,"_179":186,"_27":187},{"_43":140,"_32":141,"_30":142,"_134":-5,"_41":42,"_40":143,"_135":59,"_38":182,"_13":145,"_33":37,"_35":146,"_24":25,"_138":-5,"_179":183,"_27":184},{"_43":133,"_32":28,"_30":31,"_134":-5,"_41":42,"_40":14,"_135":59,"_38":178,"_13":137,"_33":37,"_35":36,"_24":25,"_138":-5,"_179":180,"_27":181},["D",1784446152771],"children",[],[28],["D",1784262697344],[],[141],["D",1784234996982],[],[149],["D",1784231469679],[],[157],["D",1784117326079],["D",1789558275908],{"_99":98,"_106":102},{"_99":98,"_100":-5,"_101":102,"_18":55,"_103":104,"_105":25},{"_13":14,"_32":89,"_43":42,"_90":44,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":45,"_97":98},"ctx",{"_82":-5,"_126":229,"_230":231,"_232":233,"_234":25,"_235":25,"_236":25,"_237":59,"_238":-5,"_239":-7,"_240":-7,"_241":63,"_242":25,"_243":25,"_244":-5,"_245":25,"_246":25,"_247":25,"_248":-5},"ENV",{"_200":201,"_202":203,"_204":89,"_205":206,"_207":208,"_209":210,"_211":212,"_213":214,"_215":216,"_217":218,"_219":220,"_221":222,"_223":224,"_225":226,"_227":228},"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"]

Diff · v26