@sentry/junior-dashboard 0.58.0

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+import type { JuniorDashboardOptions } from "./app";
+export type JuniorDashboardRuntimeConfig = Omit<JuniorDashboardOptions, "auth" | "reporting">;
+/** Read dashboard runtime config injected by the Nitro module. */
+export declare function resolveDashboardConfig(): Promise<JuniorDashboardRuntimeConfig>;

package/dist/handler.d.ts

@@ -0,0 +1,2 @@
+declare const handler: unknown;
+export default handler;

package/dist/handler.js

@@ -0,0 +1,563 @@
+// src/handler.ts
+import { defineHandler } from "nitro";
+
+// src/app.ts
+import { Hono } from "hono";
+import { existsSync, readFileSync } from "fs";
+import path from "path";
+import { createJuniorReporting } from "@sentry/junior/reporting";
+import { initSentry } from "@sentry/junior/instrumentation";
+
+// src/auth.ts
+import { betterAuth } from "better-auth";
+var DEFAULT_SESSION_MAX_AGE_SECONDS = 60 * 60 * 8;
+function sanitizeDashboardSession(session) {
+  const { email, emailVerified, hostedDomain, name } = session.user;
+  return {
+    user: {
+      email,
+      emailVerified,
+      hostedDomain,
+      name
+    }
+  };
+}
+function required(value, name) {
+  if (!value?.trim()) {
+    throw new Error(`${name} is required for Junior dashboard auth`);
+  }
+  return value.trim();
+}
+function firstHostedDomain(domains) {
+  return domains.length === 1 ? domains[0] : void 0;
+}
+function withHttps(host) {
+  return /^https?:\/\//.test(host) ? host : `https://${host}`;
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 1 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function resolveBaseURL(config) {
+  const explicit = config.baseURL ?? process.env.BETTER_AUTH_URL ?? process.env.JUNIOR_BASE_URL;
+  if (explicit?.trim()) {
+    return stripTrailingSlashes(withHttps(explicit.trim()));
+  }
+  const vercelProd = process.env.VERCEL_PROJECT_PRODUCTION_URL?.trim();
+  if (vercelProd) {
+    return stripTrailingSlashes(withHttps(vercelProd));
+  }
+  const vercelUrl = process.env.VERCEL_URL?.trim();
+  if (vercelUrl) {
+    return stripTrailingSlashes(withHttps(vercelUrl));
+  }
+  return "http://localhost:3000";
+}
+function createDashboardAuth(config) {
+  const secret = required(
+    config.secret ?? process.env.BETTER_AUTH_SECRET ?? process.env.JUNIOR_SECRET,
+    "JUNIOR_SECRET or BETTER_AUTH_SECRET"
+  );
+  const baseURL = resolveBaseURL(config);
+  const googleClientId = required(
+    config.googleClientId ?? process.env.GOOGLE_CLIENT_ID,
+    "GOOGLE_CLIENT_ID"
+  );
+  const googleClientSecret = required(
+    config.googleClientSecret ?? process.env.GOOGLE_CLIENT_SECRET,
+    "GOOGLE_CLIENT_SECRET"
+  );
+  const auth = betterAuth({
+    appName: "Junior Dashboard",
+    baseURL,
+    basePath: config.authPath,
+    secret,
+    trustedOrigins: config.trustedOrigins,
+    socialProviders: {
+      google: {
+        clientId: googleClientId,
+        clientSecret: googleClientSecret,
+        hd: config.googleHostedDomain,
+        prompt: "select_account",
+        mapProfileToUser(profile) {
+          return {
+            email: profile.email,
+            emailVerified: profile.email_verified,
+            hostedDomain: profile.hd,
+            image: profile.picture,
+            name: profile.name
+          };
+        }
+      }
+    },
+    user: {
+      additionalFields: {
+        hostedDomain: {
+          type: "string",
+          required: false,
+          input: false,
+          returned: true
+        }
+      }
+    },
+    account: {
+      storeStateStrategy: "cookie",
+      storeAccountCookie: false,
+      updateAccountOnSignIn: false
+    },
+    session: {
+      expiresIn: config.sessionMaxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE_SECONDS,
+      disableSessionRefresh: true,
+      cookieCache: {
+        enabled: true,
+        strategy: "jwe",
+        maxAge: config.sessionMaxAgeSeconds ?? DEFAULT_SESSION_MAX_AGE_SECONDS,
+        refreshCache: false
+      }
+    }
+  });
+  return {
+    handler(request) {
+      return auth.handler(request);
+    },
+    async getSession(request) {
+      const session = await auth.api.getSession({ headers: request.headers });
+      if (!session) {
+        return null;
+      }
+      return sanitizeDashboardSession(session);
+    },
+    async signInWithGoogle(request, callbackURL) {
+      const result = await auth.api.signInSocial({
+        body: {
+          provider: "google",
+          callbackURL
+        },
+        headers: request.headers,
+        returnHeaders: true
+      });
+      if (!("url" in result.response) || !result.response.url) {
+        throw new Error("Google sign-in did not return a redirect URL");
+      }
+      result.headers.set("location", result.response.url);
+      return new Response(null, {
+        status: 302,
+        headers: result.headers
+      });
+    }
+  };
+}
+function resolveGoogleHostedDomainHint(domains) {
+  return firstHostedDomain(domains.map((domain) => domain.toLowerCase()));
+}
+
+// src/app.ts
+var DEFAULT_BASE_PATH = "/";
+var DEFAULT_AUTH_PATH = "/api/auth";
+var DASHBOARD_CLIENT_VERSION = Date.now().toString(36);
+function hasSentryConversationLinks() {
+  return Boolean(
+    process.env.SENTRY_DSN?.trim() && process.env.SENTRY_ORG_SLUG?.trim()
+  );
+}
+function normalizePath(path2, fallback) {
+  const value = path2.trim() || fallback;
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return stripTrailingSlashes2(withSlash);
+}
+function stripTrailingSlashes2(value) {
+  let end = value.length;
+  while (end > 1 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function normalizeValues(values) {
+  return [
+    ...new Set(
+      (values ?? []).map((value) => value.trim().toLowerCase()).filter(Boolean)
+    )
+  ];
+}
+function isJsonRoute(pathname) {
+  return pathname.startsWith("/api/");
+}
+function dashboardLoginUrl(request) {
+  const url = new URL(request.url);
+  url.pathname = "/api/dashboard/login";
+  url.search = "";
+  return url.toString();
+}
+function callbackUrl(request, basePath) {
+  const url = new URL(request.url);
+  url.pathname = basePath;
+  url.search = "";
+  return url.toString();
+}
+function isAuthorized(session, allowedDomains, allowedEmails) {
+  const email = session.user.email?.toLowerCase();
+  const domain = session.user.hostedDomain?.toLowerCase();
+  if (session.user.emailVerified && email && allowedEmails.includes(email)) {
+    return true;
+  }
+  return Boolean(
+    session.user.emailVerified && domain && allowedDomains.includes(domain)
+  );
+}
+function unauthorized(request) {
+  if (isJsonRoute(new URL(request.url).pathname)) {
+    return Response.json({ error: "unauthenticated" }, { status: 401 });
+  }
+  return Response.redirect(dashboardLoginUrl(request), 302);
+}
+function forbidden(request) {
+  if (!isJsonRoute(new URL(request.url).pathname)) {
+    return new Response(
+      `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Junior access denied</title>
+  <style>
+    ${readDashboardTailwind()}
+  </style>
+</head>
+<body class="m-0 bg-black font-sans text-white [color-scheme:dark]">
+  <main class="grid min-h-screen place-items-center p-8">
+    <section class="max-w-lg border-l-4 border-rose-400 pl-4">
+      <h1 class="m-0 mb-3 text-[1.75rem] font-bold leading-tight">Access denied</h1>
+      <p class="m-0 leading-relaxed text-[#b8b8b8]">Your Google account is authenticated, but it is not allowed to use this Junior dashboard.</p>
+    </section>
+  </main>
+</body>
+</html>`,
+      {
+        headers: {
+          "cache-control": "no-store",
+          "content-type": "text/html; charset=utf-8"
+        },
+        status: 403
+      }
+    );
+  }
+  return Response.json({ error: "forbidden" }, { status: 403 });
+}
+function dashboardSessionBypass() {
+  return {
+    user: {
+      email: "local-dashboard@localhost",
+      emailVerified: true,
+      hostedDomain: "localhost"
+    }
+  };
+}
+function readDashboardAsset(fileName) {
+  const localDistUrl = new URL(`./${fileName}`, import.meta.url);
+  if (existsSync(localDistUrl)) {
+    return readFileSync(localDistUrl, "utf8");
+  }
+  const sourceDistUrl = new URL(`../dist/${fileName}`, import.meta.url);
+  if (existsSync(sourceDistUrl)) {
+    return readFileSync(sourceDistUrl, "utf8");
+  }
+  const workspacePackagePath = path.join(
+    process.cwd(),
+    "node_modules",
+    "@sentry",
+    "junior-dashboard",
+    "dist",
+    fileName
+  );
+  if (existsSync(workspacePackagePath)) {
+    return readFileSync(workspacePackagePath, "utf8");
+  }
+  return "";
+}
+function readDashboardClient() {
+  const client = readDashboardAsset("client.js");
+  if (!client) {
+    throw new Error("Junior dashboard client bundle was not found");
+  }
+  return client;
+}
+function dashboardTimeZone() {
+  return process.env.JUNIOR_TIMEZONE || "America/Los_Angeles";
+}
+function readDashboardTailwind() {
+  return readDashboardAsset("tailwind.css");
+}
+function dashboardPagePaths(basePath) {
+  return [
+    basePath,
+    basePath === "/" ? "/conversations" : `${basePath}/conversations`,
+    basePath === "/" ? "/sessions" : `${basePath}/sessions`
+  ];
+}
+function renderDashboard(basePath) {
+  return new Response(
+    `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Junior</title>
+  <style>
+    ${readDashboardTailwind()}
+  </style>
+</head>
+<body class="m-0 bg-black text-white [color-scheme:dark]">
+  <div id="dashboard-root"></div>
+  <script>
+    window.__JUNIOR_DASHBOARD_BASE_PATH__ = ${JSON.stringify(basePath)};
+    (function () {
+      function escapeHtml(value) {
+        return String(value)
+          .replace(/&/g, "&amp;")
+          .replace(/</g, "&lt;")
+          .replace(/>/g, "&gt;")
+          .replace(/"/g, "&quot;")
+          .replace(/'/g, "&#039;");
+      }
+      function errorText(error) {
+        if (!error) return "Unknown dashboard error";
+        if (typeof error === "string") return error;
+        if (error.stack) return error.stack;
+        if (error.message) return error.message;
+        try {
+          return JSON.stringify(error, null, 2);
+        } catch (_error) {
+          return String(error);
+        }
+      }
+      window.__JUNIOR_DASHBOARD_SHOW_ERROR__ = function (error) {
+        var root = document.getElementById("dashboard-root");
+        if (!root) return;
+        root.innerHTML =
+          '<main class="grid min-h-screen place-items-center bg-black p-8 text-white">' +
+          '<section class="w-full max-w-5xl border border-rose-400/50 bg-[#0b0b0b] p-5 font-sans">' +
+          '<div class="font-mono text-xs uppercase leading-none text-[#888]">Dashboard Error</div>' +
+          '<h1 class="mt-2 text-3xl font-bold leading-tight tracking-normal">Junior failed to render</h1>' +
+          '<p class="my-4 max-w-3xl text-[#b8b8b8]">The dashboard hit a client-side exception. The stack trace is shown here so the page does not fail blank.</p>' +
+          '<pre class="max-h-[60vh] overflow-auto whitespace-pre-wrap break-words border border-white/10 bg-black p-4 font-mono text-sm leading-relaxed text-white">' +
+          escapeHtml(errorText(error)) +
+          "</pre></section></main>";
+      };
+      window.addEventListener("error", function (event) {
+        window.__JUNIOR_DASHBOARD_SHOW_ERROR__(event.error || event.message);
+      });
+      window.addEventListener("unhandledrejection", function (event) {
+        window.__JUNIOR_DASHBOARD_SHOW_ERROR__(event.reason);
+      });
+    })();
+  </script>
+  <script type="module" src="/api/dashboard/client.js?v=${DASHBOARD_CLIENT_VERSION}"></script>
+</body>
+</html>`,
+    {
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "text/html; charset=utf-8"
+      }
+    }
+  );
+}
+function renderFavicon() {
+  return new Response(
+    `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32"><rect width="32" height="32" fill="#000000"/><text x="16" y="20.5" fill="#ffffff" font-family="ui-monospace, SFMono-Regular, Menlo, Consolas, monospace" font-size="11" font-weight="900" text-anchor="middle">Jr</text></svg>`,
+    { headers: { "content-type": "image/svg+xml" } }
+  );
+}
+function createDashboardApp(options) {
+  if (process.env.SENTRY_DSN?.trim()) {
+    initSentry();
+  }
+  const basePath = normalizePath(
+    options.basePath ?? DEFAULT_BASE_PATH,
+    DEFAULT_BASE_PATH
+  );
+  const authPath = normalizePath(
+    options.authPath ?? DEFAULT_AUTH_PATH,
+    DEFAULT_AUTH_PATH
+  );
+  const allowedDomains = normalizeValues(options.allowedGoogleDomains);
+  const allowedEmails = normalizeValues(options.allowedEmails);
+  const authRequired = options.authRequired !== false;
+  if (authRequired && allowedDomains.length === 0 && allowedEmails.length === 0) {
+    throw new Error(
+      "Junior dashboard auth requires allowedGoogleDomains or allowedEmails"
+    );
+  }
+  const auth = authRequired ? options.auth ?? createDashboardAuth({
+    authPath,
+    trustedOrigins: options.trustedOrigins ?? [],
+    googleHostedDomain: resolveGoogleHostedDomainHint(allowedDomains),
+    sessionMaxAgeSeconds: options.sessionMaxAgeSeconds
+  }) : void 0;
+  const reporting = options.reporting ?? createJuniorReporting();
+  const app2 = new Hono();
+  if (auth) {
+    app2.on(["GET", "POST"], `${authPath}/*`, (c) => auth.handler(c.req.raw));
+  }
+  app2.get("/favicon.ico", () => renderFavicon());
+  app2.get("/api/dashboard/login", async (c) => {
+    if (!auth) {
+      return Response.redirect(callbackUrl(c.req.raw, basePath), 302);
+    }
+    return auth.signInWithGoogle(c.req.raw, callbackUrl(c.req.raw, basePath));
+  });
+  const requireDashboardSession = async (c, next) => {
+    if (!authRequired) {
+      c.set("dashboardSession", dashboardSessionBypass());
+      await next();
+      return;
+    }
+    if (!auth) {
+      return unauthorized(c.req.raw);
+    }
+    const session = await auth.getSession(c.req.raw);
+    if (!session) {
+      return unauthorized(c.req.raw);
+    }
+    if (!isAuthorized(session, allowedDomains, allowedEmails)) {
+      return forbidden(c.req.raw);
+    }
+    c.set("dashboardSession", sanitizeDashboardSession(session));
+    await next();
+  };
+  if (basePath === "/") {
+    app2.use("/*", requireDashboardSession);
+  } else {
+    app2.use(basePath, requireDashboardSession);
+    app2.use(`${basePath}/*`, requireDashboardSession);
+  }
+  app2.use("/api/dashboard/*", requireDashboardSession);
+  for (const path2 of dashboardPagePaths(basePath)) {
+    app2.get(path2, () => renderDashboard(basePath));
+    if (path2 !== "/") {
+      app2.get(`${path2}/*`, () => renderDashboard(basePath));
+    }
+  }
+  app2.get("/api/dashboard/health", async () => {
+    return Response.json(await reporting.getHealth());
+  });
+  app2.get("/api/dashboard/runtime", async () => {
+    return Response.json(await reporting.getRuntimeInfo());
+  });
+  app2.get("/api/dashboard/plugins", async () => {
+    return Response.json(await reporting.getPlugins());
+  });
+  app2.get("/api/dashboard/skills", async () => {
+    return Response.json(await reporting.getSkills());
+  });
+  app2.get("/api/dashboard/sessions", async () => {
+    return Response.json(await reporting.getSessions());
+  });
+  app2.get("/api/dashboard/conversations/:conversationId", async (c) => {
+    return Response.json(
+      await reporting.getConversation(
+        decodeURIComponent(c.req.param("conversationId"))
+      )
+    );
+  });
+  app2.get("/api/dashboard/config", () => {
+    return Response.json({
+      allowedEmailCount: allowedEmails.length,
+      allowedGoogleDomainCount: allowedDomains.length,
+      authRequired,
+      authPath,
+      basePath,
+      sentryConversationLinks: hasSentryConversationLinks(),
+      timeZone: dashboardTimeZone()
+    });
+  });
+  app2.get("/api/dashboard/me", (c) => {
+    return Response.json(c.get("dashboardSession"));
+  });
+  app2.get("/api/dashboard/info", async () => {
+    return Response.json(await reporting.getRuntimeInfo());
+  });
+  app2.get("/api/dashboard/client.js", () => {
+    return new Response(readDashboardClient(), {
+      headers: {
+        "cache-control": "no-store",
+        "content-type": "application/javascript; charset=utf-8"
+      }
+    });
+  });
+  return app2;
+}
+
+// src/config.ts
+async function resolveDashboardConfig() {
+  try {
+    const mod = await import("#junior-dashboard/config");
+    return mod.dashboard ?? readEnvConfig();
+  } catch (error) {
+    if (!isMissingVirtualConfig(error)) {
+      throw error;
+    }
+    return readEnvConfig();
+  }
+}
+function readEnvConfig() {
+  return {
+    authRequired: process.env.JUNIOR_DASHBOARD_AUTH_REQUIRED !== "false",
+    allowedGoogleDomains: readListEnv("JUNIOR_DASHBOARD_GOOGLE_DOMAINS"),
+    allowedEmails: readListEnv("JUNIOR_DASHBOARD_ALLOWED_EMAILS"),
+    trustedOrigins: readListEnv("JUNIOR_DASHBOARD_TRUSTED_ORIGINS")
+  };
+}
+function readListEnv(name) {
+  const value = process.env[name];
+  if (!value?.trim()) {
+    return [];
+  }
+  if (value.trim().startsWith("[")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(value);
+    } catch (error) {
+      throw new Error(`${name} must be a JSON string array`, {
+        cause: error
+      });
+    }
+    if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+      throw new Error(`${name} must be a JSON string array`);
+    }
+    return parsed;
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function isMissingVirtualConfig(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const code = error.code;
+  return (code === "ERR_PACKAGE_IMPORT_NOT_DEFINED" || code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && error.message.includes("#junior-dashboard/config");
+}
+
+// src/handler.ts
+var app;
+var appPromise;
+async function resolveApp() {
+  appPromise ??= resolveDashboardConfig().then((config) => {
+    app = createDashboardApp(config);
+    return app;
+  }).catch((error) => {
+    appPromise = void 0;
+    throw error;
+  });
+  return app ?? appPromise;
+}
+var handler = defineHandler(async (event) => {
+  const dashboardApp = await resolveApp();
+  return dashboardApp.fetch(event.req);
+});
+var handler_default = handler;
+export {
+  handler_default as default
+};

package/dist/nitro.d.ts

@@ -0,0 +1,16 @@
+export interface JuniorDashboardNitroOptions {
+    basePath?: string;
+    authPath?: string;
+    authRequired?: boolean;
+    allowedGoogleDomains?: string[];
+    allowedEmails?: string[];
+    trustedOrigins?: string[];
+    sessionMaxAgeSeconds?: number;
+    disabled?: boolean;
+}
+/** Mount the authenticated Junior dashboard into a Nitro deployment. */
+export declare function juniorDashboardNitro(options: JuniorDashboardNitroOptions): {
+    nitro: {
+        setup(nitro: unknown): void;
+    };
+};

package/dist/nitro.js

@@ -0,0 +1,80 @@
+// src/nitro.ts
+function normalizePath(path, fallback) {
+  const value = path?.trim() || fallback;
+  const withSlash = value.startsWith("/") ? value : `/${value}`;
+  return stripTrailingSlashes(withSlash);
+}
+function stripTrailingSlashes(value) {
+  let end = value.length;
+  while (end > 1 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return end === value.length ? value : value.slice(0, end);
+}
+function routeEntry(handler) {
+  return { handler };
+}
+function virtualHandler(config) {
+  return `import { defineHandler } from "nitro";
+import { createDashboardApp } from "@sentry/junior-dashboard";
+
+let app;
+
+export default defineHandler(async (event) => {
+  app ??= createDashboardApp(${JSON.stringify(config)});
+  return app.fetch(event.req);
+});
+`;
+}
+function dashboardPageRoutes(basePath, handler) {
+  const sessionsPath = basePath === "/" ? "/sessions" : `${basePath}/sessions`;
+  const conversationsPath = basePath === "/" ? "/conversations" : `${basePath}/conversations`;
+  if (basePath === "/") {
+    return {
+      "/": routeEntry(handler),
+      [conversationsPath]: routeEntry(handler),
+      [`${conversationsPath}/**`]: routeEntry(handler),
+      [sessionsPath]: routeEntry(handler),
+      [`${sessionsPath}/**`]: routeEntry(handler)
+    };
+  }
+  return {
+    [basePath]: routeEntry(handler),
+    [`${basePath}/**`]: routeEntry(handler)
+  };
+}
+function juniorDashboardNitro(options) {
+  return {
+    nitro: {
+      setup(nitro) {
+        if (options.disabled) {
+          return;
+        }
+        const basePath = normalizePath(options.basePath, "/");
+        const authPath = normalizePath(options.authPath, "/api/auth");
+        const handler = "#junior-dashboard/handler";
+        const dashboardConfig = {
+          ...options,
+          basePath,
+          authPath,
+          disabled: void 0
+        };
+        nitro.options.virtual[handler] = virtualHandler(dashboardConfig);
+        nitro.options.virtual["#junior-dashboard/config"] = `export const dashboard = ${JSON.stringify(dashboardConfig)};`;
+        const dashboardRoutes = {
+          ...dashboardPageRoutes(basePath, handler),
+          "/api/dashboard/**": routeEntry(handler),
+          [authPath]: routeEntry(handler),
+          [`${authPath}/**`]: routeEntry(handler)
+        };
+        nitro.options.routes = {
+          ...dashboardRoutes,
+          ...nitro.options.routes ?? {}
+        };
+      }
+    }
+  };
+}
+export {
+  juniorDashboardNitro
+};