@sentry/junior 0.96.0 → 0.97.1

package/dist/{chunk-S5KZ5LPG.js → chunk-5HLDPVYS.js}

@@ -1,28 +1,29 @@
+import {
+  isConversationChannel,
+  isConversationScopedChannel,
+  isDmChannel,
+  normalizeSlackConversationId
+} from "./chunk-WTYEKPXU.js";
 import {
   createPluginLogger,
   createPluginState
-} from "./chunk-2NAZZPPS.js";
-import {
-  SANDBOX_WORKSPACE_ROOT,
-  sleep
-} from "./chunk-CZEX6KIQ.js";
+} from "./chunk-EOWXRY5E.js";
 import {
   getDb
-} from "./chunk-RITD7E5L.js";
+} from "./chunk-35BNLDOJ.js";
+import {
+  SANDBOX_WORKSPACE_ROOT
+} from "./chunk-G3E7SCME.js";
 import {
   botConfig,
   completeObject,
-  embedTexts,
-  getSlackBotToken
-} from "./chunk-YDVEH3SB.js";
+  embedTexts
+} from "./chunk-EEZCY5WX.js";
 import {
   isActorUserId,
   logInfo,
   logWarn,
-  parseActorUserId,
-  setSpanAttributes,
-  setSpanStatus,
-  withSpan
+  parseActorUserId
 } from "./chunk-I35CTGPO.js";
 import {
   parseSlackChannelReferenceId,
@@ -102,428 +103,6 @@ function getSlackToolContext(context) {
 
 // src/chat/credentials/subject.ts
 import { createHmac, timingSafeEqual } from "crypto";
-
-// src/chat/slack/client.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
-import { WebClient } from "@slack/web-api";
-
-// src/chat/slack/workspace-context.ts
-import { AsyncLocalStorage } from "async_hooks";
-var workspaceTeamIdStorage = new AsyncLocalStorage();
-function runWithWorkspaceTeamId(teamId, fn) {
-  if (!teamId) return fn();
-  return workspaceTeamIdStorage.run(teamId, fn);
-}
-function getWorkspaceTeamId() {
-  return workspaceTeamIdStorage.getStore();
-}
-
-// src/chat/slack/client.ts
-var SlackActionError = class extends Error {
-  code;
-  apiError;
-  needed;
-  provided;
-  statusCode;
-  requestId;
-  errorData;
-  retryAfterSeconds;
-  detail;
-  detailLine;
-  detailRule;
-  constructor(message, code, options = {}) {
-    super(message);
-    this.name = "SlackActionError";
-    this.code = code;
-    this.apiError = options.apiError;
-    this.needed = options.needed;
-    this.provided = options.provided;
-    this.statusCode = options.statusCode;
-    this.requestId = options.requestId;
-    this.errorData = options.errorData;
-    this.retryAfterSeconds = options.retryAfterSeconds;
-    this.detail = options.detail;
-    this.detailLine = options.detailLine;
-    this.detailRule = options.detailRule;
-  }
-};
-function serializeSlackErrorData(data) {
-  if (!data || typeof data !== "object") {
-    return void 0;
-  }
-  const filtered = Object.fromEntries(
-    Object.entries(data).filter(
-      ([key]) => key !== "error"
-    )
-  );
-  if (Object.keys(filtered).length === 0) {
-    return void 0;
-  }
-  try {
-    const serialized = JSON.stringify(filtered);
-    return serialized.length <= 600 ? serialized : `${serialized.slice(0, 597)}...`;
-  } catch {
-    return void 0;
-  }
-}
-function getHeaderString(headers, name) {
-  if (!headers || typeof headers !== "object") {
-    return void 0;
-  }
-  const key = name.toLowerCase();
-  const entries = headers;
-  for (const [entryKey, value] of Object.entries(entries)) {
-    if (entryKey.toLowerCase() !== key) continue;
-    if (typeof value === "string") return value;
-    if (Array.isArray(value)) {
-      const first = value.find((entry) => typeof entry === "string");
-      return typeof first === "string" ? first : void 0;
-    }
-  }
-  return void 0;
-}
-function parseSlackCanvasDetail(detail) {
-  if (typeof detail !== "string") {
-    return {};
-  }
-  const trimmed = detail.trim();
-  if (!trimmed) {
-    return {};
-  }
-  const parsed = {
-    detail: trimmed
-  };
-  const lineMatch = trimmed.match(/line\s+(\d+):/i);
-  if (lineMatch) {
-    const line = Number.parseInt(lineMatch[1] ?? "", 10);
-    if (Number.isFinite(line)) {
-      parsed.detailLine = line;
-    }
-  }
-  if (/unsupported heading depth/i.test(trimmed)) {
-    parsed.detailRule = "unsupported_heading_depth";
-  }
-  return parsed;
-}
-var installationTokenStorage = new AsyncLocalStorage2();
-var clientsByToken = /* @__PURE__ */ new Map();
-function runWithSlackInstallationToken(token, fn) {
-  const trimmed = token.trim();
-  if (!trimmed) {
-    throw new SlackActionError(
-      "Slack installation token binding requires a non-empty token",
-      "missing_token"
-    );
-  }
-  return installationTokenStorage.run({ token: trimmed }, fn);
-}
-function resolveSlackToken() {
-  const ambientToken = installationTokenStorage.getStore()?.token;
-  if (ambientToken) {
-    return ambientToken;
-  }
-  const envToken = getSlackBotToken();
-  if (envToken) {
-    return envToken;
-  }
-  const teamId = getWorkspaceTeamId();
-  if (teamId) {
-    throw new SlackActionError(
-      `Slack call is scoped to workspace ${teamId} but no installation token is bound and no default bot token is configured`,
-      "missing_token"
-    );
-  }
-  throw new SlackActionError(
-    "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack Web API actions in this service",
-    "missing_token"
-  );
-}
-function normalizeSlackConversationId(channelId) {
-  return parseSlackChannelReferenceId(channelId);
-}
-function getClient() {
-  const token = resolveSlackToken();
-  let cached = clientsByToken.get(token);
-  if (!cached) {
-    cached = new WebClient(token, {
-      retryConfig: { retries: 0 },
-      rejectRateLimitedCalls: true
-    });
-    clientsByToken.set(token, cached);
-  }
-  return cached;
-}
-function mapSlackError(error) {
-  if (error instanceof SlackActionError) {
-    return error;
-  }
-  const candidate = error;
-  const apiError = candidate.data?.error;
-  const message = candidate.message ?? "Slack action failed";
-  const baseOptions = {
-    apiError,
-    statusCode: candidate.statusCode,
-    requestId: getHeaderString(candidate.headers, "x-slack-req-id"),
-    errorData: serializeSlackErrorData(candidate.data),
-    ...parseSlackCanvasDetail(candidate.data?.detail)
-  };
-  if (apiError === "missing_scope") {
-    return new SlackActionError(message, "missing_scope", {
-      ...baseOptions,
-      needed: candidate.data?.needed,
-      provided: candidate.data?.provided
-    });
-  }
-  if (apiError === "not_in_channel") {
-    return new SlackActionError(message, "not_in_channel", baseOptions);
-  }
-  if (apiError === "restricted_action_read_only_channel") {
-    return new SlackActionError(message, "read_only_channel", baseOptions);
-  }
-  if (apiError === "already_reacted") {
-    return new SlackActionError(message, "already_reacted", baseOptions);
-  }
-  if (apiError === "no_reaction") {
-    return new SlackActionError(message, "no_reaction", baseOptions);
-  }
-  if (apiError === "invalid_arguments") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_cursor") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "invalid_name") {
-    return new SlackActionError(message, "invalid_arguments", baseOptions);
-  }
-  if (apiError === "not_found" || apiError === "channel_not_found" || apiError === "message_not_found") {
-    return new SlackActionError(message, "not_found", baseOptions);
-  }
-  if (apiError === "feature_not_enabled" || apiError === "not_allowed_token_type") {
-    return new SlackActionError(message, "feature_unavailable", baseOptions);
-  }
-  if (apiError === "canvas_creation_failed") {
-    return new SlackActionError(message, "canvas_creation_failed", baseOptions);
-  }
-  if (apiError === "canvas_editing_failed") {
-    return new SlackActionError(message, "canvas_editing_failed", baseOptions);
-  }
-  if (candidate.code === "slack_webapi_rate_limited_error" || candidate.statusCode === 429) {
-    return new SlackActionError(message, "rate_limited", {
-      ...baseOptions,
-      retryAfterSeconds: candidate.retryAfter
-    });
-  }
-  return new SlackActionError(message, "internal_error", baseOptions);
-}
-var MAX_RETRY_DELAY_MS = 1e4;
-var MAX_TOTAL_RETRY_DELAY_MS = 2e4;
-var CONNECTION_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ECONNREFUSED",
-  "ECONNRESET",
-  "ENOTFOUND",
-  "EAI_AGAIN"
-]);
-var TIMEOUT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ETIMEDOUT",
-  "ECONNABORTED",
-  "ESOCKETTIMEDOUT"
-]);
-function findNetworkErrorCode(error, depth = 0) {
-  if (!error || typeof error !== "object" || depth > 4) {
-    return void 0;
-  }
-  const candidate = error;
-  if (typeof candidate.code === "string" && (CONNECTION_ERROR_CODES.has(candidate.code) || TIMEOUT_ERROR_CODES.has(candidate.code))) {
-    return candidate.code;
-  }
-  return findNetworkErrorCode(candidate.original, depth + 1) ?? findNetworkErrorCode(candidate.cause, depth + 1);
-}
-function hasSocketHangUpMessage(error) {
-  return error instanceof Error && error.message.toLowerCase().includes("socket hang up");
-}
-function classifySlackRetry(raw, mapped) {
-  if (mapped.code === "rate_limited") {
-    return "rate_limited";
-  }
-  if (mapped.statusCode !== void 0 && mapped.statusCode >= 500) {
-    return "server_error";
-  }
-  const networkCode = findNetworkErrorCode(raw);
-  if (networkCode && CONNECTION_ERROR_CODES.has(networkCode)) {
-    return "connection";
-  }
-  if (networkCode && TIMEOUT_ERROR_CODES.has(networkCode)) {
-    return "timeout";
-  }
-  if (hasSocketHangUpMessage(raw)) {
-    return "connection";
-  }
-  return "none";
-}
-async function withSlackRetries(task, maxAttempts = 3, context = {}) {
-  let attempt = 0;
-  let totalDelayMs = 0;
-  const action = context.action ?? "unknown";
-  while (attempt < maxAttempts) {
-    attempt += 1;
-    const attemptNumber = attempt;
-    try {
-      return await withSpan(
-        `POST slack.com/api/${action}`,
-        "http.client",
-        {},
-        async () => {
-          try {
-            return await task();
-          } catch (error) {
-            const mapped = mapSlackError(error);
-            const errorAttrs = {
-              "error.type": mapped.code
-            };
-            if (mapped.apiError) {
-              errorAttrs["app.slack.api_error_code"] = mapped.apiError;
-            }
-            if (mapped.code === "rate_limited") {
-              errorAttrs["http.response.status_code"] = 429;
-              if (mapped.retryAfterSeconds) {
-                errorAttrs["app.slack.retry_after_ms"] = mapped.retryAfterSeconds * 1e3;
-              }
-            } else if (mapped.statusCode != null) {
-              errorAttrs["http.response.status_code"] = mapped.statusCode;
-            }
-            setSpanAttributes(errorAttrs);
-            setSpanStatus("error");
-            throw error;
-          }
-        },
-        {
-          "http.request.method": "POST",
-          "server.address": "slack.com",
-          "url.scheme": "https",
-          "url.path": `/api/${action}`,
-          "app.slack.method": action,
-          "app.retry.max_attempts": maxAttempts,
-          ...attemptNumber > 1 ? { "http.resend_count": attemptNumber - 1 } : {},
-          ...context.attributes ?? {},
-          ...context.spanAttributes ?? {}
-        }
-      );
-    } catch (error) {
-      const mapped = mapSlackError(error);
-      const retryClass = classifySlackRetry(error, mapped);
-      const isRetryable = retryClass === "rate_limited" || retryClass === "connection" || retryClass === "server_error" || retryClass === "timeout" && context.idempotent === true;
-      const remainingDelayBudgetMs = MAX_TOTAL_RETRY_DELAY_MS - totalDelayMs;
-      const baseLogAttributes = {
-        "app.slack.action": action,
-        "app.slack.error_code": mapped.code,
-        ...mapped.apiError ? { "app.slack.api_error": mapped.apiError } : {},
-        ...mapped.detail ? { "app.slack.detail": mapped.detail } : {},
-        ...mapped.detailLine !== void 0 ? { "app.slack.detail_line": mapped.detailLine } : {},
-        ...mapped.detailRule ? { "app.slack.detail_rule": mapped.detailRule } : {},
-        ...mapped.requestId ? { "app.slack.request_id": mapped.requestId } : {},
-        ...mapped.statusCode !== void 0 ? { "http.response.status_code": mapped.statusCode } : {},
-        ...context.attributes ?? {}
-      };
-      if (!isRetryable || attempt >= maxAttempts || remainingDelayBudgetMs <= 0) {
-        logWarn(
-          "slack_action_failed",
-          {},
-          {
-            ...baseLogAttributes,
-            ...mapped.errorData ? { "app.slack.error_data": mapped.errorData } : {}
-          },
-          "Slack action failed"
-        );
-        throw mapped;
-      }
-      logWarn(
-        "slack_action_retrying",
-        {},
-        {
-          ...baseLogAttributes,
-          "app.slack.retry_attempt": attempt,
-          "app.slack.retry_class": retryClass
-        },
-        "Retrying Slack action after transient failure"
-      );
-      const retryAfterMs = retryClass === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
-      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
-      const delayMs = Math.min(
-        retryAfterMs ?? backoffMs,
-        MAX_RETRY_DELAY_MS,
-        remainingDelayBudgetMs
-      );
-      totalDelayMs += delayMs;
-      await sleep(delayMs);
-    }
-  }
-  throw new SlackActionError(
-    "Slack action exhausted retries",
-    "internal_error"
-  );
-}
-function getSlackClient() {
-  return getClient();
-}
-function isDmChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  return Boolean(normalized && normalized.startsWith("D"));
-}
-function isConversationScopedChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G") || normalized.startsWith("D");
-}
-function isConversationChannel(channelId) {
-  const normalized = normalizeSlackConversationId(channelId);
-  if (!normalized) return false;
-  return normalized.startsWith("C") || normalized.startsWith("G");
-}
-async function getFilePermalink(fileId) {
-  const client = getClient();
-  const response = await withSlackRetries(
-    () => client.files.info({
-      file: fileId
-    }),
-    3,
-    {
-      action: "files.info",
-      idempotent: true,
-      spanAttributes: { "app.slack.file_id": fileId }
-    }
-  );
-  return response.file?.permalink;
-}
-async function downloadPrivateSlackFile(url) {
-  const token = resolveSlackToken();
-  return withSpan(
-    "GET files.slack.com",
-    "http.client",
-    {},
-    async () => {
-      const response = await fetch(url, {
-        headers: {
-          Authorization: `Bearer ${token}`
-        }
-      });
-      setSpanAttributes({ "http.response.status_code": response.status });
-      if (!response.ok) {
-        setSpanAttributes({ "error.type": String(response.status) });
-        setSpanStatus("error");
-        throw new Error(`Slack file download failed: ${response.status}`);
-      }
-      return Buffer.from(await response.arrayBuffer());
-    },
-    {
-      "http.request.method": "GET",
-      "server.address": "files.slack.com",
-      "url.scheme": "https",
-      "app.slack.method": "files.download"
-    }
-  );
-}
-
-// src/chat/credentials/subject.ts
 var CREDENTIAL_SUBJECT_HMAC_CONTEXT = "junior.credential_subject.v1";
 var CREDENTIAL_SUBJECT_SIGNATURE_VERSION = "v1";
 function getCredentialSubjectSecret() {
@@ -1427,18 +1006,6 @@ export {
   createPluginModel,
   createPluginEmbedder,
   getSlackToolContext,
-  runWithWorkspaceTeamId,
-  getWorkspaceTeamId,
-  SlackActionError,
-  getHeaderString,
-  runWithSlackInstallationToken,
-  normalizeSlackConversationId,
-  withSlackRetries,
-  getSlackClient,
-  isDmChannel,
-  isConversationScopedChannel,
-  getFilePermalink,
-  downloadPrivateSlackFile,
   bindSlackDirectCredentialSubject,
   verifySlackDirectCredentialSubject,
   resolveChannelCapabilities,

package/dist/{chunk-DZENG5ML.js → chunk-6U26PYI5.js}

@@ -4,7 +4,7 @@ import {
   juniorDestinations,
   juniorIdentities,
   juniorUsers
-} from "./chunk-RITD7E5L.js";
+} from "./chunk-35BNLDOJ.js";
 
 // src/api/people/shared.ts
 import { and, asc, desc, eq, sql } from "drizzle-orm";
@@ -96,9 +96,8 @@ function summaryFromRow(row, nowMs) {
   const channelNameRedacted = Boolean(row.destinationVisibility) && row.destinationVisibility !== "public";
   return {
     conversationId: row.conversationId,
-    cumulativeDurationMs: 0,
+    cumulativeDurationMs: row.durationMs,
     displayTitle: titleFromRow(row, surface),
-    id: row.runId ?? row.conversationId,
     lastProgressAt: new Date(
       row.executionUpdatedAt ?? row.updatedAt
     ).toISOString(),
@@ -117,6 +116,18 @@ function summaryFromRow(row, nowMs) {
     ...channelNameRedacted ? { channelNameRedacted: true } : {}
   };
 }
+function usageTokens(row) {
+  const usage = row.usage;
+  if (!usage) return void 0;
+  if (usage.totalTokens !== void 0) return usage.totalTokens;
+  const values = [
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.cachedInputTokens,
+    usage.cacheCreationTokens
+  ].filter((value) => value !== void 0);
+  return values.length > 0 ? values.reduce((sum, value) => sum + value, 0) : void 0;
+}
 function emptyTotals() {
   return {
     active: 0,
@@ -124,8 +135,7 @@ function emptyTotals() {
     conversations: 0,
     durationMs: 0,
     failed: 0,
-    hung: 0,
-    runs: 0
+    hung: 0
   };
 }
 function emptyStatsItem(label) {
@@ -135,8 +145,7 @@ function emptyStatsItem(label) {
     durationMs: 0,
     failed: 0,
     hung: 0,
-    label,
-    runs: 0
+    label
   };
 }
 function emptyActivityDay(date) {
@@ -146,8 +155,7 @@ function emptyActivityDay(date) {
     date,
     durationMs: 0,
     failed: 0,
-    hung: 0,
-    runs: 0
+    hung: 0
   };
 }
 function signals(summary) {
@@ -194,16 +202,17 @@ function activityDays(days, nowMs) {
 }
 function statsItems(map) {
   return [...map.values()].sort(
-    (left, right) => right.conversations - left.conversations || right.runs - left.runs || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
+    (left, right) => right.conversations - left.conversations || right.durationMs - left.durationMs || left.label.localeCompare(right.label)
   );
 }
-async function actorRows(options = {}, email) {
+async function actorRows(email) {
   const normalizedEmail = normalizeEmail(email);
-  const rows = await (options.db ?? getDb()).select({
+  const rows = await getDb().select({
     channelName: juniorConversations.channelName,
     conversationId: juniorConversations.conversationId,
     createdAt: juniorConversations.createdAt,
     destinationVisibility: juniorDestinations.visibility,
+    durationMs: juniorConversations.durationMs,
     email: juniorUsers.primaryEmailNormalized,
     executionStatus: juniorConversations.executionStatus,
     executionUpdatedAt: juniorConversations.executionUpdatedAt,
@@ -211,10 +220,10 @@ async function actorRows(options = {}, email) {
     handle: juniorIdentities.handle,
     lastActivityAt: juniorConversations.lastActivityAt,
     providerSubjectId: juniorIdentities.providerSubjectId,
-    runId: juniorConversations.runId,
     source: juniorConversations.source,
     title: juniorConversations.title,
-    updatedAt: juniorConversations.updatedAt
+    updatedAt: juniorConversations.updatedAt,
+    usage: juniorConversations.usage
   }).from(juniorConversations).innerJoin(
     juniorIdentities,
     eq(juniorIdentities.id, juniorConversations.actorIdentityId)
@@ -248,6 +257,7 @@ export {
   surfaceLabel,
   slackLocationLabel,
   summaryFromRow,
+  usageTokens,
   emptyTotals,
   emptyStatsItem,
   emptyActivityDay,