@sentry/junior 0.74.0 → 0.75.0

package/dist/{chunk-YRDS7VKO.js → chunk-62FUNJYS.js}

@@ -1,11 +1,9 @@
 import {
   getSlackBotToken
-} from "./chunk-GM7HTXYC.js";
+} from "./chunk-FCZO7LAR.js";
 import {
-  isSlackConversationId,
-  isSlackTeamId,
   logWarn
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-OK4KKR7B.js";
 
 // src/chat/slack/client.ts
 import { WebClient } from "@slack/web-api";
@@ -276,50 +274,6 @@ async function downloadPrivateSlackFile(url) {
   return Buffer.from(await response.arrayBuffer());
 }
 
-// src/chat/destination.ts
-import {
-  destinationSchema
-} from "@sentry/junior-plugin-api";
-function createSlackDestination(input) {
-  const channelId = normalizeSlackConversationId(input.channelId);
-  const teamId = input.teamId?.trim();
-  if (!channelId || !teamId) {
-    return void 0;
-  }
-  if (!isSlackConversationId(channelId) || !isSlackTeamId(teamId)) {
-    return void 0;
-  }
-  return { platform: "slack", teamId, channelId };
-}
-function parseDestination(value) {
-  const parsed = destinationSchema.safeParse(value);
-  return parsed.success ? parsed.data : void 0;
-}
-function requireSlackDestination(destination, action) {
-  if (destination?.platform === "slack") {
-    return destination;
-  }
-  throw new Error(`${action} requires a Slack destination`);
-}
-function sameDestination(left, right) {
-  if (left.platform !== right.platform) {
-    return false;
-  }
-  if (left.platform === "local" && right.platform === "local") {
-    return left.conversationId === right.conversationId;
-  }
-  if (left.platform === "slack" && right.platform === "slack") {
-    return left.teamId === right.teamId && left.channelId === right.channelId;
-  }
-  return false;
-}
-function destinationKey(destination) {
-  if (destination.platform === "local") {
-    return destination.conversationId;
-  }
-  return `slack:${destination.teamId}:${destination.channelId}`;
-}
-
 export {
   SlackActionError,
   getHeaderString,
@@ -330,10 +284,5 @@ export {
   isConversationScopedChannel,
   isConversationChannel,
   getFilePermalink,
-  downloadPrivateSlackFile,
-  createSlackDestination,
-  parseDestination,
-  requireSlackDestination,
-  sameDestination,
-  destinationKey
+  downloadPrivateSlackFile
 };

package/dist/{chunk-M4FLLXXD.js → chunk-74HO27II.js}

@@ -2,7 +2,7 @@ import {
   isRecord,
   toOptionalNumber,
   toOptionalString
-} from "./chunk-3BYAPS6B.js";
+} from "./chunk-OK4KKR7B.js";
 
 // src/chat/state/conversation.ts
 function coerceRole(value) {

package/dist/chunk-BNJIEFQC.js

@@ -0,0 +1,115 @@
+import {
+  getStateAdapter
+} from "./chunk-ZNNTSPNF.js";
+import {
+  logException,
+  logInfo,
+  logWarn
+} from "./chunk-OK4KKR7B.js";
+
+// src/chat/plugins/logging.ts
+function createPluginLogger(plugin) {
+  return {
+    info(message, metadata) {
+      logInfo(
+        "agent_plugin_log_info",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    warn(message, metadata) {
+      logWarn(
+        "agent_plugin_log_warn",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    },
+    error(message, metadata) {
+      logException(
+        new Error(message),
+        "agent_plugin_log_error",
+        {},
+        { "app.plugin.name": plugin, ...metadata },
+        message
+      );
+    }
+  };
+}
+
+// src/chat/plugins/state.ts
+import { createHash } from "crypto";
+var MAX_PLUGIN_STATE_KEY_LENGTH = 512;
+function hashKeyPart(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 32);
+}
+function pluginStateKey(plugin, key) {
+  const pluginPrefix = `junior:${plugin}`;
+  if (key === pluginPrefix || key.startsWith(`${pluginPrefix}:`)) {
+    return key;
+  }
+  return `junior:plugin_state:${hashKeyPart(plugin)}:${hashKeyPart(key)}`;
+}
+function validatePluginStateKey(key) {
+  if (!key.trim()) {
+    throw new Error("Plugin state key is required");
+  }
+  if (key.length > MAX_PLUGIN_STATE_KEY_LENGTH) {
+    throw new Error("Plugin state key exceeds the maximum length");
+  }
+}
+function createPluginState(plugin, adapter) {
+  const getAdapter = () => adapter ?? getStateAdapter();
+  return {
+    async delete(key) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      await state.delete(pluginStateKey(plugin, key));
+    },
+    async get(key) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      const value = await state.get(pluginStateKey(plugin, key));
+      return value ?? void 0;
+    },
+    async set(key, value, ttlMs) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      await state.set(pluginStateKey(plugin, key), value, ttlMs);
+    },
+    async setIfNotExists(key, value, ttlMs) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      return await state.setIfNotExists(
+        pluginStateKey(plugin, key),
+        value,
+        ttlMs
+      );
+    },
+    async withLock(key, ttlMs, callback) {
+      validatePluginStateKey(key);
+      const state = getAdapter();
+      await state.connect();
+      const lockKey = pluginStateKey(plugin, key);
+      const lock = await state.acquireLock(lockKey, ttlMs);
+      if (!lock) {
+        throw new Error(`Could not acquire plugin state lock for ${key}`);
+      }
+      try {
+        return await callback();
+      } finally {
+        await state.releaseLock(lock);
+      }
+    }
+  };
+}
+
+export {
+  createPluginLogger,
+  createPluginState
+};

package/dist/{chunk-YOHFWWBV.js → chunk-C3AM4Z4J.js}

@@ -1,106 +1,7 @@
 import {
   destinationKey,
   parseDestination
-} from "./chunk-YRDS7VKO.js";
-
-// src/plugins.ts
-function cloneManifests(manifests) {
-  return manifests ? structuredClone(manifests) : void 0;
-}
-function cloneInlineManifests(registrations) {
-  const inlineManifests = registrations.flatMap(
-    (plugin) => plugin.manifest ? [
-      {
-        manifest: {
-          ...structuredClone(plugin.manifest),
-          capabilities: plugin.manifest.capabilities?.map(
-            (capability) => capability.includes(".") ? capability : `${plugin.manifest.name}.${capability}`
-          ) ?? [],
-          configKeys: plugin.manifest.configKeys?.map(
-            (key) => key.includes(".") ? key : `${plugin.manifest.name}.${key}`
-          ) ?? [],
-          ...plugin.manifest.target ? {
-            target: {
-              ...plugin.manifest.target,
-              configKey: plugin.manifest.target.configKey.includes(".") ? plugin.manifest.target.configKey : `${plugin.manifest.name}.${plugin.manifest.target.configKey}`
-            }
-          } : {}
-        },
-        ...plugin.packageName ? { packageName: plugin.packageName } : {}
-      }
-    ] : []
-  );
-  return inlineManifests.length > 0 ? inlineManifests : void 0;
-}
-function assertUniquePluginNames(registrations) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const plugin of registrations) {
-    if (seen.has(plugin.name)) {
-      throw new Error(`Duplicate plugin registration name "${plugin.name}"`);
-    }
-    seen.add(plugin.name);
-  }
-}
-function assertUniquePackageNames(packageNames) {
-  const seen = /* @__PURE__ */ new Set();
-  for (const packageName of packageNames) {
-    if (seen.has(packageName)) {
-      throw new Error(`Duplicate plugin package name "${packageName}"`);
-    }
-    seen.add(packageName);
-  }
-}
-function normalizePluginInput(input) {
-  if (typeof input === "string") {
-    return { packageName: input };
-  }
-  return { registration: input };
-}
-function defineJuniorPlugins(inputs, options = {}) {
-  const normalized = inputs.map(normalizePluginInput);
-  const packageNames = normalized.flatMap(
-    (input) => input.packageName ? [input.packageName] : []
-  );
-  const registrations = normalized.flatMap(
-    (input) => input.registration ? [input.registration] : []
-  );
-  assertUniquePackageNames(packageNames);
-  assertUniquePluginNames(registrations);
-  const manifests = cloneManifests(options.manifests);
-  return {
-    packageNames,
-    registrations: registrations.map((plugin) => ({ ...plugin })),
-    ...manifests ? { manifests } : {}
-  };
-}
-function pluginCatalogConfigFromPluginSet(pluginSet) {
-  if (!pluginSet) {
-    return void 0;
-  }
-  const packages = [
-    .../* @__PURE__ */ new Set([
-      ...pluginSet.packageNames,
-      ...pluginSet.registrations.flatMap(
-        (plugin) => plugin.packageName ? [plugin.packageName] : []
-      )
-    ])
-  ];
-  const manifests = cloneManifests(pluginSet.manifests);
-  const inlineManifests = cloneInlineManifests(pluginSet.registrations);
-  if (packages.length === 0 && !manifests && !inlineManifests) {
-    return void 0;
-  }
-  return {
-    ...inlineManifests ? { inlineManifests } : {},
-    ...packages.length > 0 ? { packages } : {},
-    ...manifests ? { manifests } : {}
-  };
-}
-function pluginHookRegistrationsFromPluginSet(pluginSet) {
-  return pluginSet?.registrations.filter(
-    (plugin) => plugin.hooks || plugin.legacyStatePrefixes
-  ) ?? [];
-}
+} from "./chunk-WBZ4M5N5.js";
 
 // src/chat/task-execution/vercel-queue.ts
 import { QueueClient } from "@vercel/queue";
@@ -229,9 +130,6 @@ function getVercelConversationWorkQueue() {
 }
 
 export {
-  defineJuniorPlugins,
-  pluginCatalogConfigFromPluginSet,
-  pluginHookRegistrationsFromPluginSet,
   verifyConversationQueueMessage,
   resolveConversationWorkQueueTopic,
   getVercelConversationWorkQueue