@sentry/junior 0.12.1 → 0.14.0

package/dist/{chunk-SCG4PCEG.js → chunk-ESPIOJPM.js}

@@ -2,7 +2,7 @@ import {
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall,
   withSpan
-} from "./chunk-Y2LVMCQ3.js";
+} from "./chunk-5JHLDXBN.js";
 
 // src/chat/state/adapter.ts
 import { createMemoryState } from "@chat-adapter/state-memory";
@@ -176,7 +176,16 @@ var NON_INTERACTIVE_ENV = {
   GH_SPINNER_DISABLED: "1",
   GIT_TERMINAL_PROMPT: "0",
   GCM_INTERACTIVE: "never",
-  DEBIAN_FRONTEND: "noninteractive"
+  DEBIAN_FRONTEND: "noninteractive",
+  // Git credential isolation: prevent git from sending its own auth so the
+  // sandbox network proxy's header transforms are the sole credential source.
+  GIT_ASKPASS: "/bin/true",
+  GIT_CONFIG_NOSYSTEM: "1",
+  GIT_CONFIG_COUNT: "2",
+  GIT_CONFIG_KEY_0: "credential.helper",
+  GIT_CONFIG_VALUE_0: "",
+  GIT_CONFIG_KEY_1: "http.emptyAuth",
+  GIT_CONFIG_VALUE_1: "true"
 };
 function shellQuote(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;

package/dist/{chunk-IH4T747D.js → chunk-KTBQH6L5.js}

@@ -4,9 +4,11 @@ import {
   getPluginForSkillPath,
   getPluginSkillRoots,
   logInfo,
-  logWarn,
+  logWarn
+} from "./chunk-5JHLDXBN.js";
+import {
   skillRoots
-} from "./chunk-Y2LVMCQ3.js";
+} from "./chunk-RBB2MZAN.js";
 
 // src/chat/skills.ts
 import fs from "fs/promises";

package/dist/chunk-RBB2MZAN.js

@@ -0,0 +1,342 @@
+// src/chat/plugins/package-discovery.ts
+import path2 from "path";
+
+// src/chat/discovery.ts
+import fs, { statSync } from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function isDirectory(targetPath) {
+  try {
+    return statSync(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile(targetPath) {
+  try {
+    return statSync(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+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 unique(values) {
+  return [...new Set(values)];
+}
+function pathExists(targetPath) {
+  try {
+    fs.accessSync(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasAnyDataMarkers(appDir) {
+  return pathExists(path.join(appDir, "SOUL.md")) || pathExists(path.join(appDir, "ABOUT.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path.join(appDir, "ABOUT.md"))) {
+    score += 2;
+  }
+  if (pathExists(path.join(appDir, "skills"))) {
+    score += 1;
+  }
+  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;
+    }
+    if (seen.has(appDir)) {
+      continue;
+    }
+    seen.add(appDir);
+    resolved.push(appDir);
+  }
+  return resolved;
+}
+function homeDir() {
+  return resolveHomeDir();
+}
+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 = 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];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path.join(homeDir(), subdir)];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique(resolveContentRoots("skills"));
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function aboutPathCandidates() {
+  const candidates = dataRoots().map((root) => path.join(root, "ABOUT.md"));
+  return unique(candidates);
+}
+
+// src/chat/plugins/package-discovery.ts
+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 pathForTracingInclude(cwd, targetPath) {
+  const relative = path2.relative(cwd, targetPath);
+  if (!relative || path2.isAbsolute(relative)) {
+    return null;
+  }
+  const normalized = normalizeForGlob(relative);
+  return normalized.startsWith(".") ? normalized : `./${normalized}`;
+}
+var configuredPluginPackages;
+function setPluginPackages(packages) {
+  configuredPluginPackages = packages;
+}
+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)
+      };
+    }
+  }
+  return null;
+}
+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 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 pluginFlags = readPluginPackageFlags(resolved.dir);
+    if (!pluginFlags) {
+      continue;
+    }
+    seenPackageNames.add(packageName);
+    seenPackageDirs.add(resolved.dir);
+    discovered.push({
+      name: packageName,
+      dir: resolved.dir,
+      nodeModulesDir: resolved.nodeModulesDir,
+      ...pluginFlags
+    });
+  }
+  return discovered;
+}
+function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
+  const resolvedCwd = path2.resolve(cwd);
+  const packageNames = options?.packageNames ?? configuredPluginPackages ?? [];
+  const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
+  const discoveredPackages = discoverDeclaredPackages(
+    packageNames,
+    nodeModulesDirs
+  );
+  const manifestRoots = [];
+  const skillRoots2 = [];
+  const tracingIncludes = [];
+  for (const pkg of discoveredPackages) {
+    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 (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugin.yaml`);
+      }
+    }
+    if (pkg.hasPluginsDir) {
+      manifestRoots.push(path2.join(pkg.dir, "plugins"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
+      }
+    }
+    if (pkg.hasSkillsDir) {
+      skillRoots2.push(path2.join(pkg.dir, "skills"));
+      if (tracingBasePath) {
+        tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
+      }
+    }
+  }
+  return {
+    packageNames: uniqueStringsInOrder(
+      discoveredPackages.map((pkg) => pkg.name)
+    ),
+    manifestRoots: uniqueStringsInOrder(manifestRoots),
+    skillRoots: uniqueStringsInOrder(skillRoots2),
+    tracingIncludes: uniqueStringsInOrder(tracingIncludes)
+  };
+}
+
+export {
+  homeDir,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  aboutPathCandidates,
+  setPluginPackages,
+  discoverInstalledPluginPackageContent
+};

package/dist/cli/check.js

@@ -1,10 +1,11 @@
 import {
   parseSkillFile
-} from "../chunk-IH4T747D.js";
+} from "../chunk-KTBQH6L5.js";
 import {
   parsePluginManifest
-} from "../chunk-Y2LVMCQ3.js";
+} from "../chunk-5JHLDXBN.js";
 import "../chunk-Z3YD6NHK.js";
+import "../chunk-RBB2MZAN.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/check.ts

package/dist/cli/init.js

@@ -1,6 +1,3 @@
-import {
-  juniorVercelConfig
-} from "../chunk-ZLVM4R7R.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/init.ts
@@ -9,9 +6,7 @@ import path from "path";
 function writeServerEntry(targetDir) {
   fs.writeFileSync(
     path.join(targetDir, "server.ts"),
-    `// Static import so Vercel's NFT traces hono (used internally by @sentry/junior).
-import "hono";
-import { initSentry } from "@sentry/junior/instrumentation";
+    `import { initSentry } from "@sentry/junior/instrumentation";
 initSentry();
 
 import { createApp } from "@sentry/junior";
@@ -22,11 +17,41 @@ export default app;
 `
   );
 }
+function writeNitroConfig(targetDir) {
+  fs.writeFileSync(
+    path.join(targetDir, "nitro.config.ts"),
+    `import { defineConfig } from "nitro";
+import { juniorNitro } from "@sentry/junior/nitro";
+
+export default defineConfig({
+  preset: "vercel",
+  modules: [juniorNitro()],
+  routes: {
+    "/api/**": { handler: "./server.ts" },
+  },
+});
+`
+  );
+}
+function writeViteConfig(targetDir) {
+  fs.writeFileSync(
+    path.join(targetDir, "vite.config.ts"),
+    `import { defineConfig } from "vite";
+import { nitro } from "nitro/vite";
+
+export default defineConfig({
+  server: {
+    allowedHosts: true,
+  },
+  plugins: [nitro()],
+});
+`
+  );
+}
 function writeVercelJson(targetDir) {
-  const config = juniorVercelConfig();
   fs.writeFileSync(
     path.join(targetDir, "vercel.json"),
-    `${JSON.stringify(config, null, 2)}
+    `${JSON.stringify({ framework: "nitro", buildCommand: "pnpm build" }, null, 2)}
 `
   );
 }
@@ -54,7 +79,8 @@ async function runInit(dir, log = console.log) {
     private: true,
     type: "module",
     scripts: {
-      build: "junior snapshot create"
+      dev: "vite dev",
+      build: "junior snapshot create && vite build"
     },
     dependencies: {
       "@sentry/junior": "latest",
@@ -62,8 +88,9 @@ async function runInit(dir, log = console.log) {
       hono: "^4.12.0"
     },
     devDependencies: {
+      nitro: "3.0.260311-beta",
       typescript: "^5.9.0",
-      vercel: "^50.37.0"
+      vite: "^8.0.3"
     }
   };
   fs.writeFileSync(
@@ -97,6 +124,8 @@ Describe what ${name} helps users do.
     path.join(target, ".gitignore"),
     `node_modules/
 .vercel/
+.output/
+.nitro/
 .env
 .env.local
 `
@@ -113,10 +142,12 @@ SENTRY_DSN=
 `
   );
   writeServerEntry(target);
+  writeNitroConfig(target);
+  writeViteConfig(target);
   writeVercelJson(target);
   log(`Created ${name} at ${target}`);
   log("");
-  log(`  cd ${targetDir} && pnpm install && vercel dev`);
+  log(`  cd ${targetDir} && pnpm install && pnpm dev`);
   log("");
 }
 export {

package/dist/cli/snapshot-warmup.js

@@ -1,13 +1,14 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-SCG4PCEG.js";
+} from "../chunk-ESPIOJPM.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-Y2LVMCQ3.js";
+} from "../chunk-5JHLDXBN.js";
 import "../chunk-Z3YD6NHK.js";
+import "../chunk-RBB2MZAN.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/snapshot-warmup.ts

package/dist/nitro.d.ts

@@ -0,0 +1,13 @@
+interface JuniorNitroOptions {
+    cwd?: string;
+    maxDuration?: number;
+    pluginPackages?: string[];
+}
+/** Nitro module that copies app and plugin content into the Vercel build output. */
+declare function juniorNitro(options?: JuniorNitroOptions): {
+    nitro: {
+        setup(nitro: unknown): void;
+    };
+};
+
+export { type JuniorNitroOptions, juniorNitro };

package/dist/nitro.js

@@ -0,0 +1,69 @@
+import {
+  discoverInstalledPluginPackageContent
+} from "./chunk-RBB2MZAN.js";
+import "./chunk-2KG3PWR4.js";
+
+// src/nitro.ts
+import { cpSync, existsSync, mkdirSync } from "fs";
+import path from "path";
+function juniorNitro(options = {}) {
+  return {
+    nitro: {
+      setup(nitro) {
+        const cwd = path.resolve(
+          options.cwd ?? nitro.options.rootDir ?? process.cwd()
+        );
+        nitro.options.vercel ??= {};
+        nitro.options.vercel.functions ??= {};
+        nitro.options.vercel.functions.maxDuration ??= options.maxDuration ?? 800;
+        nitro.hooks.hook("compiled", () => {
+          copyAppAndPluginContent(
+            cwd,
+            nitro.options.output.serverDir,
+            options.pluginPackages
+          );
+        });
+      }
+    }
+  };
+}
+function copyAppAndPluginContent(cwd, serverRoot, pluginPackages) {
+  copyIfExists(path.join(cwd, "app"), path.join(serverRoot, "app"));
+  const packagedContent = discoverInstalledPluginPackageContent(cwd, {
+    packageNames: pluginPackages
+  });
+  for (const root of packagedContent.manifestRoots) {
+    if (existsSync(path.join(root, "plugin.yaml"))) {
+      const relative = path.relative(cwd, root);
+      if (!relative || path.isAbsolute(relative) || relative.startsWith("..")) {
+        continue;
+      }
+      copyIfExists(
+        path.join(root, "plugin.yaml"),
+        path.join(serverRoot, relative, "plugin.yaml")
+      );
+      continue;
+    }
+    copyRootIntoServerOutput(cwd, serverRoot, root);
+  }
+  for (const root of packagedContent.skillRoots) {
+    copyRootIntoServerOutput(cwd, serverRoot, root);
+  }
+}
+function copyIfExists(source, target) {
+  if (!existsSync(source)) {
+    return;
+  }
+  mkdirSync(path.dirname(target), { recursive: true });
+  cpSync(source, target, { recursive: true });
+}
+function copyRootIntoServerOutput(cwd, serverRoot, root) {
+  const relative = path.relative(cwd, root);
+  if (!relative || path.isAbsolute(relative) || relative.startsWith("..")) {
+    return;
+  }
+  copyIfExists(root, path.join(serverRoot, relative));
+}
+export {
+  juniorNitro
+};

package/dist/vercel.d.ts

@@ -1,13 +1,7 @@
-/** Default glob for bundling app content and plugin packages into the Vercel function. */
-/** Default glob for bundling app content and plugin package assets into the Vercel function. */
-declare const DEFAULT_INCLUDE_FILES = "{./app/**,./node_modules/@sentry/junior*/plugin.yaml,./node_modules/@sentry/junior*/skills/**,./node_modules/@sentry/junior*/plugins/**}";
 interface JuniorVercelConfigOptions {
-    entrypoint?: string;
-    maxDuration?: number;
-    includeFiles?: string;
     buildCommand?: string | null;
 }
-/** Return the default Vercel config used by scaffolded Junior apps. */
+/** Return a minimal Vercel config for scaffolded Junior apps. */
 declare function juniorVercelConfig(options?: JuniorVercelConfigOptions): Record<string, unknown>;
 
-export { DEFAULT_INCLUDE_FILES, type JuniorVercelConfigOptions, juniorVercelConfig };
+export { type JuniorVercelConfigOptions, juniorVercelConfig };

package/dist/vercel.js

@@ -1,9 +1,16 @@
-import {
-  DEFAULT_INCLUDE_FILES,
-  juniorVercelConfig
-} from "./chunk-ZLVM4R7R.js";
 import "./chunk-2KG3PWR4.js";
+
+// src/vercel.ts
+function juniorVercelConfig(options = {}) {
+  const buildCommand = options.buildCommand === void 0 ? "pnpm build" : options.buildCommand;
+  const config = {
+    framework: "nitro"
+  };
+  if (buildCommand !== null) {
+    config.buildCommand = buildCommand;
+  }
+  return config;
+}
 export {
-  DEFAULT_INCLUDE_FILES,
   juniorVercelConfig
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -12,6 +12,7 @@
   "exports": {
     ".": "./dist/app.js",
     "./instrumentation": "./dist/instrumentation.js",
+    "./nitro": "./dist/nitro.js",
     "./vercel": "./dist/vercel.js"
   },
   "files": [
@@ -46,6 +47,7 @@
     "@sentry/node": "^10.46.0",
     "@types/node": "^25.5.0",
     "msw": "^2.12.14",
+    "nitro": "3.0.260311-beta",
     "tsup": "^8.5.1",
     "typescript": "^5.9.3",
     "vercel": "^50.37.3",

package/dist/chunk-ZLVM4R7R.js

@@ -1,25 +0,0 @@
-// src/vercel.ts
-var DEFAULT_INCLUDE_FILES = "{./app/**,./node_modules/@sentry/junior*/plugin.yaml,./node_modules/@sentry/junior*/skills/**,./node_modules/@sentry/junior*/plugins/**}";
-function juniorVercelConfig(options = {}) {
-  const entrypoint = options.entrypoint ?? "server.ts";
-  const maxDuration = options.maxDuration ?? 800;
-  const buildCommand = options.buildCommand === void 0 ? "pnpm build" : options.buildCommand;
-  const config = {
-    framework: "hono",
-    functions: {
-      [entrypoint]: {
-        maxDuration,
-        includeFiles: options.includeFiles ?? DEFAULT_INCLUDE_FILES
-      }
-    }
-  };
-  if (buildCommand !== null) {
-    config.buildCommand = buildCommand;
-  }
-  return config;
-}
-
-export {
-  DEFAULT_INCLUDE_FILES,
-  juniorVercelConfig
-};