@sentry/junior 0.1.0 → 0.2.0

package/README.md

@@ -2,11 +2,6 @@
 
 `@sentry/junior` is a Slack bot package for Next.js apps.
 
-If you are contributing to this monorepo, use the root docs:
-
-- `README.md` for general usage
-- `CONTRIBUTING.md` for development workflows
-
 ## Install
 
 ```bash
@@ -14,18 +9,7 @@ pnpm add @sentry/junior
 pnpm add next react react-dom @sentry/nextjs
 ```
 
-## Required App Files
-
-Add these files under `app/`:
-
-```text
-app/SOUL.md
-app/ABOUT.md
-app/skills/
-app/plugins/ (optional)
-```
-
-## Next.js Integration
+## Quick usage
 
 `app/api/[...path]/route.js`:
 
@@ -48,44 +32,11 @@ import { withJunior } from "@sentry/junior/config";
 export default withJunior();
 ```
 
-`instrumentation.js`:
-
-```js
-export { register, onRequestError } from "@sentry/junior/instrumentation";
-```
-
-If your app does not already include a root layout:
+## Full docs
 
-`app/layout.js`:
+Canonical docs: **https://junior.sentry.dev/**
 
-```js
-export { default } from "@sentry/junior/app/layout";
-```
-
-## Scaffold a New Bot
-
-```bash
-npx junior init my-bot
-cd my-bot
-pnpm install
-pnpm dev
-```
-
-## Vercel Queue Trigger
-
-Add this `vercel.json` function trigger:
-
-```json
-{
-  "functions": {
-    "app/api/queue/callback/route.js": {
-      "experimentalTriggers": [
-        {
-          "type": "queue/v2beta",
-          "topic": "junior-thread-message"
-        }
-      ]
-    }
-  }
-}
-```
+- Quickstart: https://junior.sentry.dev/start-here/quickstart/
+- Deployment: https://junior.sentry.dev/start-here/deploy/
+- Plugin setup: https://junior.sentry.dev/extend/plugins-overview/
+- API reference: https://junior.sentry.dev/reference/api/

package/bin/junior.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import fs from "node:fs";
 import path from "node:path";
 import { parseArgs } from "node:util";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 const { positionals } = parseArgs({
   allowPositionals: true,
@@ -11,138 +11,48 @@ const { positionals } = parseArgs({
 
 const command = positionals[0];
 
-function writeWrapperFiles(targetDir) {
-  // app/api/[...path]/route.js
-  const routeDir = path.join(targetDir, "app", "api", "[...path]");
-  fs.mkdirSync(routeDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(routeDir, "route.js"),
-    'export { GET, POST } from "@sentry/junior/handler";\n' +
-      'export const runtime = "nodejs";\n'
-  );
-
-  // app/api/queue/callback/route.js
-  const queueRouteDir = path.join(targetDir, "app", "api", "queue", "callback");
-  fs.mkdirSync(queueRouteDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(queueRouteDir, "route.js"),
-    'export { POST } from "@sentry/junior/handlers/queue-callback";\n' +
-      'export const runtime = "nodejs";\n'
-  );
-
-  // app/layout.js
-  fs.mkdirSync(path.join(targetDir, "app"), { recursive: true });
-  fs.writeFileSync(
-    path.join(targetDir, "app", "layout.js"),
-    'export { default } from "@sentry/junior/app/layout";\n'
-  );
+async function loadCliFunction(moduleName, exportName, unavailableMessage) {
+  const currentFile = fileURLToPath(import.meta.url);
+  const modulePath = path.join(path.dirname(currentFile), "..", "dist", "cli", `${moduleName}.js`);
+  const moduleUrl = pathToFileURL(modulePath).href;
+  const loadedModule = await import(moduleUrl);
+  if (typeof loadedModule[exportName] !== "function") {
+    throw new Error(unavailableMessage);
+  }
+  return loadedModule[exportName];
+}
 
-  // next.config.mjs
-  fs.writeFileSync(
-    path.join(targetDir, "next.config.mjs"),
-    'import { withJunior } from "@sentry/junior/config";\n' +
-      'export default withJunior();\n'
+async function runSnapshotCreate() {
+  const runSnapshotCreateFn = await loadCliFunction(
+    "snapshot-warmup",
+    "runSnapshotCreate",
+    "Snapshot create module is unavailable; reinstall @sentry/junior and retry."
   );
+  await runSnapshotCreateFn();
+}
 
-  // instrumentation.js
-  fs.writeFileSync(
-    path.join(targetDir, "instrumentation.js"),
-    'export { register, onRequestError } from "@sentry/junior/instrumentation";\n'
-  );
+async function runInit(dir) {
+  const runInitFn = await loadCliFunction("init", "runInit", "Init module is unavailable; reinstall @sentry/junior and retry.");
+  await runInitFn(dir);
 }
 
-// ---------------------------------------------------------------------------
-// junior init <dir>
-// ---------------------------------------------------------------------------
-if (command === "init") {
-  const dir = positionals[1];
-  if (!dir) {
-    console.error("usage: junior init <dir>");
-    process.exit(1);
+async function main() {
+  const runCli = await loadCliFunction(
+    "run",
+    "runCli",
+    "CLI dispatcher module is unavailable; reinstall @sentry/junior and retry."
+  );
+  const exitCode = await runCli(positionals, {
+    runInit,
+    runSnapshotCreate
+  });
+  if (exitCode !== 0) {
+    process.exit(exitCode);
   }
-
-  const target = path.resolve(dir);
-  fs.mkdirSync(target, { recursive: true });
-
-  const name = path.basename(target);
-
-  // package.json
-  const pkg = {
-    name,
-    version: "0.1.0",
-    private: true,
-    type: "module",
-    scripts: {
-      dev: "next dev",
-      build: "next build",
-      start: "next start"
-    },
-    dependencies: {
-      "@sentry/junior": "latest",
-      next: "^16.0.0",
-      react: "^19.0.0",
-      "react-dom": "^19.0.0",
-      "@sentry/nextjs": "^10.0.0"
-    }
-  };
-  fs.writeFileSync(
-    path.join(target, "package.json"),
-    JSON.stringify(pkg, null, 2) + "\n"
-  );
-
-  // app/data/SOUL.md
-  const dataDir = path.join(target, "app", "data");
-  fs.mkdirSync(dataDir, { recursive: true });
-  fs.writeFileSync(
-    path.join(dataDir, "SOUL.md"),
-    `# ${name}\n\nYou are ${name}, a helpful assistant.\n`
-  );
-
-  // app/skills/
-  const skillsDir = path.join(target, "app", "skills");
-  fs.mkdirSync(skillsDir, { recursive: true });
-  fs.writeFileSync(path.join(skillsDir, ".gitkeep"), "");
-
-  // app/plugins/
-  const pluginsDir = path.join(target, "app", "plugins");
-  fs.mkdirSync(pluginsDir, { recursive: true });
-  fs.writeFileSync(path.join(pluginsDir, ".gitkeep"), "");
-
-  // .gitignore
-  fs.writeFileSync(
-    path.join(target, ".gitignore"),
-    [
-      "node_modules/",
-      ".next/",
-      ".env",
-      ".env.local",
-      ""
-    ].join("\n")
-  );
-
-  // .env.example
-  fs.writeFileSync(
-    path.join(target, ".env.example"),
-    [
-      "SLACK_BOT_TOKEN=",
-      "SLACK_SIGNING_SECRET=",
-      "JUNIOR_BOT_NAME=",
-      "AI_MODEL=",
-      "AI_FAST_MODEL=",
-      "REDIS_URL=",
-      "NEXT_PUBLIC_SENTRY_DSN=",
-      ""
-    ].join("\n")
-  );
-
-  writeWrapperFiles(target);
-
-  console.log(`Created ${name} at ${target}`);
-  console.log();
-  console.log(`  cd ${dir} && pnpm install && pnpm dev`);
-  console.log();
-  process.exit(0);
 }
 
-console.error("usage: junior init <dir>");
-process.exit(1);
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`junior command failed: ${message}`);
+  process.exit(1);
+});

package/dist/app/layout.d.ts

@@ -1,6 +1,9 @@
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { ReactNode } from 'react';
 
+/**
+ * Minimal root layout export for apps that do not provide one yet.
+ */
 declare function RootLayout({ children }: {
     children: ReactNode;
 }): react_jsx_runtime.JSX.Element;

package/dist/bot-T73QBC4J.js

@@ -0,0 +1,16 @@
+import {
+  appSlackRuntime,
+  bot,
+  createNormalizingStream,
+  resetBotDepsForTests,
+  setBotDepsForTests
+} from "./chunk-RXNMJQPY.js";
+import "./chunk-QHDDCUTN.js";
+import "./chunk-PY4AI2GZ.js";
+export {
+  appSlackRuntime,
+  bot,
+  createNormalizingStream,
+  resetBotDepsForTests,
+  setBotDepsForTests
+};

package/dist/{chunk-OD6TOSY4.js → chunk-JDBWDYGR.js}

@@ -6,13 +6,13 @@ import {
   setSpanStatus,
   withContext,
   withSpan
-} from "./chunk-BBOVH5RF.js";
+} from "./chunk-PY4AI2GZ.js";
 
 // src/handlers/webhooks.ts
 import { after } from "next/server";
 import * as Sentry from "@sentry/nextjs";
 async function loadBot() {
-  const { bot } = await import("./bot-DLML4Z7F.js");
+  const { bot } = await import("./bot-T73QBC4J.js");
   return bot;
 }
 async function POST(request, context) {

package/dist/{chunk-BBOVH5RF.js → chunk-PY4AI2GZ.js}

@@ -225,13 +225,21 @@ function emitSentry(level, body, attributes) {
     loggerFn(body, attributes);
     return;
   }
-  Sentry.withScope((scope) => {
-    for (const [key, value] of Object.entries(attributes)) {
-      scope.setExtra(key, value);
-    }
-    const sentryLevel = level === "warn" ? "warning" : level;
-    Sentry.captureMessage(body, sentryLevel);
-  });
+  const sentryWithScope = sentry.withScope;
+  const sentryCaptureMessage = sentry.captureMessage;
+  const sentryLevel = level === "warn" ? "warning" : level;
+  if (typeof sentryWithScope === "function" && typeof sentryCaptureMessage === "function") {
+    sentryWithScope((scope) => {
+      for (const [key, value] of Object.entries(attributes)) {
+        scope.setExtra(key, value);
+      }
+      sentryCaptureMessage(body, sentryLevel);
+    });
+    return;
+  }
+  if (typeof sentryCaptureMessage === "function") {
+    sentryCaptureMessage(body, sentryLevel);
+  }
 }
 function formatConsoleLevel(level) {
   if (level === "debug") return "DBG";
@@ -353,12 +361,22 @@ var log = {
       "exception.message": normalizedError.message,
       "exception.stacktrace": normalizedError.stack
     }, body ?? normalizedError.message);
-    Sentry.withScope((scope) => {
-      for (const [key, value] of Object.entries(mergeAttributes(contextStorage.getStore(), attrs))) {
-        scope.setExtra(key, value);
-      }
-      Sentry.captureException(normalizedError);
-    });
+    let eventId;
+    const sentryWithScope = Sentry.withScope;
+    const sentryCaptureException = Sentry.captureException;
+    if (typeof sentryWithScope === "function" && typeof sentryCaptureException === "function") {
+      sentryWithScope((scope) => {
+        for (const [key, value] of Object.entries(mergeAttributes(contextStorage.getStore(), attrs))) {
+          scope.setExtra(key, value);
+        }
+        eventId = sentryCaptureException(normalizedError);
+      });
+      return eventId;
+    }
+    if (typeof sentryCaptureException === "function") {
+      eventId = sentryCaptureException(normalizedError);
+    }
+    return eventId;
   }
 };
 function withLogContext(context, callback) {
@@ -437,7 +455,7 @@ function logError(eventName, context = {}, attributes = {}, body) {
 }
 function logException(error, eventName, context = {}, attributes = {}, body) {
   const normalizedError = error instanceof Error ? error : new Error(String(error));
-  log.exception(eventName, normalizedError, toContextAndAttributes(context, attributes), body);
+  return log.exception(eventName, normalizedError, toContextAndAttributes(context, attributes), body);
 }
 function setTags(context = {}) {
   setLogContext(context);
@@ -504,6 +522,34 @@ function setSpanStatus(status) {
 function toOptionalString(value) {
   return typeof value === "string" && value.trim() ? value : void 0;
 }
+function getActiveTraceId() {
+  const sentry = Sentry2;
+  if (typeof sentry.getActiveSpan !== "function" || typeof sentry.spanToJSON !== "function") {
+    return void 0;
+  }
+  try {
+    const span = sentry.getActiveSpan();
+    if (!span) {
+      return void 0;
+    }
+    return toOptionalString(sentry.spanToJSON(span).trace_id);
+  } catch {
+    return void 0;
+  }
+}
+function resolveErrorReference(eventId) {
+  const traceId = getActiveTraceId();
+  if (!eventId && !traceId) {
+    return null;
+  }
+  if (!traceId) {
+    return null;
+  }
+  return {
+    traceId,
+    ...eventId ? { eventId } : {}
+  };
+}
 
 export {
   logInfo,
@@ -516,5 +562,6 @@ export {
   withSpan,
   setSpanAttributes,
   setSpanStatus,
-  toOptionalString
+  toOptionalString,
+  resolveErrorReference
 };