@sentry/junior 0.3.0 → 0.4.0

package/dist/{chunk-RTQMRGZD.js → chunk-TEQ3UIS7.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-JSIREVQD.js");
+  const { bot } = await import("./bot-Y6A47LEZ.js");
   return bot;
 }
 async function POST(request, context) {

package/dist/{chunk-SP6LV35L.js → chunk-Z5E25LRN.js}

@@ -129,9 +129,9 @@ function listTopLevelPackages(nodeModulesDir) {
 }
 
 // src/chat/plugins/package-discovery.ts
-import { createRequire } from "module";
+import { readFileSync, readdirSync as readdirSync2 } from "fs";
 import path2 from "path";
-var require2 = createRequire(import.meta.url);
+import { parse as parseYaml } from "yaml";
 function normalizeForGlob(targetPath) {
   return targetPath.split(path2.sep).join("/");
 }
@@ -147,37 +147,39 @@ function uniqueStringsInOrder(values) {
   }
   return resolved;
 }
-function pathWithinCwd(cwd, targetPath) {
+function pathForTracingInclude(cwd, targetPath) {
   const relative = path2.relative(cwd, targetPath);
-  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
+  if (!relative || path2.isAbsolute(relative)) {
     return null;
   }
-  return `./${normalizeForGlob(relative)}`;
+  const normalized = normalizeForGlob(relative);
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
 }
 function parseRuntimeConfiguredPackageNames(value) {
   if (!Array.isArray(value)) {
     return null;
   }
-  const parsed = value.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+  const parsed = value.filter(
+    (entry) => typeof entry === "string" && entry.trim().length > 0
+  );
   return uniqueStringsInOrder(parsed.map((entry) => entry.trim()));
 }
 function readNextRuntimeConfiguredPackageNames() {
+  const raw = process.env.JUNIOR_PLUGIN_PACKAGES;
+  if (raw === void 0) {
+    return null;
+  }
   try {
-    const nextConfigModule = require2("next/config");
-    const getConfig = nextConfigModule.default;
-    if (typeof getConfig !== "function") {
-      return null;
-    }
-    const runtimeConfig = getConfig();
-    return parseRuntimeConfiguredPackageNames(runtimeConfig?.serverRuntimeConfig?.juniorPluginPackages) ?? [];
+    return parseRuntimeConfiguredPackageNames(JSON.parse(raw)) ?? [];
   } catch {
-    return null;
+    return [];
   }
 }
-function findContainingNodeModulesDir(targetPath) {
-  let current = path2.resolve(targetPath);
+function findWorkspaceRoot(cwd) {
+  let current = path2.resolve(cwd);
   while (true) {
-    if (path2.basename(current) === "node_modules") {
+    const candidate = path2.join(current, "pnpm-workspace.yaml");
+    if (isFile(candidate)) {
       return current;
     }
     const parent = path2.dirname(current);
@@ -187,6 +189,92 @@ function findContainingNodeModulesDir(targetPath) {
     current = parent;
   }
 }
+function listWorkspacePackageDirs(cwd) {
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  if (!workspaceRoot) {
+    return [];
+  }
+  let packagePatterns = [];
+  try {
+    const raw = readFileSync(
+      path2.join(workspaceRoot, "pnpm-workspace.yaml"),
+      "utf8"
+    );
+    const parsed = parseYaml(raw);
+    packagePatterns = Array.isArray(parsed.packages) ? parsed.packages.filter(
+      (entry) => typeof entry === "string" && entry.trim().length > 0
+    ) : [];
+  } catch {
+    return [];
+  }
+  const discovered = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addDir = (candidate) => {
+    const normalized = path2.resolve(candidate);
+    if (seen.has(normalized) || !isDirectory(normalized)) {
+      return;
+    }
+    seen.add(normalized);
+    discovered.push(normalized);
+  };
+  for (const pattern of packagePatterns) {
+    const trimmed = pattern.trim();
+    if (!trimmed) {
+      continue;
+    }
+    if (trimmed.endsWith("/*")) {
+      const baseDir = path2.join(workspaceRoot, trimmed.slice(0, -2));
+      if (!isDirectory(baseDir)) {
+        continue;
+      }
+      for (const entry of readdirSync2(baseDir)) {
+        addDir(path2.join(baseDir, entry));
+      }
+      continue;
+    }
+    addDir(path2.join(workspaceRoot, trimmed));
+  }
+  return discovered;
+}
+function readPluginPackageFlags(dir) {
+  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) {
+    return null;
+  }
+  return {
+    hasRootPluginManifest,
+    hasPluginsDir,
+    hasSkillsDir
+  };
+}
+function discoverWorkspacePluginPackageDirs(cwd, packageNames) {
+  if (packageNames !== null) {
+    return [];
+  }
+  return listWorkspacePackageDirs(cwd).filter(
+    (candidate) => readPluginPackageFlags(candidate) !== null
+  );
+}
+function readWorkspacePackageName(dir) {
+  try {
+    const raw = readFileSync(path2.join(dir, "package.json"), "utf8");
+    const name = JSON.parse(raw).name;
+    return typeof name === "string" && name.trim().length > 0 ? name : null;
+  } catch {
+    return null;
+  }
+}
+function resolveWorkspacePackageDirFromName(cwd, packageName) {
+  for (const candidate of listWorkspacePackageDirs(cwd)) {
+    if (readWorkspacePackageName(candidate) !== packageName) {
+      continue;
+    }
+    return candidate;
+  }
+  return null;
+}
 function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
   for (const nodeModulesDir of candidateNodeModulesDirs) {
     const packageDir = path2.join(nodeModulesDir, ...packageName.split("/"));
@@ -197,48 +285,36 @@ function resolvePackageDirFromName(packageName, candidateNodeModulesDirs) {
       };
     }
   }
-  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;
-  }
+  return null;
 }
-function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs) {
+function discoverDeclaredPackages(cwd, 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) {
+    const resolved = resolvePackageDirFromName(
+      packageName,
+      candidateNodeModulesDirs
+    );
+    const workspaceDir = resolved ? null : resolveWorkspacePackageDirFromName(cwd, packageName);
+    if (!resolved && !workspaceDir) {
       continue;
     }
-    if (seenPackageNames.has(packageName) || seenPackageDirs.has(resolved.dir)) {
+    const packageDir = resolved?.dir ?? workspaceDir;
+    if (seenPackageNames.has(packageName) || seenPackageDirs.has(packageDir)) {
       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) {
+    const pluginFlags = readPluginPackageFlags(packageDir);
+    if (!pluginFlags) {
       continue;
     }
     seenPackageNames.add(packageName);
-    seenPackageDirs.add(resolved.dir);
+    seenPackageDirs.add(packageDir);
     discovered.push({
       name: packageName,
-      dir: resolved.dir,
-      nodeModulesDir: resolved.nodeModulesDir,
-      hasRootPluginManifest,
-      hasPluginsDir,
-      hasSkillsDir
+      dir: packageDir,
+      nodeModulesDir: resolved?.nodeModulesDir ?? null,
+      ...pluginFlags
     });
   }
   return discovered;
@@ -247,7 +323,11 @@ function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModules
   const resolvedCwd = path2.resolve(cwd);
   const candidateNodeModulesDirs = nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
   const configuredPackageNames = packageNames ?? readNextRuntimeConfiguredPackageNames();
-  const declaredPackages = discoverDeclaredPackages(configuredPackageNames ?? [], candidateNodeModulesDirs);
+  const declaredPackages = discoverDeclaredPackages(
+    resolvedCwd,
+    configuredPackageNames ?? [],
+    candidateNodeModulesDirs
+  );
   const useFallbackScan = configuredPackageNames === null;
   const discovered = [...declaredPackages];
   const seenPackageNames = /* @__PURE__ */ new Set();
@@ -267,7 +347,9 @@ function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModules
       }
       seenPackageNames.add(pkg.name);
       seenPackageDirs.add(resolvedDir);
-      const hasRootPluginManifest = isFile(path2.join(resolvedDir, "plugin.yaml"));
+      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) {
@@ -287,33 +369,68 @@ function discoverInstalledJuniorContentPackages(cwd = process.cwd(), nodeModules
 }
 function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
   const resolvedCwd = path2.resolve(cwd);
-  const discoveredPackages = discoverInstalledJuniorContentPackages(resolvedCwd, options?.nodeModulesDirs, options?.packageNames);
+  const configuredPackageNames = options?.packageNames ?? readNextRuntimeConfiguredPackageNames();
+  const discoveredPackages = discoverInstalledJuniorContentPackages(
+    resolvedCwd,
+    options?.nodeModulesDirs,
+    configuredPackageNames
+  );
+  const workspacePluginDirs = discoverWorkspacePluginPackageDirs(
+    resolvedCwd,
+    configuredPackageNames
+  );
   const manifestRoots = [];
   const skillRoots = [];
   const tracingIncludes = [];
   for (const pkg of discoveredPackages) {
-    const packagePathFromNodeModules = pathWithinCwd(resolvedCwd, path2.join(pkg.nodeModulesDir, ...pkg.name.split("/")));
+    const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
+      resolvedCwd,
+      path2.join(pkg.nodeModulesDir, ...pkg.name.split("/"))
+    ) : pathForTracingInclude(resolvedCwd, pkg.dir);
     if (pkg.hasRootPluginManifest) {
       manifestRoots.push(pkg.dir);
-      if (packagePathFromNodeModules) {
-        tracingIncludes.push(`${packagePathFromNodeModules}/plugin.yaml`);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
       }
     }
     if (pkg.hasPluginsDir) {
       manifestRoots.push(path2.join(pkg.dir, "plugins"));
-      if (packagePathFromNodeModules) {
-        tracingIncludes.push(`${packagePathFromNodeModules}/plugins/**/*`);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
       }
     }
     if (pkg.hasSkillsDir) {
       skillRoots.push(path2.join(pkg.dir, "skills"));
-      if (packagePathFromNodeModules) {
-        tracingIncludes.push(`${packagePathFromNodeModules}/skills/**/*`);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
+      }
+    }
+  }
+  for (const pluginDir of workspacePluginDirs) {
+    const tracingBasePath = pathForTracingInclude(resolvedCwd, pluginDir);
+    if (isFile(path2.join(pluginDir, "plugin.yaml"))) {
+      manifestRoots.push(pluginDir);
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
+      }
+    }
+    if (isDirectory(path2.join(pluginDir, "plugins"))) {
+      manifestRoots.push(path2.join(pluginDir, "plugins"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
+      }
+    }
+    if (isDirectory(path2.join(pluginDir, "skills"))) {
+      skillRoots.push(path2.join(pluginDir, "skills"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
     }
   }
   return {
-    packageNames: uniqueStringsInOrder(discoveredPackages.map((pkg) => pkg.name)),
+    packageNames: uniqueStringsInOrder(
+      discoveredPackages.map((pkg) => pkg.name)
+    ),
     manifestRoots: uniqueStringsInOrder(manifestRoots),
     skillRoots: uniqueStringsInOrder(skillRoots),
     tracingIncludes: uniqueStringsInOrder(tracingIncludes)

package/dist/cli/snapshot-warmup.js

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

package/dist/handlers/queue-callback.js

@@ -1,10 +1,10 @@
 import {
   POST
-} from "../chunk-4RFOJSJL.js";
-import "../chunk-L745IWNK.js";
-import "../chunk-DPTR2FNH.js";
+} from "../chunk-DGKNXMK4.js";
+import "../chunk-RFUE5VBK.js";
+import "../chunk-OZFXD5IG.js";
 import "../chunk-PY4AI2GZ.js";
-import "../chunk-SP6LV35L.js";
+import "../chunk-Z5E25LRN.js";
 export {
   POST
 };

package/dist/handlers/router.js

@@ -1,31 +1,34 @@
 import {
   POST as POST2
-} from "../chunk-RTQMRGZD.js";
+} from "../chunk-TEQ3UIS7.js";
 import {
   POST
-} from "../chunk-4RFOJSJL.js";
+} from "../chunk-DGKNXMK4.js";
 import {
   escapeXml,
+  formatProviderLabel,
   generateAssistantReply,
-  getOAuthProviderConfig,
   getSlackClient,
   getUserTokenStore,
   publishAppHomeView,
   resolveBaseUrl,
   truncateStatusText
-} from "../chunk-L745IWNK.js";
+} from "../chunk-RFUE5VBK.js";
 import {
   GET
 } from "../chunk-4RBEYCOG.js";
 import {
   botConfig,
-  getStateAdapter
-} from "../chunk-DPTR2FNH.js";
+  buildOAuthTokenRequest,
+  getPluginOAuthConfig,
+  getStateAdapter,
+  parseOAuthTokenResponse
+} from "../chunk-OZFXD5IG.js";
 import {
   logException,
   logInfo
 } from "../chunk-PY4AI2GZ.js";
-import "../chunk-SP6LV35L.js";
+import "../chunk-Z5E25LRN.js";
 
 // src/handlers/oauth-callback.ts
 import { after } from "next/server";
@@ -50,13 +53,21 @@ function htmlErrorResponse(title, message, status) {
 }
 async function postSlackMessage(channelId, threadTs, text) {
   try {
-    await getSlackClient().chat.postMessage({ channel: channelId, thread_ts: threadTs, text });
+    await getSlackClient().chat.postMessage({
+      channel: channelId,
+      thread_ts: threadTs,
+      text
+    });
   } catch {
   }
 }
 async function setAssistantStatus(channelId, threadTs, status) {
   try {
-    await getSlackClient().assistant.threads.setStatus({ channel_id: channelId, thread_ts: threadTs, status });
+    await getSlackClient().assistant.threads.setStatus({
+      channel_id: channelId,
+      thread_ts: threadTs,
+      status
+    });
   } catch {
   }
 }
@@ -95,9 +106,12 @@ function createDebouncedStatusPoster(channelId, threadTs) {
     }
     pendingStatus = truncated;
     if (!pendingTimer) {
-      pendingTimer = setTimeout(() => {
-        void flush();
-      }, Math.max(1, STATUS_DEBOUNCE_MS - elapsed));
+      pendingTimer = setTimeout(
+        () => {
+          void flush();
+        },
+        Math.max(1, STATUS_DEBOUNCE_MS - elapsed)
+      );
     }
   };
   post.stop = () => {
@@ -138,13 +152,16 @@ function createReadOnlyConfigService(values) {
 }
 async function resumePendingMessage(stored) {
   if (!stored.pendingMessage || !stored.channelId || !stored.threadTs) return;
-  const providerLabel = stored.provider.charAt(0).toUpperCase() + stored.provider.slice(1);
+  const providerLabel = formatProviderLabel(stored.provider);
   await postSlackMessage(
     stored.channelId,
     stored.threadTs,
     `Your ${providerLabel} account is now connected. Processing your request...`
   );
-  const postStatus = createDebouncedStatusPoster(stored.channelId, stored.threadTs);
+  const postStatus = createDebouncedStatusPoster(
+    stored.channelId,
+    stored.threadTs
+  );
   await setAssistantStatus(stored.channelId, stored.threadTs, "Thinking...");
   try {
     const reply = await generateAssistantReply(stored.pendingMessage, {
@@ -191,11 +208,15 @@ async function resumePendingMessage(stored) {
 }
 async function GET2(request, context) {
   const { provider } = await context.params;
-  const providerConfig = getOAuthProviderConfig(provider);
+  const providerConfig = getPluginOAuthConfig(provider);
   if (!providerConfig) {
-    return htmlErrorResponse("Unknown provider", "The OAuth provider in this link is not recognized.", 404);
+    return htmlErrorResponse(
+      "Unknown provider",
+      "The OAuth provider in this link is not recognized.",
+      404
+    );
   }
-  const providerLabel = provider.charAt(0).toUpperCase() + provider.slice(1);
+  const providerLabel = formatProviderLabel(provider);
   const url = new URL(request.url);
   const errorParam = url.searchParams.get("error");
   const code = url.searchParams.get("code");
@@ -219,7 +240,11 @@ async function GET2(request, context) {
     );
   }
   if (!code || !state) {
-    return htmlErrorResponse("Invalid request", "This authorization link is missing required parameters.", 400);
+    return htmlErrorResponse(
+      "Invalid request",
+      "This authorization link is missing required parameters.",
+      400
+    );
   }
   const stateAdapter = getStateAdapter();
   const stateKey = `oauth-state:${state}`;
@@ -232,51 +257,76 @@ async function GET2(request, context) {
     );
   }
   if (stored.provider !== provider) {
-    return htmlErrorResponse("Provider mismatch", "This authorization link does not match the expected provider.", 400);
+    return htmlErrorResponse(
+      "Provider mismatch",
+      "This authorization link does not match the expected provider.",
+      400
+    );
   }
   await stateAdapter.delete(stateKey);
   const clientId = process.env[providerConfig.clientIdEnv]?.trim();
   const clientSecret = process.env[providerConfig.clientSecretEnv]?.trim();
   if (!clientId || !clientSecret) {
-    return htmlErrorResponse("Configuration error", "OAuth client credentials are not configured on the server.", 500);
+    return htmlErrorResponse(
+      "Configuration error",
+      "OAuth client credentials are not configured on the server.",
+      500
+    );
   }
   const baseUrl = resolveBaseUrl();
   if (!baseUrl) {
-    return htmlErrorResponse("Configuration error", "The server cannot determine its base URL.", 500);
+    return htmlErrorResponse(
+      "Configuration error",
+      "The server cannot determine its base URL.",
+      500
+    );
   }
   const redirectUri = `${baseUrl}${providerConfig.callbackPath}`;
   let tokenResponse;
   try {
-    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body: new URLSearchParams({
+    const tokenRequest = buildOAuthTokenRequest({
+      clientId,
+      clientSecret,
+      payload: {
         grant_type: "authorization_code",
         code,
-        client_id: clientId,
-        client_secret: clientSecret,
         redirect_uri: redirectUri
-      })
+      },
+      tokenAuthMethod: providerConfig.tokenAuthMethod,
+      tokenExtraHeaders: providerConfig.tokenExtraHeaders
+    });
+    tokenResponse = await fetch(providerConfig.tokenEndpoint, {
+      method: "POST",
+      headers: tokenRequest.headers,
+      body: tokenRequest.body
     });
   } catch {
-    return htmlErrorResponse("Connection failed", "Failed to exchange the authorization code. Please try again.", 500);
+    return htmlErrorResponse(
+      "Connection failed",
+      "Failed to exchange the authorization code. Please try again.",
+      500
+    );
   }
   if (!tokenResponse.ok) {
-    return htmlErrorResponse("Connection failed", "The token exchange with the provider failed. Please try again.", 500);
+    return htmlErrorResponse(
+      "Connection failed",
+      "The token exchange with the provider failed. Please try again.",
+      500
+    );
   }
   const tokenData = await tokenResponse.json();
-  if (!tokenData.access_token || !tokenData.refresh_token || typeof tokenData.expires_in !== "number") {
-    return htmlErrorResponse("Connection failed", "The provider returned an incomplete token response. Please try again.", 500);
+  let parsedTokenResponse;
+  try {
+    parsedTokenResponse = parseOAuthTokenResponse(tokenData);
+  } catch {
+    return htmlErrorResponse(
+      "Connection failed",
+      "The provider returned an incomplete token response. Please try again.",
+      500
+    );
   }
-  const accessToken = tokenData.access_token;
-  const refreshToken = tokenData.refresh_token;
-  const expiresAt = Date.now() + tokenData.expires_in * 1e3;
   const userTokenStore = getUserTokenStore();
-  await userTokenStore.set(stored.userId, provider, {
-    accessToken,
-    refreshToken,
-    expiresAt
-  });
+  await userTokenStore.set(stored.userId, provider, parsedTokenResponse);
   after(async () => {
     try {
       await publishAppHomeView(getSlackClient(), stored.userId, userTokenStore);

package/dist/handlers/webhooks.js

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