[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_104":105,"_106":107},"routes/embed.x.$handle.$name.$",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":-5},"handle","Giani","name","webhook-recorder","path","main.ts","project",{"_22":45,"_11":12,"_33":46,"_47":-5,"_48":42,"_49":50,"_51":50,"_52":53,"_54":-5,"_55":56,"_57":25,"_58":32,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":-5,"_72":73,"_74":73,"_75":76,"_77":76,"_78":76,"_79":73,"_80":73,"_81":82,"_83":84,"_85":86,"_87":42},"file",{"_22":23,"_11":14,"_24":25,"_26":-5,"_27":28,"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":40,"_41":42,"_43":-5,"_13":44},"permalink","https://www.val.town/x/Giani/webhook-recorder/code/main.ts","extension","id","1218b689-66c5-46f0-a01e-03e047fe22b9","fileId","ac1dba4e-aa8f-11f1-9f6b-1607ee4eb77e","parentId","branchId","b61392f2-6e58-403f-b412-c1385e355511","branchVersion",16,"latest",true,"createdAt",["D",1788784137360],"version",15,"fileType","http","content","/**\n * Webhook recorder — a lossless capture endpoint for inspecting inbound deliveries.\n *\n * Records each delivery byte-exact (all headers, body as base64) so the raw wire\n * format can be inspected afterwards. Some providers verify ownership of an endpoint\n * by posting a challenge value that must be echoed back; that is handled below.\n *\n * Design rules:\n * 1. A recorded path ALWAYS answers 200. Providers commonly treat any other status\n * as a failed verification and refuse to register the endpoint, so storage\n * errors are swallowed and surfaced through GET /stats instead. The sqlite\n * import is dynamic for the same reason: a module-load failure must not take\n * the handler down with it.\n * 2. Bodies are stored base64, never as text — payloads may be binary or encrypted,\n * and decoding as UTF-8 would corrupt them.\n *\n * Routes:\n * ANY /h/// record; echo a challenge if present\n * ANY /h/... (wrong token) 200 {\"ok\":true}, not recorded\n * GET /events read back (header: X-Read-Token)\n * GET /stats counts + errors (header: X-Read-Token)\n * GET / health, unauthenticated\n *\n * `env` is the first path segment after the token. The sender cannot be trusted to\n * identify its own origin — its JWT `iss` is identical across environments — so the\n * environment is stamped into the URL we register, and cross-checked against which\n * per-environment secret verifies the signature.\n *\n * Env vars (set in the UI — never in this source, which is public on a free account):\n * READ_TOKEN required — guards /events and /stats\n * HOOK_PATH_TOKEN required — the secret segment in the recording path\n * SECRET_ optional — e.g. SECRET_STG / SECRET_PRD. When set, the inbound\n * Authorization JWT is verified against each and the matching\n * environment recorded in `sig_env`.\n */\n\n/**\n * Deliveries are split across two tables by KIND, not by environment:\n *\n * handshake_v1 confirmation challenges — subscription setup and re-verification\n * events_v1 everything else — real business events and opaque payloads\n *\n * They are separate because they answer different questions and have almost no\n * overlapping fields: a handshake row is a liveness record (did we answer, with which\n * secret), an event row is business data (which order, which posting, what state).\n * Mixing them meant every event query had to remember to exclude verifications.\n *\n * deliveries_v1 is the frozen legacy table. It still holds the quarantined staging\n * rows (env = 'ARCHIVED_stg') and is never written to again.\n */\nconst T_EVENTS = \"events_v1\";\nconst T_HANDSHAKE = \"handshake_v1\";\nconst T_LEGACY = \"deliveries_v1\";\nconst SETS: Record = {\n events: T_EVENTS, handshake: T_HANDSHAKE, legacy: T_LEGACY,\n};\n\nconst SCHEMA = `(\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n received_at TEXT NOT NULL,\n env TEXT,\n topic TEXT,\n label TEXT NOT NULL,\n method TEXT NOT NULL,\n query TEXT NOT NULL,\n kind TEXT NOT NULL,\n tags TEXT,\n answered INTEGER NOT NULL,\n sig_env TEXT,\n headers TEXT NOT NULL,\n body_b64 TEXT NOT NULL,\n body_len INTEGER NOT NULL,\n event_id TEXT, subscription_id TEXT, event_topic TEXT,\n resource_type TEXT, resource_id TEXT, resource_state TEXT,\n job_id TEXT, order_id TEXT, channel_id TEXT, channel_name TEXT,\n company_ext_id TEXT, external_job_id TEXT, occurred_at TEXT,\n posting_count INTEGER,\n response_status INTEGER, response_body TEXT\n)`;\n\nlet dbPromise: Promise | null = null;\nlet lastError: string | null = null;\n\nasync function db() {\n if (!dbPromise) {\n dbPromise = (async () => {\n // Val-scoped database. Do not switch this to std/sqlite/global.ts — it\n // would point the val at a different database.\n const { sqlite } = await import(\"https://esm.town/v/std/sqlite/main.ts\");\n for (const t of [T_EVENTS, T_HANDSHAKE]) {\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS ${t} ${SCHEMA}`);\n }\n return sqlite;\n })().catch((e) => {\n dbPromise = null; // let the next request retry the import\n throw e;\n });\n }\n return dbPromise;\n}\n\nfunction toB64(bytes: Uint8Array): string {\n let s = \"\";\n const CHUNK = 0x8000;\n for (let i = 0; i < bytes.length; i += CHUNK) {\n s += String.fromCharCode(...bytes.subarray(i, i + CHUNK));\n }\n return btoa(s);\n}\n\n/** Best-effort JSON parse. Binary or encrypted bodies simply won't parse. */\nfunction tryJson(bytes: Uint8Array): any | null {\n try {\n return JSON.parse(new TextDecoder(\"utf-8\", { fatal: true }).decode(bytes));\n } catch {\n return null;\n }\n}\n\nfunction json(body: unknown, status = 200) {\n return new Response(JSON.stringify(body), {\n status,\n headers: { \"content-type\": \"application/json\" },\n });\n}\n\n/** Length-independent compare, so a wrong token leaks nothing through timing. */\nfunction tokenEq(a: string, b: string): boolean {\n if (!a || !b || a.length !== b.length) return false;\n let diff = 0;\n for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);\n return diff === 0;\n}\n\nfunction b64uToBytes(s: string): Uint8Array {\n const b64 = s.replace(/-/g, \"+\").replace(/_/g, \"/\") + \"=\".repeat((4 - s.length % 4) % 4);\n return Uint8Array.from(atob(b64), (c) => c.charCodeAt(0));\n}\n\n/**\n * Which environment's webhook secret validates this JWT?\n * Returns the env suffix of the matching SECRET_ var, \"none\" if a token was\n * present but matched nothing, or null when no secrets are configured.\n */\nasync function signatureEnv(authorization: string | null): Promise {\n const jwt = (authorization ?? \"\").replace(/^Bearer\\s+/i, \"\");\n const parts = jwt.split(\".\");\n if (parts.length !== 3) return null;\n\n const candidates: [string, string][] = [];\n for (const [k, v] of Object.entries(Deno.env.toObject())) {\n if (k.startsWith(\"SECRET_\") && v) candidates.push([k.slice(7).toLowerCase(), v]);\n }\n if (!candidates.length) return null;\n\n const msg = new TextEncoder().encode(`${parts[0]}.${parts[1]}`);\n let sig: Uint8Array;\n try {\n sig = b64uToBytes(parts[2]);\n } catch {\n return \"none\";\n }\n for (const [env, secret] of candidates) {\n try {\n const key = await crypto.subtle.importKey(\n \"raw\", new TextEncoder().encode(secret),\n { name: \"HMAC\", hash: \"SHA-256\" }, false, [\"verify\"],\n );\n if (await crypto.subtle.verify(\"HMAC\", key, sig, msg)) return env;\n } catch { /* try the next candidate */ }\n }\n return \"none\";\n}\n\n/**\n * Pull the correlation keys out of a parsed event envelope.\n * `resource.occurred_at` is preferred over the attribute-level one: it is UTC,\n * whereas `attributes.occurred_at` carries a local offset, and only the former is\n * safe to sort on. Delivery order does NOT match occurrence order.\n */\nfunction correlate(parsed: any): Record {\n const a = parsed?.data?.attributes ?? {};\n const r = a.resource ?? {};\n const postings = Array.isArray(r.postings) ? r.postings : null;\n return {\n event_id: parsed?.data?.id ?? null,\n subscription_id: a.subscription_id ?? null,\n event_topic: Array.isArray(a.topics) ? a.topics[0] ?? null : null,\n resource_type: r.type ?? null,\n resource_id: r.id ?? null,\n resource_state: r.state ?? null,\n job_id: r.job_id ?? null,\n // A posting carries order_id directly; an order event carries its own id.\n order_id: r.order_id ?? (r.type === \"order\" ? r.id ?? null : null),\n channel_id: r.channel_id ?? null,\n channel_name: r.channel_name ?? null,\n company_ext_id: r.company_id ?? null,\n external_job_id: r.external_job_id ?? null,\n occurred_at: r.occurred_at ?? a.occurred_at ?? null,\n posting_count: postings ? postings.length : null,\n };\n}\n\nexport default async function (req: Request): Promise {\n const url = new URL(req.url);\n const path = url.pathname;\n const readToken = Deno.env.get(\"READ_TOKEN\") ?? \"\";\n const pathToken = Deno.env.get(\"HOOK_PATH_TOKEN\") ?? \"\";\n\n // ---- health -------------------------------------------------------------\n if (path === \"/\" || path === \"\") {\n let storage = \"ok\";\n try {\n await db();\n } catch (e) {\n storage = `error: ${String(e)}`;\n }\n const secrets = Object.keys(Deno.env.toObject())\n .filter((k) => k.startsWith(\"SECRET_\")).map((k) => k.slice(7).toLowerCase()).sort();\n return json({\n ok: true,\n storage,\n configured: { read_token: !!readToken, path_token: !!pathToken, secrets },\n last_write_error: lastError,\n });\n }\n\n // ---- read-back ----------------------------------------------------------\n if (path === \"/events\" || path === \"/stats\") {\n if (!tokenEq(req.headers.get(\"x-read-token\") ?? \"\", readToken)) {\n return json({ error: \"forbidden\" }, 403);\n }\n try {\n const sqlite = await db();\n const set = url.searchParams.get(\"set\") ?? \"events\";\n const TABLE = SETS[set];\n if (!TABLE) {\n return json({ error: `unknown set '${set}'`, available: Object.keys(SETS) }, 400);\n }\n if (path === \"/stats\") {\n const counts: Record = {};\n for (const [name, t] of Object.entries(SETS)) {\n const r = await sqlite.execute(\n `SELECT COUNT(*) AS n, MIN(received_at) AS first, MAX(received_at) AS latest\n FROM ${t}`,\n );\n counts[name] = r.rows?.[0] ?? {};\n }\n const events = await sqlite.execute(\n `SELECT env, topic, event_topic, resource_state, COUNT(*) AS n,\n MAX(received_at) AS latest\n FROM ${T_EVENTS} GROUP BY env, topic, event_topic, resource_state\n ORDER BY env, topic, event_topic`,\n );\n const hs = await sqlite.execute(\n `SELECT env, topic, sig_env, answered, COUNT(*) AS n,\n MIN(received_at) AS first, MAX(received_at) AS latest\n FROM ${T_HANDSHAKE} GROUP BY env, topic, sig_env, answered\n ORDER BY env, topic`,\n );\n const orders = await sqlite.execute(\n `SELECT env, order_id, external_job_id, COUNT(*) AS events,\n COUNT(DISTINCT resource_id) AS resources, MIN(occurred_at) AS first_at\n FROM ${T_EVENTS} WHERE order_id IS NOT NULL\n GROUP BY env, order_id, external_job_id ORDER BY first_at`,\n );\n return json({\n tables: counts,\n events: events.rows ?? [],\n handshakes: hs.rows ?? [],\n by_order: orders.rows ?? [],\n last_write_error: lastError,\n });\n }\n // Filters compose: env, order, resource, topic, kind, job, since.\n const since = Number(url.searchParams.get(\"since\") ?? \"0\") || 0;\n const limit = Math.min(Number(url.searchParams.get(\"limit\") ?? \"50\") || 50, 200);\n const where = [\"id > ?\"];\n const args: unknown[] = [since];\n for (const [param, col] of [\n [\"env\", \"env\"], [\"order\", \"order_id\"], [\"resource\", \"resource_id\"],\n [\"kind\", \"kind\"], [\"job\", \"external_job_id\"],\n ] as const) {\n const v = url.searchParams.get(param);\n if (v) { where.push(`${col} = ?`); args.push(v); }\n }\n // `topics` is an ARRAY and one delivery routinely carries several topics, so\n // matching on event_topic (= topics[0]) silently drops events where the topic\n // of interest is not first. Match against the whole stored array instead.\n const topic = url.searchParams.get(\"topic\");\n if (topic) { where.push(`tags LIKE ?`); args.push(`%\"${topic}\"%`); }\n if (url.searchParams.get(\"nobody\")) {\n // Correlation view: skip the payload entirely, ordered by OCCURRENCE.\n const res = await sqlite.execute({\n sql: `SELECT id, received_at, env, kind, event_topic, resource_type,\n resource_id, resource_state, order_id, channel_name,\n external_job_id, occurred_at, posting_count, sig_env, body_len\n FROM ${TABLE} WHERE ${where.join(\" AND \")}\n ORDER BY COALESCE(occurred_at, received_at) ASC LIMIT ?`,\n args: [...args, limit],\n });\n return json({ events: res.rows ?? [], last_write_error: lastError });\n }\n const res = await sqlite.execute({\n sql: `SELECT * FROM ${TABLE} WHERE ${where.join(\" AND \")}\n ORDER BY id ASC LIMIT ?`,\n args: [...args, limit],\n });\n // std/sqlite returns rows as keyed objects, so decode the JSON columns\n // rather than indexing positionally.\n return json({\n events: (res.rows ?? []).map((r: any) => ({\n ...r,\n answered: !!r.answered,\n tags: r.tags ? JSON.parse(r.tags) : null,\n headers: JSON.parse(r.headers),\n })),\n last_write_error: lastError,\n });\n } catch (e) {\n return json({ error: String(e) }, 500);\n }\n }\n\n // ---- recording path -----------------------------------------------------\n // Shape: /h///. Everything from here on returns 200.\n const seg = path.replace(/^\\/+/, \"\").split(\"/\");\n const authorized = seg[0] === \"h\" && tokenEq(seg[1] ?? \"\", pathToken);\n if (!authorized) {\n // Deliberately indistinguishable from a successful delivery: an unauthorized\n // caller learns nothing about whether the path token was close.\n return json({ ok: true });\n }\n const rest = seg.slice(2);\n const label = rest.join(\"/\") || \"unlabelled\";\n // Two or more segments => /. A single segment is an un-namespaced\n // caller; record it rather than dropping it, but do not guess its environment.\n const env = rest.length >= 2 ? rest[0] : \"unknown\";\n const topic = rest.length >= 2 ? rest.slice(1).join(\"/\") : label;\n\n let bytes = new Uint8Array(0);\n try {\n bytes = new Uint8Array(await req.arrayBuffer());\n } catch { /* an empty/unreadable body still gets a 200 */ }\n\n const parsed = tryJson(bytes);\n const attrs = parsed?.data?.attributes ?? {};\n // Presence of a challenge value is the only reliable discriminator: the rest of\n // the envelope is not guaranteed to be present on a verification request.\n const challenge = attrs.challenge ?? parsed?.challenge ?? null;\n const kind = challenge ? \"verification\" : parsed ? \"event\" : \"opaque\";\n const tags = Array.isArray(attrs.topics) ? attrs.topics : null;\n const c = correlate(parsed);\n\n let sigEnv: string | null = null;\n try {\n sigEnv = await signatureEnv(req.headers.get(\"authorization\"));\n } catch { /* never let verification break the 200 */ }\n\n // Decide the reply BEFORE persisting, so the stored record is exactly what the\n // caller receives rather than a reconstruction.\n const respBody = challenge ? { challenge } : { ok: true };\n\n // Route by kind: challenges are liveness records, everything else is business data.\n const target = kind === \"verification\" ? T_HANDSHAKE : T_EVENTS;\n\n try {\n const sqlite = await db();\n await sqlite.execute({\n sql: `INSERT INTO ${target}\n (received_at,env,topic,label,method,query,kind,tags,answered,sig_env,\n headers,body_b64,body_len,\n event_id,subscription_id,event_topic,resource_type,resource_id,\n resource_state,job_id,order_id,channel_id,channel_name,\n company_ext_id,external_job_id,occurred_at,posting_count,\n response_status,response_body)\n VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,\n args: [\n new Date().toISOString(), env, topic, label, req.method, url.search, kind,\n tags ? JSON.stringify(tags) : null, challenge ? 1 : 0, sigEnv,\n JSON.stringify(Object.fromEntries(req.headers)), toB64(bytes), bytes.length,\n c.event_id, c.subscription_id, c.event_topic, c.resource_type, c.resource_id,\n c.resource_state, c.job_id, c.order_id, c.channel_id, c.channel_name,\n c.company_ext_id, c.external_job_id, c.occurred_at, c.posting_count,\n 200, JSON.stringify(respBody),\n ],\n });\n lastError = null;\n } catch (e) {\n lastError = `${new Date().toISOString()} ${String(e)}`;\n }\n\n return json(respBody);\n}\n","deleted",false,"label",[14],"13669511-c011-4ee2-a723-480fc1ee7082",["D",1788766946915],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","Lossless webhook capture endpoint for inspecting deliveries","imageUrl","userId","9797ffd6-4e86-4792-aef0-da2c78219414","pinnedFileId","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","01a07ac3-13e0-7077-9325-0f25c08474da","tursoName","13669511c0114ee2a723480fc1ee7082","tursoHostname","13669511c0114ee2a723480fc1ee7082-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789461042390],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_9":10,"_103":98},"org",{"_9":10,"_97":98,"_99":98,"_55":56,"_100":101,"_102":42},"branch",{"_35":30,"_11":88,"_22":28,"_89":45,"_90":-5,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":12,"_96":10},"isOwned","main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","","avatar","tier","free","canRestrictVals","profileImageUrl","ctx",{"_81":-5,"_137":138,"_139":140,"_141":142,"_143":42,"_144":42,"_145":42,"_146":32,"_147":-5,"_148":-7,"_149":-7,"_150":62,"_151":42,"_152":42,"_153":-5,"_154":42,"_155":42,"_156":42,"_157":-5},"ENV",{"_108":109,"_110":111,"_112":88,"_113":114,"_115":116,"_117":118,"_119":120,"_121":122,"_123":124,"_125":126,"_127":128,"_129":130,"_131":132,"_133":134,"_135":136},"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","orgs",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]