@cuylabs/channel-slack 0.9.0 → 0.11.0

package/dist/assistant/index.js

@@ -1,188 +1,19 @@
 import {
-  extractSlackActionToken
-} from "../chunk-TWJGVDA2.js";
-import {
-  resolveSlackChannelType,
-  stripLeadingMentions
-} from "../chunk-FPCE5V5Y.js";
-
-// src/assistant/thread-context-store.ts
-var ASSISTANT_THREAD_CONTEXT_EVENT_TYPE = "assistant_thread_context";
-function createSlackAssistantThreadContextStore() {
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    async get(args) {
-      args.logger?.debug?.("[channel-slack] thread context store get called");
-      const { channelId, threadTs } = extractThreadInfo(args.payload);
-      const cacheKey = contextCacheKey(channelId, threadTs);
-      const cached = cache.get(cacheKey);
-      if (cached) return cached;
-      const messages = await readThreadMessages(args, channelId, threadTs);
-      const botUserId = args.context?.botUserId;
-      const metadataMessage = findContextMessage(messages, botUserId);
-      const context = toThreadContext(metadataMessage?.metadata?.event_payload);
-      cache.set(cacheKey, context);
-      return context;
-    },
-    async save(args) {
-      args.logger?.debug?.("[channel-slack] thread context store save called");
-      const { channelId, threadTs, context } = extractThreadInfo(args.payload);
-      const cacheKey = contextCacheKey(channelId, threadTs);
-      cache.set(cacheKey, context);
-      const messages = await readThreadMessages(args, channelId, threadTs);
-      const initialMessage = findInitialBotMessage(
-        messages,
-        args.context?.botUserId
-      );
-      if (!initialMessage?.ts) return;
-      await args.client?.chat?.update?.({
-        channel: channelId,
-        ts: initialMessage.ts,
-        text: initialMessage.text ?? "",
-        blocks: Array.isArray(initialMessage.blocks) ? initialMessage.blocks : [],
-        metadata: {
-          event_type: ASSISTANT_THREAD_CONTEXT_EVENT_TYPE,
-          event_payload: context
-        }
-      });
-    }
-  };
-}
-async function readThreadMessages(args, channelId, threadTs) {
-  const replies = args.client?.conversations?.replies;
-  if (typeof replies !== "function") return [];
-  const result = await replies({
-    channel: channelId,
-    ts: threadTs,
-    oldest: threadTs,
-    include_all_metadata: true,
-    limit: 4
-  });
-  return Array.isArray(result.messages) ? result.messages.filter(isSlackMessageWithMetadata) : [];
-}
-function findContextMessage(messages, botUserId) {
-  return messages.find(
-    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_type === ASSISTANT_THREAD_CONTEXT_EVENT_TYPE
-  ) ?? messages.find(
-    (message) => isBotAuthoredMessage(message, botUserId) && message.metadata?.event_payload
-  );
-}
-function findInitialBotMessage(messages, botUserId) {
-  return messages.find((message) => isBotAuthoredMessage(message, botUserId));
-}
-function isBotAuthoredMessage(message, botUserId) {
-  if (message.subtype) return false;
-  return botUserId ? message.user === botUserId : Boolean(message.user);
-}
-function extractThreadInfo(payload) {
-  const channelId = extractChannelId(payload);
-  const threadTs = extractThreadTs(payload);
-  if (!channelId || !threadTs) {
-    const missing = [];
-    if (!channelId) missing.push("channel_id");
-    if (!threadTs) missing.push("thread_ts");
-    throw new Error(
-      `Assistant payload is missing required properties: ${missing.join(", ")}`
-    );
-  }
-  return {
-    channelId,
-    threadTs,
-    context: extractThreadContext(payload)
-  };
-}
-function extractThreadContext(payload) {
-  if (!isRecord(payload)) return {};
-  const assistantThread = payload.assistant_thread;
-  if (!isRecord(assistantThread) || !isRecord(assistantThread.context)) {
-    return {};
-  }
-  return toThreadContext(assistantThread.context);
-}
-function extractThreadTs(payload) {
-  if (!isRecord(payload)) return void 0;
-  if (isNonEmptyString(payload.thread_ts)) return payload.thread_ts;
-  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.thread_ts)) {
-    return payload.assistant_thread.thread_ts;
-  }
-  if (isRecord(payload.message) && isNonEmptyString(payload.message.thread_ts)) {
-    return payload.message.thread_ts;
-  }
-  if (isRecord(payload.previous_message) && isNonEmptyString(payload.previous_message.thread_ts)) {
-    return payload.previous_message.thread_ts;
-  }
-  return void 0;
-}
-function extractChannelId(payload) {
-  if (!isRecord(payload)) return void 0;
-  if (isNonEmptyString(payload.channel)) return payload.channel;
-  if (isRecord(payload.channel) && isNonEmptyString(payload.channel.id)) {
-    return payload.channel.id;
-  }
-  if (isNonEmptyString(payload.channel_id)) return payload.channel_id;
-  if (isRecord(payload.item) && isNonEmptyString(payload.item.channel)) {
-    return payload.item.channel;
-  }
-  if (isRecord(payload.assistant_thread) && isNonEmptyString(payload.assistant_thread.channel_id)) {
-    return payload.assistant_thread.channel_id;
-  }
-  return void 0;
-}
-function toThreadContext(value) {
-  if (!isRecord(value)) return {};
-  return {
-    ...isNonEmptyString(value.channel_id) ? { channel_id: value.channel_id } : {},
-    ...isNonEmptyString(value.team_id) ? { team_id: value.team_id } : {},
-    ..."enterprise_id" in value ? {
-      enterprise_id: typeof value.enterprise_id === "string" ? value.enterprise_id : null
-    } : {}
-  };
-}
-function isSlackMessageWithMetadata(value) {
-  return isRecord(value);
-}
-function contextCacheKey(channelId, threadTs) {
-  return `${channelId}:${threadTs}`;
-}
-function isNonEmptyString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-
-// src/assistant/message-parser.ts
-function parseSlackMessageActivityFromMessageEvent(message) {
-  if (!message || typeof message !== "object") return void 0;
-  const m = message;
-  if (m.subtype && m.subtype.length > 0) return void 0;
-  if (typeof m.text !== "string" || m.text.length === 0) return void 0;
-  if (typeof m.thread_ts !== "string" || m.thread_ts.length === 0) {
-    return void 0;
-  }
-  const channel = typeof m.channel === "string" ? m.channel : void 0;
-  if (!channel) return void 0;
-  const threadTs = m.thread_ts;
-  const messageTs = m.ts;
-  const isThread = threadTs !== messageTs;
-  const channelType = resolveSlackChannelType(channel, threadTs, isThread);
-  const rawText = m.text;
-  const text = channelType === "dm" ? rawText.trim() : stripLeadingMentions(rawText);
-  return {
-    channel,
-    threadTs,
-    channelId: channel,
-    channelType,
-    userId: m.user ?? "unknown",
-    teamId: m.team ?? void 0,
-    parentUserId: m.parent_user_id,
-    actionToken: extractSlackActionToken(m),
-    text,
-    isMention: false,
-    ...messageTs ? { messageTs } : {}
-  };
-}
+  createSlackAssistantBridge,
+  createSlackAssistantThreadContextStore,
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId
+} from "../chunk-Q6YX7HHK.js";
+import "../chunk-RHOIVQLD.js";
+import "../chunk-IRFKUPJN.js";
+import "../chunk-IAQXQESO.js";
+import "../chunk-37RN2YUI.js";
+import "../chunk-3KP3CBCC.js";
+import "../chunk-FPCE5V5Y.js";
+import "../chunk-6WHFQUYQ.js";
 export {
+  createSlackAssistantBridge,
   createSlackAssistantThreadContextStore,
-  parseSlackMessageActivityFromMessageEvent
+  parseSlackMessageActivityFromMessageEvent,
+  resolveAssistantSessionId
 };

package/dist/bolt-app-BM0tiL7c.d.ts

@@ -0,0 +1,49 @@
+import { AppOptions, SocketModeReceiverOptions, App } from '@slack/bolt';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from './types-B9NfCVrk.js';
+
+/**
+ * `createSlackSocketBoltApp` — builds a Socket Mode Bolt `App` from the
+ * package's structured auth options. Mirrors `createSlackBoltApp` without
+ * owning any assistant/app surface mounting.
+ */
+
+type ControlledSocketBoltAppOption = "receiver" | "socketMode" | "appToken" | "token" | "authorize" | "botId" | "botUserId" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions";
+type ControlledSocketModeReceiverOption = "appToken" | "clientId" | "clientSecret" | "stateSecret" | "redirectUri" | "installationStore" | "scopes" | "installerOptions" | "logger" | "logLevel";
+interface CreateSlackSocketBoltAppOptions {
+    /**
+     * Slack app-level token (`xapp-...`) with `connections:write` scope.
+     * @default process.env.SLACK_APP_TOKEN
+     */
+    appToken?: string;
+    /**
+     * Convenience override for single-workspace mode.
+     * @default process.env.SLACK_BOT_TOKEN
+     */
+    botToken?: string;
+    /**
+     * Direct-mode auth configuration.
+     *
+     * - omit for single-workspace token mode
+     * - use `{ mode: "oauth", ... }` for Bolt-managed installs
+     * - use `{ mode: "authorize", authorize }` for external token resolution
+     */
+    auth?: SlackDirectAuthOptions;
+    /**
+     * Additional Bolt `App` options passed after this package sets Socket Mode
+     * and auth. Use for logger/clientOptions and non-auth native Bolt config.
+     */
+    boltAppOptions?: Partial<Omit<AppOptions, ControlledSocketBoltAppOption>>;
+    /**
+     * Additional native Socket Mode receiver options. Use this for websocket
+     * health tuning such as ping timeouts, reconnect behavior, and receiver
+     * error handling. Auth/OAuth fields stay controlled by this helper.
+     */
+    socketModeReceiverOptions?: Partial<Omit<SocketModeReceiverOptions, ControlledSocketModeReceiverOption>>;
+}
+interface CreateSlackSocketBoltAppResult {
+    boltApp: App;
+    authMode: SlackDirectAuthMode;
+}
+declare function createSlackSocketBoltApp(options?: CreateSlackSocketBoltAppOptions): Promise<CreateSlackSocketBoltAppResult>;
+
+export { type CreateSlackSocketBoltAppOptions as C, type CreateSlackSocketBoltAppResult as a, createSlackSocketBoltApp as c };

package/dist/{chunk-TWJGVDA2.js → chunk-37RN2YUI.js}

@@ -99,10 +99,97 @@ function extractSlackAuthContext(context, eventUserId) {
   return auth;
 }
 
+// src/shared/turn-context.ts
+import { AsyncLocalStorage } from "async_hooks";
+var store = new AsyncLocalStorage();
+function currentSlackTurnContext() {
+  return store.getStore();
+}
+function runWithSlackTurnContext(value, fn) {
+  return Promise.resolve(store.run({ ...value }, fn));
+}
+
+// src/shared/follow-up.ts
+function formatSlackAttributedFollowUp(message) {
+  const slack = currentSlackTurnContext();
+  if (!slack) {
+    return message;
+  }
+  const sender = formatSlackSender(slack);
+  const conversation = formatSlackConversation(slack);
+  if (!sender && !conversation) {
+    return message;
+  }
+  const lines = ["Additional Slack follow-up for the running request."];
+  if (sender) {
+    lines.push(`Sender: ${sender}`);
+  }
+  if (conversation) {
+    lines.push(`Conversation: ${conversation}`);
+  }
+  lines.push("Message:", message);
+  return lines.join("\n");
+}
+function formatSlackSender(slack) {
+  const userId = slack.slackActivity.userId || slack.user.userId;
+  const displayName = readPreparedSlackDisplayName(slack.context) ?? slack.user.userName;
+  if (displayName && userId) {
+    return `${displayName} (${userId})`;
+  }
+  return displayName ?? userId ?? "unknown Slack user";
+}
+function formatSlackConversation(slack) {
+  const activity = slack.slackActivity;
+  const surface = formatSlackSurface(activity.channelType);
+  const parts = [
+    activity.teamId ? `team ${activity.teamId}` : void 0,
+    activity.channelId ? `channel ${activity.channelId}` : void 0,
+    activity.threadTs ? `thread ${activity.threadTs}` : activity.messageTs ? `message ${activity.messageTs}` : void 0
+  ].filter((part) => Boolean(part));
+  return parts.length > 0 ? `${surface} (${parts.join(", ")})` : surface;
+}
+function formatSlackSurface(channelType) {
+  switch (channelType) {
+    case "dm":
+      return "private Slack DM";
+    case "thread":
+      return "shared Slack thread";
+    case "channel":
+      return "shared Slack channel";
+    case "group":
+      return "shared Slack group conversation";
+    default:
+      return "Slack conversation";
+  }
+}
+function readPreparedSlackDisplayName(context) {
+  const slack = context?.slack;
+  if (!slack || typeof slack !== "object") {
+    return void 0;
+  }
+  const value = slack.userDisplayName;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/shared/session.ts
+function resolveThreadAwareSlackSessionId(info) {
+  if (info.channelType === "dm") {
+    return info.channelId;
+  }
+  if (info.threadTs) {
+    return `${info.channelId}:${info.threadTs}`;
+  }
+  return `${info.channelId}:${info.messageTs ?? info.channelId}`;
+}
+
 export {
   extractSlackActionToken,
   parseSlackMessageActivity,
   parseSlackMentionActivity,
   extractSlackUserIdentity,
-  extractSlackAuthContext
+  extractSlackAuthContext,
+  currentSlackTurnContext,
+  runWithSlackTurnContext,
+  formatSlackAttributedFollowUp,
+  resolveThreadAwareSlackSessionId
 };