@cuylabs/channel-slack 0.5.0 → 0.6.0

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" | "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",
@@ -49,6 +63,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 +80,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 +92,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 +112,8 @@ function getSlackSetupRequirements(options = {}) {
     assistantView,
     eventSubscriptions: normalizedBotEvents.length > 0,
     interactivity,
+    slashCommands,
+    shortcuts,
     socketMode: transport === "socket"
   };
   const environment = resolveEnvironment({
@@ -112,9 +135,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 +149,8 @@ function resolveSetupFeatures(options) {
   }
   return uniqueFeatures([
     ...presetFeatures ?? [],
-    ...options.features ?? []
+    ...options.features ?? [],
+    ...inferredFeatures
   ]);
 }
 function resolveEnvironment(context) {
@@ -226,6 +254,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 +376,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 +408,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 +458,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 +501,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';

package/dist/transports/index.js

@@ -0,0 +1,24 @@
+import {
+  acquireSlackSocketModePostgresLock,
+  acquireSlackSocketModeProcessLock,
+  createSlackSdkLogger,
+  createSlackSocketBoltApp,
+  createSlackSocketModeRestartGuard,
+  createSlackSocketModeRuntime,
+  redactSlackSocketModeLogValue
+} from "../chunk-73QXT7MA.js";
+import {
+  createSlackBoltApp
+} from "../chunk-QJYCHWN6.js";
+import "../chunk-S3SWPYXJ.js";
+export {
+  acquireSlackSocketModePostgresLock,
+  acquireSlackSocketModeProcessLock,
+  createSlackBoltApp,
+  createSlackBoltApp as createSlackHttpBoltApp,
+  createSlackSdkLogger,
+  createSlackSocketBoltApp,
+  createSlackSocketModeRestartGuard,
+  createSlackSocketModeRuntime,
+  redactSlackSocketModeLogValue
+};

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

@@ -0,0 +1,94 @@
+import { AppOptions, SocketModeReceiverOptions, App } from '@slack/bolt';
+export { LogLevel as SlackSdkLogLevel, Logger as SlackSdkLogger } from '@slack/bolt';
+import { e as SlackDirectAuthOptions, d as SlackDirectAuthMode } from '../../types-B9NfCVrk.js';
+import { L as Logger } from '../../logging-Bl3HfcC8.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';
+import 'node:http';
+
+/**
+ * `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>;
+
+interface SlackSocketModeProcessLockOptions {
+    appSlug: string;
+    appToken?: string;
+    enabled?: boolean;
+    lockDir?: string;
+    logger?: Logger;
+}
+interface SlackSocketModeProcessLock {
+    path: string;
+    release(): void;
+}
+declare function acquireSlackSocketModeProcessLock({ appSlug, appToken, enabled, lockDir, logger, }: SlackSocketModeProcessLockOptions): SlackSocketModeProcessLock | undefined;
+
+interface SlackSocketModePostgresLockClient {
+    query<T = unknown>(sql: string, values?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount?: number | null;
+    }>;
+    release?: () => void;
+}
+interface SlackSocketModePostgresLockPool {
+    connect(): Promise<SlackSocketModePostgresLockClient>;
+    end?: () => Promise<void>;
+}
+interface SlackSocketModePostgresLockOptions {
+    appSlug: string;
+    appToken?: string;
+    client?: SlackSocketModePostgresLockClient;
+    connectionString?: string;
+    enabled?: boolean;
+    logger?: Logger;
+    namespace?: string;
+    pool?: SlackSocketModePostgresLockPool;
+}
+interface SlackSocketModePostgresLock {
+    path: string;
+    close(): Promise<void>;
+    release(): Promise<void>;
+}
+declare function acquireSlackSocketModePostgresLock({ appSlug, appToken, client, connectionString, enabled, logger, namespace, pool, }: SlackSocketModePostgresLockOptions): Promise<SlackSocketModePostgresLock | undefined>;
+
+export { type CreateSlackSocketBoltAppOptions, type CreateSlackSocketBoltAppResult, type SlackSocketModePostgresLock, type SlackSocketModePostgresLockClient, type SlackSocketModePostgresLockOptions, type SlackSocketModePostgresLockPool, type SlackSocketModeProcessLock, type SlackSocketModeProcessLockOptions, acquireSlackSocketModePostgresLock, acquireSlackSocketModeProcessLock, createSlackSocketBoltApp };

package/dist/transports/socket/index.js

@@ -0,0 +1,19 @@
+import {
+  acquireSlackSocketModePostgresLock,
+  acquireSlackSocketModeProcessLock,
+  createSlackSdkLogger,
+  createSlackSocketBoltApp,
+  createSlackSocketModeRestartGuard,
+  createSlackSocketModeRuntime,
+  redactSlackSocketModeLogValue
+} from "../../chunk-73QXT7MA.js";
+import "../../chunk-S3SWPYXJ.js";
+export {
+  acquireSlackSocketModePostgresLock,
+  acquireSlackSocketModeProcessLock,
+  createSlackSdkLogger,
+  createSlackSocketBoltApp,
+  createSlackSocketModeRestartGuard,
+  createSlackSocketModeRuntime,
+  redactSlackSocketModeLogValue
+};

package/dist/types-B9NfCVrk.d.ts

@@ -0,0 +1,141 @@
+import { IncomingMessage, ServerResponse } from 'node:http';
+
+/**
+ * OAuth and installation type declarations for the direct Slack adapter.
+ *
+ * Pure types — no runtime imports beyond `node:http` request/response.
+ * Mirrors the public surface of `@slack/oauth` enough that callers can
+ * implement custom installation/state stores without depending on Bolt's
+ * internal types.
+ */
+
+type SlackDirectAuthMode = "single-workspace" | "oauth" | "authorize";
+interface SlackOAuthError extends Error {
+    code: string;
+}
+interface SlackInstallURLOptions {
+    scopes?: string[];
+    userScopes?: string[];
+    redirectUri?: string;
+    metadata?: string;
+    teamId?: string;
+}
+interface SlackInstallationQuery {
+    teamId: string | undefined;
+    enterpriseId: string | undefined;
+    userId?: string;
+    conversationId?: string;
+    isEnterpriseInstall: boolean;
+}
+interface SlackInstallation {
+    team?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    enterprise?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    user: {
+        id: string;
+        token?: string;
+        refreshToken?: string;
+        expiresAt?: number;
+        scopes?: string[];
+    };
+    bot?: {
+        token: string;
+        refreshToken?: string;
+        expiresAt?: number;
+        scopes: string[];
+        id?: string;
+        userId?: string;
+    };
+    incomingWebhook?: {
+        url: string;
+        channel?: string;
+        channelId?: string;
+        configurationUrl?: string;
+    };
+    appId?: string;
+    tokenType?: "bot";
+    enterpriseUrl?: string;
+    isEnterpriseInstall?: boolean;
+    authVersion?: "v1" | "v2";
+    metadata?: string;
+}
+interface SlackInstallationStore {
+    storeInstallation(installation: SlackInstallation, logger?: unknown): Promise<void>;
+    fetchInstallation(query: SlackInstallationQuery, logger?: unknown): Promise<SlackInstallation>;
+    deleteInstallation?(query: SlackInstallationQuery, logger?: unknown): Promise<void>;
+}
+interface SlackStateStore {
+    generateStateParam(installOptions: SlackInstallURLOptions, now: Date): Promise<string>;
+    verifyStateParam(now: Date, state: string): Promise<SlackInstallURLOptions>;
+}
+interface SlackOAuthInstallPathOptions {
+    beforeRedirection?: (request: IncomingMessage, response: ServerResponse, options?: SlackInstallURLOptions) => Promise<boolean>;
+}
+interface SlackOAuthCallbackOptions {
+    beforeInstallation?: (options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+    afterInstallation?: (installation: SlackInstallation, options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+    success?: (installation: SlackInstallation, options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => void;
+    successAsync?: (installation: SlackInstallation, options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => Promise<void>;
+    failure?: (error: SlackOAuthError, options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => void;
+    failureAsync?: (error: SlackOAuthError, options: SlackInstallURLOptions, request: IncomingMessage, response: ServerResponse) => Promise<void>;
+}
+interface SlackAuthorizeSource {
+    teamId: string | undefined;
+    enterpriseId: string | undefined;
+    userId?: string;
+    conversationId?: string;
+    isEnterpriseInstall: boolean;
+}
+interface SlackAuthorizeResult {
+    botToken?: string;
+    userToken?: string;
+    botId?: string;
+    botUserId?: string;
+    userId?: string;
+    teamId?: string;
+    enterpriseId?: string;
+    [key: string]: unknown;
+}
+type SlackAuthorizeFn = (source: SlackAuthorizeSource, body?: unknown) => Promise<SlackAuthorizeResult>;
+interface SlackSingleWorkspaceAuthOptions {
+    mode?: "single-workspace";
+    botToken?: string;
+    botId?: string;
+    botUserId?: string;
+}
+interface SlackOAuthAuthOptions {
+    mode: "oauth";
+    clientId?: string;
+    clientSecret?: string;
+    stateSecret?: string;
+    installationStore: SlackInstallationStore;
+    stateStore?: SlackStateStore;
+    stateVerification?: boolean;
+    legacyStateVerification?: boolean;
+    stateCookieName?: string;
+    stateCookieExpirationSeconds?: number;
+    redirectUri?: string;
+    scopes?: string[];
+    userScopes?: string[];
+    metadata?: string;
+    installPath?: string;
+    callbackPath?: string;
+    renderHtmlForInstallPath?: (url: string) => string;
+    installPathOptions?: SlackOAuthInstallPathOptions;
+    callbackOptions?: SlackOAuthCallbackOptions;
+    directInstall?: boolean;
+    authVersion?: "v1" | "v2";
+    authorizationUrl?: string;
+}
+interface SlackCustomAuthorizeAuthOptions {
+    mode: "authorize";
+    authorize: SlackAuthorizeFn;
+}
+type SlackDirectAuthOptions = SlackSingleWorkspaceAuthOptions | SlackOAuthAuthOptions | SlackCustomAuthorizeAuthOptions;
+
+export type { SlackAuthorizeFn as S, SlackAuthorizeResult as a, SlackAuthorizeSource as b, SlackCustomAuthorizeAuthOptions as c, SlackDirectAuthMode as d, SlackDirectAuthOptions as e, SlackInstallation as f, SlackInstallationQuery as g, SlackInstallationStore as h, SlackOAuthAuthOptions as i, SlackOAuthCallbackOptions as j, SlackOAuthError as k, SlackOAuthInstallPathOptions as l, SlackSingleWorkspaceAuthOptions as m, SlackStateStore as n };