@sentry/junior 0.43.0 → 0.45.0

package/dist/{chunk-YSXHRIWR.js → chunk-QAMTCT2R.js}

@@ -563,6 +563,9 @@ function getVercelSandboxCredentials() {
 function createSandboxInstance(sandbox) {
   return {
     sandboxId: sandbox.name,
+    get sandboxEgressId() {
+      return sandbox.currentSession().sessionId;
+    },
     fs: sandbox.fs,
     extendTimeout(duration) {
       return sandbox.extendTimeout(duration);

package/dist/cli/check.js

@@ -58,6 +58,81 @@ async function pathIsFile(targetPath) {
     return false;
   }
 }
+async function readJsonFile(targetPath) {
+  try {
+    return JSON.parse(await fs.readFile(targetPath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function readRootPackageJson(rootDir) {
+  return await readJsonFile(path.join(rootDir, "package.json"));
+}
+function packageInstallDir(rootDir, packageName) {
+  return path.join(rootDir, "node_modules", ...packageName.split("/"));
+}
+function declaredPackages(pkg) {
+  if (!pkg) {
+    return [];
+  }
+  const packages = /* @__PURE__ */ new Map();
+  for (const deps of [
+    pkg.dependencies,
+    pkg.optionalDependencies,
+    pkg.devDependencies
+  ]) {
+    for (const [name, spec] of Object.entries(deps ?? {})) {
+      if (!packages.has(name)) {
+        packages.set(name, spec);
+      }
+    }
+  }
+  return [...packages.entries()].map(([name, spec]) => ({ name, spec })).sort((left, right) => left.name.localeCompare(right.name));
+}
+async function readInstalledPackageVersion(rootDir, packageName) {
+  return (await readJsonFile(
+    path.join(packageInstallDir(rootDir, packageName), "package.json")
+  ))?.version;
+}
+async function packageHasPluginContent(rootDir, packageName) {
+  const packageDir = packageInstallDir(rootDir, packageName);
+  return await pathIsFile(path.join(packageDir, "plugin.yaml")) || await pathIsDirectory(path.join(packageDir, "plugins")) || await pathIsDirectory(path.join(packageDir, "skills"));
+}
+function comparableVersion(version) {
+  return version?.match(/\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?/)?.[0];
+}
+async function collectPackageWarnings(rootDir, packages) {
+  const warnings = [];
+  const packageSpecByName = new Map(
+    packages.map((declaredPackage) => [
+      declaredPackage.name,
+      declaredPackage.spec
+    ])
+  );
+  const coreVersion = comparableVersion(
+    await readInstalledPackageVersion(rootDir, "@sentry/junior") ?? packageSpecByName.get("@sentry/junior")
+  );
+  if (!coreVersion) {
+    return warnings;
+  }
+  for (const declaredPackage of packages) {
+    if (!declaredPackage.name.startsWith("@sentry/junior-")) {
+      continue;
+    }
+    if (!await packageHasPluginContent(rootDir, declaredPackage.name)) {
+      continue;
+    }
+    const pluginVersion = comparableVersion(
+      await readInstalledPackageVersion(rootDir, declaredPackage.name) ?? declaredPackage.spec
+    );
+    if (pluginVersion && pluginVersion !== coreVersion) {
+      warnings.push(
+        `${path.join(rootDir, "package.json")}: ${declaredPackage.name} version ${pluginVersion} does not match @sentry/junior version ${coreVersion}`
+      );
+    }
+  }
+  return warnings;
+}
 async function validateSkillDirectory(skillDir, duplicateNames) {
   const skillFile = path.join(skillDir, "SKILL.md");
   const errors = [];
@@ -159,6 +234,63 @@ async function collectPluginDirectories(rootDir) {
   }
   return pluginDirs.sort((left, right) => left.localeCompare(right));
 }
+async function collectPackagedContent(rootDir, packages) {
+  const pluginDirs = [];
+  const skillRoots = [];
+  for (const declaredPackage of packages) {
+    const packageDir = packageInstallDir(rootDir, declaredPackage.name);
+    if (!await pathIsDirectory(packageDir)) {
+      continue;
+    }
+    const rootManifestPath = path.join(packageDir, "plugin.yaml");
+    const hasRootManifest = await pathIsFile(rootManifestPath);
+    const packageSkillsRoot = path.join(packageDir, "skills");
+    if (hasRootManifest) {
+      pluginDirs.push({
+        pluginDir: packageDir,
+        packageName: declaredPackage.name
+      });
+    } else if (await pathIsDirectory(packageSkillsRoot)) {
+      skillRoots.push({
+        root: packageSkillsRoot,
+        packageName: declaredPackage.name
+      });
+    }
+    const nestedPluginsRoot = path.join(packageDir, "plugins");
+    let nestedEntries;
+    try {
+      nestedEntries = await fs.readdir(nestedPluginsRoot, {
+        withFileTypes: true
+      });
+    } catch {
+      continue;
+    }
+    for (const entry of nestedEntries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const pluginDir = path.join(nestedPluginsRoot, entry.name);
+      if (await pathIsFile(path.join(pluginDir, "plugin.yaml"))) {
+        pluginDirs.push({
+          pluginDir,
+          packageName: declaredPackage.name
+        });
+      }
+    }
+  }
+  return {
+    pluginDirs: pluginDirs.sort(
+      (left, right) => `${left.packageName}:${left.pluginDir}`.localeCompare(
+        `${right.packageName}:${right.pluginDir}`
+      )
+    ),
+    skillRoots: skillRoots.sort(
+      (left, right) => `${left.packageName}:${left.root}`.localeCompare(
+        `${right.packageName}:${right.root}`
+      )
+    )
+  };
+}
 async function collectSkillDirectories(root) {
   const skillDirs = [];
   let entries;
@@ -222,7 +354,8 @@ function reportPluginResult(result, io) {
     skillWarningCount
   );
   const pluginName = result.manifest?.name ?? path.basename(result.pluginDir);
-  io.info(formatHeading(status, `plugin ${pluginName}`));
+  const label = result.packageName ? `packaged plugin ${pluginName} (${result.packageName})` : `plugin ${pluginName}`;
+  io.info(formatHeading(status, label));
   for (const [index, skillResult] of result.skillResults.entries()) {
     reportSkillResult(
       skillResult,
@@ -232,7 +365,7 @@ function reportPluginResult(result, io) {
     );
   }
 }
-function reportAppSkills(skillResults, io) {
+function reportSkillGroup(label, skillResults, io) {
   const errorCount = skillResults.reduce(
     (count, skillResult) => count + skillResult.errors.length,
     0
@@ -242,11 +375,14 @@ function reportAppSkills(skillResults, io) {
     0
   );
   const status = formatStatus(errorCount, warningCount);
-  io.info(formatHeading(status, "app skills"));
+  io.info(formatHeading(status, label));
   for (const [index, skillResult] of skillResults.entries()) {
     reportSkillResult(skillResult, io, "  ", index === skillResults.length - 1);
   }
 }
+function reportAppSkills(skillResults, io) {
+  reportSkillGroup("app skills", skillResults, io);
+}
 async function validateAppFiles(appDir) {
   const errors = [];
   const warnings = [];
@@ -293,52 +429,111 @@ async function runCheck(rootDir = process.cwd(), io = DEFAULT_IO) {
       `validation root does not exist or is not a directory: ${resolvedRoot}`
     );
   }
-  const pluginDirs = await collectPluginDirectories(resolvedRoot);
+  const rootPackageJson = await readRootPackageJson(resolvedRoot);
+  const packages = declaredPackages(rootPackageJson);
+  const packageWarnings = await collectPackageWarnings(resolvedRoot, packages);
+  const packagedContent = await collectPackagedContent(resolvedRoot, packages);
+  const appPluginDirs = await collectPluginDirectories(resolvedRoot);
+  const packagedPluginDirs = packagedContent.pluginDirs;
+  const pluginDirs = [
+    ...appPluginDirs.map((pluginDir) => ({
+      pluginDir,
+      packageName: void 0
+    })),
+    ...packagedPluginDirs
+  ];
   const appSkillsRoot = contentRoot(resolvedRoot, "skills");
   const appSkillDirs = await collectSkillDirectories(appSkillsRoot);
   const pluginSkillDirs = /* @__PURE__ */ new Map();
-  for (const pluginDir of pluginDirs) {
+  for (const { pluginDir } of pluginDirs) {
     pluginSkillDirs.set(
       pluginDir,
       await collectSkillDirectories(path.join(pluginDir, "skills"))
     );
   }
-  const skillDirs = [
+  const packagedSkillDirsByPackage = /* @__PURE__ */ new Map();
+  for (const skillRoot of packagedContent.skillRoots) {
+    packagedSkillDirsByPackage.set(
+      skillRoot.packageName,
+      await collectSkillDirectories(skillRoot.root)
+    );
+  }
+  const packagedStandaloneSkillDirs = [
+    ...packagedSkillDirsByPackage.values()
+  ].flat();
+  const appAndLocalPluginSkillDirs = [
     ...appSkillDirs,
-    ...pluginDirs.flatMap((pluginDir) => pluginSkillDirs.get(pluginDir) ?? [])
+    ...appPluginDirs.flatMap(
+      (pluginDir) => pluginSkillDirs.get(pluginDir) ?? []
+    )
   ].sort((left, right) => left.localeCompare(right));
+  const packagedSkillDirs = [
+    ...packagedPluginDirs.flatMap(
+      ({ pluginDir }) => pluginSkillDirs.get(pluginDir) ?? []
+    ),
+    ...packagedStandaloneSkillDirs
+  ].sort((left, right) => left.localeCompare(right));
+  const skillDirs = [...appAndLocalPluginSkillDirs, ...packagedSkillDirs].sort(
+    (left, right) => left.localeCompare(right)
+  );
   const duplicateSkillNames = /* @__PURE__ */ new Map();
   const duplicatePluginNames = /* @__PURE__ */ new Map();
   const duplicateProviderDomains = /* @__PURE__ */ new Map();
+  const duplicatePackagedSkillNames = /* @__PURE__ */ new Map();
+  const duplicatePackagedPluginNames = /* @__PURE__ */ new Map();
+  const duplicatePackagedProviderDomains = /* @__PURE__ */ new Map();
   const warnings = [];
   const errors = [];
   const pluginResults = [];
   const skillResultsByDir = /* @__PURE__ */ new Map();
-  for (const pluginDir of pluginDirs) {
+  warnings.push(...packageWarnings);
+  for (const { pluginDir, packageName } of pluginDirs) {
+    const pluginNameMap = packageName ? duplicatePackagedPluginNames : duplicatePluginNames;
+    const providerDomainMap = packageName ? duplicatePackagedProviderDomains : duplicateProviderDomains;
     const result = await validatePluginDirectory(
       pluginDir,
-      duplicatePluginNames,
-      duplicateProviderDomains
+      pluginNameMap,
+      providerDomainMap
     );
     pluginResults.push({
       pluginDir,
       manifestPath: result.manifestPath,
+      ...packageName ? { packageName } : {},
       ...result.manifest ? { manifest: result.manifest } : {},
       errors: result.errors,
       skillResults: []
     });
     errors.push(...result.errors);
   }
-  for (const skillDir of skillDirs) {
+  for (const skillDir of appAndLocalPluginSkillDirs) {
     const result = await validateSkillDirectory(skillDir, duplicateSkillNames);
     skillResultsByDir.set(skillDir, result);
     warnings.push(...result.warnings);
     errors.push(...result.errors);
   }
+  for (const skillDir of packagedSkillDirs) {
+    const result = await validateSkillDirectory(
+      skillDir,
+      duplicatePackagedSkillNames
+    );
+    skillResultsByDir.set(skillDir, result);
+    warnings.push(...result.warnings);
+    errors.push(...result.errors);
+  }
   for (const pluginResult of pluginResults) {
     pluginResult.skillResults = (pluginSkillDirs.get(pluginResult.pluginDir) ?? []).map((skillDir) => skillResultsByDir.get(skillDir)).filter((result) => Boolean(result));
   }
   const appSkillResults = appSkillDirs.map((skillDir) => skillResultsByDir.get(skillDir)).filter((result) => Boolean(result));
+  const packagedStandaloneSkillResultsByPackage = /* @__PURE__ */ new Map();
+  for (const [packageName, packageSkillDirs] of packagedSkillDirsByPackage) {
+    const packageSkillResults = packageSkillDirs.map((skillDir) => skillResultsByDir.get(skillDir)).filter((result) => Boolean(result));
+    if (packageSkillResults.length > 0) {
+      packagedStandaloneSkillResultsByPackage.set(
+        packageName,
+        packageSkillResults
+      );
+    }
+  }
   const appDir = path.resolve(resolvedRoot, "app");
   let appFileResult = {
     errors: [],
@@ -366,6 +561,16 @@ async function runCheck(rootDir = process.cwd(), io = DEFAULT_IO) {
   for (const pluginResult of pluginResults) {
     reportPluginResult(pluginResult, io);
   }
+  for (const [
+    packageName,
+    packageSkillResults
+  ] of packagedStandaloneSkillResultsByPackage) {
+    reportSkillGroup(
+      `packaged skills (${packageName})`,
+      packageSkillResults,
+      io
+    );
+  }
   if (appSkillResults.length > 0) {
     reportAppSkills(appSkillResults, io);
   }

package/dist/cli/init.js

@@ -80,6 +80,7 @@ async function runInit(dir, log = console.log) {
     type: "module",
     scripts: {
       dev: "vite dev",
+      check: "junior check",
       build: "junior snapshot create && vite build"
     },
     dependencies: {

package/dist/cli/snapshot-warmup.js

@@ -1,7 +1,7 @@
 import {
   disconnectStateAdapter,
   resolveRuntimeDependencySnapshot
-} from "../chunk-YSXHRIWR.js";
+} from "../chunk-QAMTCT2R.js";
 import {
   getPluginProviders,
   getPluginRuntimeDependencies,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sentry/junior",
-  "version": "0.43.0",
+  "version": "0.45.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -21,9 +21,9 @@
   ],
   "dependencies": {
     "@ai-sdk/gateway": "^3.0.110",
-    "@chat-adapter/slack": "4.27.0",
-    "@chat-adapter/state-memory": "4.27.0",
-    "@chat-adapter/state-redis": "4.27.0",
+    "@chat-adapter/slack": "4.28.1",
+    "@chat-adapter/state-memory": "4.28.1",
+    "@chat-adapter/state-redis": "4.28.1",
     "@logtape/logtape": "^2.0.7",
     "@mariozechner/pi-agent-core": "0.73.0",
     "@mariozechner/pi-ai": "0.73.0",
@@ -34,7 +34,7 @@
     "@vercel/sandbox": "2.0.0-beta.19",
     "ai": "^6.0.175",
     "bash-tool": "^1.3.16",
-    "chat": "4.27.0",
+    "chat": "4.28.1",
     "hono": "^4.12.6",
     "just-bash": "2.14.2",
     "jose": "^6.2.2",