@sentry/junior 0.1.0 → 0.1.1

package/dist/{chunk-7E56WM6K.js → chunk-5LLCJPTH.js}

@@ -1,25 +1,3 @@
-import {
-  getAgentTurnSessionCheckpoint,
-  getStateAdapter,
-  upsertAgentTurnSessionCheckpoint
-} from "./chunk-ZBFSIN6G.js";
-import {
-  addReactionToMessage,
-  listChannelMembers,
-  listChannelMessages,
-  postMessageToChannel
-} from "./chunk-MM3YNA4F.js";
-import {
-  SlackActionError,
-  botConfig,
-  getFilePermalink,
-  getSlackClient,
-  isConversationChannel,
-  isConversationScopedChannel,
-  isDmChannel,
-  normalizeSlackConversationId,
-  withSlackRetries
-} from "./chunk-GDNDYMGX.js";
 import {
   logError,
   logException,
@@ -31,6 +9,370 @@ import {
   withSpan
 } from "./chunk-BBOVH5RF.js";
 
+// src/chat/config.ts
+var MIN_AGENT_TURN_TIMEOUT_MS = 10 * 1e3;
+var DEFAULT_AGENT_TURN_TIMEOUT_MS = 12 * 60 * 1e3;
+var DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS = 800;
+var TURN_TIMEOUT_BUFFER_SECONDS = 20;
+function parseAgentTurnTimeoutMs(rawValue, maxTimeoutMs) {
+  const value = Number.parseInt(rawValue ?? "", 10);
+  if (Number.isNaN(value)) {
+    return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(DEFAULT_AGENT_TURN_TIMEOUT_MS, maxTimeoutMs));
+  }
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, Math.min(value, maxTimeoutMs));
+}
+function resolveQueueCallbackMaxDurationSeconds() {
+  const value = Number.parseInt(process.env.QUEUE_CALLBACK_MAX_DURATION_SECONDS ?? "", 10);
+  if (Number.isNaN(value) || value <= 0) {
+    return DEFAULT_QUEUE_CALLBACK_MAX_DURATION_SECONDS;
+  }
+  return value;
+}
+function resolveMaxTurnTimeoutMs(queueCallbackMaxDurationSeconds) {
+  const budgetSeconds = queueCallbackMaxDurationSeconds - TURN_TIMEOUT_BUFFER_SECONDS;
+  return Math.max(MIN_AGENT_TURN_TIMEOUT_MS, budgetSeconds * 1e3);
+}
+function buildBotConfig() {
+  const queueCallbackMaxDurationSeconds = resolveQueueCallbackMaxDurationSeconds();
+  const maxTurnTimeoutMs = resolveMaxTurnTimeoutMs(queueCallbackMaxDurationSeconds);
+  return {
+    userName: process.env.JUNIOR_BOT_NAME ?? "junior",
+    modelId: process.env.AI_MODEL ?? "anthropic/claude-sonnet-4.6",
+    fastModelId: process.env.AI_FAST_MODEL ?? process.env.AI_MODEL ?? "anthropic/claude-haiku-4.5",
+    turnTimeoutMs: parseAgentTurnTimeoutMs(process.env.AGENT_TURN_TIMEOUT_MS, maxTurnTimeoutMs)
+  };
+}
+var botConfig = buildBotConfig();
+function toOptionalTrimmed(value) {
+  if (!value) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function getSlackBotToken() {
+  return toOptionalTrimmed(process.env.SLACK_BOT_TOKEN) ?? toOptionalTrimmed(process.env.SLACK_BOT_USER_TOKEN);
+}
+function getSlackSigningSecret() {
+  return toOptionalTrimmed(process.env.SLACK_SIGNING_SECRET);
+}
+function getSlackClientId() {
+  return toOptionalTrimmed(process.env.SLACK_CLIENT_ID);
+}
+function getSlackClientSecret() {
+  return toOptionalTrimmed(process.env.SLACK_CLIENT_SECRET);
+}
+function hasRedisConfig() {
+  return Boolean(process.env.REDIS_URL);
+}
+
+// src/chat/state.ts
+import { createRedisState } from "@chat-adapter/state-redis";
+import { createMemoryState } from "@chat-adapter/state-memory";
+var MIN_LOCK_TTL_MS = 1e3 * 60 * 5;
+var QUEUE_INGRESS_DEDUP_PREFIX = "junior:queue_ingress";
+var QUEUE_MESSAGE_PROCESSING_PREFIX = "junior:queue_message";
+var AGENT_TURN_SESSION_PREFIX = "junior:agent_turn_session";
+var QUEUE_MESSAGE_PROCESSING_TTL_MS = 30 * 60 * 1e3;
+var QUEUE_MESSAGE_COMPLETED_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
+var QUEUE_MESSAGE_FAILED_TTL_MS = 6 * 60 * 60 * 1e3;
+var AGENT_TURN_SESSION_TTL_MS = 24 * 60 * 60 * 1e3;
+var CLAIM_OR_RECLAIM_PROCESSING_SCRIPT = `
+  local key = KEYS[1]
+  local nowMs = tonumber(ARGV[1])
+  local ttlMs = tonumber(ARGV[2])
+  local payload = ARGV[3]
+  local current = redis.call("get", key)
+
+  if not current then
+    redis.call("set", key, payload, "PX", ttlMs)
+    return 1
+  end
+
+  local ok, parsed = pcall(cjson.decode, current)
+  if not ok or type(parsed) ~= "table" then
+    return 0
+  end
+
+  local status = parsed["status"]
+  if status == "failed" then
+    redis.call("set", key, payload, "PX", ttlMs)
+    return 3
+  end
+  if status ~= "processing" then
+    return 0
+  end
+
+  local updatedAtMs = tonumber(parsed["updatedAtMs"])
+  if not updatedAtMs then
+    return 0
+  end
+
+  if updatedAtMs + ttlMs < nowMs then
+    redis.call("set", key, payload, "PX", ttlMs)
+    return 2
+  end
+
+  return 0
+`;
+var UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT = `
+  local key = KEYS[1]
+  local ownerToken = ARGV[1]
+  local ttlMs = tonumber(ARGV[2])
+  local payload = ARGV[3]
+  local current = redis.call("get", key)
+
+  if not current then
+    return 0
+  end
+
+  local ok, parsed = pcall(cjson.decode, current)
+  if not ok or type(parsed) ~= "table" then
+    return 0
+  end
+
+  local currentOwner = parsed["ownerToken"]
+  local status = parsed["status"]
+  if currentOwner ~= ownerToken then
+    return 0
+  end
+  if status ~= "processing" then
+    return 0
+  end
+
+  redis.call("set", key, payload, "PX", ttlMs)
+  return 1
+`;
+function createQueuedStateAdapter(base) {
+  const acquireLock = async (threadId, ttlMs) => {
+    const effectiveTtlMs = Math.max(ttlMs, MIN_LOCK_TTL_MS);
+    const lock = await base.acquireLock(threadId, effectiveTtlMs);
+    return lock;
+  };
+  return {
+    connect: () => base.connect(),
+    disconnect: () => base.disconnect(),
+    subscribe: (threadId) => base.subscribe(threadId),
+    unsubscribe: (threadId) => base.unsubscribe(threadId),
+    isSubscribed: (threadId) => base.isSubscribed(threadId),
+    acquireLock,
+    releaseLock: (lock) => base.releaseLock(lock),
+    extendLock: (lock, ttlMs) => base.extendLock(lock, Math.max(ttlMs, MIN_LOCK_TTL_MS)),
+    get: (key) => base.get(key),
+    set: (key, value, ttlMs) => base.set(key, value, ttlMs),
+    setIfNotExists: (key, value, ttlMs) => base.setIfNotExists(key, value, ttlMs),
+    delete: (key) => base.delete(key)
+  };
+}
+function createStateAdapter() {
+  if (process.env.JUNIOR_STATE_ADAPTER?.trim().toLowerCase() === "memory") {
+    _redisStateAdapter = void 0;
+    return createQueuedStateAdapter(createMemoryState());
+  }
+  if (!hasRedisConfig()) {
+    throw new Error("REDIS_URL is required for durable Slack thread state");
+  }
+  const redisState = createRedisState({
+    url: process.env.REDIS_URL
+  });
+  _redisStateAdapter = redisState;
+  return createQueuedStateAdapter(redisState);
+}
+var _stateAdapter;
+var _redisStateAdapter;
+function getRedisStateAdapter() {
+  if (!_redisStateAdapter) {
+    getStateAdapter();
+  }
+  if (!_redisStateAdapter) {
+    throw new Error("Redis state adapter is unavailable for this runtime");
+  }
+  return _redisStateAdapter;
+}
+function queueMessageKey(rawKey) {
+  return `${QUEUE_MESSAGE_PROCESSING_PREFIX}:${rawKey}`;
+}
+function parseQueueMessageState(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!parsed || parsed.status !== "processing" && parsed.status !== "completed" && parsed.status !== "failed" || typeof parsed.updatedAtMs !== "number") {
+      return void 0;
+    }
+    return {
+      status: parsed.status,
+      updatedAtMs: parsed.updatedAtMs,
+      ...typeof parsed.ownerToken === "string" ? { ownerToken: parsed.ownerToken } : {},
+      ...typeof parsed.queueMessageId === "string" ? { queueMessageId: parsed.queueMessageId } : {},
+      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function agentTurnSessionKey(conversationId, sessionId) {
+  return `${AGENT_TURN_SESSION_PREFIX}:${conversationId}:${sessionId}`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseAgentTurnSessionCheckpoint(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (!isRecord(parsed)) {
+      return void 0;
+    }
+    const status = parsed.state;
+    if (status !== "running" && status !== "awaiting_resume" && status !== "completed" && status !== "failed") {
+      return void 0;
+    }
+    const conversationId = parsed.conversationId;
+    const sessionId = parsed.sessionId;
+    const sliceId = parsed.sliceId;
+    const checkpointVersion = parsed.checkpointVersion;
+    const updatedAtMs = parsed.updatedAtMs;
+    if (typeof conversationId !== "string" || typeof sessionId !== "string" || typeof sliceId !== "number" || typeof checkpointVersion !== "number" || typeof updatedAtMs !== "number") {
+      return void 0;
+    }
+    return {
+      checkpointVersion,
+      conversationId,
+      sessionId,
+      sliceId,
+      state: status,
+      updatedAtMs,
+      piMessages: Array.isArray(parsed.piMessages) ? parsed.piMessages : [],
+      ...typeof parsed.errorMessage === "string" ? { errorMessage: parsed.errorMessage } : {},
+      ...typeof parsed.resumedFromSliceId === "number" ? { resumedFromSliceId: parsed.resumedFromSliceId } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function getStateAdapter() {
+  if (!_stateAdapter) {
+    _stateAdapter = createStateAdapter();
+  }
+  return _stateAdapter;
+}
+async function claimQueueIngressDedup(rawKey, ttlMs) {
+  await getStateAdapter().connect();
+  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
+  const result = await getRedisStateAdapter().getClient().set(key, "1", {
+    NX: true,
+    PX: ttlMs
+  });
+  return result === "OK";
+}
+async function hasQueueIngressDedup(rawKey) {
+  await getStateAdapter().connect();
+  const key = `${QUEUE_INGRESS_DEDUP_PREFIX}:${rawKey}`;
+  const value = await getRedisStateAdapter().getClient().get(key);
+  return typeof value === "string" && value.length > 0;
+}
+async function getQueueMessageProcessingState(rawKey) {
+  await getStateAdapter().connect();
+  const state = await getStateAdapter().get(queueMessageKey(rawKey));
+  return parseQueueMessageState(state);
+}
+async function acquireQueueMessageProcessingOwnership(args) {
+  await getStateAdapter().connect();
+  const key = queueMessageKey(args.rawKey);
+  const nowMs = Date.now();
+  const payload = JSON.stringify({
+    status: "processing",
+    updatedAtMs: nowMs,
+    ownerToken: args.ownerToken,
+    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
+  });
+  const result = await getRedisStateAdapter().getClient().eval(CLAIM_OR_RECLAIM_PROCESSING_SCRIPT, {
+    keys: [key],
+    arguments: [String(nowMs), String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
+  });
+  if (result === 1) {
+    return "acquired";
+  }
+  if (result === 2) {
+    return "reclaimed";
+  }
+  if (result === 3) {
+    return "recovered";
+  }
+  return "blocked";
+}
+async function refreshQueueMessageProcessingOwnership(args) {
+  await getStateAdapter().connect();
+  const nowMs = Date.now();
+  const payload = JSON.stringify({
+    status: "processing",
+    updatedAtMs: nowMs,
+    ownerToken: args.ownerToken,
+    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
+  });
+  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
+    keys: [queueMessageKey(args.rawKey)],
+    arguments: [args.ownerToken, String(QUEUE_MESSAGE_PROCESSING_TTL_MS), payload]
+  });
+  return result === 1;
+}
+async function completeQueueMessageProcessingOwnership(args) {
+  await getStateAdapter().connect();
+  const payload = JSON.stringify({
+    status: "completed",
+    updatedAtMs: Date.now(),
+    ownerToken: args.ownerToken,
+    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
+  });
+  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
+    keys: [queueMessageKey(args.rawKey)],
+    arguments: [args.ownerToken, String(QUEUE_MESSAGE_COMPLETED_TTL_MS), payload]
+  });
+  return result === 1;
+}
+async function failQueueMessageProcessingOwnership(args) {
+  await getStateAdapter().connect();
+  const payload = JSON.stringify({
+    status: "failed",
+    updatedAtMs: Date.now(),
+    ownerToken: args.ownerToken,
+    errorMessage: args.errorMessage,
+    ...args.queueMessageId ? { queueMessageId: args.queueMessageId } : {}
+  });
+  const result = await getRedisStateAdapter().getClient().eval(UPDATE_PROCESSING_STATE_IF_OWNER_SCRIPT, {
+    keys: [queueMessageKey(args.rawKey)],
+    arguments: [args.ownerToken, String(QUEUE_MESSAGE_FAILED_TTL_MS), payload]
+  });
+  return result === 1;
+}
+async function getAgentTurnSessionCheckpoint(conversationId, sessionId) {
+  await getStateAdapter().connect();
+  const value = await getStateAdapter().get(agentTurnSessionKey(conversationId, sessionId));
+  return parseAgentTurnSessionCheckpoint(value);
+}
+async function upsertAgentTurnSessionCheckpoint(args) {
+  await getStateAdapter().connect();
+  const existing = await getAgentTurnSessionCheckpoint(args.conversationId, args.sessionId);
+  const checkpoint = {
+    checkpointVersion: (existing?.checkpointVersion ?? 0) + 1,
+    conversationId: args.conversationId,
+    sessionId: args.sessionId,
+    sliceId: args.sliceId,
+    state: args.state,
+    updatedAtMs: Date.now(),
+    piMessages: Array.isArray(args.piMessages) ? args.piMessages : [],
+    ...args.errorMessage ? { errorMessage: args.errorMessage } : {},
+    ...typeof args.resumedFromSliceId === "number" ? { resumedFromSliceId: args.resumedFromSliceId } : {}
+  };
+  const ttlMs = Math.max(1, args.ttlMs ?? AGENT_TURN_SESSION_TTL_MS);
+  await getStateAdapter().set(agentTurnSessionKey(args.conversationId, args.sessionId), JSON.stringify(checkpoint), ttlMs);
+  return checkpoint;
+}
+
 // src/chat/plugins/registry.ts
 import { readFileSync as readFileSync2, readdirSync, statSync as statSync2 } from "fs";
 import path3 from "path";
@@ -1314,13 +1656,268 @@ function createSkillCapabilityRuntime(options = {}) {
   });
 }
 
+// src/chat/slack-actions/client.ts
+import { WebClient } from "@slack/web-api";
+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 client = null;
+function normalizeSlackConversationId(channelId) {
+  if (!channelId) return void 0;
+  const trimmed = channelId.trim();
+  if (!trimmed) return void 0;
+  if (!trimmed.startsWith("slack:")) {
+    return trimmed;
+  }
+  const parts = trimmed.split(":");
+  return parts[1]?.trim() || void 0;
+}
+function getClient() {
+  if (client) return client;
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack canvas/list actions in this service",
+      "missing_token"
+    );
+  }
+  client = new WebClient(token);
+  return client;
+}
+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 === "invalid_arguments") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "invalid_name") {
+    return new SlackActionError(message, "invalid_arguments", baseOptions);
+  }
+  if (apiError === "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);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withSlackRetries(task, maxAttempts = 3, context = {}) {
+  let attempt = 0;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    try {
+      return await task();
+    } catch (error) {
+      const mapped = mapSlackError(error);
+      const isRetryable = mapped.code === "rate_limited";
+      const baseLogAttributes = {
+        "app.slack.action": context.action ?? "unknown",
+        "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) {
+        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
+        },
+        "Retrying Slack action after transient failure"
+      );
+      const retryAfterMs = mapped.code === "rate_limited" && mapped.retryAfterSeconds && mapped.retryAfterSeconds > 0 ? mapped.retryAfterSeconds * 1e3 : void 0;
+      const backoffMs = Math.min(2e3, 250 * 2 ** (attempt - 1));
+      await sleep(retryAfterMs ?? backoffMs);
+    }
+  }
+  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 client2 = getClient();
+  const response = await withSlackRetries(
+    () => client2.files.info({
+      file: fileId
+    })
+  );
+  return response.file?.permalink;
+}
+async function downloadPrivateSlackFile(url) {
+  const token = getSlackBotToken();
+  if (!token) {
+    throw new SlackActionError(
+      "SLACK_BOT_TOKEN (or SLACK_BOT_USER_TOKEN) is required for Slack file downloads in this service",
+      "missing_token"
+    );
+  }
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Slack file download failed: ${response.status}`);
+  }
+  return Buffer.from(await response.arrayBuffer());
+}
+
 // src/chat/capabilities/jr-rpc-command.ts
 import { randomBytes } from "crypto";
 import { Bash, defineCommand } from "just-bash";
 async function deliverPrivateMessage(input) {
-  let client;
+  let client2;
   try {
-    client = getSlackClient();
+    client2 = getSlackClient();
   } catch {
     logWarn("oauth_private_delivery_skip", {}, { "app.reason": "missing_bot_token" }, "Skipped private message delivery \u2014 no SLACK_BOT_TOKEN");
     return false;
@@ -1329,13 +1926,13 @@ async function deliverPrivateMessage(input) {
     const isDm = isDmChannel(input.channelId);
     try {
       if (isDm) {
-        await client.chat.postMessage({
+        await client2.chat.postMessage({
           channel: input.channelId,
           text: input.text,
           ...input.threadTs ? { thread_ts: input.threadTs } : {}
         });
       } else {
-        await client.chat.postEphemeral({
+        await client2.chat.postEphemeral({
           channel: input.channelId,
           user: input.userId,
           text: input.text,
@@ -1354,13 +1951,13 @@ async function deliverPrivateMessage(input) {
     }
   }
   try {
-    const openResult = await client.conversations.open({ users: input.userId });
+    const openResult = await client2.conversations.open({ users: input.userId });
     const dmChannelId = openResult.channel?.id;
     if (!dmChannelId) {
       logWarn("oauth_dm_fallback_failed", {}, { "app.reason": "no_dm_channel_id" }, "conversations.open returned no channel ID");
       return false;
     }
-    await client.chat.postMessage({ channel: dmChannelId, text: input.text });
+    await client2.chat.postMessage({ channel: dmChannelId, text: input.text });
     return "fallback_dm";
   } catch (error) {
     const slackError = error instanceof Error ? error.message : String(error);
@@ -3052,7 +3649,7 @@ var GATEWAY_PROVIDER = "vercel-ai-gateway";
 var GEN_AI_PROVIDER_NAME = GATEWAY_PROVIDER;
 var GEN_AI_OPERATION_CHAT = "chat";
 var MISSING_GATEWAY_CREDENTIALS_ERROR = "Missing AI gateway credentials (AI_GATEWAY_API_KEY or VERCEL_OIDC_TOKEN)";
-function toOptionalTrimmed(value) {
+function toOptionalTrimmed2(value) {
   if (!value) {
     return void 0;
   }
@@ -3063,14 +3660,14 @@ function isVercelRuntime() {
   return process.env.VERCEL === "1" || Boolean(process.env.VERCEL_ENV) || Boolean(process.env.VERCEL_REGION);
 }
 function getGatewayApiKey() {
-  const explicitApiKey = toOptionalTrimmed(getEnvApiKey("vercel-ai-gateway"));
+  const explicitApiKey = toOptionalTrimmed2(getEnvApiKey("vercel-ai-gateway"));
   if (explicitApiKey) {
     return explicitApiKey;
   }
   if (!isVercelRuntime()) {
     return void 0;
   }
-  return toOptionalTrimmed(process.env.VERCEL_OIDC_TOKEN);
+  return toOptionalTrimmed2(process.env.VERCEL_OIDC_TOKEN);
 }
 function extractText(message) {
   return (message.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text ?? "").join("").trim();
@@ -3488,6 +4085,197 @@ function createReadFileTool() {
 
 // src/chat/tools/slack-channel-list-members.ts
 import { Type as Type5 } from "@sinclair/typebox";
+
+// src/chat/slack-actions/channel.ts
+async function postMessageToChannel(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel message posting requires a valid channel ID");
+  }
+  const response = await withSlackRetries(
+    () => client2.chat.postMessage({
+      channel: channelId,
+      text: input.text,
+      mrkdwn: true
+    }),
+    3,
+    { action: "chat.postMessage" }
+  );
+  if (!response.ts) {
+    throw new Error("Slack channel message posted without ts");
+  }
+  let permalink;
+  try {
+    const permalinkResponse = await withSlackRetries(
+      () => client2.chat.getPermalink({
+        channel: channelId,
+        message_ts: response.ts
+      }),
+      3,
+      { action: "chat.getPermalink" }
+    );
+    permalink = permalinkResponse.permalink;
+  } catch {
+  }
+  return {
+    ts: response.ts,
+    permalink
+  };
+}
+async function addReactionToMessage(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack reaction requires a valid channel ID");
+  }
+  const timestamp = input.timestamp.trim();
+  if (!timestamp) {
+    throw new Error("Slack reaction requires a target message timestamp");
+  }
+  const emoji = input.emoji.trim().replaceAll(":", "");
+  if (!emoji) {
+    throw new Error("Slack reaction requires a non-empty emoji name");
+  }
+  await withSlackRetries(
+    () => client2.reactions.add({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    }),
+    3,
+    { action: "reactions.add" }
+  );
+  return { ok: true };
+}
+async function removeReactionFromMessage(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack reaction requires a valid channel ID");
+  }
+  const timestamp = input.timestamp.trim();
+  if (!timestamp) {
+    throw new Error("Slack reaction requires a target message timestamp");
+  }
+  const emoji = input.emoji.trim().replaceAll(":", "");
+  if (!emoji) {
+    throw new Error("Slack reaction requires a non-empty emoji name");
+  }
+  await withSlackRetries(
+    () => client2.reactions.remove({
+      channel: channelId,
+      timestamp,
+      name: emoji
+    }),
+    3,
+    { action: "reactions.remove" }
+  );
+  return { ok: true };
+}
+async function listChannelMessages(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel history lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 5, 10));
+  const messages = [];
+  let cursor = input.cursor;
+  let pages = 0;
+  while (messages.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - messages.length));
+    const response = await withSlackRetries(
+      () => client2.conversations.history({
+        channel: channelId,
+        limit: pageLimit,
+        cursor,
+        oldest: input.oldest,
+        latest: input.latest,
+        inclusive: input.inclusive
+      }),
+      3,
+      { action: "conversations.history" }
+    );
+    const batch = response.messages ?? [];
+    messages.push(...batch);
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor) {
+      break;
+    }
+  }
+  return {
+    messages: messages.slice(0, targetLimit),
+    nextCursor: cursor
+  };
+}
+async function listChannelMembers(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack channel member lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit, 200));
+  const response = await withSlackRetries(
+    () => client2.conversations.members({
+      channel: channelId,
+      limit: targetLimit,
+      cursor: input.cursor
+    }),
+    3,
+    { action: "conversations.members" }
+  );
+  const members = (response.members ?? []).slice(0, targetLimit);
+  return {
+    members: members.map((userId) => ({ user_id: userId })),
+    nextCursor: response.response_metadata?.next_cursor || void 0
+  };
+}
+async function listThreadReplies(input) {
+  const client2 = getSlackClient();
+  const channelId = normalizeSlackConversationId(input.channelId);
+  if (!channelId) {
+    throw new Error("Slack thread reply lookup requires a valid channel ID");
+  }
+  const targetLimit = Math.max(1, Math.min(input.limit ?? 1e3, 1e3));
+  const maxPages = Math.max(1, Math.min(input.maxPages ?? 10, 10));
+  const pendingTargets = new Set(
+    (input.targetMessageTs ?? []).filter((value) => typeof value === "string" && value.length > 0)
+  );
+  const replies = [];
+  let cursor;
+  let pages = 0;
+  while (replies.length < targetLimit && pages < maxPages) {
+    pages += 1;
+    const pageLimit = Math.max(1, Math.min(200, targetLimit - replies.length));
+    const response = await withSlackRetries(
+      () => client2.conversations.replies({
+        channel: channelId,
+        ts: input.threadTs,
+        limit: pageLimit,
+        cursor
+      }),
+      3,
+      { action: "conversations.replies" }
+    );
+    const batch = response.messages ?? [];
+    replies.push(...batch);
+    for (const reply of batch) {
+      if (typeof reply.ts === "string" && pendingTargets.size > 0) {
+        pendingTargets.delete(reply.ts);
+      }
+    }
+    cursor = response.response_metadata?.next_cursor || void 0;
+    if (!cursor || pendingTargets.size === 0) {
+      break;
+    }
+  }
+  return replies.slice(0, targetLimit);
+}
+
+// src/chat/tools/slack-channel-list-members.ts
 function createSlackChannelListMembersTool(context) {
   return tool({
     description: "List member IDs in the active Slack channel context. Use when the user asks who is in a channel, who to assign, or who should be notified. Do not use when thread-local participant context is sufficient.",
@@ -3737,7 +4525,7 @@ function normalizeCanvasMarkdown(markdown) {
   };
 }
 async function createCanvas(input) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const normalizedChannelId = normalizeSlackConversationId(input.channelId);
   const isConversationScoped = isConversationScopedChannel(normalizedChannelId);
   if (!isConversationScoped) {
@@ -3749,7 +4537,7 @@ async function createCanvas(input) {
   const action = "conversations.canvases.create";
   const normalizedContent = normalizeCanvasMarkdown(input.markdown);
   const result = await withSlackRetries(async () => {
-    return client.conversations.canvases.create({
+    return client2.conversations.canvases.create({
       channel_id: normalizedChannelId,
       title: input.title,
       document_content: {
@@ -3782,9 +4570,9 @@ async function createCanvas(input) {
   };
 }
 async function lookupCanvasSection(canvasId, containsText) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const response = await withSlackRetries(
-    () => client.canvases.sections.lookup({
+    () => client2.canvases.sections.lookup({
       canvas_id: canvasId,
       criteria: {
         contains_text: containsText
@@ -3802,10 +4590,10 @@ async function lookupCanvasSection(canvasId, containsText) {
   return response.sections?.[0]?.id;
 }
 async function updateCanvas(input) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const normalizedContent = normalizeCanvasMarkdown(input.markdown);
   await withSlackRetries(
-    () => client.canvases.edit({
+    () => client2.canvases.edit({
       canvas_id: input.canvasId,
       changes: [
         {
@@ -4048,9 +4836,9 @@ var DEFAULT_TODO_SCHEMA = [
   { key: "due_date", name: "Due Date", type: "date" }
 ];
 async function createTodoList(name) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const result = await withSlackRetries(
-    () => client.slackLists.create({
+    () => client2.slackLists.create({
       name,
       schema: DEFAULT_TODO_SCHEMA,
       todo_mode: true
@@ -4072,7 +4860,7 @@ async function createTodoList(name) {
   };
 }
 async function addListItems(input) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const listColumnMap = input.listColumnMap ?? {};
   if (!listColumnMap.titleColumnId) {
     throw new Error("Cannot add list items because title column could not be inferred");
@@ -4093,7 +4881,7 @@ async function addListItems(input) {
       });
     }
     const response = await withSlackRetries(
-      () => client.slackLists.items.create({
+      () => client2.slackLists.items.create({
         list_id: input.listId,
         initial_fields: initialFields
       })
@@ -4108,13 +4896,13 @@ async function addListItems(input) {
   };
 }
 async function listItems(listId, limit = 100) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const items = [];
   let cursor;
   const cappedLimit = Math.max(1, Math.min(limit, 200));
   do {
     const response = await withSlackRetries(
-      () => client.slackLists.items.list({
+      () => client2.slackLists.items.list({
         list_id: listId,
         limit: cappedLimit,
         cursor
@@ -4133,7 +4921,7 @@ async function listItems(listId, limit = 100) {
   return items;
 }
 async function updateListItem(input) {
-  const client = getSlackClient();
+  const client2 = getSlackClient();
   const cells = [];
   if (typeof input.completed === "boolean" && input.listColumnMap.completedColumnId) {
     cells.push({
@@ -4152,7 +4940,7 @@ async function updateListItem(input) {
     throw new Error("No updatable fields were provided or inferred for this list item");
   }
   await withSlackRetries(
-    () => client.slackLists.items.update({
+    () => client2.slackLists.items.update({
       list_id: input.listId,
       cells
     })
@@ -5001,7 +5789,7 @@ var SNAPSHOT_CACHE_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
 var SNAPSHOT_BUILD_LOCK_TTL_MS = 10 * 60 * 1e3;
 var SNAPSHOT_WAIT_FOR_LOCK_MS = SNAPSHOT_BUILD_LOCK_TTL_MS + 30 * 1e3;
 var DEFAULT_FLOATING_DEP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve) => {
     setTimeout(resolve, ms);
   });
@@ -5286,7 +6074,7 @@ async function withBuildLock(profileHash, callback, canUseCachedSnapshot) {
             await state.releaseLock(lock);
           }
         }
-        await sleep(500);
+        await sleep2(500);
       }
       const cached = await getCachedSnapshot(profileHash);
       if (cached?.snapshotId && canUseCachedSnapshot(cached)) {
@@ -6046,14 +6834,14 @@ function createSandboxExecutor(options) {
 }
 
 // src/chat/runtime-metadata.ts
-function toOptionalTrimmed2(value) {
+function toOptionalTrimmed3(value) {
   if (!value) return void 0;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : void 0;
 }
 function getRuntimeMetadata() {
   return {
-    version: toOptionalTrimmed2(process.env.VERCEL_GIT_COMMIT_SHA)
+    version: toOptionalTrimmed3(process.env.VERCEL_GIT_COMMIT_SHA)
   };
 }
 
@@ -7284,7 +8072,23 @@ async function publishAppHomeView(slackClient, userId, userTokenStore) {
 
 export {
   isPluginProvider,
+  botConfig,
+  getSlackBotToken,
+  getSlackSigningSecret,
+  getSlackClientId,
+  getSlackClientSecret,
+  getStateAdapter,
+  claimQueueIngressDedup,
+  hasQueueIngressDedup,
+  getQueueMessageProcessingState,
+  acquireQueueMessageProcessingOwnership,
+  refreshQueueMessageProcessingOwnership,
+  completeQueueMessageProcessingOwnership,
+  failQueueMessageProcessingOwnership,
   getUserTokenStore,
+  getSlackClient,
+  isDmChannel,
+  downloadPrivateSlackFile,
   getOAuthProviderConfig,
   resolveBaseUrl,
   startOAuthFlow,
@@ -7295,6 +8099,9 @@ export {
   GEN_AI_PROVIDER_NAME,
   completeText,
   completeObject,
+  addReactionToMessage,
+  removeReactionFromMessage,
+  listThreadReplies,
   shouldEmitDevAgentTrace,
   truncateStatusText,
   isRetryableTurnError,