@sentry/junior 0.119.0 → 0.121.0

package/dist/{chunk-BLQZACHV.js → chunk-7HYV7KFM.js}

@@ -1,21 +1,23 @@
 import {
   getDb
-} from "./chunk-D3N4BPSL.js";
+} from "./chunk-254MFDOF.js";
 import {
-  juniorConversationAnnotations
+  juniorConversationAnnotations,
+  juniorIdentities,
+  juniorUsers
 } from "./chunk-GCGJGSQL.js";
 import {
   SANDBOX_WORKSPACE_ROOT,
   getStateAdapter,
   sleep
-} from "./chunk-VJTWKJWQ.js";
+} from "./chunk-UURFXX66.js";
 import {
   botConfig,
   completeObject,
   embedTexts,
   getSlackBotToken,
   standardModelId
-} from "./chunk-VLTWQQKH.js";
+} from "./chunk-IDXLBKPS.js";
 import {
   isActorUserId,
   parseActorUserId
@@ -24,10 +26,11 @@ import {
   logException,
   logInfo,
   logWarn,
+  normalizeIdentityEmail,
   setSpanAttributes,
   setSpanStatus,
   withSpan
-} from "./chunk-ZJ6IVZVO.js";
+} from "./chunk-JZ47AFSH.js";
 import {
   parseSlackChannelReferenceId,
   parseSlackMessageTs,
@@ -321,6 +324,55 @@ function getSlackToolContext(context) {
   };
 }
 
+// src/chat/plugins/viewer-actors.ts
+import { and as and2, eq as eq2 } from "drizzle-orm";
+import {
+  actorSchema
+} from "@sentry/junior-plugin-api";
+async function readViewerActorsFromSql(db, email) {
+  const normalizedEmail = normalizeIdentityEmail(email);
+  if (!normalizedEmail) return [];
+  const rows = await db.select({
+    displayName: juniorIdentities.displayName,
+    email: juniorUsers.primaryEmail,
+    handle: juniorIdentities.handle,
+    provider: juniorIdentities.provider,
+    providerSubjectId: juniorIdentities.providerSubjectId,
+    providerTenantId: juniorIdentities.providerTenantId
+  }).from(juniorIdentities).innerJoin(juniorUsers, eq2(juniorUsers.id, juniorIdentities.userId)).where(
+    and2(
+      eq2(juniorUsers.primaryEmailNormalized, normalizedEmail),
+      eq2(juniorIdentities.kind, "user")
+    )
+  );
+  const actors = [];
+  for (const row of rows) {
+    const candidate = row.provider === "slack" ? {
+      platform: "slack",
+      teamId: row.providerTenantId,
+      userId: row.providerSubjectId,
+      email: row.email,
+      ...row.displayName ? { fullName: row.displayName } : {},
+      ...row.handle ? { userName: row.handle } : {}
+    } : row.provider === "local" ? {
+      platform: "local",
+      userId: row.providerSubjectId,
+      email: row.email,
+      ...row.displayName ? { fullName: row.displayName } : {},
+      ...row.handle ? { userName: row.handle } : {}
+    } : void 0;
+    if (!candidate) continue;
+    const parsed = actorSchema.safeParse(candidate);
+    if (parsed.success && parsed.data.platform !== "system") {
+      actors.push(parsed.data);
+    }
+  }
+  return actors;
+}
+async function readViewerActors(email) {
+  return await readViewerActorsFromSql(getDb(), email);
+}
+
 // src/chat/credentials/subject.ts
 import { createHmac, timingSafeEqual } from "crypto";
 
@@ -941,6 +993,7 @@ function invocationPluginContext(plugin, context) {
     ...base,
     conversationId: context.conversationId,
     embedder: createPluginEmbedder(plugin.manifest.name),
+    model: createPluginModel(plugin.manifest.name, plugin.model),
     source: context.source,
     text: context.userText ?? "",
     state: createPluginState(plugin.manifest.name)
@@ -968,6 +1021,32 @@ function invocationPluginContext(plugin, context) {
     actor: context.actor?.platform === "local" ? context.actor : void 0
   };
 }
+function pluginMcpContext(plugin, context) {
+  const manager = context.mcpToolManager;
+  const wrappedTools = new Set(plugin.manifest.mcp?.wrappedTools ?? []);
+  if (!manager || wrappedTools.size === 0) {
+    return void 0;
+  }
+  const provider = plugin.manifest.name;
+  const prepare = async () => {
+    await manager.activateProvider(provider);
+    return manager.getActiveProviders().includes(provider) ? "ready" : "authorization_pending";
+  };
+  return {
+    prepare,
+    async callTool(input) {
+      if (await prepare() === "authorization_pending") {
+        return { status: "authorization_pending" };
+      }
+      return await manager.callWrappedTool(
+        provider,
+        input.name,
+        input.arguments ?? {},
+        input.toolCallId ? { toolCallId: input.toolCallId } : void 0
+      );
+    }
+  };
+}
 function safeErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -1239,6 +1318,7 @@ function getPluginTools(context) {
       db: getDb(),
       plugin: pluginName
     }) : void 0;
+    const mcp = pluginMcpContext(plugin, context);
     let pluginContext;
     if (context.source.platform === "slack") {
       if (context.destination.platform !== "slack") {
@@ -1257,6 +1337,7 @@ function getPluginTools(context) {
         userText: context.userText,
         embedder: createPluginEmbedder(pluginName),
         egress: context.egress,
+        ...mcp ? { mcp } : {},
         model: createPluginModel(pluginName, plugin.model),
         state: createPluginState(pluginName)
       };
@@ -1276,6 +1357,7 @@ function getPluginTools(context) {
         userText: context.userText,
         embedder: createPluginEmbedder(pluginName),
         egress: context.egress,
+        ...mcp ? { mcp } : {},
         model: createPluginModel(pluginName, plugin.model),
         state: createPluginState(pluginName)
       };
@@ -1416,7 +1498,10 @@ function getPluginApiRoutes() {
       continue;
     }
     const app = hook({
-      ...basePluginContext(plugin)
+      ...basePluginContext(plugin),
+      viewer: {
+        actors: readViewerActors
+      }
     });
     if (app === void 0) {
       continue;
@@ -1853,6 +1938,7 @@ export {
   setDashboardConversationLinkOptions,
   getDashboardConversationLink,
   getSlackToolContext,
+  readViewerActors,
   runWithWorkspaceTeamId,
   getWorkspaceTeamId,
   SlackActionError,

package/dist/{chunk-JLJLZS2N.js → chunk-D2EMOH3N.js}

@@ -1,7 +1,7 @@
 // package.json
 var package_default = {
   name: "@sentry/junior",
-  version: "0.119.0",
+  version: "0.121.0",
   private: false,
   publishConfig: {
     access: "public"
@@ -49,7 +49,8 @@ var package_default = {
   files: [
     "dist",
     "bin",
-    "migrations"
+    "migrations",
+    "skills"
   ],
   scripts: {
     prepare: "pnpm run build",
@@ -61,7 +62,7 @@ var package_default = {
     test: "vitest run --maxWorkers=4",
     "test:watch": "vitest",
     typecheck: "tsc --noEmit",
-    "skills:check": "node scripts/check-skills.mjs",
+    "skills:check": "node --test scripts/check-skills.test.mjs && node scripts/check-skills.mjs",
     "test:coverage": "vitest run --maxWorkers=4 --coverage --reporter=default --reporter=junit --outputFile.junit=coverage/results.junit.xml"
   },
   dependencies: {

package/dist/{chunk-R53UT2OI.js → chunk-ET2SDCNV.js}

@@ -5,14 +5,14 @@ import {
   logInfo,
   logWarn,
   setSpanAttributes
-} from "./chunk-ZJ6IVZVO.js";
+} from "./chunk-JZ47AFSH.js";
 import {
   discoverInstalledPluginPackageContent,
   normalizePluginPackageNames
-} from "./chunk-B3IT5END.js";
+} from "./chunk-OOUNJNMR.js";
 import {
   pluginRoots
-} from "./chunk-3V7OFJZC.js";
+} from "./chunk-H4HBKISO.js";
 
 // src/chat/plugins/manifest.ts
 import { z } from "zod";
@@ -64,6 +64,7 @@ function inlineMcpSource(mcp) {
   setDefined(result, "url", mcp.url);
   setDefined(result, "headers", mcp.headers);
   setDefined(result, "allowed-tools", mcp.allowedTools);
+  setDefined(result, "wrapped-tools", mcp.wrappedTools);
   return result;
 }
 function inlineOauthSource(oauth) {
@@ -300,7 +301,8 @@ var mcpSourceSchema = z.object({
   }).optional(),
   url: httpsUrlString,
   headers: stringMapSchema.optional(),
-  "allowed-tools": nonEmptyStringArraySchema("allowed-tools").optional()
+  "allowed-tools": nonEmptyStringArraySchema("allowed-tools").optional(),
+  "wrapped-tools": nonEmptyStringArraySchema("wrapped-tools").optional()
 }).passthrough();
 var targetSourceSchema = z.object({
   type: nonEmptyTrimmedString.refine((value) => PLUGIN_NAME_RE.test(value), {
@@ -389,6 +391,7 @@ function manifestConfigPatch(config) {
       setDefined2(mcp, "url", config.mcp.url);
       setDefined2(mcp, "headers", config.mcp.headers);
       setDefined2(mcp, "allowed-tools", config.mcp.allowedTools);
+      setDefined2(mcp, "wrapped-tools", config.mcp.wrappedTools);
       result.mcp = mcp;
     }
   }
@@ -829,7 +832,8 @@ function normalizeMcp(data, envVars, name) {
     transport: "http",
     url: result.data.url,
     ...headers ? { headers } : {},
-    ...result.data["allowed-tools"] ? { allowedTools: result.data["allowed-tools"] } : {}
+    ...result.data["allowed-tools"] ? { allowedTools: result.data["allowed-tools"] } : {},
+    ...result.data["wrapped-tools"] ? { wrappedTools: result.data["wrapped-tools"] } : {}
   };
 }
 function parseManifestSource(parsedSource, dir, config, options) {

package/dist/chunk-H4HBKISO.js

@@ -0,0 +1,417 @@
+// src/chat/discovery.ts
+import fs, { statSync as statSync2 } from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/package-resolution.ts
+import { statSync } from "fs";
+import { createRequire } from "module";
+import path 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 uniqueResolvedPathsInOrder(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const value of values) {
+    const normalized = path.resolve(value);
+    if (seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    resolved.push(normalized);
+  }
+  return resolved;
+}
+function ancestorNodeModulesDirs(cwd) {
+  const dirs = [];
+  let current = path.resolve(cwd);
+  while (true) {
+    const nodeModulesDir = path.join(current, "node_modules");
+    if (isDirectory(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function packageDirInNodeModules(nodeModulesDir, packageName) {
+  const packageDir = path.join(nodeModulesDir, ...packageName.split("/"));
+  return isDirectory(packageDir) ? path.resolve(packageDir) : void 0;
+}
+function isValidPackageSegment(segment) {
+  return Boolean(segment) && segment !== "." && segment !== ".." && !segment.startsWith(".") && /^[A-Za-z0-9._~-]+$/.test(segment);
+}
+function isValidPackageName(packageName) {
+  if (!packageName || packageName.includes("\\") || path.isAbsolute(packageName)) {
+    return false;
+  }
+  const parts = packageName.split("/");
+  if (parts[0].startsWith("@")) {
+    return parts.length === 2 && parts[0].length > 1 && isValidPackageSegment(parts[0].slice(1)) && isValidPackageSegment(parts[1]);
+  }
+  return parts.length === 1 && isValidPackageSegment(parts[0]);
+}
+function findPackageRoot(entryPath) {
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    if (isFile(path.join(dir, "package.json"))) {
+      return path.resolve(dir);
+    }
+    dir = path.dirname(dir);
+  }
+  return void 0;
+}
+function findPackageNodeModulesDir(packageDir, packageName) {
+  const parts = path.resolve(packageDir).split(path.sep);
+  const packageParts = packageName.split("/");
+  for (let index = parts.length - 1; index >= 0; index -= 1) {
+    if (parts[index] !== "node_modules") {
+      continue;
+    }
+    const candidatePackageParts = parts.slice(
+      index + 1,
+      index + 1 + packageParts.length
+    );
+    if (candidatePackageParts.join("/") !== packageParts.join("/")) {
+      continue;
+    }
+    return path.resolve(parts.slice(0, index + 1).join(path.sep) || path.sep);
+  }
+  return void 0;
+}
+function resolvePackageWithNode(cwd, packageName) {
+  let requireFromCwd;
+  try {
+    requireFromCwd = createRequire(path.join(cwd, "package.json"));
+  } catch {
+    return void 0;
+  }
+  for (const specifier of [`${packageName}/package.json`, packageName]) {
+    try {
+      const resolved = requireFromCwd.resolve(specifier);
+      const dir = specifier.endsWith("/package.json") ? path.dirname(resolved) : findPackageRoot(resolved);
+      if (!dir) {
+        continue;
+      }
+      const nodeModulesDir = findPackageNodeModulesDir(dir, packageName);
+      return {
+        dir,
+        ...nodeModulesDir ? { nodeModulesDir } : {}
+      };
+    } catch {
+    }
+  }
+  return void 0;
+}
+function resolvePackageLocation(cwd, packageName, options) {
+  if (!isValidPackageName(packageName)) {
+    return void 0;
+  }
+  const nodeModulesDirs = uniqueResolvedPathsInOrder([
+    ...options?.nodeModulesDirs ?? [],
+    ...ancestorNodeModulesDirs(cwd)
+  ]);
+  for (const nodeModulesDir of nodeModulesDirs) {
+    const dir = packageDirInNodeModules(nodeModulesDir, packageName);
+    if (dir) {
+      return { dir, nodeModulesDir };
+    }
+  }
+  return resolvePackageWithNode(cwd, packageName);
+}
+function resolvePackageDir(cwd, packageName) {
+  return resolvePackageLocation(cwd, packageName)?.dir;
+}
+
+// src/chat/discovery.ts
+function isDirectory2(targetPath) {
+  try {
+    return statSync2(targetPath).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isFile2(targetPath) {
+  try {
+    return statSync2(targetPath).isFile();
+  } catch {
+    return false;
+  }
+}
+function normalizePath(targetPath) {
+  return path2.resolve(targetPath);
+}
+function uniqueResolvedPathsInOrder2(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 path2.basename(candidatePath) === "node_modules";
+}
+function isInsidePnpmStore(candidatePath) {
+  return candidatePath.split(path2.sep).includes(".pnpm");
+}
+function runningFromInstalledPackage() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const marker = `${path2.sep}node_modules${path2.sep}@sentry${path2.sep}junior${path2.sep}`;
+  return currentFile.includes(marker);
+}
+function listInstalledPackageNodeModulesDirs() {
+  if (!runningFromInstalledPackage()) {
+    return [];
+  }
+  const dirs = [];
+  let current = path2.resolve(path2.dirname(fileURLToPath(import.meta.url)));
+  while (true) {
+    if (isNodeModulesPath(current) && !isInsidePnpmStore(current) && isDirectory2(current)) {
+      dirs.push(current);
+    }
+    const parent = path2.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 = path2.join(current, "node_modules");
+    if (isDirectory2(nodeModulesDir)) {
+      dirs.push(nodeModulesDir);
+    }
+    if (isFile2(path2.join(current, "package.json"))) {
+      break;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return dirs;
+}
+function discoverNodeModulesDirs(cwd = process.cwd(), options) {
+  const explicit = options?.candidateDirs?.filter((dir) => isDirectory2(dir)) ?? [];
+  if (explicit.length > 0) {
+    return uniqueResolvedPathsInOrder2(explicit);
+  }
+  return uniqueResolvedPathsInOrder2([
+    ...listInstalledPackageNodeModulesDirs(),
+    ...listCwdAncestorNodeModulesDirs(cwd)
+  ]);
+}
+function discoverProjectRoots(cwd = process.cwd(), options) {
+  const roots = discoverNodeModulesDirs(
+    cwd,
+    options?.nodeModulesDirs ? { candidateDirs: options.nodeModulesDirs } : void 0
+  ).map((nodeModulesDir) => path2.dirname(nodeModulesDir));
+  return uniqueResolvedPathsInOrder2([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(path2.join(appDir, "SOUL.md")) || pathExists(path2.join(appDir, "WORLD.md"));
+}
+function scoreAppCandidate(appDir) {
+  let score = 0;
+  if (pathExists(path2.join(appDir, "SOUL.md"))) {
+    score += 4;
+  }
+  if (pathExists(path2.join(appDir, "WORLD.md"))) {
+    score += 2;
+  }
+  if (pathExists(path2.join(appDir, "skills"))) {
+    score += 1;
+  }
+  if (pathExists(path2.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 = path2.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 = path2.resolve(cwd);
+  const directApp = path2.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 = path2.relative(resolvedCwd, left).split(path2.sep).length;
+    const rightDistance = path2.relative(resolvedCwd, right).split(path2.sep).length;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return left.localeCompare(right);
+  });
+  return candidates[0];
+}
+function resolveContentRoots(subdir) {
+  if (subdir === "data") {
+    return [homeDir()];
+  }
+  return [path2.join(homeDir(), subdir)];
+}
+function builtInSkillsDir() {
+  const moduleDir = path2.dirname(fileURLToPath(import.meta.url));
+  if (path2.basename(moduleDir) === "dist") {
+    return path2.join(path2.dirname(moduleDir), "skills");
+  }
+  if (path2.basename(moduleDir) === "chat" && path2.basename(path2.dirname(moduleDir)) === "src") {
+    return path2.resolve(moduleDir, "../../skills");
+  }
+  const packageDir = resolvePackageDir(process.cwd(), "@sentry/junior");
+  return path2.join(packageDir ?? moduleDir, "skills");
+}
+function dataDir() {
+  return resolveContentRoots("data")[0];
+}
+function soulPath() {
+  return path2.join(dataDir(), "SOUL.md");
+}
+function worldPath() {
+  return path2.join(dataDir(), "WORLD.md");
+}
+function descriptionPath() {
+  return path2.join(dataDir(), "DESCRIPTION.md");
+}
+function skillsDir() {
+  return resolveContentRoots("skills")[0];
+}
+function pluginsDir() {
+  return resolveContentRoots("plugins")[0];
+}
+function dataRoots() {
+  return unique(resolveContentRoots("data"));
+}
+function skillRoots() {
+  return unique([builtInSkillsDir(), ...resolveContentRoots("skills")]);
+}
+function pluginRoots() {
+  return unique(resolveContentRoots("plugins"));
+}
+function soulPathCandidates() {
+  const candidates = dataRoots().map((root) => path2.join(root, "SOUL.md"));
+  return unique(candidates);
+}
+function worldPathCandidates() {
+  const candidates = dataRoots().map((root) => path2.join(root, "WORLD.md"));
+  return unique(candidates);
+}
+function descriptionPathCandidates() {
+  const candidates = dataRoots().map(
+    (root) => path2.join(root, "DESCRIPTION.md")
+  );
+  return unique(candidates);
+}
+var RESERVED_APP_FILES = /* @__PURE__ */ new Set([
+  "SOUL.md",
+  "WORLD.md",
+  "DESCRIPTION.md",
+  "ABOUT.md"
+]);
+function listReferenceFiles() {
+  const appDir = homeDir();
+  try {
+    const entries = fs.readdirSync(appDir, { withFileTypes: true });
+    return entries.filter(
+      (entry) => entry.isFile() && entry.name.endsWith(".md") && !RESERVED_APP_FILES.has(entry.name)
+    ).map((entry) => path2.join(appDir, entry.name)).sort();
+  } catch {
+    return [];
+  }
+}
+
+export {
+  isValidPackageName,
+  resolvePackageLocation,
+  resolvePackageDir,
+  isDirectory2 as isDirectory,
+  isFile2 as isFile,
+  discoverNodeModulesDirs,
+  discoverProjectRoots,
+  homeDir,
+  resolveHomeDir,
+  builtInSkillsDir,
+  dataDir,
+  soulPath,
+  worldPath,
+  descriptionPath,
+  skillsDir,
+  pluginsDir,
+  dataRoots,
+  skillRoots,
+  pluginRoots,
+  soulPathCandidates,
+  worldPathCandidates,
+  descriptionPathCandidates,
+  listReferenceFiles
+};

package/dist/{chunk-VLTWQQKH.js → chunk-IDXLBKPS.js}

@@ -12,7 +12,7 @@ import {
   normalizeGenAiFinishReason,
   serializeGenAiAttribute,
   withSpan
-} from "./chunk-ZJ6IVZVO.js";
+} from "./chunk-JZ47AFSH.js";
 
 // src/chat/config.ts
 import { getModel as getModel2 } from "@earendil-works/pi-ai/compat";

package/dist/{chunk-NUENIPQL.js → chunk-IK4QSS5H.js}

@@ -1,6 +1,6 @@
 import {
   JUNIOR_VERSION
-} from "./chunk-JLJLZS2N.js";
+} from "./chunk-D2EMOH3N.js";
 
 // src/deployment.ts
 var JUNIOR_HEARTBEAT_ROUTE = "/api/internal/heartbeat";