@debugkit/dashboard 0.5.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.
- package/.env.example +3 -0
- package/dist/client/assets/_authed-BMdIkvB6.js +7 -0
- package/dist/client/assets/_authed-Rg-Gabby.js +1 -0
- package/dist/client/assets/{charts-C0zeGTzu.js → charts-QIIL2Fv7.js} +6 -6
- package/dist/client/assets/index-CMjwqklY.js +10 -0
- package/dist/client/assets/invite._token-CDogkC9p.js +1 -0
- package/dist/client/assets/issues._fingerprint-DLe_lV5d.js +1 -0
- package/dist/client/assets/login-BG9v4zhc.js +1 -0
- package/dist/client/assets/{preload-helper-CDziuvpw.js → preload-helper-Dscj_TcA.js} +1 -1
- package/dist/client/assets/settings-Ce1uqKl0.js +1 -0
- package/dist/client/assets/styles-DztngwT9.css +2 -0
- package/dist/client/assets/team-TUMAZ4jv.js +1 -0
- package/dist/client/assets/{ui-BiRMJGWB.js → ui-C0HGOza2.js} +1 -1
- package/dist/server/assets/{_authed-DODQ_Iys.js → _authed-DDQ5yYfy.js} +31 -18
- package/dist/server/assets/{_authed-CuDay0Tl.js → _authed-Dray_9Ct.js} +1 -1
- package/dist/server/assets/{_tanstack-start-manifest_v-BBxgjm04.js → _tanstack-start-manifest_v-BItoYCqL.js} +19 -7
- package/dist/server/assets/{demo-hrRBo9_U.js → demo-BsMMDk_F.js} +2 -2
- package/dist/server/assets/{dynamodb-DyPK9SVV.js → dynamodb-Zkk1-mgz.js} +93 -2
- package/dist/server/assets/{firestore-B2xzpzYA.js → firestore-C52q_vwM.js} +43 -2
- package/dist/server/assets/{fns-DPsnK0zS.js → fns-DwGaMi8S.js} +30 -2
- package/dist/server/assets/fns-mbUIXXep.js +529 -0
- package/dist/server/assets/invite._token-BWiwnST7.js +136 -0
- package/dist/server/assets/{issues._fingerprint-CZCZDm7t.js → issues._fingerprint-D9vjIk3M.js} +2 -2
- package/dist/server/assets/{login-D-UG6SFw.js → login-BXi46U4B.js} +2 -2
- package/dist/server/assets/{memory-Do0CDoAX.js → memory-BssaqdZm.js} +30 -0
- package/dist/server/assets/{queries-CxHrgTdM.js → queries-BJxX3Kjp.js} +744 -30
- package/dist/server/assets/{router-CIIGBCmL.js → router-m6Hpq6Ep.js} +58 -35
- package/dist/server/assets/{settings-BHfngShx.js → settings-ByFLIJce.js} +2 -2
- package/dist/server/assets/src-D83GYTrp.js +9 -0
- package/dist/server/assets/team-CifrrNkf.js +255 -0
- package/dist/server/server.js +42 -14
- package/handler.mjs +95 -0
- package/lambda.mjs +61 -0
- package/package.json +16 -7
- package/server.mjs +4 -39
- package/dist/client/assets/_authed-DTn7rMla.js +0 -1
- package/dist/client/assets/_authed-Dc7covsB.js +0 -7
- package/dist/client/assets/index-D12jr1bm.js +0 -10
- package/dist/client/assets/issues._fingerprint-C6ryZvIu.js +0 -1
- package/dist/client/assets/login-oLP1Yyz3.js +0 -1
- package/dist/client/assets/settings-9oQsCwdV.js +0 -1
- package/dist/client/assets/styles-DBg7wMRg.css +0 -2
- package/dist/server/assets/fns-hk_OJe6M.js +0 -250
- package/dist/server/assets/src-D9VHcuh4.js +0 -491
- package/dist/server/assets/src-JXktBs5H.js +0 -4
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { a as getCookie, i as deleteCookie, o as getRequestHeader, s as setCookie } from "../server.js";
|
|
2
|
-
import { a as SEVERITY_ORDER, d as severityFromCount, i as DEFAULT_SEVERITY_THRESHOLDS, l as percentileMs, o as compareVersions } from "./memory-
|
|
3
|
-
import { t as MAX_RETENTION_DAYS } from "./src-
|
|
4
|
-
import { createHmac, randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
|
|
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
5
|
// src/server/config.ts
|
|
6
6
|
var loaded = false;
|
|
7
7
|
function loadEnv() {
|
|
@@ -49,7 +49,9 @@ function config() {
|
|
|
49
49
|
githubRepo: env.DEBUG_GITHUB_REPO || void 0,
|
|
50
50
|
dashboardUrl: env.DEBUG_DASHBOARD_URL || void 0
|
|
51
51
|
},
|
|
52
|
-
secureCookies: env.NODE_ENV === "production" && env.DEBUG_INSECURE_COOKIES !== "1"
|
|
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"
|
|
53
55
|
};
|
|
54
56
|
}
|
|
55
57
|
// src/server/store.ts
|
|
@@ -73,22 +75,22 @@ async function create() {
|
|
|
73
75
|
case "firestore": {
|
|
74
76
|
const { initializeApp, getApps } = await import("firebase-admin/app");
|
|
75
77
|
const { getFirestore } = await import("firebase-admin/firestore");
|
|
76
|
-
const { FirestoreStore } = await import("./firestore-
|
|
78
|
+
const { FirestoreStore } = await import("./firestore-C52q_vwM.js");
|
|
77
79
|
if (!getApps().length) initializeApp();
|
|
78
80
|
return new FirestoreStore(getFirestore(), { root: cfg.firestoreRoot });
|
|
79
81
|
}
|
|
80
82
|
case "dynamodb": {
|
|
81
83
|
const { DynamoDBClient } = await import("@aws-sdk/client-dynamodb");
|
|
82
84
|
const { DynamoDBDocumentClient } = await import("@aws-sdk/lib-dynamodb");
|
|
83
|
-
const { DynamoStore } = await import("./dynamodb-
|
|
85
|
+
const { DynamoStore } = await import("./dynamodb-Zkk1-mgz.js");
|
|
84
86
|
return new DynamoStore(DynamoDBDocumentClient.from(new DynamoDBClient({})), { table: cfg.dynamoTable });
|
|
85
87
|
}
|
|
86
88
|
case "memory": {
|
|
87
|
-
const { MemoryStore } = await import("./memory-
|
|
89
|
+
const { MemoryStore } = await import("./memory-BssaqdZm.js").then((n) => n.n);
|
|
88
90
|
return new MemoryStore();
|
|
89
91
|
}
|
|
90
92
|
default: {
|
|
91
|
-
const { seedDemo } = await import("./demo-
|
|
93
|
+
const { seedDemo } = await import("./demo-BsMMDk_F.js");
|
|
92
94
|
return seedDemo();
|
|
93
95
|
}
|
|
94
96
|
}
|
|
@@ -234,14 +236,643 @@ async function restampStep(app, cursor) {
|
|
|
234
236
|
}
|
|
235
237
|
throw new Error("Settings can't be changed from this dashboard.");
|
|
236
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
|
+
};
|
|
237
866
|
// src/server/auth.ts
|
|
238
|
-
var
|
|
867
|
+
var cookie = () => config().cookieName;
|
|
239
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;
|
|
240
871
|
var DEMO_USER = {
|
|
241
872
|
email: "demo@debug.local",
|
|
242
873
|
password: "demo-debug"
|
|
243
874
|
};
|
|
244
|
-
function
|
|
875
|
+
function envUsers() {
|
|
245
876
|
const cfg = config();
|
|
246
877
|
const map = /* @__PURE__ */ new Map();
|
|
247
878
|
for (const pair of cfg.users.split(",").map((s) => s.trim()).filter(Boolean)) {
|
|
@@ -250,9 +881,17 @@ function users() {
|
|
|
250
881
|
}
|
|
251
882
|
return map;
|
|
252
883
|
}
|
|
884
|
+
/** Emails of the bootstrap logins (always owners). */
|
|
885
|
+
var envOwnerEmails = () => demoLoginEnabled() ? [DEMO_USER.email] : [...envUsers().keys()];
|
|
253
886
|
function demoLoginEnabled() {
|
|
254
|
-
return config().store === "demo" &&
|
|
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")}`;
|
|
255
893
|
}
|
|
894
|
+
var DUMMY = "scrypt.00000000000000000000000000000000." + "00".repeat(64);
|
|
256
895
|
function verifyHash(password, stored) {
|
|
257
896
|
const [algo, saltHex, hashHex] = stored.split(".");
|
|
258
897
|
if (algo !== "scrypt" || !saltHex || !hashHex) return false;
|
|
@@ -260,20 +899,66 @@ function verifyHash(password, stored) {
|
|
|
260
899
|
const actual = scryptSync(password, Buffer.from(saltHex, "hex"), expected.length);
|
|
261
900
|
return timingSafeEqual(actual, expected);
|
|
262
901
|
}
|
|
263
|
-
|
|
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) {
|
|
264
930
|
const e = email.trim().toLowerCase();
|
|
265
|
-
if (demoLoginEnabled()
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
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;
|
|
269
952
|
}
|
|
270
953
|
var sign = (payload) => createHmac("sha256", config().sessionSecret).update(payload).digest("base64url");
|
|
271
954
|
function startSession(user) {
|
|
272
955
|
const payload = Buffer.from(JSON.stringify({
|
|
273
956
|
email: user.email,
|
|
274
|
-
exp: Date.now() + MAX_AGE_S * 1e3
|
|
957
|
+
exp: Date.now() + MAX_AGE_S * 1e3,
|
|
958
|
+
s: user.source,
|
|
959
|
+
v: user.v
|
|
275
960
|
})).toString("base64url");
|
|
276
|
-
setCookie(
|
|
961
|
+
setCookie(cookie(), `${payload}.${sign(payload)}`, {
|
|
277
962
|
httpOnly: true,
|
|
278
963
|
sameSite: "lax",
|
|
279
964
|
secure: config().secureCookies,
|
|
@@ -282,27 +967,44 @@ function startSession(user) {
|
|
|
282
967
|
});
|
|
283
968
|
}
|
|
284
969
|
function endSession() {
|
|
285
|
-
deleteCookie(
|
|
970
|
+
deleteCookie(cookie(), { path: "/" });
|
|
286
971
|
}
|
|
287
|
-
function readSession() {
|
|
288
|
-
const raw = getCookie(
|
|
972
|
+
async function readSession() {
|
|
973
|
+
const raw = getCookie(cookie());
|
|
289
974
|
if (!raw) return null;
|
|
290
975
|
const [payload, sig] = raw.split(".");
|
|
291
976
|
if (!payload || !sig) return null;
|
|
292
977
|
const expected = Buffer.from(sign(payload));
|
|
293
978
|
const given = Buffer.from(sig);
|
|
294
979
|
if (expected.length !== given.length || !timingSafeEqual(expected, given)) return null;
|
|
980
|
+
let data;
|
|
295
981
|
try {
|
|
296
|
-
|
|
297
|
-
if (Date.now() > data.exp) return null;
|
|
298
|
-
return { email: data.email };
|
|
982
|
+
data = JSON.parse(Buffer.from(payload, "base64url").toString());
|
|
299
983
|
} catch {
|
|
300
984
|
return null;
|
|
301
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
|
+
};
|
|
302
1003
|
}
|
|
1004
|
+
var canManage = (u) => u?.role === "owner" || u?.role === "admin";
|
|
303
1005
|
/** For /api/* routes: a browser session or `Authorization: Bearer $DEBUG_API_TOKEN`. */
|
|
304
|
-
function authorizeApi(request) {
|
|
305
|
-
if (readSession()) return true;
|
|
1006
|
+
async function authorizeApi(request) {
|
|
1007
|
+
if (await readSession()) return true;
|
|
306
1008
|
const token = config().apiToken;
|
|
307
1009
|
const header = request.headers.get("authorization") ?? getRequestHeader("authorization") ?? "";
|
|
308
1010
|
if (!token || !header.startsWith("Bearer ")) return false;
|
|
@@ -379,6 +1081,18 @@ function weekOf(day) {
|
|
|
379
1081
|
return dayKey$1(t - (new Date(t).getUTCDay() + 6) % 7 * DAY$1);
|
|
380
1082
|
}
|
|
381
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
|
+
}
|
|
382
1096
|
var DAY = 864e5;
|
|
383
1097
|
var HOUR = 36e5;
|
|
384
1098
|
var dayKey = (t) => new Date(t).toISOString().slice(0, 10);
|
|
@@ -470,7 +1184,7 @@ async function buildSummary(store, appParam, thresholds, now = Date.now(), opts
|
|
|
470
1184
|
const criticalFlows = appSettings?.criticalFlows ?? [];
|
|
471
1185
|
const critical = new Set(criticalFlows);
|
|
472
1186
|
const usersSince = hourly ? dayKey(now - DAY) : from;
|
|
473
|
-
const [users, crashedUsers] = await Promise.all([store
|
|
1187
|
+
const [users, crashedUsers] = await Promise.all([countUsersSafe(store, app, "app", usersSince), countUsersSafe(store, app, "crash", usersSince)]);
|
|
474
1188
|
const last24 = new Set(h24);
|
|
475
1189
|
let errors24h = 0;
|
|
476
1190
|
let errorsPrev24h = 0;
|
|
@@ -517,7 +1231,7 @@ async function buildSummary(store, appParam, thresholds, now = Date.now(), opts
|
|
|
517
1231
|
const latestVersion = versionsInRange[versionsInRange.length - 1] ?? null;
|
|
518
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);
|
|
519
1233
|
const active = issueRows.filter((i) => i.status !== "ignored" && i.status !== "resolved");
|
|
520
|
-
await Promise.all(active.slice(0, 10).map(async (i) => i.users = await store
|
|
1234
|
+
await Promise.all(active.slice(0, 10).map(async (i) => i.users = await countUsersSafe(store, app, `issue:${i.fingerprint}`, usersSince)));
|
|
521
1235
|
const firstDay = /* @__PURE__ */ new Map();
|
|
522
1236
|
for (const r of releaseRows) {
|
|
523
1237
|
const cur = firstDay.get(r.key);
|
|
@@ -829,7 +1543,7 @@ async function buildIssueDetail(store, app, fingerprint, thresholds, now = Date.
|
|
|
829
1543
|
runtime: split((e) => [e.context.runtime.name, e.context.runtime.engine].filter(Boolean).join(" / "))
|
|
830
1544
|
};
|
|
831
1545
|
const usersSince = range.preset === "24h" ? dayKey(now - DAY) : range.from;
|
|
832
|
-
const affectedUsers = await store
|
|
1546
|
+
const affectedUsers = await countUsersSafe(store, app, `issue:${fingerprint}`, usersSince) || new Set(events.map((e) => e.user?.id ?? e.user?.anonymousId ?? e.sessionId)).size;
|
|
833
1547
|
const row = toIssueRow(issue, count24h, countRange, thresholds);
|
|
834
1548
|
const hints = hintsFor(issue, breakdowns, events);
|
|
835
1549
|
const detail = {
|
|
@@ -952,4 +1666,4 @@ function hintsFor(issue, b, events) {
|
|
|
952
1666
|
});
|
|
953
1667
|
return hints;
|
|
954
1668
|
}
|
|
955
|
-
export { writeRetention as _, authorizeApi as a,
|
|
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 };
|