@cuylabs/channel-slack 0.5.1 → 0.7.0

package/dist/chunk-QJYCHWN6.js

@@ -0,0 +1,76 @@
+import {
+  normalizeSlackEventsPath,
+  resolveDirectAuth,
+  trimToUndefined
+} from "./chunk-S3SWPYXJ.js";
+
+// src/transports/http/bolt-app.ts
+async function createSlackBoltApp(options = {}) {
+  const boltModule = await import("@slack/bolt");
+  const routePath = normalizeSlackEventsPath(options.path ?? "/slack/events");
+  const signingSecret = trimToUndefined(
+    options.signingSecret ?? process.env.SLACK_SIGNING_SECRET
+  );
+  if (!signingSecret) {
+    throw new Error(
+      "Slack signing secret is required. Pass `signingSecret` or set SLACK_SIGNING_SECRET."
+    );
+  }
+  const auth = resolveDirectAuth(options);
+  const receiver = new boltModule.ExpressReceiver({
+    ...options.receiverOptions,
+    signingSecret,
+    endpoints: routePath,
+    processBeforeResponse: options.processBeforeResponse,
+    signatureVerification: options.signatureVerification,
+    // Bolt is typed against Express 4 while this repo uses Express 5 types.
+    // The runtime contract is compatible; keep the cast localized here.
+    app: options.app,
+    ...auth.mode === "oauth" ? {
+      clientId: auth.clientId,
+      clientSecret: auth.clientSecret,
+      stateSecret: auth.stateSecret,
+      installationStore: auth.installationStore,
+      redirectUri: auth.redirectUri,
+      scopes: auth.scopes,
+      installerOptions: {
+        stateStore: auth.stateStore,
+        stateVerification: auth.stateVerification,
+        legacyStateVerification: auth.legacyStateVerification,
+        stateCookieName: auth.stateCookieName,
+        stateCookieExpirationSeconds: auth.stateCookieExpirationSeconds,
+        metadata: auth.metadata,
+        userScopes: auth.userScopes,
+        installPath: auth.installPath,
+        redirectUriPath: auth.callbackPath,
+        renderHtmlForInstallPath: auth.renderHtmlForInstallPath,
+        installPathOptions: auth.installPathOptions,
+        callbackOptions: auth.callbackOptions,
+        directInstall: auth.directInstall,
+        authVersion: auth.authVersion,
+        authorizationUrl: auth.authorizationUrl
+      }
+    } : {}
+  });
+  const boltApp = new boltModule.App({
+    ...options.boltAppOptions,
+    receiver,
+    ...auth.mode === "single-workspace" ? {
+      token: auth.botToken,
+      botId: auth.botId,
+      botUserId: auth.botUserId
+    } : {},
+    ...auth.mode === "authorize" ? { authorize: auth.authorize } : {}
+  });
+  return {
+    boltApp,
+    receiver,
+    app: options.app ?? receiver.app,
+    authMode: auth.mode,
+    routePath
+  };
+}
+
+export {
+  createSlackBoltApp
+};

package/dist/chunk-S3SWPYXJ.js

@@ -0,0 +1,81 @@
+// src/auth/resolve.ts
+function resolveDirectAuth(options) {
+  const provided = options.auth;
+  if (!provided || provided.mode === void 0 || provided.mode === "single-workspace") {
+    const singleWorkspace = provided;
+    const botToken = firstNonEmptyString(
+      singleWorkspace?.botToken,
+      options.botToken,
+      process.env.SLACK_BOT_TOKEN
+    );
+    if (!botToken) {
+      throw new Error(
+        'Slack bot token is required for single-workspace mode. Pass `botToken`, use `auth: { mode: "oauth", ... }`, or use `auth: { mode: "authorize", ... }`.'
+      );
+    }
+    return {
+      mode: "single-workspace",
+      botToken,
+      botId: singleWorkspace?.botId,
+      botUserId: singleWorkspace?.botUserId
+    };
+  }
+  if (provided.mode === "authorize") {
+    return provided;
+  }
+  const oauth = provided;
+  const clientId = firstNonEmptyString(
+    oauth.clientId,
+    process.env.SLACK_CLIENT_ID
+  );
+  const clientSecret = firstNonEmptyString(
+    oauth.clientSecret,
+    process.env.SLACK_CLIENT_SECRET
+  );
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "Slack OAuth mode requires `clientId` and `clientSecret` or SLACK_CLIENT_ID / SLACK_CLIENT_SECRET."
+    );
+  }
+  if (oauth.stateVerification !== false && !trimToUndefined(oauth.stateSecret) && !oauth.stateStore && !trimToUndefined(process.env.SLACK_STATE_SECRET)) {
+    throw new Error(
+      "Slack OAuth mode requires `stateSecret` or a custom `stateStore` when state verification is enabled."
+    );
+  }
+  return {
+    ...oauth,
+    mode: "oauth",
+    clientId,
+    clientSecret,
+    stateSecret: firstNonEmptyString(
+      oauth.stateSecret,
+      process.env.SLACK_STATE_SECRET
+    )
+  };
+}
+function normalizeSlackEventsPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    throw new Error("Slack events path must not be empty.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function trimToUndefined(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    const trimmed = trimToUndefined(value);
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return void 0;
+}
+
+export {
+  resolveDirectAuth,
+  normalizeSlackEventsPath,
+  trimToUndefined
+};

package/dist/{chunk-JZG4IETE.js → chunk-X4WBBBYM.js}

@@ -1,53 +1,3 @@
-// src/shared/formatting.ts
-function resolveSlackMessageFormatter(options) {
-  if (options.formatMessageText) {
-    return options.formatMessageText;
-  }
-  if (options.formatChatMarkdown === false) {
-    return identity;
-  }
-  return markdownToSlackMrkdwn;
-}
-function markdownToSlackMrkdwn(markdown) {
-  if (!markdown) {
-    return markdown;
-  }
-  const fences = [];
-  const withoutFences = markdown.replace(
-    /```[^\n`]*\n([\s\S]*?)```/g,
-    (_match, code) => {
-      const index = fences.push(`\`\`\`
-${code}\`\`\``) - 1;
-      return `@@SLACK_FENCE_${index}@@`;
-    }
-  );
-  const boldSegments = [];
-  const withBoldPlaceholders = withoutFences.split("\n").map(formatMarkdownLine).join("\n").replace(/\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g, "<$2|$1>").replace(/\*\*([^*\n]+)\*\*/g, (_match, text) => {
-    const index = boldSegments.push(`*${text}*`) - 1;
-    return `@@SLACK_BOLD_${index}@@`;
-  }).replace(/__([^_\n]+)__/g, (_match, text) => {
-    const index = boldSegments.push(`*${text}*`) - 1;
-    return `@@SLACK_BOLD_${index}@@`;
-  });
-  const converted = withBoldPlaceholders.replace(
-    /(^|[\s([{"'])\*([^*\n][^*\n]*?)\*(?=[\s.,;:!?)}\]'"]|$)/g,
-    "$1_$2_"
-  );
-  return converted.replace(/@@SLACK_BOLD_(\d+)@@/g, (_match, rawIndex) => {
-    const index = Number(rawIndex);
-    return boldSegments[index] ?? "";
-  }).replace(/@@SLACK_FENCE_(\d+)@@/g, (_match, rawIndex) => {
-    const index = Number(rawIndex);
-    return fences[index] ?? "";
-  });
-}
-function formatMarkdownLine(line) {
-  return line.replace(/^(\s*)#{1,6}\s+(.+?)\s*#*\s*$/, "$1**$2**");
-}
-function identity(text) {
-  return text;
-}
-
 // src/shared/turn-context.ts
 import { AsyncLocalStorage } from "async_hooks";
 var store = new AsyncLocalStorage();
@@ -132,8 +82,6 @@ function resolveThreadAwareSlackSessionId(info) {
 }
 
 export {
-  resolveSlackMessageFormatter,
-  markdownToSlackMrkdwn,
   currentSlackTurnContext,
   runWithSlackTurnContext,
   formatSlackAttributedFollowUp,

package/dist/core.js

@@ -1,11 +1,13 @@
 import {
   currentSlackTurnContext,
   formatSlackAttributedFollowUp,
-  markdownToSlackMrkdwn,
-  resolveSlackMessageFormatter,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-JZG4IETE.js";
+} from "./chunk-X4WBBBYM.js";
+import {
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter
+} from "./chunk-6WHFQUYQ.js";
 import {
   extractSlackActionToken,
   extractSlackAuthContext,

package/dist/diagnostics/index.d.ts

@@ -0,0 +1,71 @@
+import { g as SlackIdentityExpectations, b as SlackAuthTestIdentity } from '../inspect-BpY5JA0K.js';
+export { I as InspectSlackConnectionOptions, a as InspectSlackTokenScopesOptions, S as SlackApiInspectionError, c as SlackConnectionInspection, d as SlackConnectionInspectionFinding, e as SlackConnectionInspectionFindingSeverity, f as SlackDiagnosticsClient, h as SlackIdentityMismatch, i as SlackScopeInspection, j as SlackScopeInspectionMethod, k as SlackScopeInspectionMethodError, l as SlackTokenSource, m as compareSlackIdentity, n as formatSlackIdentityMismatches, o as inspectSlackConnection, p as inspectSlackTokenScopes, q as normalizeSlackAuthTestIdentity } from '../inspect-BpY5JA0K.js';
+import { d as SlackSocketModeRuntimePolicy } from '../runtime-BNBHOZSQ.js';
+import '@slack/bolt';
+import '../logging-Bl3HfcC8.js';
+
+interface SlackPayloadDebugSummary {
+    rawArgs: unknown;
+    rawArgsActionTokenPaths: string[];
+    rawArgsKeyPaths: string[];
+    rawArgsTokenLikePaths: string[];
+    slackActivity: unknown;
+    threadContext: unknown;
+}
+declare function summarizeSlackPayloadDebug({ rawArgs, slackActivity, threadContext, }: {
+    rawArgs?: unknown;
+    slackActivity: unknown;
+    threadContext: unknown;
+}): SlackPayloadDebugSummary;
+declare function selectSlackRawArgsForDebug(rawArgs: unknown): unknown;
+declare function selectSlackBodyForDebug(body: unknown): unknown;
+declare function redactSlackDebugValue(value: unknown, depth?: number): unknown;
+declare function collectJsonKeyPaths(value: unknown): string[];
+declare function findJsonKeyPaths(value: unknown, predicate: (key: string) => boolean): string[];
+
+type SlackStartupReadinessTransport = "http" | "socket";
+interface SlackStartupReadinessConfig extends SlackIdentityExpectations {
+    authMode: "single-workspace" | string;
+    botToken?: string;
+    enabled: boolean;
+    socketModeRuntimePolicy?: SlackSocketModeRuntimePolicy;
+    transport: SlackStartupReadinessTransport;
+}
+interface SlackStartupReadinessOptions {
+    clientFactory?: (botToken: string) => SlackStartupAuthTestClient;
+    config: SlackStartupReadinessConfig;
+    logger?: SlackStartupReadinessLogger;
+}
+interface SlackStartupReadinessResult {
+    authMode: string;
+    identity?: SlackAuthTestIdentity;
+    identityCheck: "disabled" | "passed" | "skipped";
+    socketModeRuntimePolicy?: SlackSocketModeRuntimePolicy;
+    transport: SlackStartupReadinessTransport;
+}
+interface SlackStartupAuthTestClient {
+    auth: {
+        test(): Promise<SlackStartupAuthTestResponse>;
+    };
+}
+interface SlackStartupAuthTestResponse {
+    bot_id?: string;
+    error?: string;
+    ok?: boolean;
+    team?: string;
+    team_id?: string;
+    url?: string;
+    user_id?: string;
+}
+interface SlackStartupReadinessLogger {
+    debug?(message: string, attributes?: Record<string, unknown>): void;
+    info?(message: string, attributes?: Record<string, unknown>): void;
+    warn?(message: string, attributes?: Record<string, unknown>): void;
+}
+declare class SlackStartupReadinessError extends Error {
+    readonly issues: readonly string[];
+    constructor(issues: readonly string[]);
+}
+declare function runSlackStartupReadiness({ clientFactory, config, logger, }: SlackStartupReadinessOptions): Promise<SlackStartupReadinessResult>;
+
+export { SlackAuthTestIdentity, SlackIdentityExpectations, type SlackPayloadDebugSummary, type SlackStartupAuthTestClient, type SlackStartupAuthTestResponse, type SlackStartupReadinessConfig, SlackStartupReadinessError, type SlackStartupReadinessLogger, type SlackStartupReadinessOptions, type SlackStartupReadinessResult, type SlackStartupReadinessTransport, collectJsonKeyPaths, findJsonKeyPaths, redactSlackDebugValue, runSlackStartupReadiness, selectSlackBodyForDebug, selectSlackRawArgsForDebug, summarizeSlackPayloadDebug };

package/dist/{diagnostics.js → diagnostics/index.js}

@@ -1,4 +1,5 @@
 import {
+  SlackStartupReadinessError,
   collectJsonKeyPaths,
   compareSlackIdentity,
   findJsonKeyPaths,
@@ -7,11 +8,13 @@ import {
   inspectSlackTokenScopes,
   normalizeSlackAuthTestIdentity,
   redactSlackDebugValue,
+  runSlackStartupReadiness,
   selectSlackBodyForDebug,
   selectSlackRawArgsForDebug,
   summarizeSlackPayloadDebug
-} from "./chunk-IDVDMJ5U.js";
+} from "../chunk-6JSGIVQH.js";
 export {
+  SlackStartupReadinessError,
   collectJsonKeyPaths,
   compareSlackIdentity,
   findJsonKeyPaths,
@@ -20,6 +23,7 @@ export {
   inspectSlackTokenScopes,
   normalizeSlackAuthTestIdentity,
   redactSlackDebugValue,
+  runSlackStartupReadiness,
   selectSlackBodyForDebug,
   selectSlackRawArgsForDebug,
   summarizeSlackPayloadDebug

package/dist/entrypoints/index.d.ts

@@ -0,0 +1,120 @@
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
+
+interface RawSlackSlashCommandPayload {
+    command?: string;
+    text?: string;
+    response_url?: string;
+    trigger_id?: string;
+    user_id?: string;
+    user_name?: string;
+    team_id?: string;
+    team_domain?: string;
+    channel_id?: string;
+    channel_name?: string;
+    api_app_id?: string;
+    enterprise_id?: string;
+    enterprise_name?: string;
+    is_enterprise_install?: string | boolean;
+    [key: string]: unknown;
+}
+interface SlackSlashCommandEntrypoint {
+    kind: "slash-command";
+    command: string;
+    activity: SlackActivityInfo;
+    triggerId?: string;
+    responseUrl?: string;
+    userName?: string;
+    channelName?: string;
+    teamDomain?: string;
+    appId?: string;
+    enterpriseId?: string;
+    enterpriseName?: string;
+    isEnterpriseInstall?: boolean;
+}
+declare function parseSlackSlashCommandEntrypoint(payload: RawSlackSlashCommandPayload): SlackSlashCommandEntrypoint;
+
+interface RawSlackShortcutUser {
+    id?: string;
+    name?: string;
+    username?: string;
+    team_id?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutTeam {
+    id?: string;
+    domain?: string;
+    enterprise_id?: string;
+    enterprise_name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutEnterprise {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutChannel {
+    id?: string;
+    name?: string;
+    [key: string]: unknown;
+}
+interface RawSlackShortcutMessage {
+    type?: string;
+    user?: string;
+    channel?: string;
+    ts?: string;
+    thread_ts?: string;
+    text?: string;
+    blocks?: unknown[];
+    attachments?: unknown[];
+    [key: string]: unknown;
+}
+interface RawSlackShortcutPayload {
+    type?: "shortcut" | "message_action" | string;
+    callback_id?: string;
+    trigger_id?: string;
+    response_url?: string;
+    action_ts?: string;
+    message_ts?: string;
+    user?: RawSlackShortcutUser;
+    team?: RawSlackShortcutTeam | null;
+    enterprise?: RawSlackShortcutEnterprise;
+    channel?: RawSlackShortcutChannel;
+    message?: RawSlackShortcutMessage;
+    is_enterprise_install?: boolean;
+    [key: string]: unknown;
+}
+interface SlackShortcutEntrypointBase {
+    callbackId: string;
+    triggerId?: string;
+    actionTs?: string;
+    userId: string;
+    userName?: string;
+    teamId?: string;
+    teamDomain?: string;
+    enterpriseId?: string;
+    enterpriseName?: string;
+    isEnterpriseInstall?: boolean;
+}
+interface SlackGlobalShortcutEntrypoint extends SlackShortcutEntrypointBase {
+    kind: "global-shortcut";
+}
+interface SlackMessageShortcutSelection {
+    channelId: string;
+    channelName?: string;
+    messageTs?: string;
+    threadTs?: string;
+    userId?: string;
+    text: string;
+}
+interface SlackMessageShortcutEntrypoint extends SlackShortcutEntrypointBase {
+    kind: "message-shortcut";
+    activity: SlackActivityInfo;
+    responseUrl?: string;
+    selectedMessage: SlackMessageShortcutSelection;
+}
+type SlackShortcutEntrypoint = SlackGlobalShortcutEntrypoint | SlackMessageShortcutEntrypoint;
+declare function parseSlackShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackShortcutEntrypoint;
+declare function parseSlackGlobalShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackGlobalShortcutEntrypoint;
+declare function parseSlackMessageShortcutEntrypoint(payload: RawSlackShortcutPayload): SlackMessageShortcutEntrypoint;
+
+export { type RawSlackShortcutChannel, type RawSlackShortcutEnterprise, type RawSlackShortcutMessage, type RawSlackShortcutPayload, type RawSlackShortcutTeam, type RawSlackShortcutUser, type RawSlackSlashCommandPayload, type SlackGlobalShortcutEntrypoint, type SlackMessageShortcutEntrypoint, type SlackMessageShortcutSelection, type SlackShortcutEntrypoint, type SlackShortcutEntrypointBase, type SlackSlashCommandEntrypoint, parseSlackGlobalShortcutEntrypoint, parseSlackMessageShortcutEntrypoint, parseSlackShortcutEntrypoint, parseSlackSlashCommandEntrypoint };

package/dist/entrypoints/index.js

@@ -0,0 +1,132 @@
+import {
+  extractSlackMessageText,
+  resolveSlackChannelType
+} from "../chunk-FPCE5V5Y.js";
+
+// src/entrypoints/commands.ts
+function parseSlackSlashCommandEntrypoint(payload) {
+  const channelId = readString(payload.channel_id) ?? "unknown";
+  const teamId = readString(payload.team_id);
+  const text = readString(payload.text) ?? "";
+  const triggerId = readString(payload.trigger_id);
+  const responseUrl = readString(payload.response_url);
+  const userName = readString(payload.user_name);
+  const channelName = readString(payload.channel_name);
+  const teamDomain = readString(payload.team_domain);
+  const appId = readString(payload.api_app_id);
+  const enterpriseId = readString(payload.enterprise_id);
+  const enterpriseName = readString(payload.enterprise_name);
+  const activity = {
+    channelId,
+    channelType: resolveSlackChannelType(channelId, void 0, false),
+    userId: readString(payload.user_id) ?? "unknown",
+    ...teamId ? { teamId } : {},
+    text,
+    isMention: false
+  };
+  return {
+    kind: "slash-command",
+    command: readString(payload.command) ?? "unknown",
+    activity,
+    ...triggerId ? { triggerId } : {},
+    ...responseUrl ? { responseUrl } : {},
+    ...userName ? { userName } : {},
+    ...channelName ? { channelName } : {},
+    ...teamDomain ? { teamDomain } : {},
+    ...appId ? { appId } : {},
+    ...enterpriseId ? { enterpriseId } : {},
+    ...enterpriseName ? { enterpriseName } : {},
+    ...payload.is_enterprise_install !== void 0 ? {
+      isEnterpriseInstall: payload.is_enterprise_install === true || payload.is_enterprise_install === "true"
+    } : {}
+  };
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+
+// src/entrypoints/shortcuts.ts
+function parseSlackShortcutEntrypoint(payload) {
+  return payload.type === "message_action" || payload.message ? parseSlackMessageShortcutEntrypoint(payload) : parseSlackGlobalShortcutEntrypoint(payload);
+}
+function parseSlackGlobalShortcutEntrypoint(payload) {
+  return {
+    kind: "global-shortcut",
+    ...parseShortcutBase(payload)
+  };
+}
+function parseSlackMessageShortcutEntrypoint(payload) {
+  const base = parseShortcutBase(payload);
+  const message = readRecord(payload.message) ?? {};
+  const channel = readRecord(payload.channel);
+  const channelId = readString2(channel?.id) ?? readString2(message.channel) ?? "unknown";
+  const messageTs = readString2(payload.message_ts) ?? readString2(message.ts) ?? void 0;
+  const threadTs = readString2(message.thread_ts);
+  const isThread = Boolean(threadTs && threadTs !== messageTs);
+  const responseUrl = readString2(payload.response_url);
+  const channelName = readString2(channel?.name);
+  const selectedMessageUserId = readString2(message.user);
+  const text = extractSlackMessageText(message, {
+    stripLeadingMentions: channelId.startsWith("D") ? false : true
+  });
+  const activity = {
+    channelId,
+    channelType: resolveSlackChannelType(channelId, threadTs, isThread),
+    userId: base.userId,
+    ...base.teamId ? { teamId: base.teamId } : {},
+    ...isThread ? { threadTs } : {},
+    ...messageTs ? { messageTs } : {},
+    text,
+    isMention: false
+  };
+  return {
+    kind: "message-shortcut",
+    ...base,
+    activity,
+    ...responseUrl ? { responseUrl } : {},
+    selectedMessage: {
+      channelId,
+      ...channelName ? { channelName } : {},
+      ...messageTs ? { messageTs } : {},
+      ...threadTs ? { threadTs } : {},
+      ...selectedMessageUserId ? { userId: selectedMessageUserId } : {},
+      text
+    }
+  };
+}
+function parseShortcutBase(payload) {
+  const user = readRecord(payload.user);
+  const team = readRecord(payload.team);
+  const enterprise = readRecord(payload.enterprise);
+  const teamId = readString2(team?.id) ?? readString2(user?.team_id);
+  const enterpriseId = readString2(enterprise?.id) ?? readString2(team?.enterprise_id);
+  const enterpriseName = readString2(enterprise?.name) ?? readString2(team?.enterprise_name);
+  const triggerId = readString2(payload.trigger_id);
+  const actionTs = readString2(payload.action_ts);
+  const userName = readString2(user?.name) ?? readString2(user?.username);
+  const teamDomain = readString2(team?.domain);
+  return {
+    callbackId: readString2(payload.callback_id) ?? "unknown",
+    userId: readString2(user?.id) ?? "unknown",
+    ...triggerId ? { triggerId } : {},
+    ...actionTs ? { actionTs } : {},
+    ...userName ? { userName } : {},
+    ...teamId ? { teamId } : {},
+    ...teamDomain ? { teamDomain } : {},
+    ...enterpriseId ? { enterpriseId } : {},
+    ...enterpriseName ? { enterpriseName } : {},
+    ...payload.is_enterprise_install !== void 0 ? { isEnterpriseInstall: payload.is_enterprise_install } : {}
+  };
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+export {
+  parseSlackGlobalShortcutEntrypoint,
+  parseSlackMessageShortcutEntrypoint,
+  parseSlackShortcutEntrypoint,
+  parseSlackSlashCommandEntrypoint
+};

package/dist/{feedback.js → feedback/index.js}

@@ -1,3 +1,7 @@
+import {
+  openSlackModal
+} from "../chunk-IRFKUPJN.js";
+
 // src/feedback/block.ts
 var SLACK_FEEDBACK_ACTION_ID = "agent_feedback";
 function createSlackFeedbackBlock(options = {}) {
@@ -76,13 +80,7 @@ function registerSlackFeedbackAction(app, options) {
               "Slack feedback payload did not include trigger_id."
             );
           }
-          if (typeof client.views?.open !== "function") {
-            throw new Error("Slack client does not expose views.open.");
-          }
-          await client.views.open({
-            trigger_id: triggerId,
-            view
-          });
+          await openSlackModal({ client, triggerId, view });
         };
         const acknowledgeEphemeral = async (text) => {
           await client.chat.postEphemeral({

package/dist/{history.d.ts → history/index.d.ts}

@@ -1,6 +1,6 @@
-import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
 import { ConversationsHistoryResponse, ConversationsRepliesResponse, WebClient } from '@slack/web-api';
-import { L as Logger } from './logging-Bl3HfcC8.js';
+import { L as Logger } from '../logging-Bl3HfcC8.js';
 
 type SlackContextFragmentRole = "system" | "user";
 type SlackContextFragmentPlacement = "before-history" | "after-latest-user" | "after-history";

package/dist/{history.js → history/index.js}

@@ -1,6 +1,6 @@
 import {
   extractSlackMessageText
-} from "./chunk-FPCE5V5Y.js";
+} from "../chunk-FPCE5V5Y.js";
 
 // src/history/context/assistant-root.ts
 function normalizeAssistantSurfaceThreadRootMessages(messages, options) {

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { S as SlackActivityInfo, a as SlackChannelType, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
 export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackApprovalRequest, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackEventInteractiveRequestHandler, SlackHumanInputRequest, SlackInteractiveMessage, SlackInteractiveMessageRef, SlackInteractiveRequest, SlackInteractiveRequestBaseContext, SlackInteractiveRequestContext, SlackInteractiveRequestHandler, SlackInteractiveRequestKind, SlackInteractiveResponder, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
-export { PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackSyncMessagePolicyStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages } from './policy.js';
+export { InMemorySlackThreadParticipationStateStoreOptions, PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, PostgresSlackThreadParticipationStateStore, PostgresSlackThreadParticipationStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackQuietThreadRejectedDecision, SlackSyncMessagePolicyStateStore, SlackThreadAwareMessagePolicyConfig, SlackThreadAwareMessagePolicyDecision, SlackThreadAwareMessagePolicyResolver, SlackThreadParticipationEligibility, SlackThreadParticipationEligibilityOptions, SlackThreadParticipationMode, SlackThreadParticipationPostgresClient, SlackThreadParticipationPruneResult, SlackThreadParticipationReactivation, SlackThreadParticipationState, SlackThreadParticipationStateContext, SlackThreadParticipationStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages } from './policy/index.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';