@sentry/junior 0.2.0 → 0.3.0

package/README.md

@@ -29,7 +29,10 @@ export const runtime = "nodejs";
 
 ```js
 import { withJunior } from "@sentry/junior/config";
-export default withJunior();
+
+export default withJunior({
+  pluginPackages: ["@sentry/junior-github", "@sentry/junior-sentry"]
+});
 ```
 
 ## Full docs

package/dist/{bot-T73QBC4J.js → bot-JSIREVQD.js}

@@ -4,9 +4,10 @@ import {
   createNormalizingStream,
   resetBotDepsForTests,
   setBotDepsForTests
-} from "./chunk-RXNMJQPY.js";
-import "./chunk-QHDDCUTN.js";
+} from "./chunk-L745IWNK.js";
+import "./chunk-DPTR2FNH.js";
 import "./chunk-PY4AI2GZ.js";
+import "./chunk-SP6LV35L.js";
 export {
   appSlackRuntime,
   bot,

package/dist/{chunk-TQSDLJVE.js → chunk-4RFOJSJL.js}

@@ -4,7 +4,7 @@ import {
   downloadPrivateSlackFile,
   getThreadMessageTopic,
   removeReactionFromMessage
-} from "./chunk-RXNMJQPY.js";
+} from "./chunk-L745IWNK.js";
 import {
   acquireQueueMessageProcessingOwnership,
   completeQueueMessageProcessingOwnership,
@@ -12,7 +12,7 @@ import {
   getQueueMessageProcessingState,
   getStateAdapter,
   refreshQueueMessageProcessingOwnership
-} from "./chunk-QHDDCUTN.js";
+} from "./chunk-DPTR2FNH.js";
 import {
   createRequestContext,
   logError,

package/dist/{chunk-QHDDCUTN.js → chunk-DPTR2FNH.js}

@@ -4,6 +4,10 @@ import {
   setSpanAttributes,
   withSpan
 } from "./chunk-PY4AI2GZ.js";
+import {
+  discoverInstalledPluginPackageContent,
+  discoverProjectRoots
+} from "./chunk-SP6LV35L.js";
 
 // src/chat/config.ts
 var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
@@ -385,15 +389,15 @@ import { createHash } from "crypto";
 import { Sandbox } from "@vercel/sandbox";
 
 // src/chat/plugins/registry.ts
-import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
-import path3 from "path";
+import { readFileSync, readdirSync, statSync } from "fs";
+import path2 from "path";
 import { parse as parseYaml } from "yaml";
 
 // src/chat/home.ts
 import fs from "fs";
 import path from "path";
 function homeDir() {
-  return detectAppDir();
+  return resolveHomeDir();
 }
 function unique(values) {
   return [...new Set(values)];
@@ -409,46 +413,60 @@ function pathExists(targetPath) {
 function hasAnyDataMarkers(appDir) {
   return pathExists(path.join(appDir, "SOUL.md"));
 }
-function detectAppDir() {
-  const cwd = process.cwd();
-  const directApp = path.resolve(cwd, "app");
-  if (pathExists(directApp)) {
-    return directApp;
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path.join(appDir, "SOUL.md"))) {
+    score += 4;
   }
-  const candidates = [];
-  const packageRoots = [];
-  const localPackagesDir = path.join(cwd, "packages");
-  if (pathExists(localPackagesDir)) {
-    for (const entry of fs.readdirSync(localPackagesDir)) {
-      packageRoots.push(path.join(localPackagesDir, entry));
-    }
+  if (pathExists(path.join(appDir, "ABOUT.md"))) {
+    score += 2;
   }
-  for (const entry of fs.readdirSync(cwd)) {
-    const child = path.join(cwd, entry);
-    const nestedPackages = path.join(child, "packages");
-    if (!pathExists(nestedPackages)) {
-      continue;
-    }
-    for (const nestedEntry of fs.readdirSync(nestedPackages)) {
-      packageRoots.push(path.join(nestedPackages, nestedEntry));
-    }
+  if (pathExists(path.join(appDir, "skills"))) {
+    score += 1;
   }
-  for (const root of packageRoots) {
-    const appDir = path.join(root, "app");
+  if (pathExists(path.join(appDir, "plugins"))) {
+    score += 1;
+  }
+  return score;
+}
+function resolveCandidateAppDirs(cwd, projectRoots) {
+  const roots = projectRoots ?? discoverProjectRoots(cwd);
+  const resolved = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    const appDir = path.resolve(root, "app");
     if (!pathExists(appDir)) {
       continue;
     }
-    candidates.push(appDir);
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
   }
+  return resolved;
+}
+function resolveHomeDir(cwd = process.cwd(), options) {
+  const resolvedCwd = path.resolve(cwd);
+  const directApp = path.resolve(resolvedCwd, "app");
+  if (pathExists(directApp) && hasAnyDataMarkers(directApp)) {
+    return directApp;
+  }
+  const candidates = resolveCandidateAppDirs(resolvedCwd, options?.projectRoots);
   if (candidates.length === 0) {
     return directApp;
   }
   candidates.sort((left, right) => {
-    const leftScore = Number(hasAnyDataMarkers(left));
-    const rightScore = Number(hasAnyDataMarkers(right));
+    const leftScore = scoreAppCandidate(left);
+    const rightScore = scoreAppCandidate(right);
     if (leftScore !== rightScore) {
       return rightScore - leftScore;
     }
+    const leftDistance = path.relative(resolvedCwd, left).split(path.sep).length;
+    const rightDistance = path.relative(resolvedCwd, right).split(path.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
     return left.localeCompare(right);
   });
   return candidates[0];
@@ -553,8 +571,8 @@ function createAppJwt(appId, privateKeyEnv) {
   const signature = signer.sign(getPrivateKey(privateKeyEnv)).toString("base64").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
   return `${signingInput}.${signature}`;
 }
-async function githubRequest(apiBase, path4, params) {
-  const response = await fetch(`${apiBase}${path4}`, {
+async function githubRequest(apiBase, path3, params) {
+  const response = await fetch(`${apiBase}${path3}`, {
     method: params.method ?? "GET",
     headers: {
       Accept: "application/vnd.github+json",
@@ -801,98 +819,6 @@ function createOAuthBearerBroker(manifest, credentials, deps) {
   };
 }
 
-// src/chat/plugins/package-discovery.ts
-import { readFileSync, statSync } from "fs";
-import path2 from "path";
-function isDirectory(targetPath) {
-  try {
-    return statSync(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isFile(targetPath) {
-  try {
-    return statSync(targetPath).isFile();
-  } catch {
-    return false;
-  }
-}
-function readRootPackageJson(cwd) {
-  const rootPackageJsonPath = path2.join(cwd, "package.json");
-  try {
-    const raw = readFileSync(rootPackageJsonPath, "utf8");
-    return JSON.parse(raw);
-  } catch {
-    return null;
-  }
-}
-function uniqueSorted(values) {
-  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
-}
-function readInstalledDependencyNames(cwd) {
-  const rootPackageJson = readRootPackageJson(cwd);
-  if (!rootPackageJson) {
-    return [];
-  }
-  return uniqueSorted([
-    ...Object.keys(rootPackageJson.dependencies ?? {}),
-    ...Object.keys(rootPackageJson.optionalDependencies ?? {})
-  ]);
-}
-function packageInstallDir(cwd, packageName) {
-  return path2.join(cwd, "node_modules", ...packageName.split("/"));
-}
-function discoverInstalledJuniorContentPackages(cwd = process.cwd()) {
-  const dependencies = readInstalledDependencyNames(cwd);
-  const discovered = [];
-  for (const dependency of dependencies) {
-    const dir = packageInstallDir(cwd, dependency);
-    if (!isDirectory(dir)) {
-      continue;
-    }
-    const hasRootPluginManifest = isFile(path2.join(dir, "plugin.yaml"));
-    const hasPluginsDir = isDirectory(path2.join(dir, "plugins"));
-    const hasSkillsDir = isDirectory(path2.join(dir, "skills"));
-    if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
-      continue;
-    }
-    discovered.push({
-      name: dependency,
-      dir,
-      hasRootPluginManifest,
-      hasPluginsDir,
-      hasSkillsDir
-    });
-  }
-  return discovered;
-}
-function discoverInstalledPluginPackageContent(cwd = process.cwd()) {
-  const manifestRoots = [];
-  const skillRoots2 = [];
-  const tracingIncludes = [];
-  for (const pkg of discoverInstalledJuniorContentPackages(cwd)) {
-    const base = `./node_modules/${pkg.name}`;
-    if (pkg.hasRootPluginManifest) {
-      manifestRoots.push(pkg.dir);
-      tracingIncludes.push(`${base}/plugin.yaml`);
-    }
-    if (pkg.hasPluginsDir) {
-      manifestRoots.push(path2.join(pkg.dir, "plugins"));
-      tracingIncludes.push(`${base}/plugins/**/*`);
-    }
-    if (pkg.hasSkillsDir) {
-      skillRoots2.push(path2.join(pkg.dir, "skills"));
-      tracingIncludes.push(`${base}/skills/**/*`);
-    }
-  }
-  return {
-    manifestRoots: uniqueSorted(manifestRoots),
-    skillRoots: uniqueSorted(skillRoots2),
-    tracingIncludes: uniqueSorted(tracingIncludes)
-  };
-}
-
 // src/chat/plugins/registry.ts
 var PLUGIN_NAME_RE = /^[a-z][a-z0-9-]*$/;
 var SHORT_CAPABILITY_RE = /^[a-z0-9]+(\.[a-z0-9-]+)*$/;
@@ -1210,7 +1136,7 @@ function registerPluginManifest(raw, pluginDir) {
   const definition = {
     manifest,
     dir: pluginDir,
-    skillsDir: path3.join(pluginDir, "skills")
+    skillsDir: path2.join(pluginDir, "skills")
   };
   pluginDefinitions.push(definition);
   pluginsByName.set(manifest.name, definition);
@@ -1231,7 +1157,7 @@ function loadPlugins() {
     let entries;
     let rootStat;
     try {
-      rootStat = statSync2(pluginsRoot);
+      rootStat = statSync(pluginsRoot);
     } catch (error) {
       logWarn("plugin_root_read_failed", {}, {
         "file.directory": pluginsRoot,
@@ -1240,15 +1166,15 @@ function loadPlugins() {
       continue;
     }
     if (rootStat.isDirectory()) {
-      const manifestPath = path3.join(pluginsRoot, "plugin.yaml");
+      const manifestPath = path2.join(pluginsRoot, "plugin.yaml");
       let hasRootManifest = false;
       try {
-        hasRootManifest = statSync2(manifestPath).isFile();
+        hasRootManifest = statSync(manifestPath).isFile();
       } catch {
         hasRootManifest = false;
       }
       if (hasRootManifest) {
-        const rawRootManifest = readFileSync2(manifestPath, "utf8");
+        const rawRootManifest = readFileSync(manifestPath, "utf8");
         registerPluginManifest(rawRootManifest, pluginsRoot);
         continue;
       }
@@ -1263,17 +1189,17 @@ function loadPlugins() {
       continue;
     }
     for (const entry of entries.sort()) {
-      const pluginDir = path3.join(pluginsRoot, entry);
+      const pluginDir = path2.join(pluginsRoot, entry);
       try {
-        const stat = statSync2(pluginDir);
+        const stat = statSync(pluginDir);
         if (!stat.isDirectory()) continue;
       } catch {
         continue;
       }
-      const manifestPath = path3.join(pluginDir, "plugin.yaml");
+      const manifestPath = path2.join(pluginDir, "plugin.yaml");
       let raw;
       try {
-        raw = readFileSync2(manifestPath, "utf8");
+        raw = readFileSync(manifestPath, "utf8");
       } catch {
         continue;
       }

package/dist/{chunk-RXNMJQPY.js → chunk-L745IWNK.js}

@@ -25,7 +25,7 @@ import {
   skillRoots,
   soulPathCandidates,
   upsertAgentTurnSessionCheckpoint
-} from "./chunk-QHDDCUTN.js";
+} from "./chunk-DPTR2FNH.js";
 import {
   logError,
   logException,

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

@@ -12,7 +12,7 @@ import {
 import { after } from "next/server";
 import * as Sentry from "@sentry/nextjs";
 async function loadBot() {
-  const { bot } = await import("./bot-T73QBC4J.js");
+  const { bot } = await import("./bot-JSIREVQD.js");
   return bot;
 }
 async function POST(request, context) {

package/dist/chunk-SP6LV35L.js

@@ -0,0 +1,328 @@
+// src/chat/fs-utils.ts
+import { statSync } from "fs";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/chat/discovery-roots.ts
+import { readdirSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function normalizePath(targetPath) {
+  return path.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = normalizePath(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function isNodeModulesPath(candidatePath) {
+  return path.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path.sep}node_modules${path.sep}@sentry${path.sep}junior${path.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path.resolve(path.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory(current)) {
+      dirs.push(current);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function listCwdAncestorNodeModulesDirs(cwd) {
+  const resolvedCwd = normalizePath(cwd);
+  const dirs = [];
+  let current = resolvedCwd;
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile(path.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder(explicit);
+  }
+  return uniqueResolvedPathsInOrder([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(cwd, options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0).map((nodeModulesDir) => path.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder([cwd, ...roots]);
+}
+function listTopLevelPackages(nodeModulesDir) {
+  const entries = readdirSync(nodeModulesDir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".") && entry.name !== ".bin" && entry.name !== ".pnpm").sort((left, right) => left.name.localeCompare(right.name));
+  const packages = [];
+  for (const entry of entries) {
+    const entryPath = path.join(nodeModulesDir, entry.name);
+    if (entry.name.startsWith("@")) {
+      if (!isDirectory(entryPath)) {
+        continue;
+      }
+      const scopedEntries = readdirSync(entryPath, { withFileTypes: true }).sort(
+        (left, right) => left.name.localeCompare(right.name)
+      );
+      for (const scopedEntry of scopedEntries) {
+        const packageName = `${entry.name}/${scopedEntry.name}`;
+        const packagePath = path.join(entryPath, scopedEntry.name);
+        if (!isDirectory(packagePath)) {
+          continue;
+        }
+        packages.push({ name: packageName, dir: packagePath });
+      }
+      continue;
+    }
+    if (!isDirectory(entryPath)) {
+      continue;
+    }
+    packages.push({ name: entry.name, dir: entryPath });
+  }
+  return packages;
+}
+
+// src/chat/plugins/package-discovery.ts
+import { createRequire } from "module";
+import path2 from "path";
+var require2 = createRequire(import.meta.url);
+function normalizeForGlob(targetPath) {
+  return targetPath.split(path2.sep).join("/");
+}
+function uniqueStringsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    if (seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    resolved.push(value);
+  }
+  return resolved;
+}
+function pathWithinCwd(cwd, targetPath) {
+  const relative = path2.relative(cwd, targetPath);
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
+    return null;
+  }
+  return `./${normalizeForGlob(relative)}`;
+}
+function parseRuntimeConfiguredPackageNames(value) {
+  if (!Array.isArray(value)) {
+    return null;
+  }
+  const parsed = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  return uniqueStringsInOrder(parsed.map((entry) => entry.trim()));
+}
+function readNextRuntimeConfiguredPackageNames() {
+  try {
+    const nextConfigModule = require2("next/config");
+    const getConfig = nextConfigModule.default;
+    if (typeof getConfig !== "function") {
+      return null;
+    }
+    const runtimeConfig = getConfig();
+    return parseRuntimeConfiguredPackageNames(runtimeConfig?.serverRuntimeConfig?.juniorPluginPackages) ?? [];
+  } catch {
+    return null;
+  }
+}
+function findContainingNodeModulesDir(targetPath) {
+  let current = path2.resolve(targetPath);
+  while (true) {
+    if (path2.basename(current) === "node_modules") {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
+  for (const nodeModulesDir of candidateNodeModulesDirs) {
+    const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
+    if (isDirectory(packageDir)) {
+      return {
+        dir: path2.resolve(packageDir),
+        nodeModulesDir: path2.resolve(nodeModulesDir)
+      };
+    }
+  }
+  try {
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const dir = path2.dirname(packageJsonPath);
+    const nodeModulesDir = findContainingNodeModulesDir(dir);
+    if (!nodeModulesDir) {
+      return null;
+    }
+    return {
+      dir: path2.resolve(dir),
+      nodeModulesDir: path2.resolve(nodeModulesDir)
+    };
+  } catch {
+    return null;
+  }
+}
+function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs) {
+  const discovered = [];
+  const seenPackageNames = /* @__PURE__ */ new Set();
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const packageName of packageNames) {
+    const resolved = resolvePackageDirFromName(packageName, candidateNodeModulesDirs);
+    if (!resolved) {
+      continue;
+    }
+    if (seenPackageNames.has(packageName) || seenPackageDirs.has(resolved.dir)) {
+      continue;
+    }
+    const hasRootPluginManifest = isFile(path2.join(resolved.dir, "plugin.yaml"));
+    const hasPluginsDir = isDirectory(path2.join(resolved.dir, "plugins"));
+    const hasSkillsDir = isDirectory(path2.join(resolved.dir, "skills"));
+    if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+      continue;
+    }
+    seenPackageNames.add(packageName);
+    seenPackageDirs.add(resolved.dir);
+    discovered.push({
+      name: packageName,
+      dir: resolved.dir,
+      nodeModulesDir: resolved.nodeModulesDir,
+      hasRootPluginManifest,
+      hasPluginsDir,
+      hasSkillsDir
+    });
+  }
+  return discovered;
+}
+function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModulesDirs, packageNames) {
+  const resolvedCwd = path2.resolve(cwd);
+  const candidateNodeModulesDirs = nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
+  const configuredPackageNames = packageNames ?? readNextRuntimeConfiguredPackageNames();
+  const declaredPackages = discoverDeclaredPackages(configuredPackageNames ?? [], candidateNodeModulesDirs);
+  const useFallbackScan = configuredPackageNames === null;
+  const discovered = [...declaredPackages];
+  const seenPackageNames = /* @__PURE__ */ new Set();
+  const seenPackageDirs = /* @__PURE__ */ new Set();
+  for (const pkg of declaredPackages) {
+    seenPackageNames.add(pkg.name);
+    seenPackageDirs.add(pkg.dir);
+  }
+  if (!useFallbackScan) {
+    return discovered;
+  }
+  for (const nodeModulesDir of candidateNodeModulesDirs) {
+    for (const pkg of listTopLevelPackages(nodeModulesDir)) {
+      const resolvedDir = path2.resolve(pkg.dir);
+      if (seenPackageNames.has(pkg.name) || seenPackageDirs.has(resolvedDir)) {
+        continue;
+      }
+      seenPackageNames.add(pkg.name);
+      seenPackageDirs.add(resolvedDir);
+      const hasRootPluginManifest = isFile(path2.join(resolvedDir, "plugin.yaml"));
+      const hasPluginsDir = isDirectory(path2.join(resolvedDir, "plugins"));
+      const hasSkillsDir = isDirectory(path2.join(resolvedDir, "skills"));
+      if (!hasRootPluginManifest && !hasPluginsDir && !hasSkillsDir) {
+        continue;
+      }
+      discovered.push({
+        name: pkg.name,
+        dir: resolvedDir,
+        nodeModulesDir: path2.resolve(nodeModulesDir),
+        hasRootPluginManifest,
+        hasPluginsDir,
+        hasSkillsDir
+      });
+    }
+  }
+  return discovered;
+}
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+  const resolvedCwd = path2.resolve(cwd);
+  const discoveredPackages = discoverInstalledJuniorContentPackages(resolvedCwd, options?.nodeModulesDirs, options?.packageNames);
+  const manifestRoots = [];
+  const skillRoots = [];
+  const tracingIncludes = [];
+  for (const pkg of discoveredPackages) {
+    const packagePathFromNodeModules = pathWithinCwd(resolvedCwd, path2.join(pkg.nodeModulesDir, ...pkg.name.split("/")));
+    if (pkg.hasRootPluginManifest) {
+      manifestRoots.push(pkg.dir);
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/plugin.yaml`);
+      }
+    }
+    if (pkg.hasPluginsDir) {
+      manifestRoots.push(path2.join(pkg.dir, "plugins"));
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/plugins/**/*`);
+      }
+    }
+    if (pkg.hasSkillsDir) {
+      skillRoots.push(path2.join(pkg.dir, "skills"));
+      if (packagePathFromNodeModules) {
+        tracingIncludes.push(`${packagePathFromNodeModules}/skills/**/*`);
+      }
+    }
+  }
+  return {
+    packageNames: uniqueStringsInOrder(discoveredPackages.map((pkg) => pkg.name)),
+    manifestRoots: uniqueStringsInOrder(manifestRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots),
+    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+  };
+}
+
+export {
+  isDirectory,
+  discoverNodeModulesDirs,
+  discoverProjectRoots,
+  discoverInstalledPluginPackageContent
+};

package/dist/cli/snapshot-warmup.js

@@ -1,8 +1,9 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-QHDDCUTN.js";
+} from "../chunk-DPTR2FNH.js";
 import "../chunk-PY4AI2GZ.js";
+import "../chunk-SP6LV35L.js";
 
 // src/cli/snapshot-warmup.ts
 var DEFAULT_RUNTIME = "node22";

package/dist/handlers/queue-callback.js

@@ -1,9 +1,10 @@
 import {
   POST
-} from "../chunk-TQSDLJVE.js";
-import "../chunk-RXNMJQPY.js";
-import "../chunk-QHDDCUTN.js";
+} from "../chunk-4RFOJSJL.js";
+import "../chunk-L745IWNK.js";
+import "../chunk-DPTR2FNH.js";
 import "../chunk-PY4AI2GZ.js";
+import "../chunk-SP6LV35L.js";
 export {
   POST
 };

package/dist/handlers/router.js

@@ -1,9 +1,9 @@
 import {
   POST as POST2
-} from "../chunk-JDBWDYGR.js";
+} from "../chunk-RTQMRGZD.js";
 import {
   POST
-} from "../chunk-TQSDLJVE.js";
+} from "../chunk-4RFOJSJL.js";
 import {
   escapeXml,
   generateAssistantReply,
@@ -13,18 +13,19 @@ import {
   publishAppHomeView,
   resolveBaseUrl,
   truncateStatusText
-} from "../chunk-RXNMJQPY.js";
+} from "../chunk-L745IWNK.js";
 import {
   GET
 } from "../chunk-4RBEYCOG.js";
 import {
   botConfig,
   getStateAdapter
-} from "../chunk-QHDDCUTN.js";
+} from "../chunk-DPTR2FNH.js";
 import {
   logException,
   logInfo
 } from "../chunk-PY4AI2GZ.js";
+import "../chunk-SP6LV35L.js";
 
 // src/handlers/oauth-callback.ts
 import { after } from "next/server";

package/dist/handlers/webhooks.js

@@ -1,6 +1,6 @@
 import {
   POST
-} from "../chunk-JDBWDYGR.js";
+} from "../chunk-RTQMRGZD.js";
 import "../chunk-PY4AI2GZ.js";
 export {
   POST

package/dist/next-config.d.ts

@@ -7,7 +7,7 @@ interface JuniorConfigOptions {
     dataDir?: string;
     skillsDir?: string;
     pluginsDir?: string;
-    sentry?: boolean;
+    pluginPackages?: string[];
 }
 type NextConfigFactory = (phase: string, ctx: {
     defaultConfig: NextConfig;
@@ -17,6 +17,6 @@ type NextConfigFactory = (phase: string, ctx: {
  *
  * Supports both object and function-style Next config exports.
  */
-declare function withJunior(nextConfig?: NextConfig | NextConfigFactory, options?: JuniorConfigOptions): NextConfig | NextConfigFactory;
+declare function withJunior(options?: JuniorConfigOptions, nextConfig?: NextConfig | NextConfigFactory): NextConfig | NextConfigFactory;
 
 export { type JuniorConfigOptions, withJunior };

package/dist/next-config.js

@@ -1,59 +1,53 @@
+import {
+  discoverInstalledPluginPackageContent,
+  discoverNodeModulesDirs,
+  isDirectory
+} from "./chunk-SP6LV35L.js";
+
 // src/next-config.ts
 import { createRequire } from "module";
-import { readFileSync, statSync } from "fs";
 import path from "path";
 var require2 = createRequire(import.meta.url);
-function isDirectory(targetPath) {
-  try {
-    return statSync(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
+function unique(values) {
+  return [...new Set(values)];
 }
-function isFile(targetPath) {
-  try {
-    return statSync(targetPath).isFile();
-  } catch {
-    return false;
-  }
+function sentryConfigured() {
+  return Boolean(process.env.NEXT_PUBLIC_SENTRY_DSN || process.env.SENTRY_DSN);
 }
-function discoverInstalledPluginPackageTracingIncludes(cwd = process.cwd()) {
-  const rootPackageJsonPath = path.join(cwd, "package.json");
-  let rootPackageJson;
-  try {
-    rootPackageJson = JSON.parse(readFileSync(rootPackageJsonPath, "utf8"));
-  } catch {
-    return [];
-  }
-  const dependencies = [
-    ...Object.keys(rootPackageJson.dependencies ?? {}),
-    ...Object.keys(rootPackageJson.optionalDependencies ?? {})
-  ];
-  const tracingIncludes = [];
-  for (const dependency of dependencies) {
-    const packageDir = path.join(cwd, "node_modules", ...dependency.split("/"));
-    if (!isDirectory(packageDir)) {
-      continue;
-    }
-    const base = `./node_modules/${dependency}`;
-    if (isFile(path.join(packageDir, "plugin.yaml"))) {
-      tracingIncludes.push(`${base}/plugin.yaml`);
-    }
-    if (isDirectory(path.join(packageDir, "plugins"))) {
-      tracingIncludes.push(`${base}/plugins/**/*`);
-    }
-    if (isDirectory(path.join(packageDir, "skills"))) {
-      tracingIncludes.push(`${base}/skills/**/*`);
-    }
-  }
-  return [...new Set(tracingIncludes)].sort((left, right) => left.localeCompare(right));
+function isPackageInstalled(cwd, packageName) {
+  const nodeModulesDirs = discoverNodeModulesDirs(cwd);
+  return nodeModulesDirs.some(
+    (nodeModulesDir) => isDirectory(path.join(nodeModulesDir, ...packageName.split("/")))
+  );
 }
 function applyJuniorConfig(nextConfig, options) {
+  const existingServerRuntimeConfig = nextConfig?.serverRuntimeConfig ?? {};
   const dataDir = options?.dataDir ?? "./app/data";
   const skillsDir = options?.skillsDir ?? "./app/skills";
   const pluginsDir = options?.pluginsDir ?? "./app/plugins";
+  const configuredPluginPackages = unique(options?.pluginPackages ?? []);
+  const discoveredPlugins = discoverInstalledPluginPackageContent(process.cwd(), { packageNames: configuredPluginPackages });
+  const unresolvedConfiguredPackages = configuredPluginPackages.filter(
+    (packageName) => !discoveredPlugins.packageNames.includes(packageName)
+  );
+  const invalidPluginPackages = unresolvedConfiguredPackages.filter(
+    (packageName) => isPackageInstalled(process.cwd(), packageName)
+  );
+  const missingPluginPackages = unresolvedConfiguredPackages.filter(
+    (packageName) => !invalidPluginPackages.includes(packageName)
+  );
+  if (invalidPluginPackages.length > 0) {
+    throw new Error(
+      `withJunior pluginPackages contains installed packages that are not valid Junior plugins: ${invalidPluginPackages.join(", ")}`
+    );
+  }
+  if (missingPluginPackages.length > 0) {
+    throw new Error(
+      `withJunior pluginPackages contains unresolved packages: ${missingPluginPackages.join(", ")}`
+    );
+  }
   const defaultDataTracingIncludes = options?.dataDir ? [`${dataDir}/**/*`] : ["./app/SOUL.md", "./app/ABOUT.md"];
-  const pluginPackageTracingIncludes = discoverInstalledPluginPackageTracingIncludes();
+  const pluginPackageTracingIncludes = discoveredPlugins.tracingIncludes;
   const tracingIncludes = Array.from(/* @__PURE__ */ new Set([
     ...defaultDataTracingIncludes,
     `${skillsDir}/**/*`,
@@ -69,6 +63,7 @@ function applyJuniorConfig(nextConfig, options) {
     ...nextConfig,
     serverExternalPackages: Array.from(/* @__PURE__ */ new Set([
       ...nextConfig?.serverExternalPackages ?? [],
+      "@vercel/queue",
       "@vercel/sandbox",
       "bash-tool",
       "just-bash",
@@ -80,23 +75,27 @@ function applyJuniorConfig(nextConfig, options) {
     outputFileTracingIncludes: {
       ...nextConfig?.outputFileTracingIncludes,
       "/*": mergedGlobalTracingIncludes
+    },
+    serverRuntimeConfig: {
+      ...existingServerRuntimeConfig,
+      juniorPluginPackages: configuredPluginPackages
     }
   };
-  if (options?.sentry) {
-    const { withSentryConfig } = require2("@sentry/nextjs");
-    return withSentryConfig(config, {
-      org: process.env.SENTRY_ORG,
-      project: process.env.SENTRY_PROJECT,
-      authToken: process.env.SENTRY_AUTH_TOKEN,
-      silent: !process.env.CI,
-      sourcemaps: {
-        disable: false
-      }
-    });
+  if (!sentryConfigured()) {
+    return config;
   }
-  return config;
+  const { withSentryConfig } = require2("@sentry/nextjs");
+  return withSentryConfig(config, {
+    org: process.env.SENTRY_ORG,
+    project: process.env.SENTRY_PROJECT,
+    authToken: process.env.SENTRY_AUTH_TOKEN,
+    silent: !process.env.CI,
+    sourcemaps: {
+      disable: false
+    }
+  });
 }
-function withJunior(nextConfig, options) {
+function withJunior(options, nextConfig) {
   if (typeof nextConfig === "function") {
     return async (phase, ctx) => {
       const resolved = await nextConfig(phase, ctx);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "publishConfig": {
     "access": "public"