@sentry/junior 0.118.0 → 0.120.0

package/dist/{chunk-B3IT5END.js → chunk-OOUNJNMR.js}

@@ -1,149 +1,15 @@
 import {
   discoverNodeModulesDirs,
   isDirectory,
-  isFile
-} from "./chunk-3V7OFJZC.js";
-
-// src/package-resolution.ts
-import { statSync } from "fs";
-import { createRequire } from "module";
-import path from "path";
-function isDirectory2(targetPath) {
-  try {
-    return statSync(targetPath).isDirectory();
-  } catch {
-    return false;
-  }
-}
-function isFile2(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 (isDirectory2(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 isDirectory2(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 (isFile2(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;
-}
+  isFile,
+  isValidPackageName,
+  resolvePackageLocation
+} from "./chunk-H4HBKISO.js";
 
 // src/chat/plugins/package-discovery.ts
-import path2 from "path";
+import path from "path";
 function normalizeForGlob(targetPath) {
-  return targetPath.split(path2.sep).join("/");
+  return targetPath.split(path.sep).join("/");
 }
 function uniqueStringsInOrder(values) {
   const seen = /* @__PURE__ */ new Set();
@@ -158,8 +24,8 @@ function uniqueStringsInOrder(values) {
   return resolved;
 }
 function pathForTracingInclude(cwd, targetPath) {
-  const relative = path2.relative(cwd, targetPath);
-  if (!relative || path2.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path2.sep}`)) {
+  const relative = path.relative(cwd, targetPath);
+  if (!relative || path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) {
     return null;
   }
   const normalized = normalizeForGlob(relative);
@@ -196,10 +62,10 @@ function resolvePackageDirFromName(cwd, packageName, candidateNodeModulesDirs) {
   }) ?? null;
 }
 function readPluginPackageFlags(dir) {
-  const hasRootPluginManifest = isFile(path2.join(dir, "plugin.yaml"));
-  const hasMigrationsDir = isDirectory(path2.join(dir, "migrations"));
-  const hasPluginsDir = isDirectory(path2.join(dir, "plugins"));
-  const hasSkillsDir = isDirectory(path2.join(dir, "skills"));
+  const hasRootPluginManifest = isFile(path.join(dir, "plugin.yaml"));
+  const hasMigrationsDir = isDirectory(path.join(dir, "migrations"));
+  const hasPluginsDir = isDirectory(path.join(dir, "plugins"));
+  const hasSkillsDir = isDirectory(path.join(dir, "skills"));
   if (!hasRootPluginManifest && !hasMigrationsDir && !hasPluginsDir && !hasSkillsDir) {
     return null;
   }
@@ -244,7 +110,7 @@ function discoverDeclaredPackages(packageNames, candidateNodeModulesDirs, cwd) {
   return discovered;
 }
 function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
-  const resolvedCwd = path2.resolve(cwd);
+  const resolvedCwd = path.resolve(cwd);
   const packageNames = normalizePluginPackageNames(options?.packageNames);
   const nodeModulesDirs = options?.nodeModulesDirs ?? discoverNodeModulesDirs(resolvedCwd);
   const discoveredPackages = discoverDeclaredPackages(
@@ -258,7 +124,7 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
   for (const pkg of discoveredPackages) {
     const tracingBasePath = pkg.nodeModulesDir ? pathForTracingInclude(
       resolvedCwd,
-      path2.join(pkg.nodeModulesDir, ...pkg.packageName.split("/"))
+      path.join(pkg.nodeModulesDir, ...pkg.packageName.split("/"))
     ) : pathForTracingInclude(resolvedCwd, pkg.dir);
     if (pkg.hasRootPluginManifest) {
       manifestRoots.push(pkg.dir);
@@ -272,13 +138,13 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
       }
     }
     if (pkg.hasPluginsDir) {
-      manifestRoots.push(path2.join(pkg.dir, "plugins"));
+      manifestRoots.push(path.join(pkg.dir, "plugins"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/plugins/**/*`);
       }
     }
     if (pkg.hasSkillsDir) {
-      skillRoots.push(path2.join(pkg.dir, "skills"));
+      skillRoots.push(path.join(pkg.dir, "skills"));
       if (tracingBasePath) {
         tracingIncludes.push(`${tracingBasePath}/skills/**/*`);
       }
@@ -301,8 +167,6 @@ function discoverInstalledPluginPackageContent(cwd = process.cwd(), options) {
 }
 
 export {
-  isValidPackageName,
-  resolvePackageDir,
   normalizePluginPackageNames,
   discoverInstalledPluginPackageContent
 };

package/dist/{chunk-HN6LFYG3.js → chunk-Q3RL6A4E.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-PE44LDDQ.js";
 import {
   normalizeSlackConversationId
-} from "./chunk-GT2ZUALJ.js";
+} from "./chunk-24B5R6OU.js";
 import {
   parseSlackThreadId
-} from "./chunk-FXOYURO4.js";
+} from "./chunk-HDFGNU5E.js";
 
 // src/handlers/health.ts
 function readHealthReport() {

package/dist/{chunk-3MUSSFMP.js → chunk-QOQPPRFS.js}

@@ -5,6 +5,7 @@ import {
   ConversationTurnLifecycleService,
   buildDeliveredTurnStatePatch,
   finalizeFailedTurnReplyWithEvent,
+  getInterruptionMarker,
   getTurnUserMessage,
   getTurnUserMessageId,
   getTurnUserReplyAttachmentContext,
@@ -12,7 +13,7 @@ import {
   persistAuthPauseTurnState,
   requireTurnFailureEventId,
   scheduleSessionCompletedPluginTasks
-} from "./chunk-6BGUAOYP.js";
+} from "./chunk-BHXW734F.js";
 import {
   buildSentryConversationUrl
 } from "./chunk-4CODA7P5.js";
@@ -31,15 +32,15 @@ import {
   getMcpAuthSession,
   getMcpProviderErrorAttributes,
   getMcpStoredOAuthCredentials,
+  normalizeSlackReplyMarkdown,
   normalizeSlackStatusText,
   parseOAuthStatePayload,
   postSlackMessage,
   removeReactionFromMessage,
   resolveBaseUrl,
   resolvePluginOAuthAccount,
-  splitSlackReplyText,
   truncateStatusText
-} from "./chunk-S6R23MFB.js";
+} from "./chunk-TKUCRFNX.js";
 import {
   JUNIOR_THREAD_STATE_TTL_MS,
   TurnSliceLimitExceededError,
@@ -69,7 +70,7 @@ import {
   recordDeliveredAssistantMessage,
   turnHasReply,
   updateConversationStats
-} from "./chunk-PJPKHGLG.js";
+} from "./chunk-JQWP6V22.js";
 import {
   SlackActionError,
   getDashboardConversationLink,
@@ -78,19 +79,19 @@ import {
   getSlackClient,
   isDmChannel,
   normalizeSlackConversationId
-} from "./chunk-GT2ZUALJ.js";
+} from "./chunk-24B5R6OU.js";
 import {
   getConversationEventStore,
   getConversationStore,
   parseDestination,
   requireSlackDestination,
   sameDestination
-} from "./chunk-KC5EE27Y.js";
+} from "./chunk-M243JMZH.js";
 import {
   acquireActiveLock,
   getDefaultRedisStateAdapterFor,
   getStateAdapter
-} from "./chunk-3N3FMCKN.js";
+} from "./chunk-ALAKN7LR.js";
 import {
   FUNCTION_TIMEOUT_BUFFER_SECONDS,
   botConfig,
@@ -99,24 +100,24 @@ import {
   getRuntimeMetadata,
   normalizeSlackEmojiName,
   standardModelId
-} from "./chunk-PWRFTDTY.js";
+} from "./chunk-VURFJVFH.js";
 import {
   parseSlackThreadId,
   readSlackRawMessageContext,
   resolveSlackChannelIdFromMessage,
   resolveSlackChannelIdFromThreadId
-} from "./chunk-FXOYURO4.js";
+} from "./chunk-HDFGNU5E.js";
 import {
   discoverSkills
-} from "./chunk-7GADTCNS.js";
+} from "./chunk-EIVE6GL4.js";
 import {
   pluginCatalogRuntime
-} from "./chunk-UXLYAVYL.js";
+} from "./chunk-GNNV3UTY.js";
 import {
   buildOAuthTokenRequest,
   hasRequiredOAuthScope,
   parseOAuthTokenResponse
-} from "./chunk-3LGCVRBQ.js";
+} from "./chunk-XAI2HNAY.js";
 import {
   createSlackResumeActor,
   isUserActor,
@@ -127,7 +128,7 @@ import {
   logException,
   logInfo,
   logWarn
-} from "./chunk-MLZFK4KP.js";
+} from "./chunk-ALYQOZG7.js";
 import {
   isRecord,
   toOptionalNumber,
@@ -138,7 +139,7 @@ import {
 } from "./chunk-F3B2YJ76.js";
 import {
   homeDir
-} from "./chunk-3V7OFJZC.js";
+} from "./chunk-H4HBKISO.js";
 
 // src/chat/slack/assistant-thread/status-render.ts
 var DEFAULT_STATUS_CONTEXTS = {
@@ -545,6 +546,210 @@ function buildSlackReplyBlocks(text, footer) {
   return blocks;
 }
 
+// src/chat/slack/output.ts
+var MAX_INLINE_CHARS = 2200;
+var MAX_INLINE_LINES = 45;
+var CONTINUED_MARKER = "\n\n[Continued below]";
+function countSlackLines(text) {
+  if (!text) {
+    return 0;
+  }
+  return text.split("\n").length;
+}
+function fitsInlineBudget(text, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return text.length <= maxChars && countSlackLines(text) <= maxLines;
+}
+function findSplitIndex(text, maxChars) {
+  if (text.length <= maxChars) {
+    return text.length;
+  }
+  const bounded = text.slice(0, maxChars);
+  const newlineIndex = bounded.lastIndexOf("\n");
+  if (newlineIndex > 0) {
+    return newlineIndex;
+  }
+  const spaceIndex = bounded.lastIndexOf(" ");
+  if (spaceIndex > 0) {
+    return spaceIndex;
+  }
+  return maxChars;
+}
+function splitByLineBudget(text, maxLines) {
+  if (maxLines <= 0) {
+    return "";
+  }
+  const lines = text.split("\n");
+  if (lines.length <= maxLines) {
+    return text;
+  }
+  return lines.slice(0, maxLines).join("\n");
+}
+function reserveInlineBudgetForSuffix(suffix, maxChars = MAX_INLINE_CHARS, maxLines = MAX_INLINE_LINES) {
+  return {
+    maxChars: Math.max(1, maxChars - suffix.length),
+    maxLines: Math.max(1, maxLines - Math.max(0, countSlackLines(suffix) - 1))
+  };
+}
+function forceSplitBudget(text, budget) {
+  const lineCount = countSlackLines(text);
+  return {
+    maxChars: text.length <= budget.maxChars ? Math.max(1, text.length - 1) : budget.maxChars,
+    maxLines: lineCount <= budget.maxLines ? Math.max(1, lineCount - 1) : budget.maxLines
+  };
+}
+function getFenceContinuation(text) {
+  let open;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trimStart();
+    const openerMatch = trimmed.match(/^(`{3,}|~{3,})(.*)$/);
+    if (!openerMatch) {
+      continue;
+    }
+    if (!open) {
+      open = {
+        fence: openerMatch[1],
+        openerLine: trimmed
+      };
+      continue;
+    }
+    if (new RegExp(`^${open.fence}\\s*$`).test(trimmed)) {
+      open = void 0;
+    }
+  }
+  if (!open) {
+    return null;
+  }
+  return {
+    closeSuffix: text.endsWith("\n") ? open.fence : `
+${open.fence}`,
+    reopenPrefix: `${open.openerLine}
+`
+  };
+}
+function appendSlackSuffix(text, marker) {
+  const carryover = getFenceContinuation(text);
+  return `${text}${carryover?.closeSuffix ?? ""}${marker}`;
+}
+function stripTrailingContinuationMarker(text) {
+  return text.endsWith(CONTINUED_MARKER) ? text.slice(0, -CONTINUED_MARKER.length) : text;
+}
+function takeSlackContinuationChunk(text, budget) {
+  let { prefix, rest } = takeSlackInlinePrefix(text, budget);
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, budget)
+    ));
+  }
+  let carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  const carryoverBudget = reserveInlineBudgetForSuffix(
+    `${carryover.closeSuffix}${CONTINUED_MARKER}`
+  );
+  ({ prefix, rest } = takeSlackInlinePrefix(text, carryoverBudget));
+  if (!rest) {
+    ({ prefix, rest } = takeSlackInlinePrefix(
+      text,
+      forceSplitBudget(text, carryoverBudget)
+    ));
+  }
+  carryover = rest ? getFenceContinuation(prefix) : null;
+  if (!carryover) {
+    return { prefix, rest };
+  }
+  return {
+    prefix,
+    rest: `${carryover.reopenPrefix}${rest}`
+  };
+}
+function takeSlackContinuationPrefix(text, options) {
+  const budget = {
+    maxChars: options?.maxChars ?? getSlackContinuationBudget().maxChars,
+    maxLines: options?.maxLines ?? getSlackContinuationBudget().maxLines
+  };
+  const { prefix, rest } = (() => {
+    if (options?.forceSplit) {
+      return takeSlackContinuationChunk(text, budget);
+    }
+    const initial = takeSlackInlinePrefix(text, budget);
+    return initial.rest ? takeSlackContinuationChunk(text, budget) : initial;
+  })();
+  return {
+    prefix,
+    renderedPrefix: rest ? appendSlackSuffix(prefix, CONTINUED_MARKER) : prefix,
+    rest
+  };
+}
+function takeSlackInlinePrefix(text, options) {
+  const maxChars = options?.maxChars ?? MAX_INLINE_CHARS;
+  const maxLines = options?.maxLines ?? MAX_INLINE_LINES;
+  const normalized = text.replace(/\r\n?/g, "\n");
+  if (!normalized) {
+    return { prefix: "", rest: "" };
+  }
+  if (fitsInlineBudget(normalized, maxChars, maxLines)) {
+    return { prefix: normalized, rest: "" };
+  }
+  const lineBounded = splitByLineBudget(normalized, maxLines);
+  const cutIndex = findSplitIndex(lineBounded, maxChars);
+  const prefix = lineBounded.slice(0, cutIndex).trimEnd();
+  if (prefix) {
+    return {
+      prefix,
+      rest: normalized.slice(prefix.length).trimStart()
+    };
+  }
+  const hardPrefix = normalized.slice(0, Math.max(1, maxChars)).trimEnd();
+  return {
+    prefix: hardPrefix || normalized.slice(0, Math.max(1, maxChars)),
+    rest: normalized.slice(hardPrefix.length || Math.max(1, maxChars)).trimStart()
+  };
+}
+function splitSlackReplyText(text, options) {
+  const normalized = normalizeSlackReplyMarkdown(text);
+  if (!normalized) {
+    return [];
+  }
+  const chunks = [];
+  const continuationBudget = reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+  let remaining = normalized;
+  while (remaining) {
+    const fitsFinalChunk = options?.interrupted ? fitsInlineBudget(appendSlackSuffix(remaining, getInterruptionMarker())) : fitsInlineBudget(remaining);
+    if (fitsFinalChunk) {
+      chunks.push(
+        options?.interrupted ? appendSlackSuffix(remaining, getInterruptionMarker()) : remaining
+      );
+      break;
+    }
+    const { renderedPrefix, rest } = takeSlackContinuationPrefix(remaining, {
+      ...continuationBudget,
+      forceSplit: true
+    });
+    chunks.push(renderedPrefix);
+    remaining = rest;
+  }
+  if (chunks.length === 2) {
+    chunks[0] = stripTrailingContinuationMarker(chunks[0] ?? "");
+  }
+  return chunks;
+}
+function getSlackContinuationBudget() {
+  return reserveInlineBudgetForSuffix(CONTINUED_MARKER);
+}
+function buildSlackOutputMessage(text) {
+  const normalized = normalizeSlackReplyMarkdown(text);
+  if (!normalized) {
+    throw new Error(
+      `Slack output normalized to empty content: original_length=${text.length} parsed_length=${normalized.length}`
+    );
+  }
+  return {
+    markdown: normalized
+  };
+}
+
 // src/chat/slack/reply.ts
 async function sendSlackReply(args) {
   const chunks = splitSlackReplyText(args.text);
@@ -4328,6 +4533,8 @@ export {
   removeActiveConversation2 as removeActiveConversation,
   listActiveConversationIds2 as listActiveConversationIds,
   createSlackAdapterAssistantStatusSession,
+  splitSlackReplyText,
+  buildSlackOutputMessage,
   sendSlackReply,
   getSlackApiErrorCode,
   getSlackErrorObservabilityAttributes,