@debugkit/dashboard 0.4.0 → 0.6.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. package/.env.example +3 -0
  2. package/dist/client/assets/_authed-BMdIkvB6.js +7 -0
  3. package/dist/client/assets/_authed-Rg-Gabby.js +1 -0
  4. package/dist/client/assets/{charts-C76vsG2N.js → charts-QIIL2Fv7.js} +18 -18
  5. package/dist/client/assets/index-CMjwqklY.js +10 -0
  6. package/dist/client/assets/invite._token-CDogkC9p.js +1 -0
  7. package/dist/client/assets/issues._fingerprint-DLe_lV5d.js +1 -0
  8. package/dist/client/assets/login-BG9v4zhc.js +1 -0
  9. package/dist/client/assets/preload-helper-Dscj_TcA.js +3 -0
  10. package/dist/client/assets/settings-Ce1uqKl0.js +1 -0
  11. package/dist/client/assets/styles-DztngwT9.css +2 -0
  12. package/dist/client/assets/team-TUMAZ4jv.js +1 -0
  13. package/dist/client/assets/ui-C0HGOza2.js +1 -0
  14. package/dist/server/assets/_authed-DDQ5yYfy.js +73 -0
  15. package/dist/server/assets/{_authed-ClbGOSDJ.js → _authed-Dray_9Ct.js} +296 -70
  16. package/dist/server/assets/_tanstack-start-manifest_v-BItoYCqL.js +61 -0
  17. package/dist/server/assets/{charts-CNlV7Pga.js → charts-DzTVqJ8z.js} +21 -4
  18. package/dist/server/assets/{demo-DTdlXNgj.js → demo-BsMMDk_F.js} +87 -10
  19. package/dist/server/assets/dynamodb-Zkk1-mgz.js +445 -0
  20. package/dist/server/assets/firestore-C52q_vwM.js +237 -0
  21. package/dist/server/assets/fns-DwGaMi8S.js +107 -0
  22. package/dist/server/assets/fns-mbUIXXep.js +529 -0
  23. package/dist/server/assets/invite._token-BWiwnST7.js +136 -0
  24. package/dist/server/assets/{issues._fingerprint-D78dy5os.js → issues._fingerprint-D9vjIk3M.js} +159 -17
  25. package/dist/server/assets/{login-h3B5Vdhl.js → login-BXi46U4B.js} +3 -3
  26. package/dist/server/assets/{queries-DIVV-5j6.js → memory-BssaqdZm.js} +234 -504
  27. package/dist/server/assets/queries-BJxX3Kjp.js +1669 -0
  28. package/dist/server/assets/range-picker-0zbSGr3Z.js +106 -0
  29. package/dist/server/assets/rolldown-runtime-D8jQpDG7.js +12 -0
  30. package/dist/server/assets/{router-DqTf7XfT.js → router-m6Hpq6Ep.js} +114 -51
  31. package/dist/server/assets/settings-ByFLIJce.js +371 -0
  32. package/dist/server/assets/src-D83GYTrp.js +9 -0
  33. package/dist/server/assets/team-CifrrNkf.js +255 -0
  34. package/dist/server/assets/{ui-Lv-KcOoP.js → ui-BJokJdYa.js} +25 -3
  35. package/dist/server/server.js +60 -8
  36. package/handler.mjs +95 -0
  37. package/lambda.mjs +61 -0
  38. package/package.json +16 -7
  39. package/server.mjs +4 -39
  40. package/dist/client/assets/_authed-Bi62GTX3.js +0 -7
  41. package/dist/client/assets/_authed-mWCAMokt.js +0 -1
  42. package/dist/client/assets/index-D7uhDdvA.js +0 -12
  43. package/dist/client/assets/issues._fingerprint-fVGLnT37.js +0 -1
  44. package/dist/client/assets/login-MqvT094Y.js +0 -1
  45. package/dist/client/assets/styles-CZZRuG1z.css +0 -2
  46. package/dist/client/assets/ui-Bj6uJIr8.js +0 -1
  47. package/dist/server/assets/_authed-BaehIntL.js +0 -40
  48. package/dist/server/assets/_tanstack-start-manifest_v-eNUCOzFz.js +0 -40
  49. package/dist/server/assets/dynamodb-DejcakaF.js +0 -187
  50. package/dist/server/assets/firestore-BH-gx9no.js +0 -112
  51. package/dist/server/assets/fns-CgB12FUN.js +0 -31
  52. package/dist/server/assets/fns-Yg8sT1Cb.js +0 -87
  53. package/dist/server/assets/memory-4DwW5cTO.js +0 -59
  54. package/dist/server/assets/rollups-JXbazRNh.js +0 -22
  55. package/dist/server/assets/src-D5jyi_C4.js +0 -235
@@ -0,0 +1,1669 @@
1
+ import { a as getCookie, i as deleteCookie, o as getRequestHeader, s as setCookie } from "../server.js";
2
+ import { a as SEVERITY_ORDER, c as parseStack, d as severityFromCount, i as DEFAULT_SEVERITY_THRESHOLDS, l as percentileMs, o as compareVersions, r as Envelope, u as releaseKey } from "./memory-BssaqdZm.js";
3
+ import { n as TEAM_ROLES, t as MAX_RETENTION_DAYS } from "./src-D83GYTrp.js";
4
+ import { createHash, createHmac, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
5
+ // src/server/config.ts
6
+ var loaded = false;
7
+ function loadEnv() {
8
+ if (loaded) return;
9
+ loaded = true;
10
+ try {
11
+ process.loadEnvFile?.(process.env.DEBUG_ENV_FILE ?? ".env");
12
+ } catch {}
13
+ }
14
+ var generatedSecret;
15
+ function config() {
16
+ loadEnv();
17
+ const env = process.env;
18
+ const store = env.DEBUG_STORE ?? "demo";
19
+ let secret = env.DEBUG_SESSION_SECRET;
20
+ if (!secret || secret.length < 32) {
21
+ if (store !== "demo" && store !== "memory") throw new Error("DEBUG_SESSION_SECRET must be set (≥32 chars) when not in demo mode. Try: openssl rand -hex 32");
22
+ secret = generatedSecret ??= randomBytes(32).toString("hex");
23
+ }
24
+ const num = (v, d) => v && !Number.isNaN(Number(v)) ? Number(v) : d;
25
+ const severity = {
26
+ critical: num(env.DEBUG_SEVERITY_CRITICAL, DEFAULT_SEVERITY_THRESHOLDS.critical),
27
+ high: num(env.DEBUG_SEVERITY_HIGH, DEFAULT_SEVERITY_THRESHOLDS.high),
28
+ medium: num(env.DEBUG_SEVERITY_MEDIUM, DEFAULT_SEVERITY_THRESHOLDS.medium)
29
+ };
30
+ return {
31
+ store,
32
+ sessionSecret: secret,
33
+ users: env.DEBUG_DASHBOARD_USERS ?? "",
34
+ apiToken: env.DEBUG_API_TOKEN,
35
+ /** Demo mode: keys accepted by POST /api/ingest. "*" = any app. */
36
+ localIngestKeys: env.DEBUG_LOCAL_INGEST_KEYS ?? "pk_local:*",
37
+ firestoreRoot: env.DEBUG_FIRESTORE_ROOT ?? "debug_apps",
38
+ dynamoTable: env.DEBUG_DYNAMO_TABLE ?? "debug",
39
+ severity,
40
+ /** The ingest function's admin routes (…/admin) and their token, for changing settings. */
41
+ adminUrl: env.DEBUG_ADMIN_URL?.replace(/\/+$/, ""),
42
+ adminToken: env.DEBUG_ADMIN_TOKEN,
43
+ /** The deployment's default retention (what ingest uses before an app has a setting). */
44
+ retentionDays: num(env.DEBUG_RETENTION_DAYS, 0) || void 0,
45
+ /** "Create issue" buttons on the issue page. */
46
+ trackers: {
47
+ linear: env.DEBUG_LINEAR === "1" || !!env.DEBUG_LINEAR_TEAM,
48
+ linearTeam: env.DEBUG_LINEAR_TEAM || void 0,
49
+ githubRepo: env.DEBUG_GITHUB_REPO || void 0,
50
+ dashboardUrl: env.DEBUG_DASHBOARD_URL || void 0
51
+ },
52
+ secureCookies: env.NODE_ENV === "production" && env.DEBUG_INSECURE_COOKIES !== "1",
53
+ /** Firebase Hosting only forwards a cookie named __session to the function behind it. */
54
+ cookieName: /^[A-Za-z0-9_]{1,40}$/.test(env.DEBUG_COOKIE_NAME ?? "") ? env.DEBUG_COOKIE_NAME : "debug_session"
55
+ };
56
+ }
57
+ // src/server/store.ts
58
+ var store;
59
+ /** The dashboard only ever reads. Point it at read-only credentials. */
60
+ function getStore() {
61
+ return store ??= create();
62
+ }
63
+ /**
64
+ * Demo mode only: the in-memory store also accepts events, so a local app can send to
65
+ * http://localhost:4400/api/ingest and see them on the dashboard. Real stores stay read-only.
66
+ */
67
+ async function getLocalWriteStore() {
68
+ const kind = config().store;
69
+ if (kind !== "demo" && kind !== "memory") return null;
70
+ return await getStore();
71
+ }
72
+ async function create() {
73
+ const cfg = config();
74
+ switch (cfg.store) {
75
+ case "firestore": {
76
+ const { initializeApp, getApps } = await import("firebase-admin/app");
77
+ const { getFirestore } = await import("firebase-admin/firestore");
78
+ const { FirestoreStore } = await import("./firestore-C52q_vwM.js");
79
+ if (!getApps().length) initializeApp();
80
+ return new FirestoreStore(getFirestore(), { root: cfg.firestoreRoot });
81
+ }
82
+ case "dynamodb": {
83
+ const { DynamoDBClient } = await import("@aws-sdk/client-dynamodb");
84
+ const { DynamoDBDocumentClient } = await import("@aws-sdk/lib-dynamodb");
85
+ const { DynamoStore } = await import("./dynamodb-Zkk1-mgz.js");
86
+ return new DynamoStore(DynamoDBDocumentClient.from(new DynamoDBClient({})), { table: cfg.dynamoTable });
87
+ }
88
+ case "memory": {
89
+ const { MemoryStore } = await import("./memory-BssaqdZm.js").then((n) => n.n);
90
+ return new MemoryStore();
91
+ }
92
+ default: {
93
+ const { seedDemo } = await import("./demo-BsMMDk_F.js");
94
+ return seedDemo();
95
+ }
96
+ }
97
+ }
98
+ // src/server/settings.ts
99
+ function settingsWriter() {
100
+ const c = config();
101
+ if (c.store === "demo" || c.store === "memory") return "local";
102
+ return c.adminUrl && c.adminToken ? "admin" : "none";
103
+ }
104
+ async function admin(method, route, body, query) {
105
+ const c = config();
106
+ const url = new URL(`${c.adminUrl}${route}`);
107
+ for (const [k, v] of Object.entries(query ?? {})) url.searchParams.set(k, v);
108
+ const res = await fetch(url, {
109
+ method,
110
+ headers: {
111
+ authorization: `Bearer ${c.adminToken}`,
112
+ ...body ? { "content-type": "application/json" } : {}
113
+ },
114
+ body: body ? JSON.stringify(body) : void 0
115
+ });
116
+ const json = await res.json().catch(() => ({}));
117
+ if (!res.ok) throw new Error(json.error ?? `The ingest function answered ${res.status}`);
118
+ return json;
119
+ }
120
+ async function readSettings(app) {
121
+ const writer = settingsWriter();
122
+ const c = config();
123
+ if (writer === "admin") try {
124
+ const out = await admin("GET", "/settings", void 0, { app });
125
+ return {
126
+ app,
127
+ retentionDays: out.retentionDays,
128
+ criticalFlows: out.settings?.criticalFlows ?? [],
129
+ alerts: out.settings?.alerts ?? {},
130
+ source: out.settings?.retentionDays ? "setting" : "default",
131
+ updatedAt: out.settings?.updatedAt,
132
+ writer
133
+ };
134
+ } catch (err) {
135
+ return {
136
+ app,
137
+ retentionDays: c.retentionDays ?? null,
138
+ criticalFlows: [],
139
+ alerts: {},
140
+ source: c.retentionDays ? "default" : "unknown",
141
+ writer,
142
+ note: `Couldn't reach the ingest function: ${err.message}`
143
+ };
144
+ }
145
+ const s = await (await getStore()).getSettings(app).catch(() => null);
146
+ const hook = s?.alerts?.slackWebhookUrl;
147
+ return {
148
+ app,
149
+ retentionDays: s?.retentionDays ?? c.retentionDays ?? (writer === "local" ? 30 : null),
150
+ criticalFlows: s?.criticalFlows ?? [],
151
+ alerts: {
152
+ ...s?.alerts,
153
+ slackWebhookUrl: hook ? `https://hooks.slack.com/…${hook.slice(-4)}` : void 0
154
+ },
155
+ source: s?.retentionDays ? "setting" : c.retentionDays || writer === "local" ? "default" : "unknown",
156
+ updatedAt: s?.updatedAt,
157
+ writer,
158
+ note: writer === "none" ? "Changing settings needs DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN (npx debugkit init sets them)." : void 0
159
+ };
160
+ }
161
+ function validRetention(days) {
162
+ const n = Number(days);
163
+ if (!Number.isInteger(n) || n < 1 || n > 3650) throw new Error(`Retention must be a whole number of days from 1 to ${MAX_RETENTION_DAYS}.`);
164
+ return n;
165
+ }
166
+ async function writeRetention(app, days) {
167
+ const writer = settingsWriter();
168
+ if (writer === "admin") await admin("PUT", "/settings", {
169
+ app,
170
+ retentionDays: days
171
+ });
172
+ else if (writer === "local") await (await getLocalWriteStore()).putSettings(app, { retentionDays: days });
173
+ else throw new Error("Settings can't be changed from this dashboard: DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN aren't set.");
174
+ return readSettings(app);
175
+ }
176
+ /** Change critical flows and/or alert settings. Validation happens in the ingest function (or here, locally). */
177
+ async function writeSettings(app, patch) {
178
+ const writer = settingsWriter();
179
+ if (writer === "admin") await admin("PUT", "/settings", {
180
+ app,
181
+ ...patch
182
+ });
183
+ else if (writer === "local") {
184
+ const store = await getLocalWriteStore();
185
+ const cur = await store.getSettings(app);
186
+ const url = patch.alerts?.slackWebhookUrl;
187
+ if (patch.alerts && url && !url.includes("…") && !/^https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]{10,200}$/.test(url)) throw new Error("Use a Slack incoming-webhook URL (https://hooks.slack.com/services/…).");
188
+ const alerts = patch.alerts ? {
189
+ ...patch.alerts,
190
+ slackWebhookUrl: url?.includes("…") ? cur?.alerts?.slackWebhookUrl : url || void 0
191
+ } : void 0;
192
+ await store.putSettings(app, {
193
+ ...patch.criticalFlows ? { criticalFlows: patch.criticalFlows } : {},
194
+ ...alerts ? { alerts } : {}
195
+ });
196
+ } else throw new Error("Settings can't be changed from this dashboard: DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN aren't set.");
197
+ return readSettings(app);
198
+ }
199
+ async function testAlert(app) {
200
+ if (settingsWriter() !== "admin") throw new Error("Test alerts are sent by your ingest function, so they need a cloud setup (not demo or local mode).");
201
+ await admin("POST", "/alert-test", { app });
202
+ }
203
+ /** Open, resolve (optionally "fixed in <version>") or ignore an issue. */
204
+ async function writeIssueStatus(app, fingerprint, status, resolvedIn) {
205
+ const writer = settingsWriter();
206
+ if (writer === "admin") return admin("PUT", "/issue", {
207
+ app,
208
+ fingerprint,
209
+ status,
210
+ resolvedIn
211
+ });
212
+ if (writer === "local") {
213
+ const issue = await (await getLocalWriteStore()).setIssueStatus(app, fingerprint, {
214
+ status,
215
+ resolvedIn
216
+ });
217
+ if (!issue) throw new Error("No such issue.");
218
+ return {
219
+ status: issue.status,
220
+ resolvedIn: issue.resolvedIn ?? null
221
+ };
222
+ }
223
+ throw new Error("Issue status can't be changed from this dashboard: DEBUG_ADMIN_URL and DEBUG_ADMIN_TOKEN aren't set.");
224
+ }
225
+ /** One page of re-stamping existing events with the current retention. */
226
+ async function restampStep(app, cursor) {
227
+ const writer = settingsWriter();
228
+ if (writer === "admin") return admin("POST", "/restamp", {
229
+ app,
230
+ cursor
231
+ });
232
+ if (writer === "local") {
233
+ const store = await getLocalWriteStore();
234
+ const days = (await store.getSettings(app))?.retentionDays ?? config().retentionDays ?? 30;
235
+ return store.restampExpiry(app, days, { cursor });
236
+ }
237
+ throw new Error("Settings can't be changed from this dashboard.");
238
+ }
239
+ var EMAIL = /^[^\s@/]{1,64}@[^\s@/]{1,190}\.[^\s@/]{2,63}$/;
240
+ var HASH = /^scrypt\.[0-9a-f]{32}\.[0-9a-f]{128}$/;
241
+ var bad = (error, status = 400) => ({
242
+ status,
243
+ body: {
244
+ ok: false,
245
+ error
246
+ }
247
+ });
248
+ var hashInviteToken = (token) => createHash("sha256").update(token).digest("hex");
249
+ /** A member as shown to people: never the password hash. */
250
+ function publicMember(m) {
251
+ const { passwordHash: _h, ...rest } = m;
252
+ return rest;
253
+ }
254
+ var role = (v) => TEAM_ROLES.includes(v) ? v : void 0;
255
+ var email = (v) => typeof v === "string" && EMAIL.test(v.trim()) ? v.trim().toLowerCase() : void 0;
256
+ async function teamAction(store, action, body, now = /* @__PURE__ */ new Date()) {
257
+ const at = now.toISOString();
258
+ switch (action) {
259
+ case "invite": {
260
+ const r = role(body.role);
261
+ if (!r) return bad("role must be owner, admin or member");
262
+ const by = email(body.invitedBy);
263
+ if (!by) return bad("invitedBy must be an email");
264
+ const to = body.email ? email(body.email) : void 0;
265
+ if (body.email && !to) return bad("email isn't a valid address");
266
+ if (to) {
267
+ const m = await store.getMember(to);
268
+ if (m && !m.removedAt) return bad(`${to} is already on the team`, 409);
269
+ }
270
+ const token = randomBytes(32).toString("base64url");
271
+ const invite = {
272
+ id: hashInviteToken(token),
273
+ role: r,
274
+ email: to,
275
+ invitedBy: by,
276
+ createdAt: at,
277
+ expiresAt: new Date(now.getTime() + 6048e5).toISOString()
278
+ };
279
+ await store.putInvite(invite);
280
+ return {
281
+ status: 200,
282
+ body: {
283
+ ok: true,
284
+ token,
285
+ invite
286
+ }
287
+ };
288
+ }
289
+ case "accept": {
290
+ const token = typeof body.token === "string" ? body.token : "";
291
+ if (!/^[A-Za-z0-9_-]{40,64}$/.test(token)) return bad("This invite link isn't valid.", 404);
292
+ const who = email(body.email);
293
+ if (!who) return bad("Enter a valid email address.");
294
+ if (typeof body.passwordHash !== "string" || !HASH.test(body.passwordHash)) return bad("passwordHash must be a scrypt hash");
295
+ const name = typeof body.name === "string" ? body.name.trim().slice(0, 80) || void 0 : void 0;
296
+ const invite = await store.getInvite(hashInviteToken(token));
297
+ if (!invite || invite.usedAt || invite.revokedAt) return bad("This invite link has already been used or was cancelled. Ask for a new one.", 410);
298
+ if (Date.parse(invite.expiresAt) < now.getTime()) return bad("This invite link has expired. Ask for a new one.", 410);
299
+ if (invite.email && invite.email !== who) return bad(`This invite is for ${invite.email}.`, 403);
300
+ const existing = await store.getMember(who);
301
+ if (existing && !existing.removedAt) return bad(`${who} already has access. Sign in instead.`, 409);
302
+ if (!await store.claimInvite(invite.id, who, at)) return bad("This invite link has already been used. Ask for a new one.", 410);
303
+ const member = {
304
+ email: who,
305
+ name,
306
+ role: invite.role,
307
+ passwordHash: body.passwordHash,
308
+ sessionVersion: (existing?.sessionVersion ?? 0) + 1,
309
+ createdAt: existing?.createdAt ?? at,
310
+ updatedAt: at,
311
+ invitedBy: invite.invitedBy
312
+ };
313
+ await store.putMember(member);
314
+ return {
315
+ status: 200,
316
+ body: {
317
+ ok: true,
318
+ member: publicMember(member)
319
+ }
320
+ };
321
+ }
322
+ case "role": {
323
+ const who = email(body.email);
324
+ const r = role(body.role);
325
+ if (!who || !r) return bad("email and role are required");
326
+ const m = await store.getMember(who);
327
+ if (!m || m.removedAt) return bad("No such member.", 404);
328
+ const next = {
329
+ ...m,
330
+ role: r,
331
+ updatedAt: at
332
+ };
333
+ await store.putMember(next);
334
+ return {
335
+ status: 200,
336
+ body: {
337
+ ok: true,
338
+ member: publicMember(next)
339
+ }
340
+ };
341
+ }
342
+ case "remove": {
343
+ const who = email(body.email);
344
+ if (!who) return bad("email is required");
345
+ const m = await store.getMember(who);
346
+ if (!m || m.removedAt) return bad("No such member.", 404);
347
+ const next = {
348
+ ...m,
349
+ removedAt: at,
350
+ updatedAt: at,
351
+ sessionVersion: m.sessionVersion + 1
352
+ };
353
+ await store.putMember(next);
354
+ return {
355
+ status: 200,
356
+ body: {
357
+ ok: true,
358
+ member: publicMember(next)
359
+ }
360
+ };
361
+ }
362
+ case "revoke": {
363
+ const id = typeof body.id === "string" && /^[0-9a-f]{64}$/.test(body.id) ? body.id : void 0;
364
+ if (!id) return bad("id is required");
365
+ const i = await store.getInvite(id);
366
+ if (!i) return bad("No such invite.", 404);
367
+ if (!i.usedAt && !i.revokedAt) await store.putInvite({
368
+ ...i,
369
+ revokedAt: at
370
+ });
371
+ return {
372
+ status: 200,
373
+ body: { ok: true }
374
+ };
375
+ }
376
+ default: return bad("not found", 404);
377
+ }
378
+ }
379
+ // ../../packages/ingest/src/alerts.ts
380
+ /** Slack incoming webhooks only: anything else could make ingest call arbitrary URLs. */
381
+ var SLACK_WEBHOOK = /^https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9/_-]{10,200}$/;
382
+ var recent = /* @__PURE__ */ new Map();
383
+ var HOUR$1 = 36e5;
384
+ var defaultPost = (url, body) => fetch(url, {
385
+ method: "POST",
386
+ headers: { "content-type": "application/json" },
387
+ body: JSON.stringify(body),
388
+ signal: AbortSignal.timeout(3e3)
389
+ });
390
+ /**
391
+ * Tell Slack about new and regressed issues, per the app's alert settings. At most one alert
392
+ * per issue per hour per function instance, and never more than 10 per batch. Failures are
393
+ * logged, never thrown: alerts must not break ingest.
394
+ */
395
+ async function sendAlerts(app, outcome, issues, settings, post = defaultPost) {
396
+ const a = settings?.alerts;
397
+ if (!outcome || !a?.slackWebhookUrl || !SLACK_WEBHOOK.test(a.slackWebhookUrl)) return 0;
398
+ const critical = new Set(settings?.criticalFlows ?? []);
399
+ const picks = [...a.newIssues !== false ? outcome.created.map((fp) => ({
400
+ fp,
401
+ kind: "new"
402
+ })) : [], ...a.regressions !== false ? outcome.regressed.map((fp) => ({
403
+ fp,
404
+ kind: "regressed"
405
+ })) : []].filter(({ fp }) => !a.onlyCriticalFlows || critical.has(issues.get(fp)?.flow ?? "")).filter(({ fp, kind }) => {
406
+ const k = `${app}|${fp}|${kind}`;
407
+ const at = recent.get(k);
408
+ if (at && Date.now() - at < HOUR$1) return false;
409
+ recent.set(k, Date.now());
410
+ return true;
411
+ }).slice(0, 10);
412
+ if (recent.size > 5e3) recent.clear();
413
+ let sent = 0;
414
+ for (const { fp, kind } of picks) {
415
+ const u = issues.get(fp);
416
+ if (!u) continue;
417
+ const link = a.dashboardUrl ? `${a.dashboardUrl.replace(/\/+$/, "")}/issues/${fp}?app=${encodeURIComponent(app)}` : void 0;
418
+ const where = [
419
+ u.culprit && `\`${u.culprit}\``,
420
+ u.flow && `flow \`${u.flow}\`${critical.has(u.flow) ? " (critical)" : ""}`,
421
+ u.version && `version ${u.version}`
422
+ ].filter(Boolean).join(" · ");
423
+ const text = `${kind === "new" ? ":new: New issue" : ":rotating_light: Regressed"} in *${app}*: ${link ? `<${link}|${u.title}>` : u.title}${where ? `\n${where}` : ""}`;
424
+ try {
425
+ await post(a.slackWebhookUrl, { text });
426
+ sent++;
427
+ } catch (err) {
428
+ console.error("[deBug] Slack alert failed", err);
429
+ }
430
+ }
431
+ return sent;
432
+ }
433
+ var CACHE_MS = 6e4;
434
+ var cache = /* @__PURE__ */ new Map();
435
+ /**
436
+ * The retention period for an app: its stored setting, else the deployment's default. Settings
437
+ * are cached for a minute per function instance, so a change from the dashboard applies to new
438
+ * events within about a minute, without a read on every request.
439
+ */
440
+ async function cachedSettings(store, app) {
441
+ const hit = cache.get(app);
442
+ if (hit && Date.now() - hit.at < CACHE_MS) return hit.settings;
443
+ let settings;
444
+ try {
445
+ settings = await store.getSettings(app);
446
+ } catch {
447
+ settings = null;
448
+ }
449
+ cache.set(app, {
450
+ at: Date.now(),
451
+ settings
452
+ });
453
+ return settings;
454
+ }
455
+ async function effectiveRetention(store, app, fallback) {
456
+ return (await cachedSettings(store, app))?.retentionDays ?? fallback ?? 30;
457
+ }
458
+ // ../../packages/ingest/src/country.ts
459
+ /**
460
+ * Rough location from what the device already reports: its timezone, then its locale's region.
461
+ * Never from IP addresses. Timezone wins because many phones keep an en-US or en-GB locale
462
+ * wherever they are.
463
+ */
464
+ var TZ = {
465
+ "Africa/Johannesburg": "ZA",
466
+ "Africa/Lagos": "NG",
467
+ "Africa/Nairobi": "KE",
468
+ "Africa/Cairo": "EG",
469
+ "Africa/Casablanca": "MA",
470
+ "Africa/Accra": "GH",
471
+ "Africa/Harare": "ZW",
472
+ "Africa/Lusaka": "ZM",
473
+ "Africa/Maputo": "MZ",
474
+ "Africa/Windhoek": "NA",
475
+ "Africa/Gaborone": "BW",
476
+ "Africa/Kampala": "UG",
477
+ "Africa/Dar_es_Salaam": "TZ",
478
+ "Africa/Addis_Ababa": "ET",
479
+ "Africa/Kigali": "RW",
480
+ "Africa/Algiers": "DZ",
481
+ "Africa/Tunis": "TN",
482
+ "Africa/Abidjan": "CI",
483
+ "Africa/Dakar": "SN",
484
+ "Africa/Luanda": "AO",
485
+ "Europe/London": "GB",
486
+ "Europe/Dublin": "IE",
487
+ "Europe/Paris": "FR",
488
+ "Europe/Berlin": "DE",
489
+ "Europe/Madrid": "ES",
490
+ "Europe/Rome": "IT",
491
+ "Europe/Amsterdam": "NL",
492
+ "Europe/Brussels": "BE",
493
+ "Europe/Lisbon": "PT",
494
+ "Europe/Stockholm": "SE",
495
+ "Europe/Oslo": "NO",
496
+ "Europe/Copenhagen": "DK",
497
+ "Europe/Helsinki": "FI",
498
+ "Europe/Warsaw": "PL",
499
+ "Europe/Zurich": "CH",
500
+ "Europe/Vienna": "AT",
501
+ "Europe/Athens": "GR",
502
+ "Europe/Istanbul": "TR",
503
+ "Europe/Moscow": "RU",
504
+ "Europe/Kyiv": "UA",
505
+ "Europe/Kiev": "UA",
506
+ "Europe/Prague": "CZ",
507
+ "Europe/Budapest": "HU",
508
+ "Europe/Bucharest": "RO",
509
+ "America/New_York": "US",
510
+ "America/Chicago": "US",
511
+ "America/Denver": "US",
512
+ "America/Los_Angeles": "US",
513
+ "America/Phoenix": "US",
514
+ "America/Anchorage": "US",
515
+ "Pacific/Honolulu": "US",
516
+ "America/Detroit": "US",
517
+ "America/Toronto": "CA",
518
+ "America/Vancouver": "CA",
519
+ "America/Edmonton": "CA",
520
+ "America/Halifax": "CA",
521
+ "America/Mexico_City": "MX",
522
+ "America/Sao_Paulo": "BR",
523
+ "America/Argentina/Buenos_Aires": "AR",
524
+ "America/Bogota": "CO",
525
+ "America/Lima": "PE",
526
+ "America/Santiago": "CL",
527
+ "Asia/Dubai": "AE",
528
+ "Asia/Riyadh": "SA",
529
+ "Asia/Qatar": "QA",
530
+ "Asia/Jerusalem": "IL",
531
+ "Asia/Kolkata": "IN",
532
+ "Asia/Calcutta": "IN",
533
+ "Asia/Karachi": "PK",
534
+ "Asia/Dhaka": "BD",
535
+ "Asia/Bangkok": "TH",
536
+ "Asia/Jakarta": "ID",
537
+ "Asia/Singapore": "SG",
538
+ "Asia/Kuala_Lumpur": "MY",
539
+ "Asia/Manila": "PH",
540
+ "Asia/Ho_Chi_Minh": "VN",
541
+ "Asia/Hong_Kong": "HK",
542
+ "Asia/Shanghai": "CN",
543
+ "Asia/Tokyo": "JP",
544
+ "Asia/Seoul": "KR",
545
+ "Asia/Taipei": "TW",
546
+ "Australia/Sydney": "AU",
547
+ "Australia/Melbourne": "AU",
548
+ "Australia/Brisbane": "AU",
549
+ "Australia/Perth": "AU",
550
+ "Australia/Adelaide": "AU",
551
+ "Pacific/Auckland": "NZ",
552
+ "Indian/Mauritius": "MU"
553
+ };
554
+ function countryOf(ctx) {
555
+ const tz = ctx.timezone ? TZ[ctx.timezone] : void 0;
556
+ if (tz) return tz;
557
+ return /[-_]([A-Z]{2})(?:\b|$)/.exec(ctx.locale ?? "")?.[1] ?? "unknown";
558
+ }
559
+ // ../../packages/ingest/src/fingerprint.ts
560
+ /** Strip volatile parts so "User 123 not found" and "User 456 not found" group together. */
561
+ function normaliseMessage(msg) {
562
+ return msg.replace(/https?:\/\/\S+/g, "<url>").replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi, "<uuid>").replace(/\b[0-9a-f]{16,}\b/gi, "<hex>").replace(/[\w.+-]+@[\w-]+\.[\w.]+/g, "<email>").replace(/\d+(\.\d+)?/g, "<n>").replace(/(["'`]).*?\1/g, "<str>").trim().slice(0, 300);
563
+ }
564
+ /** Remove build hashes / absolute prefixes so the same code location matches across builds and devices. */
565
+ function normaliseFile(file) {
566
+ if (!file) return "";
567
+ let f = file.replace(/\/\/&.*$/, "").replace(/[?#].*$/, "").replace(/^[a-z]+:\/\/[^/]+/i, "");
568
+ if (/\.(?:js)?bundle$/.test(f)) return f.replace(/^.*\//, "");
569
+ for (const root of [
570
+ "/src/",
571
+ "/lib/",
572
+ "/app/"
573
+ ]) {
574
+ const i = f.lastIndexOf(root);
575
+ if (i >= 0) {
576
+ f = f.slice(i + 1);
577
+ break;
578
+ }
579
+ }
580
+ return f.replace(/\.[0-9a-f]{6,}\./g, ".");
581
+ }
582
+ function topInAppFrame(frames) {
583
+ return frames?.find((f) => f.inApp !== false && f.file) ?? frames?.[0];
584
+ }
585
+ function culpritOf(e) {
586
+ const f = topInAppFrame(e.error.frames);
587
+ if (!f) return void 0;
588
+ const loc = normaliseFile(f.file) + (f.line ? `:${f.line}` : "");
589
+ return f.fn ? `${f.fn} (${loc})` : loc;
590
+ }
591
+ /**
592
+ * Fingerprint = error name + top in-app frame (function + file, not line, so small edits
593
+ * don't split issues) + flow. Falls back to the normalised message when there's no stack.
594
+ */
595
+ function fingerprint(e) {
596
+ const f = topInAppFrame(e.error.frames);
597
+ const r = e.request;
598
+ const where = r ? `${r.method.toUpperCase()} ${r.url} ${r.status ? `${Math.floor(r.status / 100)}xx` : "failed"}` : f ? `${f.fn ?? "?"}@${normaliseFile(f.file)}` : normaliseMessage(e.error.message);
599
+ return createHash("sha256").update([
600
+ e.error.name,
601
+ where,
602
+ e.flow ?? ""
603
+ ].join("|")).digest("hex").slice(0, 24);
604
+ }
605
+ function titleOf(e) {
606
+ return `${e.error.name}: ${e.error.message}`.slice(0, 200);
607
+ }
608
+ // ../../packages/ingest/src/index.ts
609
+ /** "pk_abc:megaton-native,pk_def:other-app" → { pk_abc: "megaton-native", ... } */
610
+ function parseIngestKeys(raw) {
611
+ const out = {};
612
+ for (const pair of (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean)) {
613
+ const [key, app] = pair.split(":");
614
+ if (key && app) out[key] = app;
615
+ }
616
+ return out;
617
+ }
618
+ var dayOf = (iso) => iso.slice(0, 10);
619
+ /** Clamp client clocks: events claiming to be from the future or very old are pinned to receipt time. */
620
+ function sanitiseTs(ts, now) {
621
+ const t = Date.parse(ts);
622
+ const n = now.getTime();
623
+ if (Number.isNaN(t) || t > n + 3e5 || t < n - 6048e5) return now.toISOString();
624
+ return new Date(t).toISOString();
625
+ }
626
+ function enrich(ctx) {
627
+ return {
628
+ ...ctx,
629
+ os: {
630
+ ...ctx.os,
631
+ name: ctx.os.name.toLowerCase()
632
+ },
633
+ runtime: {
634
+ ...ctx.runtime,
635
+ name: ctx.runtime.name.toLowerCase()
636
+ }
637
+ };
638
+ }
639
+ /** Platform-agnostic ingest. Wrap with ./firebase or ./lambda to deploy. */
640
+ async function ingest(rawBody, ingestKey, opts) {
641
+ const now = opts.now?.() ?? /* @__PURE__ */ new Date();
642
+ if (!ingestKey || !opts.keys[ingestKey]) return {
643
+ status: 401,
644
+ body: {
645
+ ok: false,
646
+ error: "invalid ingest key"
647
+ }
648
+ };
649
+ if (Buffer.byteLength(rawBody) > (opts.maxBytes ?? 524288)) return {
650
+ status: 413,
651
+ body: {
652
+ ok: false,
653
+ error: "payload too large"
654
+ }
655
+ };
656
+ let json;
657
+ try {
658
+ json = JSON.parse(rawBody);
659
+ } catch {
660
+ return {
661
+ status: 400,
662
+ body: {
663
+ ok: false,
664
+ error: "invalid json"
665
+ }
666
+ };
667
+ }
668
+ const parsed = Envelope.safeParse(json);
669
+ if (!parsed.success) return {
670
+ status: 400,
671
+ body: {
672
+ ok: false,
673
+ error: "invalid envelope",
674
+ issues: parsed.error.flatten()
675
+ }
676
+ };
677
+ const env = parsed.data;
678
+ const app = env.context.app.id;
679
+ if (opts.keys[ingestKey] !== app && opts.keys[ingestKey] !== "*") return {
680
+ status: 403,
681
+ body: {
682
+ ok: false,
683
+ error: `key not allowed for app ${app}`
684
+ }
685
+ };
686
+ const context = enrich(env.context);
687
+ const receivedAt = now.toISOString();
688
+ const stored = [];
689
+ const rollups = [];
690
+ const issues = /* @__PURE__ */ new Map();
691
+ /** Where this envelope's user counts: "app", "crash", "issue:<fp>". */
692
+ const scopes = /* @__PURE__ */ new Set();
693
+ for (const raw of env.events) {
694
+ const event = {
695
+ ...raw,
696
+ ts: sanitiseTs(raw.ts, now)
697
+ };
698
+ if (event.type === "error" && !event.error.frames?.length && event.error.stack) event.error.frames = parseStack(event.error.stack);
699
+ const day = dayOf(event.ts);
700
+ if (event.type === "session") {
701
+ rollups.push({
702
+ app,
703
+ day,
704
+ dimension: "session",
705
+ key: `${context.app.version || "unknown"}|${event.status}`,
706
+ kind: "event",
707
+ by: 1
708
+ });
709
+ scopes.add("app");
710
+ if (event.status === "started") rollups.push({
711
+ app,
712
+ day,
713
+ dimension: "release",
714
+ key: releaseKey(context.app),
715
+ kind: "event",
716
+ by: 1
717
+ });
718
+ if (event.status === "crashed") scopes.add("crash");
719
+ continue;
720
+ }
721
+ scopes.add("app");
722
+ if (event.type === "metric") {
723
+ rollups.push({
724
+ app,
725
+ day,
726
+ dimension: "requests",
727
+ key: event.key,
728
+ kind: "event",
729
+ by: event.count
730
+ });
731
+ if (event.errors) rollups.push({
732
+ app,
733
+ day,
734
+ dimension: "requests",
735
+ key: event.key,
736
+ kind: "error",
737
+ by: event.errors
738
+ });
739
+ event.buckets.forEach((n, i) => n && rollups.push({
740
+ app,
741
+ day,
742
+ dimension: "latency",
743
+ key: `${event.key}|${i}`,
744
+ kind: "event",
745
+ by: n
746
+ }));
747
+ continue;
748
+ }
749
+ const kind = event.type === "error" ? "error" : "event";
750
+ const inc = (dimension, key) => rollups.push({
751
+ app,
752
+ day,
753
+ dimension,
754
+ key: key || "unknown",
755
+ kind,
756
+ by: 1
757
+ });
758
+ let fp;
759
+ if (event.type === "error") {
760
+ fp = fingerprint(event);
761
+ const cur = issues.get(fp);
762
+ const se = {
763
+ app,
764
+ day,
765
+ fingerprint: fp,
766
+ event,
767
+ context,
768
+ user: env.user,
769
+ sessionId: env.session.id,
770
+ receivedAt
771
+ };
772
+ issues.set(fp, {
773
+ app,
774
+ fingerprint: fp,
775
+ title: titleOf(event),
776
+ culprit: culpritOf(event),
777
+ flow: event.flow,
778
+ by: (cur?.by ?? 0) + 1,
779
+ ts: cur && cur.ts > event.ts ? cur.ts : event.ts,
780
+ firstTs: cur && cur.firstTs < event.ts ? cur.firstTs : event.ts,
781
+ lastEvent: cur && cur.ts > event.ts ? cur.lastEvent : se,
782
+ version: context.app.version
783
+ });
784
+ scopes.add(`issue:${fp}`);
785
+ inc("issue", fp);
786
+ if (event.request) inc("endpoint", `${event.request.method.toUpperCase()} ${event.request.url}`);
787
+ rollups.push({
788
+ app,
789
+ day: event.ts.slice(0, 13),
790
+ dimension: "issueHour",
791
+ key: fp,
792
+ kind,
793
+ by: 1
794
+ });
795
+ }
796
+ inc("total", "all");
797
+ inc("flow", event.flow ?? "untagged");
798
+ inc("os", `${context.os.name} ${context.os.version ?? ""}`.trim());
799
+ inc("appVersion", context.app.version);
800
+ inc("deviceModel", context.device.model);
801
+ if (event.type === "event" && event.outcome && event.flow) {
802
+ inc("flowOutcome", `${event.flow}|${event.outcome}`);
803
+ if (event.step) inc("flowStep", `${event.flow}|${event.step}|${event.outcome}`);
804
+ }
805
+ if (event.type === "error") {
806
+ inc("network", context.network?.type);
807
+ inc("country", countryOf(context));
808
+ }
809
+ stored.push({
810
+ app,
811
+ day,
812
+ fingerprint: fp,
813
+ event,
814
+ context,
815
+ user: env.user,
816
+ sessionId: env.session.id,
817
+ receivedAt
818
+ });
819
+ }
820
+ await opts.store.registerApp(app);
821
+ const retentionDays = stored.length ? await effectiveRetention(opts.store, app, opts.retentionDays) : void 0;
822
+ const [, outcome] = await Promise.all([
823
+ stored.length ? opts.store.writeEvents(stored, { retentionDays }) : void 0,
824
+ opts.store.upsertIssues([...issues.values()]),
825
+ opts.store.incrementRollups(rollups),
826
+ markUsers(opts.store, app, env.user?.id ?? env.user?.anonymousId ?? env.session.id, scopes, dayOf(receivedAt))
827
+ ]);
828
+ if (outcome && (outcome.created.length || outcome.regressed.length)) await sendAlerts(app, outcome, issues, await cachedSettings(opts.store, app));
829
+ return {
830
+ status: 202,
831
+ body: {
832
+ ok: true,
833
+ accepted: env.events.length
834
+ }
835
+ };
836
+ }
837
+ /** Recently written (scope, member, day) marks, so a busy user costs one write per day, not per batch. */
838
+ var seenMarks = /* @__PURE__ */ new Set();
839
+ /**
840
+ * Count the envelope's user in each scope. The id is hashed, so the store never holds user ids,
841
+ * and each (scope, user, day) is written at most once per function instance.
842
+ */
843
+ async function markUsers(store, app, who, scopes, day) {
844
+ if (!scopes.size) return;
845
+ const member = createHash("sha256").update(`${app}\u0000${who}`).digest("hex").slice(0, 24);
846
+ const marks = [];
847
+ for (const scope of scopes) {
848
+ const k = `${app}|${scope}|${member}|${day}`;
849
+ if (seenMarks.has(k)) continue;
850
+ seenMarks.add(k);
851
+ marks.push({
852
+ scope,
853
+ member,
854
+ day
855
+ });
856
+ }
857
+ if (seenMarks.size > 5e4) seenMarks.clear();
858
+ if (marks.length) await store.markUsers(app, marks);
859
+ }
860
+ var CORS_HEADERS = {
861
+ "access-control-allow-origin": "*",
862
+ "access-control-allow-methods": "POST, OPTIONS",
863
+ "access-control-allow-headers": "content-type, x-debug-key",
864
+ "access-control-max-age": "86400"
865
+ };
866
+ // src/server/auth.ts
867
+ var cookie = () => config().cookieName;
868
+ var MAX_AGE_S = 43200;
869
+ /** How long a member's record is trusted before it's read again (removals apply within this). */
870
+ var MEMBER_CACHE_MS = 1e4;
871
+ var DEMO_USER = {
872
+ email: "demo@debug.local",
873
+ password: "demo-debug"
874
+ };
875
+ function envUsers() {
876
+ const cfg = config();
877
+ const map = /* @__PURE__ */ new Map();
878
+ for (const pair of cfg.users.split(",").map((s) => s.trim()).filter(Boolean)) {
879
+ const i = pair.indexOf("=");
880
+ if (i > 0) map.set(pair.slice(0, i).toLowerCase(), pair.slice(i + 1));
881
+ }
882
+ return map;
883
+ }
884
+ /** Emails of the bootstrap logins (always owners). */
885
+ var envOwnerEmails = () => demoLoginEnabled() ? [DEMO_USER.email] : [...envUsers().keys()];
886
+ function demoLoginEnabled() {
887
+ return config().store === "demo" && envUsers().size === 0;
888
+ }
889
+ /** scrypt.<salt>.<hash>, the same format as scripts/hash-password.mjs and the CLI. */
890
+ function hashPassword(password) {
891
+ const salt = randomBytes(16);
892
+ return `scrypt.${salt.toString("hex")}.${scryptSync(password, salt, 64).toString("hex")}`;
893
+ }
894
+ var DUMMY = "scrypt.00000000000000000000000000000000." + "00".repeat(64);
895
+ function verifyHash(password, stored) {
896
+ const [algo, saltHex, hashHex] = stored.split(".");
897
+ if (algo !== "scrypt" || !saltHex || !hashHex) return false;
898
+ const expected = Buffer.from(hashHex, "hex");
899
+ const actual = scryptSync(password, Buffer.from(saltHex, "hex"), expected.length);
900
+ return timingSafeEqual(actual, expected);
901
+ }
902
+ var members = /* @__PURE__ */ new Map();
903
+ function forgetMember(email) {
904
+ if (email) members.delete(email);
905
+ else members.clear();
906
+ }
907
+ async function member(email) {
908
+ const hit = members.get(email);
909
+ if (hit && Date.now() - hit.at < MEMBER_CACHE_MS) return hit.m;
910
+ const store = await getStore();
911
+ const m = typeof store.getMember === "function" ? await store.getMember(email).catch(() => null) : null;
912
+ members.set(email, {
913
+ m,
914
+ at: Date.now()
915
+ });
916
+ return m;
917
+ }
918
+ var failures = /* @__PURE__ */ new Map();
919
+ var WINDOW_MS = 9e5;
920
+ function tooManyAttempts(email) {
921
+ const now = Date.now();
922
+ const recent = (failures.get(email) ?? []).filter((t) => now - t < WINDOW_MS);
923
+ failures.set(email, recent);
924
+ return recent.length >= 10;
925
+ }
926
+ function recordFailure(email) {
927
+ failures.set(email, [...failures.get(email) ?? [], Date.now()]);
928
+ }
929
+ async function checkCredentials(email, password) {
930
+ const e = email.trim().toLowerCase();
931
+ if (demoLoginEnabled() && e === DEMO_USER.email) return password === DEMO_USER.password ? {
932
+ email: e,
933
+ role: "owner",
934
+ source: "env"
935
+ } : null;
936
+ const env = envUsers().get(e);
937
+ if (env) return verifyHash(password, env) ? {
938
+ email: e,
939
+ role: "owner",
940
+ source: "env"
941
+ } : null;
942
+ forgetMember(e);
943
+ const m = await member(e);
944
+ const ok = verifyHash(password, m && !m.removedAt ? m.passwordHash : DUMMY);
945
+ return m && !m.removedAt && ok ? {
946
+ email: e,
947
+ role: m.role,
948
+ name: m.name,
949
+ source: "team",
950
+ v: m.sessionVersion
951
+ } : null;
952
+ }
953
+ var sign = (payload) => createHmac("sha256", config().sessionSecret).update(payload).digest("base64url");
954
+ function startSession(user) {
955
+ const payload = Buffer.from(JSON.stringify({
956
+ email: user.email,
957
+ exp: Date.now() + MAX_AGE_S * 1e3,
958
+ s: user.source,
959
+ v: user.v
960
+ })).toString("base64url");
961
+ setCookie(cookie(), `${payload}.${sign(payload)}`, {
962
+ httpOnly: true,
963
+ sameSite: "lax",
964
+ secure: config().secureCookies,
965
+ path: "/",
966
+ maxAge: MAX_AGE_S
967
+ });
968
+ }
969
+ function endSession() {
970
+ deleteCookie(cookie(), { path: "/" });
971
+ }
972
+ async function readSession() {
973
+ const raw = getCookie(cookie());
974
+ if (!raw) return null;
975
+ const [payload, sig] = raw.split(".");
976
+ if (!payload || !sig) return null;
977
+ const expected = Buffer.from(sign(payload));
978
+ const given = Buffer.from(sig);
979
+ if (expected.length !== given.length || !timingSafeEqual(expected, given)) return null;
980
+ let data;
981
+ try {
982
+ data = JSON.parse(Buffer.from(payload, "base64url").toString());
983
+ } catch {
984
+ return null;
985
+ }
986
+ if (Date.now() > data.exp) return null;
987
+ if (data.s === "team") {
988
+ const m = await member(data.email);
989
+ if (!m || m.removedAt || m.sessionVersion !== data.v) return null;
990
+ return {
991
+ email: m.email,
992
+ role: m.role,
993
+ name: m.name,
994
+ source: "team"
995
+ };
996
+ }
997
+ if (demoLoginEnabled() ? data.email !== DEMO_USER.email : !envUsers().has(data.email)) return null;
998
+ return {
999
+ email: data.email,
1000
+ role: "owner",
1001
+ source: "env"
1002
+ };
1003
+ }
1004
+ var canManage = (u) => u?.role === "owner" || u?.role === "admin";
1005
+ /** For /api/* routes: a browser session or `Authorization: Bearer $DEBUG_API_TOKEN`. */
1006
+ async function authorizeApi(request) {
1007
+ if (await readSession()) return true;
1008
+ const token = config().apiToken;
1009
+ const header = request.headers.get("authorization") ?? getRequestHeader("authorization") ?? "";
1010
+ if (!token || !header.startsWith("Bearer ")) return false;
1011
+ const a = Buffer.from(header.slice(7));
1012
+ const b = Buffer.from(token);
1013
+ return a.length === b.length && timingSafeEqual(a, b);
1014
+ }
1015
+ // src/server/range.ts
1016
+ /** The date range a dashboard view covers, worked out from the URL (range=7d, or from/to). */
1017
+ var RANGE_PRESETS = [
1018
+ "24h",
1019
+ "7d",
1020
+ "14d",
1021
+ "30d",
1022
+ "90d"
1023
+ ];
1024
+ var DAY$1 = 864e5;
1025
+ var dayKey$1 = (t) => new Date(t).toISOString().slice(0, 10);
1026
+ var ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
1027
+ function short(day) {
1028
+ return (/* @__PURE__ */ new Date(`${day}T00:00:00Z`)).toLocaleDateString("en-GB", {
1029
+ day: "numeric",
1030
+ month: "short",
1031
+ timeZone: "UTC"
1032
+ });
1033
+ }
1034
+ function resolveRange(input, now = Date.now()) {
1035
+ const today = dayKey$1(now);
1036
+ let preset = RANGE_PRESETS.includes(input.range ?? "") ? input.range : "14d";
1037
+ let from;
1038
+ let to = today;
1039
+ let days;
1040
+ if (input.range === "custom" && ISO_DAY.test(input.from ?? "") && ISO_DAY.test(input.to ?? "") && !Number.isNaN(Date.parse(input.from)) && !Number.isNaN(Date.parse(input.to))) {
1041
+ preset = "custom";
1042
+ to = input.to > today ? today : input.to;
1043
+ from = input.from > to ? to : input.from;
1044
+ days = Math.round((Date.parse(to) - Date.parse(from)) / DAY$1) + 1;
1045
+ if (days > 730) {
1046
+ from = dayKey$1(Date.parse(to) - 729 * DAY$1);
1047
+ days = 730;
1048
+ }
1049
+ } else if (preset === "24h") {
1050
+ from = dayKey$1(now - DAY$1);
1051
+ days = 1;
1052
+ } else {
1053
+ days = Number(preset.replace("d", ""));
1054
+ from = dayKey$1(now - (days - 1) * DAY$1);
1055
+ }
1056
+ const prevTo = dayKey$1(Date.parse(from) - DAY$1);
1057
+ const prevFrom = dayKey$1(Date.parse(from) - days * DAY$1);
1058
+ const span = preset === "24h" ? "24 hours" : `${days} day${days === 1 ? "" : "s"}`;
1059
+ const label = preset === "custom" ? from === to ? short(from) : `${short(from)} – ${short(to)}` : `the last ${span}`;
1060
+ return {
1061
+ preset,
1062
+ from,
1063
+ to,
1064
+ days,
1065
+ label,
1066
+ span,
1067
+ prevFrom,
1068
+ prevTo,
1069
+ granularity: preset === "24h" ? "hour" : days > 90 ? "week" : "day"
1070
+ };
1071
+ }
1072
+ /** Every UTC day from `from` to `to`, inclusive. */
1073
+ function daysBetween(from, to) {
1074
+ const out = [];
1075
+ for (let t = Date.parse(`${from}T00:00:00Z`); t <= Date.parse(`${to}T00:00:00Z`); t += DAY$1) out.push(dayKey$1(t));
1076
+ return out;
1077
+ }
1078
+ /** The Monday a day's week starts on, for weekly buckets. */
1079
+ function weekOf(day) {
1080
+ const t = Date.parse(`${day}T00:00:00Z`);
1081
+ return dayKey$1(t - (new Date(t).getUTCDay() + 6) % 7 * DAY$1);
1082
+ }
1083
+ // src/server/queries.ts
1084
+ /**
1085
+ * Distinct users, or 0 when the count can't be made (for example a Firestore index added in a
1086
+ * newer release isn't deployed yet). The rest of the page still loads.
1087
+ */
1088
+ async function countUsersSafe(store, app, scope, since) {
1089
+ try {
1090
+ return await store.countUsers(app, scope, since);
1091
+ } catch (err) {
1092
+ console.warn(`deBug: couldn't count users (${scope}): ${err.message.split("\n")[0]}`);
1093
+ return 0;
1094
+ }
1095
+ }
1096
+ var DAY = 864e5;
1097
+ var HOUR = 36e5;
1098
+ var dayKey = (t) => new Date(t).toISOString().slice(0, 10);
1099
+ var hourKey = (t) => new Date(t).toISOString().slice(0, 13);
1100
+ function hours(now, n) {
1101
+ return Array.from({ length: n }, (_, i) => hourKey(now - (n - 1 - i) * HOUR));
1102
+ }
1103
+ /** Description of every field, shipped with the JSON API so agents can interpret it without docs. */
1104
+ var SUMMARY_FIELDS = {
1105
+ range: "The period the numbers cover. Query with ?range=24h|7d|14d|30d|90d, or ?range=custom&from=YYYY-MM-DD&to=YYYY-MM-DD. Default 14d.",
1106
+ retention: "How long raw events are kept. Counts, issues and release health are kept forever; event details older than detailsFrom have expired.",
1107
+ "totals.errors24h": "Error events in the trailing 24 hours (exact, from hourly rollups).",
1108
+ "totals.errorsRange": "Error events in the selected range.",
1109
+ "totals.changePct": "Percent change of errors vs the previous period of the same length. null when that period had fewer than 10 errors.",
1110
+ "totals.activeIssues": "Distinct grouped errors (issues) seen in the range.",
1111
+ "totals.criticalIssues": "Issues whose 24h occurrence count meets the critical threshold.",
1112
+ "flows[]": "Parts of the app as tagged by the developer (e.g. auth.login). Sorted by severity, then errors24h, then errorsRange.",
1113
+ "flows[].failureRate": "failures/(failures+successes) in the range from events logged with an outcome. null when the app logs no outcomes for that flow.",
1114
+ "issues[]": "Grouped errors seen in the range. Sorted by severity, then count24h, then countRange.",
1115
+ "issues[].severity": "Derived from count24h using thresholds critical/high/medium.",
1116
+ "issues[].culprit": "Top in-app stack frame: function (file:line).",
1117
+ "trend[]": "Errors and non-error events per hour (24h), UTC day (up to 90 days) or week (longer).",
1118
+ breakdowns: "Errors in the range split by OS, app version and device model.",
1119
+ narrative: "Plain-language summary of what is going wrong in the range.",
1120
+ "health.crashFreeRate": "Share of sessions in the range with no fatal crash. Sessions are recorded automatically by the SDK.",
1121
+ "health.errorFreeRate": "Share of sessions in the range with no unhandled error.",
1122
+ "health.releases[]": "Crash-free and error-free rates per app version.",
1123
+ "health.endpoints[]": "HTTP endpoints whose requests failed most (5xx, timeouts, network errors), from automatic network capture.",
1124
+ "health.users": "Distinct users active since the start of the range (user id when set, else the install's anonymous id; stored hashed).",
1125
+ "health.crashFreeUsersRate": "Share of those users who didn't crash.",
1126
+ "issues[].status": "open, resolved, ignored, or regressed (seen again in the fixed release or later).",
1127
+ "issues[].newInLatest": "First seen in latestVersion: likely introduced by the newest release.",
1128
+ "issues[].users": "Distinct users affected since the start of the range (top issues only).",
1129
+ "releases[]": "Releases first seen inside the range, with the day they appeared: markers on the trend.",
1130
+ "steps[]": "track(flow, step) outcomes per step in the range, most failures first.",
1131
+ "timings[]": "Busiest endpoints with p50/p95 response time (bucket upper bounds, ms) and error rate, from automatic request timing.",
1132
+ "breakdowns.network": "Errors by network type (wifi, cellular...).",
1133
+ "breakdowns.country": "Errors by country, from the device's timezone or locale (never IP).",
1134
+ criticalFlows: "Flows marked critical in Settings; their issues rank one severity level higher."
1135
+ };
1136
+ var sumRows = (rows, field = "errors") => rows.reduce((a, r) => a + r[field], 0);
1137
+ /** Retention as the dashboard knows it: the app's setting, else the deployment default it was told about. */
1138
+ async function retentionFor(store, app, fallbackDays, now = Date.now()) {
1139
+ let days = null;
1140
+ let source = "unknown";
1141
+ try {
1142
+ const s = await store.getSettings(app);
1143
+ if (s?.retentionDays) [days, source] = [s.retentionDays, "setting"];
1144
+ } catch {}
1145
+ if (days === null && fallbackDays) [days, source] = [fallbackDays, "default"];
1146
+ return {
1147
+ days,
1148
+ source,
1149
+ detailsFrom: days ? dayKey(now - days * DAY) : null
1150
+ };
1151
+ }
1152
+ async function buildSummary(store, appParam, thresholds, now = Date.now(), opts = {}) {
1153
+ const apps = await store.listApps();
1154
+ const app = appParam && apps.includes(appParam) ? appParam : apps[0];
1155
+ if (!app) return null;
1156
+ const range = resolveRange(opts.range ?? {}, now);
1157
+ const { from, to } = range;
1158
+ const hourly = range.preset === "24h";
1159
+ const h24 = hours(now, 24);
1160
+ const [sessionRows, endpointRows, total, prevTotal, flowRows, outcomeRows, os, appVersion, deviceModel, issueDays, issues, hourRows, retention] = await Promise.all([
1161
+ store.getRollups(app, "session", from, to),
1162
+ store.getRollups(app, "endpoint", from, to),
1163
+ store.getRollups(app, "total", from, to),
1164
+ store.getRollups(app, "total", range.prevFrom, range.prevTo),
1165
+ store.getRollups(app, "flow", from, to),
1166
+ store.getRollups(app, "flowOutcome", from, to),
1167
+ store.getRollups(app, "os", from, to),
1168
+ store.getRollups(app, "appVersion", from, to),
1169
+ store.getRollups(app, "deviceModel", from, to),
1170
+ store.getRollups(app, "issue", from, to),
1171
+ store.listIssues(app, { limit: 500 }),
1172
+ store.getRollups(app, "issueHour", hours(now, 48)[0], hourKey(now)),
1173
+ retentionFor(store, app, opts.retentionDays, now)
1174
+ ]);
1175
+ const [releaseRows, stepRows, requestRows, latencyRows, networkRows, countryRows, appSettings] = await Promise.all([
1176
+ store.getRollups(app, "release", dayKey(Date.parse(`${from}T00:00:00Z`) - 365 * DAY), to),
1177
+ store.getRollups(app, "flowStep", from, to),
1178
+ store.getRollups(app, "requests", from, to),
1179
+ store.getRollups(app, "latency", from, to),
1180
+ store.getRollups(app, "network", from, to),
1181
+ store.getRollups(app, "country", from, to),
1182
+ store.getSettings(app).catch(() => null)
1183
+ ]);
1184
+ const criticalFlows = appSettings?.criticalFlows ?? [];
1185
+ const critical = new Set(criticalFlows);
1186
+ const usersSince = hourly ? dayKey(now - DAY) : from;
1187
+ const [users, crashedUsers] = await Promise.all([countUsersSafe(store, app, "app", usersSince), countUsersSafe(store, app, "crash", usersSince)]);
1188
+ const last24 = new Set(h24);
1189
+ let errors24h = 0;
1190
+ let errorsPrev24h = 0;
1191
+ const issue24h = /* @__PURE__ */ new Map();
1192
+ for (const r of hourRows) if (last24.has(r.day)) {
1193
+ errors24h += r.errors;
1194
+ issue24h.set(r.key, (issue24h.get(r.key) ?? 0) + r.errors);
1195
+ } else errorsPrev24h += r.errors;
1196
+ let trend;
1197
+ if (hourly) trend = h24.map((h) => ({
1198
+ day: h,
1199
+ errors: hourRows.filter((r) => r.day === h).reduce((a, r) => a + r.errors, 0),
1200
+ events: 0
1201
+ }));
1202
+ else {
1203
+ const byDay = new Map(total.map((r) => [r.day, r]));
1204
+ const daily = daysBetween(from, to).map((day) => ({
1205
+ day,
1206
+ errors: byDay.get(day)?.errors ?? 0,
1207
+ events: byDay.get(day)?.events ?? 0
1208
+ }));
1209
+ if (range.granularity === "week") {
1210
+ const weeks = /* @__PURE__ */ new Map();
1211
+ for (const d of daily) {
1212
+ const w = weekOf(d.day);
1213
+ const cur = weeks.get(w) ?? {
1214
+ day: w,
1215
+ errors: 0,
1216
+ events: 0
1217
+ };
1218
+ cur.errors += d.errors;
1219
+ cur.events += d.events;
1220
+ weeks.set(w, cur);
1221
+ }
1222
+ trend = [...weeks.values()];
1223
+ } else trend = daily;
1224
+ }
1225
+ const errorsRange = hourly ? errors24h : sumRows(total);
1226
+ const errorsPrev = hourly ? errorsPrev24h : sumRows(prevTotal);
1227
+ const issueRange = /* @__PURE__ */ new Map();
1228
+ for (const r of issueDays) issueRange.set(r.key, (issueRange.get(r.key) ?? 0) + r.errors);
1229
+ const rangeStart = hourly ? (/* @__PURE__ */ new Date(now - DAY)).toISOString() : `${from}T00:00:00.000Z`;
1230
+ const versionsInRange = [...new Set(sessionRows.map((r) => r.key.split("|")[0]).filter((v) => v && v !== "unknown"))].sort(compareVersions);
1231
+ const latestVersion = versionsInRange[versionsInRange.length - 1] ?? null;
1232
+ const issueRows = issues.filter((i) => i.lastSeen >= rangeStart && i.firstSeen <= `${to}T23:59:59.999Z`).map((i) => toIssueRow(i, issue24h.get(i.fingerprint) ?? 0, hourly ? issue24h.get(i.fingerprint) ?? 0 : issueRange.get(i.fingerprint) ?? 0, thresholds, latestVersion, critical)).sort(bySeverityThenCount);
1233
+ const active = issueRows.filter((i) => i.status !== "ignored" && i.status !== "resolved");
1234
+ await Promise.all(active.slice(0, 10).map(async (i) => i.users = await countUsersSafe(store, app, `issue:${i.fingerprint}`, usersSince)));
1235
+ const firstDay = /* @__PURE__ */ new Map();
1236
+ for (const r of releaseRows) {
1237
+ const cur = firstDay.get(r.key);
1238
+ if (!cur) firstDay.set(r.key, {
1239
+ day: r.day,
1240
+ sessions: r.events
1241
+ });
1242
+ else {
1243
+ if (r.day < cur.day) cur.day = r.day;
1244
+ cur.sessions += r.events;
1245
+ }
1246
+ }
1247
+ const releases = [...firstDay.entries()].filter(([, v]) => v.day >= from && v.day <= to).map(([release, v]) => ({
1248
+ release,
1249
+ firstDay: v.day,
1250
+ sessions: v.sessions
1251
+ })).sort((a, b) => a.firstDay.localeCompare(b.firstDay));
1252
+ const flowMap = /* @__PURE__ */ new Map();
1253
+ const flowOf = (flow) => {
1254
+ let f = flowMap.get(flow);
1255
+ if (!f) flowMap.set(flow, f = {
1256
+ flow,
1257
+ errors24h: 0,
1258
+ errorsRange: 0,
1259
+ severity: "low",
1260
+ issues: 0,
1261
+ successesRange: 0,
1262
+ failuresRange: 0,
1263
+ failureRate: null,
1264
+ critical: critical.has(flow)
1265
+ });
1266
+ return f;
1267
+ };
1268
+ for (const r of flowRows) if (r.errors > 0) flowOf(r.key).errorsRange += r.errors;
1269
+ for (const i of active) {
1270
+ const f = flowOf(i.flow ?? "untagged");
1271
+ f.issues++;
1272
+ f.errors24h += i.count24h;
1273
+ if (SEVERITY_ORDER[i.severity] > SEVERITY_ORDER[f.severity]) f.severity = i.severity;
1274
+ }
1275
+ for (const r of outcomeRows) {
1276
+ const [flow, outcome] = r.key.split("|");
1277
+ const f = flowOf(flow);
1278
+ if (outcome === "success") f.successesRange += r.events;
1279
+ else if (outcome === "failure") f.failuresRange += r.events;
1280
+ }
1281
+ const flows = [...flowMap.values()].map((f) => ({
1282
+ ...f,
1283
+ failureRate: f.successesRange + f.failuresRange > 0 ? f.failuresRange / (f.successesRange + f.failuresRange) : null
1284
+ })).filter((f) => f.errorsRange > 0 || f.failuresRange > 0 || f.errors24h > 0).sort((a, b) => SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity] || b.errors24h - a.errors24h || b.errorsRange - a.errorsRange);
1285
+ const top = (rows) => {
1286
+ const m = /* @__PURE__ */ new Map();
1287
+ for (const r of rows) m.set(r.key, (m.get(r.key) ?? 0) + r.errors);
1288
+ return [...m.entries()].map(([key, errors]) => ({
1289
+ key,
1290
+ errors
1291
+ })).filter((r) => r.errors > 0).sort((a, b) => b.errors - a.errors).slice(0, 8);
1292
+ };
1293
+ const summary = {
1294
+ app,
1295
+ apps,
1296
+ generatedAt: new Date(now).toISOString(),
1297
+ range,
1298
+ retention,
1299
+ totals: {
1300
+ errors24h,
1301
+ errorsRange,
1302
+ errorsPrev,
1303
+ changePct: errorsPrev >= 10 ? Math.round((errorsRange - errorsPrev) / errorsPrev * 100) : null,
1304
+ eventsRange: sumRows(total, "events"),
1305
+ activeIssues: active.length,
1306
+ criticalIssues: active.filter((i) => i.severity === "critical").length,
1307
+ failingFlows: flows.filter((f) => (hourly ? f.errors24h : f.errorsRange) > 0).length
1308
+ },
1309
+ narrative: [],
1310
+ trend,
1311
+ flows,
1312
+ issues: issueRows,
1313
+ breakdowns: {
1314
+ os: top(os),
1315
+ appVersion: top(appVersion),
1316
+ deviceModel: top(deviceModel),
1317
+ network: top(networkRows),
1318
+ country: top(countryRows)
1319
+ },
1320
+ steps: buildSteps(stepRows),
1321
+ timings: buildTimings(requestRows, latencyRows),
1322
+ criticalFlows,
1323
+ health: {
1324
+ ...buildHealth(sessionRows, endpointRows, dayKey(now)),
1325
+ users,
1326
+ crashedUsers,
1327
+ crashFreeUsersRate: users > 0 ? Math.max(0, 1 - crashedUsers / users) : null
1328
+ },
1329
+ releases,
1330
+ latestVersion
1331
+ };
1332
+ summary.narrative = narrate(summary);
1333
+ return summary;
1334
+ }
1335
+ var rate = (bad, total) => total > 0 ? Math.max(0, 1 - bad / total) : null;
1336
+ function buildHealth(sessionRows, endpointRows, today) {
1337
+ const byVersion = /* @__PURE__ */ new Map();
1338
+ for (const r of sessionRows) {
1339
+ const [version = "unknown", status] = r.key.split("|");
1340
+ let v = byVersion.get(version);
1341
+ if (!v) byVersion.set(version, v = {
1342
+ version,
1343
+ sessions: 0,
1344
+ errored: 0,
1345
+ crashed: 0,
1346
+ crashFreeRate: null,
1347
+ errorFreeRate: null
1348
+ });
1349
+ if (status === "started") v.sessions += r.events;
1350
+ else if (status === "errored") v.errored += r.events;
1351
+ else if (status === "crashed") v.crashed += r.events;
1352
+ }
1353
+ const releases = [...byVersion.values()].map((v) => ({
1354
+ ...v,
1355
+ crashFreeRate: rate(v.crashed, v.sessions),
1356
+ errorFreeRate: rate(v.errored, v.sessions)
1357
+ })).filter((v) => v.sessions > 0).sort((a, b) => compareVersions(b.version, a.version)).slice(0, 8);
1358
+ const sum = (k) => [...byVersion.values()].reduce((a, v) => a + v[k], 0);
1359
+ const eps = /* @__PURE__ */ new Map();
1360
+ for (const r of endpointRows) {
1361
+ let e = eps.get(r.key);
1362
+ if (!e) eps.set(r.key, e = {
1363
+ endpoint: r.key,
1364
+ failuresRange: 0,
1365
+ failures24h: 0
1366
+ });
1367
+ e.failuresRange += r.errors;
1368
+ if (r.day === today) e.failures24h += r.errors;
1369
+ }
1370
+ return {
1371
+ sessionsRange: sum("sessions"),
1372
+ crashFreeRate: rate(sum("crashed"), sum("sessions")),
1373
+ errorFreeRate: rate(sum("errored"), sum("sessions")),
1374
+ releases,
1375
+ endpoints: [...eps.values()].sort((a, b) => b.failuresRange - a.failuresRange).slice(0, 8)
1376
+ };
1377
+ }
1378
+ var BUMP = {
1379
+ low: "medium",
1380
+ medium: "high",
1381
+ high: "critical",
1382
+ critical: "critical"
1383
+ };
1384
+ function buildSteps(rows) {
1385
+ const m = /* @__PURE__ */ new Map();
1386
+ for (const r of rows) {
1387
+ const [flow = "", step = "", outcome] = r.key.split("|");
1388
+ const k = `${flow}|${step}`;
1389
+ let s = m.get(k);
1390
+ if (!s) m.set(k, s = {
1391
+ flow,
1392
+ step,
1393
+ successes: 0,
1394
+ failures: 0,
1395
+ abandoned: 0,
1396
+ failureRate: null
1397
+ });
1398
+ if (outcome === "success") s.successes += r.events;
1399
+ else if (outcome === "failure") s.failures += r.events;
1400
+ else if (outcome === "abandoned") s.abandoned += r.events;
1401
+ }
1402
+ return [...m.values()].map((s) => ({
1403
+ ...s,
1404
+ failureRate: s.successes + s.failures > 0 ? s.failures / (s.successes + s.failures) : null
1405
+ })).sort((a, b) => b.failures - a.failures || (b.failureRate ?? 0) - (a.failureRate ?? 0)).slice(0, 30);
1406
+ }
1407
+ function buildTimings(requestRows, latencyRows) {
1408
+ const totals = /* @__PURE__ */ new Map();
1409
+ for (const r of requestRows) {
1410
+ const t = totals.get(r.key) ?? {
1411
+ requests: 0,
1412
+ failed: 0
1413
+ };
1414
+ t.requests += r.events;
1415
+ t.failed += r.errors;
1416
+ totals.set(r.key, t);
1417
+ }
1418
+ const hist = /* @__PURE__ */ new Map();
1419
+ for (const r of latencyRows) {
1420
+ const cut = r.key.lastIndexOf("|");
1421
+ const key = r.key.slice(0, cut);
1422
+ const i = Number(r.key.slice(cut + 1));
1423
+ const b = hist.get(key) ?? new Array(13).fill(0);
1424
+ if (i >= 0 && i < 13) b[i] += r.events;
1425
+ hist.set(key, b);
1426
+ }
1427
+ return [...totals.entries()].map(([endpoint, t]) => {
1428
+ const b = hist.get(endpoint) ?? [];
1429
+ return {
1430
+ endpoint,
1431
+ requests: t.requests,
1432
+ failed: t.failed,
1433
+ errorRate: t.requests ? t.failed / t.requests : 0,
1434
+ p50: percentileMs(b, .5),
1435
+ p95: percentileMs(b, .95)
1436
+ };
1437
+ }).sort((a, b) => b.requests - a.requests).slice(0, 10);
1438
+ }
1439
+ function toIssueRow(i, count24h, countRange, t, latestVersion = null, critical = /* @__PURE__ */ new Set()) {
1440
+ const base = severityFromCount(count24h, t);
1441
+ return {
1442
+ status: i.status ?? "open",
1443
+ resolvedIn: i.resolvedIn,
1444
+ firstVersion: i.firstVersion,
1445
+ lastVersion: i.lastVersion,
1446
+ newInLatest: !!latestVersion && i.firstVersion === latestVersion,
1447
+ fingerprint: i.fingerprint,
1448
+ title: i.title,
1449
+ culprit: i.culprit,
1450
+ flow: i.flow,
1451
+ severity: i.flow && critical.has(i.flow) && count24h > 0 ? BUMP[base] : base,
1452
+ count24h,
1453
+ countRange,
1454
+ countTotal: i.count,
1455
+ firstSeen: i.firstSeen,
1456
+ lastSeen: i.lastSeen
1457
+ };
1458
+ }
1459
+ var bySeverityThenCount = (a, b) => SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity] || b.count24h - a.count24h || b.countRange - a.countRange || b.lastSeen.localeCompare(a.lastSeen);
1460
+ var pct = (n) => `${Math.round(n * 100)}%`;
1461
+ var pctOne = (n) => `${(Math.floor(n * 1e3) / 10).toFixed(1)}%`;
1462
+ var plural = (n, word) => `${n.toLocaleString()} ${word}${n === 1 ? "" : "s"}`;
1463
+ function narrate(s) {
1464
+ const out = [];
1465
+ const t = s.totals;
1466
+ const r = s.range;
1467
+ if (t.errorsRange === 0) {
1468
+ out.push(`No errors in ${r.label}.`);
1469
+ return out;
1470
+ }
1471
+ const change = t.changePct === null ? "" : t.changePct === 0 ? `, flat versus the previous ${r.span}` : t.changePct > 500 ? `, up from ${t.errorsPrev.toLocaleString()} in the previous ${r.span}` : `, ${t.changePct > 0 ? "up" : "down"} ${Math.abs(t.changePct)}% on the previous ${r.span}`;
1472
+ out.push(`${plural(t.errorsRange, "error")} in ${r.label}${change}, across ${t.failingFlows} part${t.failingFlows === 1 ? "" : "s"} of the app.`);
1473
+ const f = s.flows[0];
1474
+ if (f && (f.errors24h > 0 || f.errorsRange > 0)) {
1475
+ const failRate = f.failureRate !== null ? ` ${pct(f.failureRate)} of attempts fail.` : "";
1476
+ const n = r.preset === "24h" ? f.errors24h : f.errorsRange;
1477
+ out.push(`${f.flow}${f.critical ? " (a critical flow)" : ""} is the most affected flow (${f.severity}): ${plural(n, "error")} in ${r.label} from ${plural(f.issues, "issue")}.${failRate}`);
1478
+ }
1479
+ const i = s.issues.find((x) => x.status !== "ignored" && x.status !== "resolved");
1480
+ if (i && i.countRange > 0) {
1481
+ const isNew = Date.parse(s.generatedAt) - Date.parse(i.firstSeen) < 3 * DAY;
1482
+ out.push(`Top issue: "${i.title}"${i.culprit ? ` in ${i.culprit}` : ""}, ${plural(i.countRange, "time")} in ${r.label}${isNew ? `, first seen ${relDays(s.generatedAt, i.firstSeen)}` : ""}.`);
1483
+ }
1484
+ const h = s.health;
1485
+ const latest = h.releases[0];
1486
+ const prev = h.releases[1];
1487
+ if (latest?.crashFreeRate != null && latest.sessions >= 20 && latest.crashFreeRate < .995) {
1488
+ const vs = prev?.crashFreeRate != null && prev.sessions >= 20 ? ` (${prev.version}: ${pctOne(prev.crashFreeRate)})` : "";
1489
+ out.push(`${latest.version} is ${pctOne(latest.crashFreeRate)} crash-free across ${plural(latest.sessions, "session")}${vs}.`);
1490
+ }
1491
+ const ep = h.endpoints[0];
1492
+ if (ep && ep.failuresRange > 0) out.push(`${ep.endpoint} is the most failing endpoint: ${plural(ep.failuresRange, "failed request")} in ${r.label}.`);
1493
+ const net = s.breakdowns.network.filter((r) => r.key !== "unknown");
1494
+ const netTotal = net.reduce((a, b) => a + b.errors, 0);
1495
+ if (net[0] && netTotal >= 20 && net[0].errors / netTotal > .6 && net[0].key !== "wifi") out.push(`${pct(net[0].errors / netTotal)} of errors happen on ${net[0].key}: check timeouts and retries on slow connections.`);
1496
+ const os = s.breakdowns.os;
1497
+ const osTotal = os.reduce((a, b) => a + b.errors, 0);
1498
+ if (os[0] && osTotal > 20 && os[0].errors / osTotal > .6) out.push(`${pct(os[0].errors / osTotal)} of errors in ${r.label} come from ${os[0].key}.`);
1499
+ return out;
1500
+ }
1501
+ function relDays(now, then) {
1502
+ const d = Math.floor((Date.parse(now) - Date.parse(then)) / DAY);
1503
+ return d === 0 ? "today" : d === 1 ? "yesterday" : `${d} days ago`;
1504
+ }
1505
+ async function buildIssueDetail(store, app, fingerprint, thresholds, now = Date.now(), opts = {}) {
1506
+ const issue = await store.getIssue(app, fingerprint);
1507
+ if (!issue) return null;
1508
+ const range = resolveRange(opts.range ?? {}, now);
1509
+ const hs = hours(now, 48);
1510
+ const [hourRows, dayRows, events, retention] = await Promise.all([
1511
+ store.getRollups(app, "issueHour", hs[0], hs[hs.length - 1]),
1512
+ store.getRollups(app, "issue", range.from, range.to),
1513
+ store.listIssueEvents(app, fingerprint, { limit: 200 }),
1514
+ retentionFor(store, app, opts.retentionDays, now)
1515
+ ]);
1516
+ const hourly = hs.map((hour) => ({
1517
+ hour,
1518
+ count: hourRows.filter((r) => r.key === fingerprint && r.day === hour).reduce((a, r) => a + r.errors, 0)
1519
+ }));
1520
+ const daily = daysBetween(range.from, range.to).map((day) => ({
1521
+ day,
1522
+ count: dayRows.filter((r) => r.key === fingerprint && r.day === day).reduce((a, r) => a + r.errors, 0)
1523
+ }));
1524
+ const count24h = hourly.slice(-24).reduce((a, h) => a + h.count, 0);
1525
+ const countRange = range.preset === "24h" ? count24h : daily.reduce((a, d) => a + d.count, 0);
1526
+ const split = (pick) => {
1527
+ const m = /* @__PURE__ */ new Map();
1528
+ for (const e of events) {
1529
+ const k = pick(e) || "unknown";
1530
+ m.set(k, (m.get(k) ?? 0) + 1);
1531
+ }
1532
+ return [...m.entries()].map(([key, count]) => ({
1533
+ key,
1534
+ count,
1535
+ share: events.length ? count / events.length : 0
1536
+ })).sort((a, b) => b.count - a.count).slice(0, 6);
1537
+ };
1538
+ const breakdowns = {
1539
+ os: split((e) => `${e.context.os.name} ${e.context.os.version ?? ""}`.trim()),
1540
+ appVersion: split((e) => e.context.app.version),
1541
+ deviceModel: split((e) => e.context.device.model),
1542
+ network: split((e) => e.context.network?.type),
1543
+ runtime: split((e) => [e.context.runtime.name, e.context.runtime.engine].filter(Boolean).join(" / "))
1544
+ };
1545
+ const usersSince = range.preset === "24h" ? dayKey(now - DAY) : range.from;
1546
+ const affectedUsers = await countUsersSafe(store, app, `issue:${fingerprint}`, usersSince) || new Set(events.map((e) => e.user?.id ?? e.user?.anonymousId ?? e.sessionId)).size;
1547
+ const row = toIssueRow(issue, count24h, countRange, thresholds);
1548
+ const hints = hintsFor(issue, breakdowns, events);
1549
+ const detail = {
1550
+ app,
1551
+ range,
1552
+ retention,
1553
+ issue: row,
1554
+ hourly,
1555
+ daily,
1556
+ breakdowns,
1557
+ affectedUsers,
1558
+ links: {},
1559
+ sample: events[0] ?? issue.lastEvent ?? null,
1560
+ recent: events.slice(0, 25).map((e) => ({
1561
+ ts: e.event.ts,
1562
+ os: `${e.context.os.name} ${e.context.os.version ?? ""}`.trim(),
1563
+ appVersion: e.context.app.version,
1564
+ device: e.context.device.model,
1565
+ message: e.event.type === "error" ? e.event.error.message : e.event.type === "event" ? e.event.name : e.event.type === "session" ? `session ${e.event.status}` : `requests to ${e.event.key}`,
1566
+ userId: e.user?.id
1567
+ })),
1568
+ hints
1569
+ };
1570
+ detail.links = trackerLinks(detail, opts.trackers ?? {});
1571
+ return detail;
1572
+ }
1573
+ /** The issue as a ticket: what, where, how often, what to look at. Kept short enough for a URL. */
1574
+ function issueStory(d, dashboardUrl) {
1575
+ const i = d.issue;
1576
+ const top = (rows) => rows.filter((r) => r.key !== "unknown").slice(0, 3).map((r) => `${r.key} (${Math.round(r.share * 100)}%)`).join(", ") || "n/a";
1577
+ const frames = d.sample?.event.type === "error" ? (d.sample.event.error.frames ?? []).filter((f) => f.inApp).slice(0, 3) : [];
1578
+ const body = [
1579
+ `**${i.title}**`,
1580
+ i.culprit ? `At \`${i.culprit}\`${i.flow ? ` in flow \`${i.flow}\`` : ""}.` : i.flow ? `In flow \`${i.flow}\`.` : "",
1581
+ "",
1582
+ `- ${i.countRange.toLocaleString()} occurrences in ${d.range.label}, ${i.count24h} in the last 24h (severity: ${i.severity})`,
1583
+ `- ${d.affectedUsers.toLocaleString()} users affected`,
1584
+ `- First seen ${i.firstSeen.slice(0, 10)}${i.firstVersion ? ` in ${i.firstVersion}` : ""}; last seen ${i.lastSeen.slice(0, 10)}${i.lastVersion ? ` in ${i.lastVersion}` : ""}`,
1585
+ `- Versions: ${top(d.breakdowns.appVersion)}`,
1586
+ `- OS: ${top(d.breakdowns.os)}; devices: ${top(d.breakdowns.deviceModel)}`,
1587
+ ...frames.length ? [
1588
+ "",
1589
+ "Stack (in-app frames):",
1590
+ ...frames.map((f) => `- \`${f.fn ?? "?"}\` ${f.file ?? ""}:${f.line ?? ""}`)
1591
+ ] : [],
1592
+ ...d.hints.length ? [
1593
+ "",
1594
+ "What to look at:",
1595
+ ...d.hints.slice(0, 3).map((h) => `- ${h.title}: ${h.detail}`)
1596
+ ] : [],
1597
+ ...dashboardUrl ? ["", `deBug: ${dashboardUrl.replace(/\/+$/, "")}/issues/${i.fingerprint}?app=${encodeURIComponent(d.app)}`] : []
1598
+ ].filter((l, n, all) => !(l === "" && all[n - 1] === "")).join("\n");
1599
+ return {
1600
+ title: `[deBug] ${i.title}`.slice(0, 200),
1601
+ body: body.slice(0, 3e3)
1602
+ };
1603
+ }
1604
+ function trackerLinks(d, t) {
1605
+ const { title, body } = issueStory(d, t.dashboardUrl);
1606
+ const q = (p) => new URLSearchParams(p).toString();
1607
+ return {
1608
+ ...t.linear || t.linearTeam ? { linear: `${t.linearTeam ? `https://linear.app/team/${encodeURIComponent(t.linearTeam)}/new` : "https://linear.new"}?${q({
1609
+ title,
1610
+ description: body
1611
+ })}` } : {},
1612
+ ...t.githubRepo && /^[\w.-]+\/[\w.-]+$/.test(t.githubRepo) ? { github: `https://github.com/${t.githubRepo}/issues/new?${q({
1613
+ title,
1614
+ body
1615
+ })}` } : {}
1616
+ };
1617
+ }
1618
+ /** Rule-based "what to look at" hints. Phase 2 replaces/augments these with an LLM over the same data. */
1619
+ function hintsFor(issue, b, events) {
1620
+ const hints = [];
1621
+ const text = `${issue.title} ${events[0]?.event.type === "error" ? events[0].event.error.stack ?? "" : ""}`.toLowerCase();
1622
+ const crumbs = events.flatMap((e) => e.event.type === "error" ? e.event.breadcrumbs ?? [] : []);
1623
+ const concentrated = (label, rows) => {
1624
+ const r = rows[0];
1625
+ if (r && r.key !== "unknown" && r.share >= .8 && events.length >= 5 && rows.length >= 1) hints.push({
1626
+ title: `Concentrated on ${label} ${r.key}`,
1627
+ detail: `${Math.round(r.share * 100)}% of recent occurrences. Reproduce on ${r.key} first, and check what changed for it.`
1628
+ });
1629
+ };
1630
+ concentrated("app version", b.appVersion);
1631
+ concentrated("OS", b.os);
1632
+ concentrated("device", b.deviceModel);
1633
+ if (/cannot read propert|undefined is not an object|of undefined|of null|is not a function/.test(text)) hints.push({
1634
+ title: "A value is missing when the code expects it",
1635
+ detail: `Something is null/undefined at ${issue.culprit ?? "the top frame"}. Check the data the previous step returns (API response shape, async state not yet loaded) and add a guard or loading state.`
1636
+ });
1637
+ if (/network request failed|failed to fetch|networkerror|timeout|timed out|econn|socket/.test(text)) hints.push({
1638
+ title: "Network failure",
1639
+ detail: "Check if errors line up with poor connectivity (see the network breakdown), add retries with backoff, and show an offline/timeout state instead of failing."
1640
+ });
1641
+ if (/\b401\b|\b403\b|unauthori[sz]ed|forbidden|token expired|jwt/.test(text)) hints.push({
1642
+ title: "Auth/session problem",
1643
+ detail: "Look for expired or missing tokens. Confirm the token refresh runs before this call, and that the clock/expiry handling is right."
1644
+ });
1645
+ if (/json|unexpected token|syntaxerror/.test(text)) hints.push({
1646
+ title: "Bad response body",
1647
+ detail: "The app tried to parse something that isn't the JSON it expected — often an HTML error page or an empty 204/5xx. Log the status and content-type before parsing."
1648
+ });
1649
+ if (/\b5\d\d\b|internal server error|bad gateway|service unavailable/.test(text)) hints.push({
1650
+ title: "Server-side failure",
1651
+ detail: "The backend returned a 5xx. Correlate the timestamps with your API logs."
1652
+ });
1653
+ const failingRequests = crumbs.filter((c) => c.category === "network" && (c.level === "error" || /\b[45]\d\d\b/.test(c.message)));
1654
+ if (failingRequests.length) {
1655
+ const m = /* @__PURE__ */ new Map();
1656
+ for (const c of failingRequests) m.set(c.message, (m.get(c.message) ?? 0) + 1);
1657
+ const [msg] = [...m.entries()].sort((a, b) => b[1] - a[1])[0];
1658
+ hints.push({
1659
+ title: "A request fails right before the error",
1660
+ detail: `Most common: ${msg}`
1661
+ });
1662
+ }
1663
+ if (hints.length === 0) hints.push({
1664
+ title: "Start at the culprit frame",
1665
+ detail: `Open ${issue.culprit ?? "the top stack frame"} and use the breadcrumbs below to replay what the user did.`
1666
+ });
1667
+ return hints;
1668
+ }
1669
+ export { getLocalWriteStore as A, restampStep as C, writeIssueStatus as D, validRetention as E, config as M, writeRetention as O, readSettings as S, testAlert as T, CORS_HEADERS as _, authorizeApi as a, hashInviteToken as b, demoLoginEnabled as c, forgetMember as d, hashPassword as f, tooManyAttempts as g, startSession as h, DEMO_USER as i, getStore as j, writeSettings as k, endSession as l, recordFailure as m, buildIssueDetail as n, canManage as o, readSession as p, buildSummary as r, checkCredentials as s, SUMMARY_FIELDS as t, envOwnerEmails as u, ingest as v, settingsWriter as w, teamAction as x, parseIngestKeys as y };