@sentry/junior 0.12.0 → 0.13.0

package/dist/chunk-XH7TV4JS.js

@@ -0,0 +1,560 @@
+// src/chat/plugins/package-discovery.ts
+import { readFileSync, readdirSync as readdirSync2 } from "fs";
+import path2 from "path";
+import { parse as parseYaml } from "yaml";
+
+// src/chat/discovery.ts
+import fs, { readdirSync, 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 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;
+}
+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}`;
+}
+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()));
+}
+var configuredPluginPackages;
+function setPluginPackages(packages) {
+  configuredPluginPackages = packages;
+}
+function readNextRuntimeConfiguredPackageNames() {
+  if (configuredPluginPackages !== void 0) {
+    return configuredPluginPackages;
+  }
+  const raw = process.env.JUNIOR_PLUGIN_PACKAGES;
+  if (raw === void 0) {
+    return null;
+  }
+  try {
+    return parseRuntimeConfiguredPackageNames(JSON.parse(raw)) ?? [];
+  } catch {
+    return [];
+  }
+}
+function findWorkspaceRoot(cwd) {
+  let current = path2.resolve(cwd);
+  while (true) {
+    const candidate = path2.join(current, "pnpm-workspace.yaml");
+    if (isFile(candidate)) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    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("/"));
+    if (isDirectory(packageDir)) {
+      return {
+        dir: path2.resolve(packageDir),
+        nodeModulesDir: path2.resolve(nodeModulesDir)
+      };
+    }
+  }
+  return null;
+}
+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
+    );
+    const workspaceDir = resolved ? null : resolveWorkspacePackageDirFromName(cwd, packageName);
+    if (!resolved && !workspaceDir) {
+      continue;
+    }
+    const packageDir = resolved?.dir ?? workspaceDir;
+    if (seenPackageNames.has(packageName) || seenPackageDirs.has(packageDir)) {
+      continue;
+    }
+    const pluginFlags = readPluginPackageFlags(packageDir);
+    if (!pluginFlags) {
+      continue;
+    }
+    seenPackageNames.add(packageName);
+    seenPackageDirs.add(packageDir);
+    discovered.push({
+      name: packageName,
+      dir: packageDir,
+      nodeModulesDir: resolved?.nodeModulesDir ?? null,
+      ...pluginFlags
+    });
+  }
+  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(
+    resolvedCwd,
+    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 configuredPackageNames = options?.packageNames ?? readNextRuntimeConfiguredPackageNames();
+  const discoveredPackages = discoverInstalledJuniorContentPackages(
+    resolvedCwd,
+    options?.nodeModulesDirs,
+    configuredPackageNames
+  );
+  const workspacePluginDirs = discoverWorkspacePluginPackageDirs(
+    resolvedCwd,
+    configuredPackageNames
+  );
+  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/**/*`);
+      }
+    }
+  }
+  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"))) {
+      skillRoots2.push(path2.join(pluginDir, "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-7YFFZCL4.js";
 import {
   parsePluginManifest
-} from "../chunk-Y2LVMCQ3.js";
+} from "../chunk-WZXIUH5S.js";
 import "../chunk-Z3YD6NHK.js";
+import "../chunk-XH7TV4JS.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,8 +6,7 @@ import path from "path";
 function writeServerEntry(targetDir) {
   fs.writeFileSync(
     path.join(targetDir, "server.ts"),
-    `import "hono";
-import { initSentry } from "@sentry/junior/instrumentation";
+    `import { initSentry } from "@sentry/junior/instrumentation";
 initSentry();
 
 import { createApp } from "@sentry/junior";
@@ -21,11 +17,35 @@ export default app;
 `
   );
 }
+function writeNitroConfig(targetDir) {
+  fs.writeFileSync(
+    path.join(targetDir, "nitro.config.ts"),
+    `import { juniorNitroConfig } from "@sentry/junior/nitro";
+import { defineConfig } from "nitro";
+
+export default defineConfig(juniorNitroConfig());
+`
+  );
+}
+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({ buildCommand: "pnpm build" }, null, 2)}
 `
   );
 }
@@ -53,7 +73,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",
@@ -61,8 +82,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(
@@ -96,6 +118,8 @@ Describe what ${name} helps users do.
     path.join(target, ".gitignore"),
     `node_modules/
 .vercel/
+.output/
+.nitro/
 .env
 .env.local
 `
@@ -112,10 +136,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-C4N7XWDT.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,
   getPluginRuntimePostinstall
-} from "../chunk-Y2LVMCQ3.js";
+} from "../chunk-WZXIUH5S.js";
 import "../chunk-Z3YD6NHK.js";
+import "../chunk-XH7TV4JS.js";
 import "../chunk-2KG3PWR4.js";
 
 // src/cli/snapshot-warmup.ts

package/dist/nitro.d.ts

@@ -0,0 +1,27 @@
+interface JuniorNitroConfigOptions {
+    cwd?: string;
+    maxDuration?: number;
+}
+/** Return the default Nitro config used by scaffolded Junior apps. */
+declare function juniorNitroConfig(options?: JuniorNitroConfigOptions): {
+    preset: "vercel";
+    vercel: {
+        functions: {
+            maxDuration: number;
+        };
+    };
+    modules: {
+        setup(nitro: {
+            hooks: {
+                hook(name: "compiled", callback: () => void): void;
+            };
+            options: {
+                output: {
+                    serverDir: string;
+                };
+            };
+        }): void;
+    }[];
+};
+
+export { type JuniorNitroConfigOptions, juniorNitroConfig };