@cuylabs/channel-slack 0.5.1 → 0.7.0

package/dist/index.js

@@ -1,12 +1,30 @@
-import "./chunk-NE57BLLU.js";
+import {
+  createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
+  createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
+  createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
+  createSlackMessagePolicyMessageKey,
+  createSlackMessagePolicyResolver,
+  createSlackMessagePolicyThreadKey,
+  initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
+  prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
+  shouldRegisterSlackPassiveChannelMessages
+} from "./chunk-DNVSH7H5.js";
 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,
@@ -22,21 +40,13 @@ import {
   resolveSlackChannelType,
   stripLeadingMentions
 } from "./chunk-FPCE5V5Y.js";
-import {
-  createAsyncSlackMessagePolicyResolver,
-  createInMemorySlackMessagePolicyStateStore,
-  createPostgresSlackMessagePolicyStateStore,
-  createSlackMessagePolicyMessageKey,
-  createSlackMessagePolicyResolver,
-  createSlackMessagePolicyThreadKey,
-  initializePostgresSlackMessagePolicyState,
-  prunePostgresSlackMessagePolicyState,
-  shouldRegisterSlackPassiveChannelMessages
-} from "./chunk-CMR6B76C.js";
 export {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
@@ -49,13 +59,16 @@ export {
   extractSlackUserIdentity,
   formatSlackAttributedFollowUp,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   isProcessableMessage,
   markdownToSlackMrkdwn,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
+  resolveSlackThreadParticipationEligibility,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext,
   shouldRegisterSlackPassiveChannelMessages,

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

@@ -1,4 +1,4 @@
-import { S as SlackActivityInfo } from './activity-ByrD9Ftr.js';
+import { S as SlackActivityInfo } from '../activity-ByrD9Ftr.js';
 
 type MaybePromise<T> = T | Promise<T>;
 type SlackChannelMessagePolicy = "disabled" | "mentioned-threads" | "allowed-channels" | "any-added-channel";
@@ -173,4 +173,105 @@ declare function createInMemorySlackMessagePolicyStateStore({ maxAcceptedMessage
     maxMentionedThreads?: number;
 }): SlackSyncMessagePolicyStateStore;
 
-export { type PostgresSlackMessagePolicyPruneResult, type PostgresSlackMessagePolicyStateStore, type PostgresSlackMessagePolicyStateStoreOptions, type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyPostgresClient, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackSyncMessagePolicyStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages };
+type SlackThreadParticipationMode = "quiet" | "active";
+interface SlackThreadParticipationState {
+    mode: "quiet";
+    reason?: string;
+    sourceMessageTs?: string;
+    updatedAt?: string;
+    updatedByUserId?: string;
+}
+interface SlackThreadParticipationStateContext {
+    activity: SlackActivityInfo;
+    key: string;
+}
+interface SlackThreadParticipationPruneResult {
+    quietThreadsDeleted: number;
+}
+interface SlackThreadParticipationStateStore {
+    get(key: string, context: SlackThreadParticipationStateContext): Promise<SlackThreadParticipationState | undefined>;
+    setQuiet(key: string, state: Omit<SlackThreadParticipationState, "mode" | "updatedAt">, context: SlackThreadParticipationStateContext): Promise<void>;
+    clear(key: string, context: SlackThreadParticipationStateContext): Promise<void>;
+    close?(): Promise<void>;
+    prune?(): Promise<SlackThreadParticipationPruneResult>;
+}
+interface SlackThreadParticipationEligibility {
+    available: boolean;
+    reason?: string;
+    threadKey?: string;
+    threadTs?: string;
+}
+interface SlackThreadParticipationEligibilityOptions {
+    activity: SlackActivityInfo;
+    policy: Pick<SlackMessagePolicyConfig, "messagePolicy" | "threadReplyPolicy">;
+    stateStore?: SlackThreadParticipationStateStore;
+}
+interface InMemorySlackThreadParticipationStateStoreOptions {
+    maxThreads?: number;
+    now?: () => Date;
+}
+interface SlackThreadParticipationPostgresClient {
+    end?: () => Promise<void>;
+    query<T = unknown>(sql: string, values?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount?: number | null;
+    }>;
+}
+interface PostgresSlackThreadParticipationStateStoreOptions {
+    client?: SlackThreadParticipationPostgresClient;
+    connectionString?: string;
+    ensureSchema?: boolean;
+    onPruneError?: (error: unknown) => void;
+    pruneBatchSize?: number;
+    pruneIntervalMs?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}
+interface PostgresSlackThreadParticipationStateStore extends SlackThreadParticipationStateStore {
+    close(): Promise<void>;
+    prune(): Promise<SlackThreadParticipationPruneResult>;
+}
+declare function resolveSlackThreadParticipationEligibility({ activity, policy, stateStore, }: SlackThreadParticipationEligibilityOptions): SlackThreadParticipationEligibility;
+declare function createInMemorySlackThreadParticipationStateStore({ maxThreads, now, }?: InMemorySlackThreadParticipationStateStoreOptions): SlackThreadParticipationStateStore;
+declare function createPostgresSlackThreadParticipationStateStore({ client, connectionString, ensureSchema, onPruneError, pruneBatchSize, pruneIntervalMs, retentionMs, schema, tableName, }: PostgresSlackThreadParticipationStateStoreOptions): PostgresSlackThreadParticipationStateStore;
+declare function initializePostgresSlackThreadParticipationState({ client, ensureSchema, schema, tableName, }: {
+    client: SlackThreadParticipationPostgresClient;
+    ensureSchema?: boolean;
+    schema?: string;
+    tableName?: string;
+}): Promise<void>;
+declare function prunePostgresSlackThreadParticipationState({ client, pruneBatchSize, retentionMs, schema, tableName, }: {
+    client: SlackThreadParticipationPostgresClient;
+    pruneBatchSize?: number;
+    retentionMs?: number;
+    schema?: string;
+    tableName?: string;
+}): Promise<SlackThreadParticipationPruneResult>;
+
+interface SlackThreadParticipationReactivation {
+    reason?: string;
+    threadKey: string;
+    threadTs?: string;
+}
+interface SlackQuietThreadRejectedDecision {
+    accepted: false;
+    activity: SlackActivityInfo;
+    reason: "quiet-thread";
+    threadKey: string;
+    threadParticipationReason?: string;
+    threadTs?: string;
+}
+type SlackThreadAwareMessagePolicyDecision = (SlackMessagePolicyDecision & {
+    reactivatedThreadParticipation?: SlackThreadParticipationReactivation;
+}) | SlackQuietThreadRejectedDecision;
+interface SlackThreadAwareMessagePolicyResolver {
+    resolve(activity: SlackActivityInfo): Promise<SlackThreadAwareMessagePolicyDecision>;
+    resolveMessage(activity: SlackActivityInfo): Promise<string | undefined>;
+}
+interface SlackThreadAwareMessagePolicyConfig extends SlackAsyncMessagePolicyConfig {
+    threadParticipationStore?: SlackThreadParticipationStateStore;
+}
+declare function createAsyncSlackThreadAwareMessagePolicyResolver(config?: SlackThreadAwareMessagePolicyConfig): SlackThreadAwareMessagePolicyResolver;
+
+export { type InMemorySlackThreadParticipationStateStoreOptions, type PostgresSlackMessagePolicyPruneResult, type PostgresSlackMessagePolicyStateStore, type PostgresSlackMessagePolicyStateStoreOptions, type PostgresSlackThreadParticipationStateStore, type PostgresSlackThreadParticipationStateStoreOptions, type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyPostgresClient, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackQuietThreadRejectedDecision, type SlackSyncMessagePolicyStateStore, type SlackThreadAwareMessagePolicyConfig, type SlackThreadAwareMessagePolicyDecision, type SlackThreadAwareMessagePolicyResolver, type SlackThreadParticipationEligibility, type SlackThreadParticipationEligibilityOptions, type SlackThreadParticipationMode, type SlackThreadParticipationPostgresClient, type SlackThreadParticipationPruneResult, type SlackThreadParticipationReactivation, type SlackThreadParticipationState, type SlackThreadParticipationStateContext, type SlackThreadParticipationStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createAsyncSlackThreadAwareMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createInMemorySlackThreadParticipationStateStore, createPostgresSlackMessagePolicyStateStore, createPostgresSlackThreadParticipationStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, initializePostgresSlackThreadParticipationState, prunePostgresSlackMessagePolicyState, prunePostgresSlackThreadParticipationState, resolveSlackThreadParticipationEligibility, shouldRegisterSlackPassiveChannelMessages };

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

@@ -1,22 +1,34 @@
 import {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
   shouldRegisterSlackPassiveChannelMessages
-} from "./chunk-CMR6B76C.js";
+} from "../chunk-DNVSH7H5.js";
 export {
   createAsyncSlackMessagePolicyResolver,
+  createAsyncSlackThreadAwareMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createInMemorySlackThreadParticipationStateStore,
   createPostgresSlackMessagePolicyStateStore,
+  createPostgresSlackThreadParticipationStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
   initializePostgresSlackMessagePolicyState,
+  initializePostgresSlackThreadParticipationState,
   prunePostgresSlackMessagePolicyState,
+  prunePostgresSlackThreadParticipationState,
+  resolveSlackThreadParticipationEligibility,
   shouldRegisterSlackPassiveChannelMessages
 };

package/dist/runtime-BNBHOZSQ.d.ts

@@ -0,0 +1,53 @@
+import { Logger } from '@slack/bolt';
+import { L as Logger$1 } from './logging-Bl3HfcC8.js';
+
+type SlackSocketModeRuntimePolicy = "single-instance" | "external-coordination";
+interface SlackSocketModeReceiverRuntimeOptions {
+    autoReconnectEnabled?: boolean;
+    clientPingTimeout?: number;
+    pingPongLoggingEnabled?: boolean;
+    serverPingTimeout?: number;
+}
+interface SlackSocketModeRuntimeOptions {
+    appSlug: string;
+    appToken?: string;
+    autoReconnectEnabled?: boolean;
+    clientPingTimeoutMs?: number;
+    exitProcess?: (code: number) => never | void;
+    lockDir?: string;
+    lockEnabled?: boolean;
+    logger?: Logger$1;
+    logLevel?: "debug" | "info" | "warn" | "error";
+    pingPongLoggingEnabled?: boolean;
+    restartGuardEnabled?: boolean;
+    restartGuardMaxWarnings?: number;
+    restartGuardWindowMs?: number;
+    runtimePolicy?: SlackSocketModeRuntimePolicy;
+    serverPingTimeoutMs?: number;
+}
+interface SlackSocketModeRuntime {
+    boltAppOptions: {
+        logger: Logger;
+    };
+    close(): void;
+    socketModeReceiverOptions: SlackSocketModeReceiverRuntimeOptions;
+}
+interface SlackSocketModeRestartGuard {
+    record(message: string): void;
+}
+declare function createSlackSocketModeRuntime({ appSlug, appToken, autoReconnectEnabled, clientPingTimeoutMs, exitProcess, lockDir, lockEnabled, logger, logLevel, pingPongLoggingEnabled, restartGuardEnabled, restartGuardMaxWarnings, restartGuardWindowMs, runtimePolicy, serverPingTimeoutMs, }: SlackSocketModeRuntimeOptions): SlackSocketModeRuntime;
+declare function createSlackSocketModeRestartGuard({ enabled, exitProcess, logger, maxWarnings, windowMs, }: {
+    enabled: boolean;
+    exitProcess: (code: number) => never | void;
+    logger?: Logger$1;
+    maxWarnings: number;
+    windowMs: number;
+}): SlackSocketModeRestartGuard;
+declare function createSlackSdkLogger({ level, logger, restartGuard, }: {
+    level: "debug" | "info" | "warn" | "error";
+    logger?: Logger$1;
+    restartGuard?: SlackSocketModeRestartGuard;
+}): Logger;
+declare function redactSlackSocketModeLogValue(value: unknown, depth?: number): unknown;
+
+export { type SlackSocketModeReceiverRuntimeOptions as S, type SlackSocketModeRestartGuard as a, type SlackSocketModeRuntime as b, type SlackSocketModeRuntimeOptions as c, type SlackSocketModeRuntimePolicy as d, createSlackSdkLogger as e, createSlackSocketModeRestartGuard as f, createSlackSocketModeRuntime as g, redactSlackSocketModeLogValue as r };

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

@@ -1,6 +1,6 @@
-import { I as InspectSlackConnectionOptions, f as SlackDiagnosticsClient, c as SlackConnectionInspection } from './inspect-BpY5JA0K.js';
+import { I as InspectSlackConnectionOptions, f as SlackDiagnosticsClient, c as SlackConnectionInspection } from '../inspect-BpY5JA0K.js';
 
-type SlackSetupFeature = "assistant" | "app-mentions" | "direct-messages" | "channel-messages" | "history" | "interactivity" | "feedback" | "user-profiles" | "user-emails";
+type SlackSetupFeature = "assistant" | "app-mentions" | "direct-messages" | "channel-messages" | "slash-commands" | "shortcuts" | "artifacts" | "canvas-artifacts" | "history" | "interactivity" | "views" | "feedback" | "user-profiles" | "user-emails" | "workspace-search";
 type SlackSetupFeaturePreset = "assistant" | "channel-adapter" | "agent-app";
 type SlackSetupTransport = "http" | "socket";
 interface SlackSetupEnvironmentVariable {
@@ -11,6 +11,8 @@ interface SlackSetupSettingsRequirements {
     assistantView: boolean;
     eventSubscriptions: boolean;
     interactivity: boolean;
+    slashCommands: boolean;
+    shortcuts: boolean;
     socketMode: boolean;
 }
 interface SlackSetupRequirements {
@@ -43,6 +45,16 @@ interface GetSlackSetupRequirementsOptions {
      * is used as-is.
      */
     features?: readonly SlackSetupFeature[];
+    /**
+     * Slash commands exposed by the host app. Supplying at least one command
+     * automatically enables the `slash-commands` feature.
+     */
+    slashCommands?: readonly SlackManifestSlashCommand[];
+    /**
+     * Global or message shortcuts exposed by the host app. Supplying at least one
+     * shortcut automatically enables the `shortcuts` feature.
+     */
+    shortcuts?: readonly SlackManifestShortcut[];
     /**
      * Inbound transport used by the direct Slack app.
      *
@@ -76,6 +88,19 @@ interface SlackManifestSuggestedPrompt {
     title: string;
     message: string;
 }
+interface SlackManifestShortcut {
+    type: "global" | "message";
+    name: string;
+    callback_id: string;
+    description: string;
+}
+interface SlackManifestSlashCommand {
+    command: string;
+    description: string;
+    should_escape?: boolean;
+    url?: string;
+    usage_hint?: string;
+}
 interface SlackAppManifest {
     display_information: {
         name: string;
@@ -92,6 +117,8 @@ interface SlackAppManifest {
             assistant_description?: string;
             suggested_prompts?: SlackManifestSuggestedPrompt[];
         };
+        shortcuts?: SlackManifestShortcut[];
+        slash_commands?: SlackManifestSlashCommand[];
     };
     oauth_config: {
         scopes: {
@@ -162,4 +189,4 @@ interface SlackAppSetupInspection {
 }
 declare function inspectSlackAppSetup(options?: InspectSlackAppSetupOptions): Promise<SlackAppSetupInspection>;
 
-export { type CreateSlackAppManifestOptions, type GetSlackSetupRequirementsOptions, type InspectSlackAppSetupOptions, type SlackAppManifest, type SlackAppManifestComparison, type SlackAppManifestComparisonFinding, type SlackAppManifestComparisonFindingSeverity, type SlackAppSetupInspection, SlackDiagnosticsClient, type SlackManifestAppHome, type SlackManifestSuggestedPrompt, type SlackSetupEnvironmentVariable, type SlackSetupFeature, type SlackSetupFeaturePreset, type SlackSetupRequirements, type SlackSetupSettingsRequirements, type SlackSetupTransport, compareSlackAppManifest, createSlackAppManifest, getSlackSetupRequirements, inspectSlackAppSetup, slackSetupFeaturePresets };
+export { type CreateSlackAppManifestOptions, type GetSlackSetupRequirementsOptions, type InspectSlackAppSetupOptions, type SlackAppManifest, type SlackAppManifestComparison, type SlackAppManifestComparisonFinding, type SlackAppManifestComparisonFindingSeverity, type SlackAppSetupInspection, SlackDiagnosticsClient, type SlackManifestAppHome, type SlackManifestShortcut, type SlackManifestSlashCommand, type SlackManifestSuggestedPrompt, type SlackSetupEnvironmentVariable, type SlackSetupFeature, type SlackSetupFeaturePreset, type SlackSetupRequirements, type SlackSetupSettingsRequirements, type SlackSetupTransport, compareSlackAppManifest, createSlackAppManifest, getSlackSetupRequirements, inspectSlackAppSetup, slackSetupFeaturePresets };

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

@@ -1,6 +1,6 @@
 import {
   inspectSlackConnection
-} from "./chunk-IDVDMJ5U.js";
+} from "../chunk-6JSGIVQH.js";
 
 // src/setup/requirements.ts
 var DEFAULT_EVENTS_PATH = "/slack/events";
@@ -27,6 +27,20 @@ var FEATURE_REQUIREMENTS = {
     botScopes: ["channels:history", "chat:write", "groups:history"],
     botEvents: ["message.channels", "message.groups"]
   },
+  "slash-commands": {
+    botScopes: ["commands"],
+    interactivity: true
+  },
+  shortcuts: {
+    botScopes: ["commands"],
+    interactivity: true
+  },
+  artifacts: {
+    botScopes: ["chat:write", "files:write"]
+  },
+  "canvas-artifacts": {
+    botScopes: ["canvases:write"]
+  },
   history: {
     botScopes: [
       "channels:history",
@@ -39,6 +53,9 @@ var FEATURE_REQUIREMENTS = {
     botScopes: ["chat:write"],
     interactivity: true
   },
+  views: {
+    interactivity: true
+  },
   feedback: {
     botScopes: ["chat:write"],
     interactivity: true
@@ -49,6 +66,9 @@ var FEATURE_REQUIREMENTS = {
   },
   "user-emails": {
     botScopes: ["users:read", "users:read.email"]
+  },
+  "workspace-search": {
+    botScopes: ["search:read.files", "search:read.public", "search:read.users"]
   }
 };
 function getSlackSetupRequirements(options = {}) {
@@ -63,6 +83,8 @@ function getSlackSetupRequirements(options = {}) {
   const botEvents = [];
   let assistantView = false;
   let interactivity = false;
+  let slashCommands = false;
+  let shortcuts = false;
   for (const feature of features) {
     const requirement = FEATURE_REQUIREMENTS[feature];
     if (!requirement) {
@@ -73,6 +95,8 @@ function getSlackSetupRequirements(options = {}) {
     collect(requirement.botEvents, botEvents);
     assistantView ||= requirement.assistantView === true;
     interactivity ||= requirement.interactivity === true;
+    slashCommands ||= feature === "slash-commands";
+    shortcuts ||= feature === "shortcuts";
   }
   collect(options.extraBotScopes, botScopes);
   collect(options.extraOptionalBotScopes, optionalBotScopes);
@@ -91,6 +115,8 @@ function getSlackSetupRequirements(options = {}) {
     assistantView,
     eventSubscriptions: normalizedBotEvents.length > 0,
     interactivity,
+    slashCommands,
+    shortcuts,
     socketMode: transport === "socket"
   };
   const environment = resolveEnvironment({
@@ -112,9 +138,13 @@ function getSlackSetupRequirements(options = {}) {
   };
 }
 function resolveSetupFeatures(options) {
+  const inferredFeatures = [
+    ...options.slashCommands && options.slashCommands.length > 0 ? ["slash-commands"] : [],
+    ...options.shortcuts && options.shortcuts.length > 0 ? ["shortcuts"] : []
+  ];
   const preset = options.preset ?? "agent-app";
   if (preset === false) {
-    return uniqueFeatures(options.features ?? []);
+    return uniqueFeatures([...options.features ?? [], ...inferredFeatures]);
   }
   const presetFeatures = slackSetupFeaturePresets[preset];
   if (!presetFeatures) {
@@ -122,7 +152,8 @@ function resolveSetupFeatures(options) {
   }
   return uniqueFeatures([
     ...presetFeatures ?? [],
-    ...options.features ?? []
+    ...options.features ?? [],
+    ...inferredFeatures
   ]);
 }
 function resolveEnvironment(context) {
@@ -226,6 +257,27 @@ function createSlackAppManifest(options) {
       ...options.suggestedPrompts ? { suggested_prompts: [...options.suggestedPrompts] } : {}
     };
   }
+  const slashCommands = normalizeSlashCommands(options.slashCommands ?? []);
+  if (requirements.settings.slashCommands) {
+    if (slashCommands.length === 0) {
+      throw new Error(
+        "Slack slash command definitions are required when the `slash-commands` feature is enabled."
+      );
+    }
+    features.slash_commands = slashCommands.map((command) => ({
+      ...command,
+      ...command.url || requirements.transport !== "http" ? {} : requirements.requestUrl ? { url: requirements.requestUrl } : {}
+    }));
+  }
+  const shortcuts = normalizeShortcuts(options.shortcuts ?? []);
+  if (requirements.settings.shortcuts) {
+    if (shortcuts.length === 0) {
+      throw new Error(
+        "Slack shortcut definitions are required when the `shortcuts` feature is enabled."
+      );
+    }
+    features.shortcuts = shortcuts;
+  }
   const settings = {
     socket_mode_enabled: requirements.settings.socketMode,
     token_rotation_enabled: options.tokenRotationEnabled ?? false
@@ -327,6 +379,8 @@ function compareSettings(manifest, requirements, findings) {
   const settings = readRecord(manifestRecord?.settings);
   const eventSubscriptions = readRecord(settings?.event_subscriptions);
   const interactivity = readRecord(settings?.interactivity);
+  const slashCommands = features?.slash_commands;
+  const shortcuts = features?.shortcuts;
   if (requirements.settings.assistantView && !readRecord(features?.assistant_view)) {
     findings.push({
       severity: "error",
@@ -357,6 +411,26 @@ function compareSettings(manifest, requirements, findings) {
       actual: readBoolean(interactivity?.is_enabled) ?? false
     });
   }
+  if (requirements.settings.slashCommands && !Array.isArray(slashCommands)) {
+    findings.push({
+      severity: "error",
+      code: "slash-commands-missing",
+      message: "Slack manifest must configure slash commands for selected features.",
+      path: "features.slash_commands",
+      expected: true,
+      actual: void 0
+    });
+  }
+  if (requirements.settings.shortcuts && !Array.isArray(shortcuts)) {
+    findings.push({
+      severity: "error",
+      code: "shortcuts-missing",
+      message: "Slack manifest must configure shortcuts for selected features.",
+      path: "features.shortcuts",
+      expected: true,
+      actual: void 0
+    });
+  }
   if (requirements.settings.socketMode && readBoolean(settings?.socket_mode_enabled) !== true) {
     findings.push({
       severity: "error",
@@ -387,6 +461,28 @@ function compareSettings(manifest, requirements, findings) {
       actual: readString(interactivity?.request_url)
     });
   }
+  if (requirements.requestUrl && requirements.transport === "http" && requirements.settings.slashCommands && Array.isArray(slashCommands)) {
+    const mismatched = slashCommands.map((command, index) => ({
+      index,
+      command: readRecord(command)
+    })).filter(
+      ({ command }) => readString(command?.url) !== requirements.requestUrl
+    );
+    if (mismatched.length > 0) {
+      findings.push({
+        severity: "error",
+        code: "slash-command-url-mismatch",
+        message: `Slack manifest slash command URL(s) must be ${requirements.requestUrl}.`,
+        path: "features.slash_commands",
+        expected: requirements.requestUrl,
+        actual: mismatched.map(({ index, command }) => ({
+          index,
+          command: readString(command?.command),
+          url: readString(command?.url)
+        }))
+      });
+    }
+  }
 }
 function trimString2(value) {
   const trimmed = value?.trim();
@@ -408,6 +504,44 @@ function uniqueSorted2(values) {
   }
   return [...unique.values()].sort((a, b) => a.localeCompare(b));
 }
+function normalizeSlashCommands(values) {
+  return values.map((command) => {
+    const normalized = {
+      command: requireTrimmed(command.command, "slash command"),
+      description: requireTrimmed(
+        command.description,
+        `description for ${command.command}`
+      ),
+      ...trimString2(command.usage_hint) ? { usage_hint: trimString2(command.usage_hint) } : {},
+      ...trimString2(command.url) ? { url: trimString2(command.url) } : {},
+      ...command.should_escape !== void 0 ? { should_escape: command.should_escape } : {}
+    };
+    if (!normalized.command.startsWith("/")) {
+      throw new Error(
+        `Slack slash command must start with "/": ${normalized.command}`
+      );
+    }
+    return normalized;
+  });
+}
+function normalizeShortcuts(values) {
+  return values.map((shortcut) => ({
+    type: shortcut.type,
+    name: requireTrimmed(shortcut.name, "shortcut name"),
+    callback_id: requireTrimmed(shortcut.callback_id, "shortcut callback_id"),
+    description: requireTrimmed(
+      shortcut.description,
+      `description for ${shortcut.callback_id}`
+    )
+  }));
+}
+function requireTrimmed(value, label) {
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`Slack ${label} must not be empty.`);
+  }
+  return trimmed;
+}
 function readRecord(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }

package/dist/transports/http/index.d.ts

@@ -0,0 +1,68 @@
+import { Application } from 'express';
+import { AppOptions, ExpressReceiverOptions, App, ExpressReceiver } from '@slack/bolt';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from '../../types-B9NfCVrk.js';
+import 'node:http';
+
+/**
+ * `createSlackBoltApp` — builds a Bolt `App` + `ExpressReceiver` pair from
+ * the package's structured `CreateSlackBoltAppOptions`. Supports
+ * single-workspace, OAuth, and custom-authorize auth modes.
+ */
+
+interface CreateSlackBoltAppOptions {
+    /**
+     * Slack signing secret used to verify inbound requests.
+     * Defaults to `SLACK_SIGNING_SECRET`.
+     */
+    signingSecret?: string;
+    /**
+     * Exact Slack Events API endpoint path.
+     * Defaults to `/slack/events`.
+     */
+    path?: 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;
+    /**
+     * Convenience override for single-workspace mode.
+     * Defaults to `SLACK_BOT_TOKEN`.
+     */
+    botToken?: string;
+    /**
+     * Pre-existing Express app to mount onto.
+     */
+    app?: Application;
+    processBeforeResponse?: boolean;
+    signatureVerification?: boolean;
+    /**
+     * Additional Bolt `App` options passed through after this package sets
+     * receiver/auth. Use for logger/clientOptions and other native Bolt config.
+     */
+    boltAppOptions?: Partial<Omit<AppOptions, "receiver" | "token" | "authorize" | "botId" | "botUserId">>;
+    /**
+     * Additional Bolt `ExpressReceiver` options passed through after this
+     * package sets signing/auth/endpoints. Use for router, custom properties,
+     * and receiver-level error handlers.
+     */
+    receiverOptions?: Partial<Omit<ExpressReceiverOptions, "signingSecret" | "endpoints" | "processBeforeResponse" | "signatureVerification" | "app" | "clientId" | "clientSecret" | "stateSecret" | "installationStore" | "redirectUri" | "scopes" | "installerOptions">>;
+}
+interface CreateSlackBoltAppResult {
+    /** Bolt `App` used for event registration and outbound Slack calls. */
+    boltApp: App;
+    /** Bolt `ExpressReceiver` that owns request verification and OAuth routes. */
+    receiver: ExpressReceiver;
+    /** Express app that should receive `receiver.router`. */
+    app: Application;
+    /** Resolved direct auth mode. */
+    authMode: SlackDirectAuthMode;
+    /** Exact normalized events endpoint path. */
+    routePath: string;
+}
+declare function createSlackBoltApp(options?: CreateSlackBoltAppOptions): Promise<CreateSlackBoltAppResult>;
+
+export { type CreateSlackBoltAppOptions, type CreateSlackBoltAppResult, createSlackBoltApp, createSlackBoltApp as createSlackHttpBoltApp };

package/dist/transports/http/index.js

@@ -0,0 +1,8 @@
+import {
+  createSlackBoltApp
+} from "../../chunk-QJYCHWN6.js";
+import "../../chunk-S3SWPYXJ.js";
+export {
+  createSlackBoltApp,
+  createSlackBoltApp as createSlackHttpBoltApp
+};

package/dist/transports/index.d.ts

@@ -0,0 +1,8 @@
+export { CreateSlackBoltAppOptions, CreateSlackBoltAppResult, createSlackBoltApp, createSlackBoltApp as createSlackHttpBoltApp } from './http/index.js';
+export { CreateSlackSocketBoltAppOptions, CreateSlackSocketBoltAppResult, SlackSocketModePostgresLock, SlackSocketModePostgresLockClient, SlackSocketModePostgresLockOptions, SlackSocketModePostgresLockPool, SlackSocketModeProcessLock, SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp } from './socket/index.js';
+export { S as SlackSocketModeReceiverRuntimeOptions, a as SlackSocketModeRestartGuard, b as SlackSocketModeRuntime, c as SlackSocketModeRuntimeOptions, d as SlackSocketModeRuntimePolicy, e as createSlackSdkLogger, f as createSlackSocketModeRestartGuard, g as createSlackSocketModeRuntime, r as redactSlackSocketModeLogValue } from '../runtime-BNBHOZSQ.js';
+export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
+import 'express';
+import '../types-B9NfCVrk.js';
+import 'node:http';
+import '../logging-Bl3HfcC8.js';