@maroonedsoftware/slack 1.8.0

package/dist/index.js

@@ -0,0 +1,363 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/slack.config.ts
+import { Injectable } from "injectkit";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+var SlackConfig = class {
+  static {
+    __name(this, "SlackConfig");
+  }
+};
+SlackConfig = _ts_decorate([
+  Injectable()
+], SlackConfig);
+
+// src/slack.error.ts
+import { ServerkitError } from "@maroonedsoftware/errors";
+var SlackError = class extends ServerkitError {
+  static {
+    __name(this, "SlackError");
+  }
+};
+var IsSlackError = /* @__PURE__ */ __name((error) => error instanceof SlackError, "IsSlackError");
+
+// src/slack.signature.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS = 300;
+var verifySlackSignature = /* @__PURE__ */ __name((input) => {
+  const { signingSecret, rawBody, timestamp, signature, maxAgeSeconds = SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS, now = Math.floor(Date.now() / 1e3) } = input;
+  if (!timestamp) {
+    throw new SlackError("Slack request missing X-Slack-Request-Timestamp header").withInternalDetails({
+      reason: "missing_timestamp"
+    });
+  }
+  const ts = Number(timestamp);
+  if (!Number.isFinite(ts) || !Number.isInteger(ts)) {
+    throw new SlackError("Slack request timestamp is not a valid integer").withInternalDetails({
+      reason: "invalid_timestamp",
+      timestamp
+    });
+  }
+  if (Math.abs(now - ts) > maxAgeSeconds) {
+    throw new SlackError("Slack request timestamp is outside the allowed window").withInternalDetails({
+      reason: "stale_timestamp",
+      timestamp: ts,
+      now,
+      maxAgeSeconds
+    });
+  }
+  if (!signature) {
+    throw new SlackError("Slack request missing X-Slack-Signature header").withInternalDetails({
+      reason: "missing_signature"
+    });
+  }
+  const expected = `v0=${createHmac("sha256", signingSecret).update(`v0:${ts}:${rawBody}`).digest("hex")}`;
+  const expectedBuf = Buffer.from(expected, "utf8");
+  const providedBuf = Buffer.from(signature, "utf8");
+  if (expectedBuf.length !== providedBuf.length || !timingSafeEqual(expectedBuf, providedBuf)) {
+    throw new SlackError("Slack request signature does not match").withInternalDetails({
+      reason: "invalid_signature"
+    });
+  }
+}, "verifySlackSignature");
+
+// src/slack.interaction.handler.ts
+var interactionRouteKey = /* @__PURE__ */ __name((payload) => {
+  switch (payload.type) {
+    case "block_actions": {
+      const id = payload.actions?.[0]?.action_id;
+      return id ? `block_actions:${id}` : void 0;
+    }
+    case "view_submission":
+    case "view_closed": {
+      const id = payload.view?.callback_id;
+      return id ? `${payload.type}:${id}` : void 0;
+    }
+    case "shortcut":
+    case "message_action": {
+      return payload.callback_id ? `${payload.type}:${payload.callback_id}` : void 0;
+    }
+    default: {
+      return payload.callback_id ? `${payload.type}:${payload.callback_id}` : void 0;
+    }
+  }
+}, "interactionRouteKey");
+
+// src/slack.dispatcher.ts
+import { Injectable as Injectable2 } from "injectkit";
+import { Logger } from "@maroonedsoftware/logger";
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var SlackCommandHandlerMap = class extends Map {
+  static {
+    __name(this, "SlackCommandHandlerMap");
+  }
+};
+SlackCommandHandlerMap = _ts_decorate2([
+  Injectable2()
+], SlackCommandHandlerMap);
+var SlackEventHandlerMap = class extends Map {
+  static {
+    __name(this, "SlackEventHandlerMap");
+  }
+};
+SlackEventHandlerMap = _ts_decorate2([
+  Injectable2()
+], SlackEventHandlerMap);
+var SlackInteractionHandlerMap = class extends Map {
+  static {
+    __name(this, "SlackInteractionHandlerMap");
+  }
+};
+SlackInteractionHandlerMap = _ts_decorate2([
+  Injectable2()
+], SlackInteractionHandlerMap);
+var SlackDispatcher = class {
+  static {
+    __name(this, "SlackDispatcher");
+  }
+  events;
+  commands;
+  interactions;
+  logger;
+  constructor(events, commands, interactions, logger) {
+    this.events = events;
+    this.commands = commands;
+    this.interactions = interactions;
+    this.logger = logger;
+  }
+  /**
+  * Dispatch a parsed Events API body.
+  *
+  * - Returns `{ challenge }` for `url_verification` — the caller serializes
+  *   it as the response body.
+  * - For `event_callback`, looks up a handler in {@link SlackEventHandlerMap}
+  *   keyed by `event.type` and invokes it. Returns `undefined`. Slack retries
+  *   any non-2xx so unknown event types are logged at debug and acked.
+  * - For any other top-level type, logs and returns `undefined`.
+  */
+  async dispatchEvent(body) {
+    if (body.type === "url_verification") {
+      return {
+        challenge: body.challenge
+      };
+    }
+    if (body.type === "event_callback") {
+      const envelope = body;
+      const handler = this.events.get(envelope.event.type);
+      if (handler) {
+        await handler.handle(envelope.event, {
+          teamId: envelope.team_id,
+          eventId: envelope.event_id,
+          eventTime: envelope.event_time,
+          envelope
+        });
+      } else {
+        this.logger.debug("No Slack event handler registered for event type", {
+          type: envelope.event.type
+        });
+      }
+      return void 0;
+    }
+    this.logger.debug("Unhandled Slack events payload type", {
+      type: body.type
+    });
+    return void 0;
+  }
+  /**
+  * Dispatch a parsed slash-command payload.
+  *
+  * Looks up a handler in {@link SlackCommandHandlerMap} keyed by
+  * `payload.command` (e.g. `/deploy`). If the handler returns a response,
+  * the caller serializes it as JSON; otherwise the caller acks with `200 ''`
+  * and the handler is expected to follow up via `payload.response_url`.
+  */
+  async dispatchCommand(payload) {
+    const handler = this.commands.get(payload.command);
+    if (!handler) {
+      this.logger.debug("No Slack command handler registered", {
+        command: payload.command
+      });
+      return void 0;
+    }
+    return await handler.handle(payload);
+  }
+  /**
+  * Dispatch a parsed interactive payload (block actions, view submission,
+  * shortcut, etc.). Computes a routing key via {@link interactionRouteKey}
+  * and looks it up in {@link SlackInteractionHandlerMap}.
+  */
+  async dispatchInteraction(payload) {
+    const key = interactionRouteKey(payload);
+    if (!key) {
+      this.logger.debug("Slack interaction payload missing routable identifier", {
+        type: payload.type
+      });
+      return void 0;
+    }
+    const handler = this.interactions.get(key);
+    if (!handler) {
+      this.logger.debug("No Slack interaction handler registered", {
+        key
+      });
+      return void 0;
+    }
+    return await handler.handle(payload);
+  }
+};
+SlackDispatcher = _ts_decorate2([
+  Injectable2(),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof SlackEventHandlerMap === "undefined" ? Object : SlackEventHandlerMap,
+    typeof SlackCommandHandlerMap === "undefined" ? Object : SlackCommandHandlerMap,
+    typeof SlackInteractionHandlerMap === "undefined" ? Object : SlackInteractionHandlerMap,
+    typeof Logger === "undefined" ? Object : Logger
+  ])
+], SlackDispatcher);
+
+// src/client/slack.client.ts
+import { Injectable as Injectable3 } from "injectkit";
+import { WebClient } from "@slack/web-api";
+import { Logger as Logger2 } from "@maroonedsoftware/logger";
+
+// src/client/slack.logger.adapter.ts
+var adaptLogger = /* @__PURE__ */ __name((logger, name = "slack-web-api") => {
+  const state = {
+    name,
+    level: "info"
+  };
+  const forward = /* @__PURE__ */ __name((fn) => (...msg) => {
+    const [first, ...rest] = msg;
+    fn(first ?? "", ...rest);
+  }, "forward");
+  return {
+    debug: forward(logger.debug.bind(logger)),
+    info: forward(logger.info.bind(logger)),
+    warn: forward(logger.warn.bind(logger)),
+    error: forward(logger.error.bind(logger)),
+    setLevel: /* @__PURE__ */ __name((level) => {
+      state.level = level;
+    }, "setLevel"),
+    getLevel: /* @__PURE__ */ __name(() => state.level, "getLevel"),
+    setName: /* @__PURE__ */ __name((n) => {
+      state.name = n;
+    }, "setName")
+  };
+}, "adaptLogger");
+
+// src/client/slack.client.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
+function _ts_metadata2(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata2, "_ts_metadata");
+var SlackClient = class {
+  static {
+    __name(this, "SlackClient");
+  }
+  config;
+  logger;
+  /** Underlying `@slack/web-api` client. */
+  web;
+  constructor(config, logger) {
+    this.config = config;
+    this.logger = logger;
+    this.web = new WebClient(config.botToken, {
+      logger: adaptLogger(logger)
+    });
+  }
+  /** Posts a message via `chat.postMessage`. */
+  postMessage(args) {
+    return this.web.chat.postMessage(args);
+  }
+  /** Updates a message via `chat.update`. */
+  updateMessage(args) {
+    return this.web.chat.update(args);
+  }
+  /** Deletes a message via `chat.delete`. */
+  deleteMessage(args) {
+    return this.web.chat.delete(args);
+  }
+  /** Opens a modal view via `views.open`. */
+  openView(args) {
+    return this.web.views.open(args);
+  }
+  /**
+  * POSTs a payload to a Slack incoming-webhook-style URL — either the
+  * configured `incomingWebhookUrl` or an explicit URL (e.g. the
+  * `response_url` from a slash command or interactive payload).
+  *
+  * @throws {@link SlackError} if no URL is available or the response is non-2xx.
+  */
+  async postWebhook(payload, url) {
+    const target = url ?? this.config.incomingWebhookUrl;
+    if (!target) {
+      throw new SlackError("SlackClient.postWebhook called but no incomingWebhookUrl is configured and no url was provided");
+    }
+    const response = await fetch(target, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      this.logger.warn("Slack webhook POST returned non-OK status", {
+        status: response.status,
+        body
+      });
+      throw new SlackError(`Slack webhook POST returned ${response.status}`).withInternalDetails({
+        status: response.status,
+        body,
+        url: target
+      });
+    }
+  }
+};
+SlackClient = _ts_decorate3([
+  Injectable3(),
+  _ts_metadata2("design:type", Function),
+  _ts_metadata2("design:paramtypes", [
+    typeof SlackConfig === "undefined" ? Object : SlackConfig,
+    typeof Logger2 === "undefined" ? Object : Logger2
+  ])
+], SlackClient);
+export {
+  IsSlackError,
+  SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS,
+  SlackClient,
+  SlackCommandHandlerMap,
+  SlackConfig,
+  SlackDispatcher,
+  SlackError,
+  SlackEventHandlerMap,
+  SlackInteractionHandlerMap,
+  adaptLogger,
+  interactionRouteKey,
+  verifySlackSignature
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/slack.config.ts","../src/slack.error.ts","../src/slack.signature.ts","../src/slack.interaction.handler.ts","../src/slack.dispatcher.ts","../src/client/slack.client.ts","../src/client/slack.logger.adapter.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */\nimport { Injectable } from 'injectkit';\n\n/**\n * Configuration for the Slack package. Declared as an abstract `@Injectable()`\n * class so it doubles as a DI token (mirrors the `Logger` pattern in\n * `@maroonedsoftware/logger`).\n *\n * Consumers register a concrete value at bootstrap, typically resolved from\n * `AppConfig`:\n *\n * ```ts\n * const slackConfig = appConfig.getAs<SlackConfig>('slack');\n * container.register(SlackConfig, { useValue: slackConfig });\n * ```\n *\n * Services in this package take `SlackConfig` directly in their constructor.\n */\nexport interface SlackConfig {\n  /** Bot user OAuth token (`xoxb-...`). Required for Web API calls. */\n  botToken: string;\n  /** App-level signing secret used to verify request signatures. */\n  signingSecret: string;\n  /** Optional incoming webhook URL used as the default target for `SlackClient.postWebhook`. */\n  incomingWebhookUrl?: string;\n  /**\n   * Maximum age (in seconds) for request timestamps before signature\n   * verification rejects them as replays. Defaults to `300` (5 minutes).\n   */\n  signatureMaxAgeSeconds?: number;\n}\n\n@Injectable()\nexport abstract class SlackConfig implements SlackConfig {}\n","import { ServerkitError } from '@maroonedsoftware/errors';\n\n/**\n * Domain error raised by the Slack package for non-HTTP failures (e.g.\n * incoming-webhook POST failed, unknown handler dispatch).\n *\n * Extends {@link ServerkitError} so `errorMiddleware` renders a 500 with\n * `{ message, details }` if one of these escapes a route handler. Inside\n * route handlers, throw `httpError(...)` directly for status-coded responses.\n */\nexport class SlackError extends ServerkitError {}\n\n/**\n * Type guard for {@link SlackError}. Narrows `unknown` to `SlackError` so\n * `details`, `internalDetails`, and the chainable setters are accessible\n * without further checks. Returns `true` for any subclass.\n */\nexport const IsSlackError = (error: unknown): error is SlackError => error instanceof SlackError;\n","import { createHmac, timingSafeEqual } from 'node:crypto';\nimport { SlackError } from './slack.error.js';\n\n/** Default replay-protection window in seconds (5 minutes — matches Slack's recommendation). */\nexport const SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS = 300;\n\n/**\n * Reason codes attached to {@link SlackError.internalDetails} when verification\n * fails. Useful for callers that want to log structured reasons without\n * pattern-matching on error messages.\n */\nexport type SlackSignatureFailureReason =\n  | 'missing_timestamp'\n  | 'invalid_timestamp'\n  | 'stale_timestamp'\n  | 'missing_signature'\n  | 'invalid_signature';\n\n/**\n * Inputs to {@link verifySlackSignature}. All values are taken verbatim from\n * the request — the helper does no header lookups or body reads of its own.\n */\nexport type VerifySlackSignatureInput = {\n  /** App signing secret (`SlackConfig.signingSecret`). */\n  signingSecret: string;\n  /** Raw, unparsed request body — exactly as Slack sent it. */\n  rawBody: string;\n  /** Value of the `X-Slack-Request-Timestamp` header. */\n  timestamp: string | undefined;\n  /** Value of the `X-Slack-Signature` header (e.g. `\"v0=abc123…\"`). */\n  signature: string | undefined;\n  /**\n   * Maximum age in seconds before the request is rejected as a replay.\n   * Defaults to {@link SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS}.\n   */\n  maxAgeSeconds?: number;\n  /**\n   * Override for the current Unix time in seconds. Mostly useful for tests;\n   * defaults to `Math.floor(Date.now() / 1000)`.\n   */\n  now?: number;\n};\n\n/**\n * Verifies a Slack request signature against the app signing secret.\n *\n * Implements Slack's v0 scheme:\n * 1. Reject the request if `X-Slack-Request-Timestamp` is missing, non-numeric,\n *    or older than `maxAgeSeconds` (replay protection).\n * 2. Compute `v0=` + `HMAC-SHA256(signingSecret, \"v0:{timestamp}:{rawBody}\")`\n *    as hex.\n * 3. Compare against the provided `X-Slack-Signature` value using a\n *    constant-time compare.\n *\n * Pure: no request/context coupling. The caller extracts the headers and raw\n * body from whatever transport it's using and passes them in.\n *\n * @throws {@link SlackError} on any failure. The error's `internalDetails.reason`\n *   is one of {@link SlackSignatureFailureReason}; map to HTTP 401 at the route boundary.\n *\n * @example\n * ```ts\n * try {\n *   verifySlackSignature({\n *     signingSecret: config.signingSecret,\n *     rawBody,\n *     timestamp: req.headers['x-slack-request-timestamp'],\n *     signature: req.headers['x-slack-signature'],\n *   });\n * } catch (err) {\n *   throw httpError(401).withCause(err);\n * }\n * ```\n */\nexport const verifySlackSignature = (input: VerifySlackSignatureInput): void => {\n  const {\n    signingSecret,\n    rawBody,\n    timestamp,\n    signature,\n    maxAgeSeconds = SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS,\n    now = Math.floor(Date.now() / 1000),\n  } = input;\n\n  if (!timestamp) {\n    throw new SlackError('Slack request missing X-Slack-Request-Timestamp header').withInternalDetails({\n      reason: 'missing_timestamp' satisfies SlackSignatureFailureReason,\n    });\n  }\n\n  const ts = Number(timestamp);\n  if (!Number.isFinite(ts) || !Number.isInteger(ts)) {\n    throw new SlackError('Slack request timestamp is not a valid integer').withInternalDetails({\n      reason: 'invalid_timestamp' satisfies SlackSignatureFailureReason,\n      timestamp,\n    });\n  }\n\n  if (Math.abs(now - ts) > maxAgeSeconds) {\n    throw new SlackError('Slack request timestamp is outside the allowed window').withInternalDetails({\n      reason: 'stale_timestamp' satisfies SlackSignatureFailureReason,\n      timestamp: ts,\n      now,\n      maxAgeSeconds,\n    });\n  }\n\n  if (!signature) {\n    throw new SlackError('Slack request missing X-Slack-Signature header').withInternalDetails({\n      reason: 'missing_signature' satisfies SlackSignatureFailureReason,\n    });\n  }\n\n  const expected = `v0=${createHmac('sha256', signingSecret).update(`v0:${ts}:${rawBody}`).digest('hex')}`;\n  const expectedBuf = Buffer.from(expected, 'utf8');\n  const providedBuf = Buffer.from(signature, 'utf8');\n\n  // timingSafeEqual throws on length mismatch — short-circuit so the caller\n  // gets a uniform \"invalid_signature\" error instead of a crypto exception.\n  if (expectedBuf.length !== providedBuf.length || !timingSafeEqual(expectedBuf, providedBuf)) {\n    throw new SlackError('Slack request signature does not match').withInternalDetails({\n      reason: 'invalid_signature' satisfies SlackSignatureFailureReason,\n    });\n  }\n};\n","/**\n * The supported interactive payload types Slack POSTs to the interactivity\n * endpoint. Each maps to a different identifier shape (see\n * {@link interactionRouteKey}).\n */\nexport type SlackInteractionType = 'block_actions' | 'view_submission' | 'view_closed' | 'shortcut' | 'message_action' | string;\n\n/**\n * Loose typing for the interactive payload; consumers narrow per handler.\n * Slack's payloads vary by type, but every variant has a `type` field plus\n * one of: `actions[].action_id`, `view.callback_id`, or top-level `callback_id`.\n */\nexport type SlackInteractionPayload = {\n  type: SlackInteractionType;\n  team?: { id: string; domain?: string };\n  user?: { id: string; name?: string };\n  trigger_id?: string;\n  response_url?: string;\n  actions?: Array<{ action_id: string; block_id?: string; value?: string; [key: string]: unknown }>;\n  view?: { id: string; callback_id: string; [key: string]: unknown };\n  callback_id?: string;\n  [key: string]: unknown;\n};\n\n/**\n * Optional response Slack accepts for `view_submission` / `view_closed`\n * payloads (e.g. to display validation errors or update a modal).\n */\nexport type SlackInteractionResponse = {\n  response_action?: 'errors' | 'update' | 'push' | 'clear';\n  errors?: Record<string, string>;\n  view?: unknown;\n  [key: string]: unknown;\n};\n\n/**\n * Handler for one interactive payload, keyed in {@link SlackInteractionHandlerMap}\n * by `${type}:${identifier}` — see {@link interactionRouteKey}.\n */\nexport interface SlackInteractionHandler {\n  handle(payload: SlackInteractionPayload): Promise<SlackInteractionResponse | void>;\n}\n\n/**\n * Computes the routing key used by {@link SlackDispatcher.dispatchInteraction}\n * to look a handler up in {@link SlackInteractionHandlerMap}.\n *\n * - `block_actions` → `block_actions:<first action.action_id>`\n * - `view_submission` / `view_closed` → `<type>:<view.callback_id>`\n * - `shortcut` / `message_action` → `<type>:<callback_id>`\n * - any other type with a `callback_id` → `<type>:<callback_id>`\n *\n * @returns The routing key, or `undefined` if the payload doesn't carry an\n *   identifier we can route on (e.g. a `block_actions` payload with no actions).\n */\nexport const interactionRouteKey = (payload: SlackInteractionPayload): string | undefined => {\n  switch (payload.type) {\n    case 'block_actions': {\n      const id = payload.actions?.[0]?.action_id;\n      return id ? `block_actions:${id}` : undefined;\n    }\n    case 'view_submission':\n    case 'view_closed': {\n      const id = payload.view?.callback_id;\n      return id ? `${payload.type}:${id}` : undefined;\n    }\n    case 'shortcut':\n    case 'message_action': {\n      return payload.callback_id ? `${payload.type}:${payload.callback_id}` : undefined;\n    }\n    default: {\n      return payload.callback_id ? `${payload.type}:${payload.callback_id}` : undefined;\n    }\n  }\n};\n","import { Injectable } from 'injectkit';\nimport { Logger } from '@maroonedsoftware/logger';\nimport type { SlackEventCallback, SlackEventHandler } from './slack.event.handler.js';\nimport type { SlackCommandHandler, SlackCommandPayload, SlackCommandResponse } from './slack.command.handler.js';\nimport {\n  interactionRouteKey,\n  SlackInteractionHandler,\n  type SlackInteractionPayload,\n  type SlackInteractionResponse,\n} from './slack.interaction.handler.js';\n\n/**\n * Body shape Slack POSTs to the Events API endpoint. The handshake variant\n * (`url_verification`) is sent once during app configuration; the rest of the\n * traffic is `event_callback` envelopes (or other future top-level types).\n */\nexport type SlackEventsRequest =\n  | { type: 'url_verification'; challenge: string; token?: string }\n  | SlackEventCallback\n  | { type: string; [key: string]: unknown };\n\n/**\n * Response Slack expects for the `url_verification` handshake. For\n * `event_callback` and unknown event types, the dispatcher returns\n * `undefined` and the caller should ack with HTTP 200.\n */\nexport type SlackEventsResponse = { challenge: string } | undefined;\n\n/**\n * Injectable map of command keyword (e.g. `/deploy`) → {@link SlackCommandHandler}.\n *\n * @example\n * ```ts\n * const commands = new SlackCommandHandlerMap();\n * commands.set('/deploy', container.get(DeployCommandHandler));\n * container.register(SlackCommandHandlerMap, { useValue: commands });\n * ```\n */\n@Injectable()\nexport class SlackCommandHandlerMap extends Map<string, SlackCommandHandler> {}\n\n/**\n * Injectable map of Slack event type → {@link SlackEventHandler}. Consumers\n * register handlers at bootstrap and place an instance of this map in their\n * DI container; {@link SlackDispatcher.dispatchEvent} resolves it per request.\n *\n * @example\n * ```ts\n * const handlers = new SlackEventHandlerMap();\n * handlers.set('app_mention', container.get(MyAppMentionHandler));\n * container.register(SlackEventHandlerMap, { useValue: handlers });\n * ```\n */\n@Injectable()\nexport class SlackEventHandlerMap extends Map<string, SlackEventHandler> {}\n\n/**\n * Injectable map of interaction routing keys → {@link SlackInteractionHandler}.\n *\n * Keys are produced by `interactionRouteKey(payload)`, which combines the\n * payload `type` with the relevant identifier (`action_id`, `callback_id`,\n * etc.). Register handlers under the same key shape:\n *\n * @example\n * ```ts\n * const interactions = new SlackInteractionHandlerMap();\n * interactions.set('block_actions:approve_button', container.get(ApproveHandler));\n * interactions.set('view_submission:create_ticket_modal', container.get(CreateTicketHandler));\n * container.register(SlackInteractionHandlerMap, { useValue: interactions });\n * ```\n */\n@Injectable()\nexport class SlackInteractionHandlerMap extends Map<string, SlackInteractionHandler> {}\n\n/**\n * Single entry point for dispatching parsed Slack payloads to registered\n * handlers. Transport-agnostic: the consumer is responsible for receiving\n * the HTTP request, verifying the signature, parsing the body, calling the\n * appropriate `dispatch*` method, and serializing the response.\n *\n * @example Koa route\n * ```ts\n * router.post('/slack/events', async (ctx) => {\n *   const raw = await rawBody(ctx.req, { encoding: 'utf8' });\n *   verifySlackSignature({\n *     signingSecret: ctx.container.get(SlackConfig).signingSecret,\n *     rawBody: raw,\n *     timestamp: ctx.get('x-slack-request-timestamp'),\n *     signature: ctx.get('x-slack-signature'),\n *   });\n *   const result = await ctx.container.get(SlackDispatcher).dispatchEvent(JSON.parse(raw));\n *   if (result) ctx.body = result;\n *   else { ctx.status = 200; ctx.body = ''; }\n * });\n * ```\n */\n@Injectable()\nexport class SlackDispatcher {\n  constructor(\n    private readonly events: SlackEventHandlerMap,\n    private readonly commands: SlackCommandHandlerMap,\n    private readonly interactions: SlackInteractionHandlerMap,\n    private readonly logger: Logger,\n  ) {}\n\n  /**\n   * Dispatch a parsed Events API body.\n   *\n   * - Returns `{ challenge }` for `url_verification` — the caller serializes\n   *   it as the response body.\n   * - For `event_callback`, looks up a handler in {@link SlackEventHandlerMap}\n   *   keyed by `event.type` and invokes it. Returns `undefined`. Slack retries\n   *   any non-2xx so unknown event types are logged at debug and acked.\n   * - For any other top-level type, logs and returns `undefined`.\n   */\n  async dispatchEvent(body: SlackEventsRequest): Promise<SlackEventsResponse> {\n    if (body.type === 'url_verification') {\n      return { challenge: (body as { challenge: string }).challenge };\n    }\n\n    if (body.type === 'event_callback') {\n      const envelope = body as SlackEventCallback;\n      const handler = this.events.get(envelope.event.type);\n      if (handler) {\n        await handler.handle(envelope.event, {\n          teamId: envelope.team_id,\n          eventId: envelope.event_id,\n          eventTime: envelope.event_time,\n          envelope,\n        });\n      } else {\n        this.logger.debug('No Slack event handler registered for event type', { type: envelope.event.type });\n      }\n      return undefined;\n    }\n\n    this.logger.debug('Unhandled Slack events payload type', { type: body.type });\n    return undefined;\n  }\n\n  /**\n   * Dispatch a parsed slash-command payload.\n   *\n   * Looks up a handler in {@link SlackCommandHandlerMap} keyed by\n   * `payload.command` (e.g. `/deploy`). If the handler returns a response,\n   * the caller serializes it as JSON; otherwise the caller acks with `200 ''`\n   * and the handler is expected to follow up via `payload.response_url`.\n   */\n  async dispatchCommand(payload: SlackCommandPayload): Promise<SlackCommandResponse | void> {\n    const handler = this.commands.get(payload.command);\n    if (!handler) {\n      this.logger.debug('No Slack command handler registered', { command: payload.command });\n      return undefined;\n    }\n    return await handler.handle(payload);\n  }\n\n  /**\n   * Dispatch a parsed interactive payload (block actions, view submission,\n   * shortcut, etc.). Computes a routing key via {@link interactionRouteKey}\n   * and looks it up in {@link SlackInteractionHandlerMap}.\n   */\n  async dispatchInteraction(payload: SlackInteractionPayload): Promise<SlackInteractionResponse | void> {\n    const key = interactionRouteKey(payload);\n    if (!key) {\n      this.logger.debug('Slack interaction payload missing routable identifier', { type: payload.type });\n      return undefined;\n    }\n    const handler = this.interactions.get(key);\n    if (!handler) {\n      this.logger.debug('No Slack interaction handler registered', { key });\n      return undefined;\n    }\n    return await handler.handle(payload);\n  }\n}\n","import { Injectable } from 'injectkit';\nimport { WebClient } from '@slack/web-api';\nimport type { ChatPostMessageArguments, ChatPostMessageResponse, ChatUpdateArguments, ChatUpdateResponse, ChatDeleteArguments, ChatDeleteResponse, ViewsOpenArguments, ViewsOpenResponse } from '@slack/web-api';\nimport { Logger } from '@maroonedsoftware/logger';\nimport { SlackConfig } from '../slack.config.js';\nimport { SlackError } from '../slack.error.js';\nimport { adaptLogger } from './slack.logger.adapter.js';\n\n/**\n * Payload for an incoming-webhook POST. Mirrors the subset of fields Slack's\n * incoming webhooks accept (text, blocks, attachments, response shaping).\n * The body is JSON-stringified verbatim, so any extra fields are preserved.\n */\nexport type IncomingWebhookPayload = {\n  text?: string;\n  blocks?: unknown[];\n  attachments?: unknown[];\n  thread_ts?: string;\n  response_type?: 'in_channel' | 'ephemeral';\n  replace_original?: boolean;\n  delete_original?: boolean;\n  unfurl_links?: boolean;\n  unfurl_media?: boolean;\n  [key: string]: unknown;\n};\n\n/**\n * Thin DI-friendly wrapper around `@slack/web-api`'s `WebClient`. Constructed\n * once per request scope (or as a singleton, depending on how the consumer\n * registers it) and exposes typed passthroughs for the most common Web API\n * methods plus a `postWebhook` helper for incoming-webhook URLs and the\n * `response_url` returned by slash commands and interactive payloads.\n *\n * Reach for {@link SlackClient.web} directly for anything else the underlying\n * client supports.\n *\n * @example\n * ```ts\n * await container.get(SlackClient).postMessage({ channel: '#ops', text: 'hello' });\n * await container.get(SlackClient).postWebhook({ text: 'follow-up' }, payload.response_url);\n * ```\n */\n@Injectable()\nexport class SlackClient {\n  /** Underlying `@slack/web-api` client. */\n  readonly web: WebClient;\n\n  constructor(\n    private readonly config: SlackConfig,\n    private readonly logger: Logger,\n  ) {\n    this.web = new WebClient(config.botToken, { logger: adaptLogger(logger) });\n  }\n\n  /** Posts a message via `chat.postMessage`. */\n  postMessage(args: ChatPostMessageArguments): Promise<ChatPostMessageResponse> {\n    return this.web.chat.postMessage(args);\n  }\n\n  /** Updates a message via `chat.update`. */\n  updateMessage(args: ChatUpdateArguments): Promise<ChatUpdateResponse> {\n    return this.web.chat.update(args);\n  }\n\n  /** Deletes a message via `chat.delete`. */\n  deleteMessage(args: ChatDeleteArguments): Promise<ChatDeleteResponse> {\n    return this.web.chat.delete(args);\n  }\n\n  /** Opens a modal view via `views.open`. */\n  openView(args: ViewsOpenArguments): Promise<ViewsOpenResponse> {\n    return this.web.views.open(args);\n  }\n\n  /**\n   * POSTs a payload to a Slack incoming-webhook-style URL — either the\n   * configured `incomingWebhookUrl` or an explicit URL (e.g. the\n   * `response_url` from a slash command or interactive payload).\n   *\n   * @throws {@link SlackError} if no URL is available or the response is non-2xx.\n   */\n  async postWebhook(payload: IncomingWebhookPayload, url?: string): Promise<void> {\n    const target = url ?? this.config.incomingWebhookUrl;\n    if (!target) {\n      throw new SlackError('SlackClient.postWebhook called but no incomingWebhookUrl is configured and no url was provided');\n    }\n    const response = await fetch(target, {\n      method: 'POST',\n      headers: { 'content-type': 'application/json' },\n      body: JSON.stringify(payload),\n    });\n    if (!response.ok) {\n      const body = await response.text().catch(() => '');\n      this.logger.warn('Slack webhook POST returned non-OK status', { status: response.status, body });\n      throw new SlackError(`Slack webhook POST returned ${response.status}`).withInternalDetails({ status: response.status, body, url: target });\n    }\n  }\n}\n","import type { Logger as SlackLogger, LogLevel } from '@slack/web-api';\nimport { Logger } from '@maroonedsoftware/logger';\n\n/**\n * Adapts a ServerKit {@link Logger} to the `@slack/web-api` {@link SlackLogger}\n * interface so the WebClient can route its diagnostics through the host\n * application's logger.\n *\n * The Slack SDK's logger calls `logger.info(...args)` with a variable number\n * of arguments and no separate \"primary message\"; the adapter forwards them\n * to ServerKit's `(message, ...optionalParams)` shape, with an empty-string\n * primary when no args are passed.\n *\n * `setLevel`, `setName`, and `getLevel` are stored locally — ServerKit\n * loggers do not expose these knobs but the SDK expects them on its logger.\n *\n * @param logger - The ServerKit logger to forward calls to.\n * @param name - Initial value for the SDK logger's name. Defaults to `'slack-web-api'`.\n * @returns A `@slack/web-api`-compatible logger object.\n */\nexport const adaptLogger = (logger: Logger, name = 'slack-web-api'): SlackLogger => {\n  const state = { name, level: 'info' as LogLevel };\n  const forward = (fn: (message: unknown, ...optionalParams: unknown[]) => void) => (...msg: unknown[]) => {\n    const [first, ...rest] = msg;\n    fn(first ?? '', ...rest);\n  };\n  return {\n    debug: forward(logger.debug.bind(logger)),\n    info: forward(logger.info.bind(logger)),\n    warn: forward(logger.warn.bind(logger)),\n    error: forward(logger.error.bind(logger)),\n    setLevel: (level: LogLevel) => {\n      state.level = level;\n    },\n    getLevel: () => state.level,\n    setName: (n: string) => {\n      state.name = n;\n    },\n  };\n};\n"],"mappings":";;;;AACA,SAASA,kBAAkB;;;;;;;;AAgCpB,IAAeC,cAAf,MAAeA;SAAAA;;;AAAoC;;;;;;ACjC1D,SAASC,sBAAsB;AAUxB,IAAMC,aAAN,cAAyBC,eAAAA;EAVhC,OAUgCA;;;AAAgB;AAOzC,IAAMC,eAAe,wBAACC,UAAwCA,iBAAiBH,YAA1D;;;ACjB5B,SAASI,YAAYC,uBAAuB;AAIrC,IAAMC,0CAA0C;AAsEhD,IAAMC,uBAAuB,wBAACC,UAAAA;AACnC,QAAM,EACJC,eACAC,SACAC,WACAC,WACAC,gBAAgBP,yCAChBQ,MAAMC,KAAKC,MAAMC,KAAKH,IAAG,IAAK,GAAA,EAAK,IACjCN;AAEJ,MAAI,CAACG,WAAW;AACd,UAAM,IAAIO,WAAW,wDAAA,EAA0DC,oBAAoB;MACjGC,QAAQ;IACV,CAAA;EACF;AAEA,QAAMC,KAAKC,OAAOX,SAAAA;AAClB,MAAI,CAACW,OAAOC,SAASF,EAAAA,KAAO,CAACC,OAAOE,UAAUH,EAAAA,GAAK;AACjD,UAAM,IAAIH,WAAW,gDAAA,EAAkDC,oBAAoB;MACzFC,QAAQ;MACRT;IACF,CAAA;EACF;AAEA,MAAII,KAAKU,IAAIX,MAAMO,EAAAA,IAAMR,eAAe;AACtC,UAAM,IAAIK,WAAW,uDAAA,EAAyDC,oBAAoB;MAChGC,QAAQ;MACRT,WAAWU;MACXP;MACAD;IACF,CAAA;EACF;AAEA,MAAI,CAACD,WAAW;AACd,UAAM,IAAIM,WAAW,gDAAA,EAAkDC,oBAAoB;MACzFC,QAAQ;IACV,CAAA;EACF;AAEA,QAAMM,WAAW,MAAMC,WAAW,UAAUlB,aAAAA,EAAemB,OAAO,MAAMP,EAAAA,IAAMX,OAAAA,EAAS,EAAEmB,OAAO,KAAA,CAAA;AAChG,QAAMC,cAAcC,OAAOC,KAAKN,UAAU,MAAA;AAC1C,QAAMO,cAAcF,OAAOC,KAAKpB,WAAW,MAAA;AAI3C,MAAIkB,YAAYI,WAAWD,YAAYC,UAAU,CAACC,gBAAgBL,aAAaG,WAAAA,GAAc;AAC3F,UAAM,IAAIf,WAAW,wCAAA,EAA0CC,oBAAoB;MACjFC,QAAQ;IACV,CAAA;EACF;AACF,GAlDoC;;;ACnB7B,IAAMgB,sBAAsB,wBAACC,YAAAA;AAClC,UAAQA,QAAQC,MAAI;IAClB,KAAK,iBAAiB;AACpB,YAAMC,KAAKF,QAAQG,UAAU,CAAA,GAAIC;AACjC,aAAOF,KAAK,iBAAiBA,EAAAA,KAAOG;IACtC;IACA,KAAK;IACL,KAAK,eAAe;AAClB,YAAMH,KAAKF,QAAQM,MAAMC;AACzB,aAAOL,KAAK,GAAGF,QAAQC,IAAI,IAAIC,EAAAA,KAAOG;IACxC;IACA,KAAK;IACL,KAAK,kBAAkB;AACrB,aAAOL,QAAQO,cAAc,GAAGP,QAAQC,IAAI,IAAID,QAAQO,WAAW,KAAKF;IAC1E;IACA,SAAS;AACP,aAAOL,QAAQO,cAAc,GAAGP,QAAQC,IAAI,IAAID,QAAQO,WAAW,KAAKF;IAC1E;EACF;AACF,GAnBmC;;;ACvDnC,SAASG,cAAAA,mBAAkB;AAC3B,SAASC,cAAc;;;;;;;;;;;;AAsChB,IAAMC,yBAAN,cAAqCC,IAAAA;SAAAA;;;AAAkC;;;;AAevE,IAAMC,uBAAN,cAAmCD,IAAAA;SAAAA;;;AAAgC;;;;AAkBnE,IAAME,6BAAN,cAAyCF,IAAAA;SAAAA;;;AAAsC;;;;AAyB/E,IAAMG,kBAAN,MAAMA;SAAAA;;;;;;;EACX,YACmBC,QACAC,UACAC,cACAC,QACjB;SAJiBH,SAAAA;SACAC,WAAAA;SACAC,eAAAA;SACAC,SAAAA;EAChB;;;;;;;;;;;EAYH,MAAMC,cAAcC,MAAwD;AAC1E,QAAIA,KAAKC,SAAS,oBAAoB;AACpC,aAAO;QAAEC,WAAYF,KAA+BE;MAAU;IAChE;AAEA,QAAIF,KAAKC,SAAS,kBAAkB;AAClC,YAAME,WAAWH;AACjB,YAAMI,UAAU,KAAKT,OAAOU,IAAIF,SAASG,MAAML,IAAI;AACnD,UAAIG,SAAS;AACX,cAAMA,QAAQG,OAAOJ,SAASG,OAAO;UACnCE,QAAQL,SAASM;UACjBC,SAASP,SAASQ;UAClBC,WAAWT,SAASU;UACpBV;QACF,CAAA;MACF,OAAO;AACL,aAAKL,OAAOgB,MAAM,oDAAoD;UAAEb,MAAME,SAASG,MAAML;QAAK,CAAA;MACpG;AACA,aAAOc;IACT;AAEA,SAAKjB,OAAOgB,MAAM,uCAAuC;MAAEb,MAAMD,KAAKC;IAAK,CAAA;AAC3E,WAAOc;EACT;;;;;;;;;EAUA,MAAMC,gBAAgBC,SAAoE;AACxF,UAAMb,UAAU,KAAKR,SAASS,IAAIY,QAAQC,OAAO;AACjD,QAAI,CAACd,SAAS;AACZ,WAAKN,OAAOgB,MAAM,uCAAuC;QAAEI,SAASD,QAAQC;MAAQ,CAAA;AACpF,aAAOH;IACT;AACA,WAAO,MAAMX,QAAQG,OAAOU,OAAAA;EAC9B;;;;;;EAOA,MAAME,oBAAoBF,SAA4E;AACpG,UAAMG,MAAMC,oBAAoBJ,OAAAA;AAChC,QAAI,CAACG,KAAK;AACR,WAAKtB,OAAOgB,MAAM,yDAAyD;QAAEb,MAAMgB,QAAQhB;MAAK,CAAA;AAChG,aAAOc;IACT;AACA,UAAMX,UAAU,KAAKP,aAAaQ,IAAIe,GAAAA;AACtC,QAAI,CAAChB,SAAS;AACZ,WAAKN,OAAOgB,MAAM,2CAA2C;QAAEM;MAAI,CAAA;AACnE,aAAOL;IACT;AACA,WAAO,MAAMX,QAAQG,OAAOU,OAAAA;EAC9B;AACF;;;;;;;;;;;;;AC/KA,SAASK,cAAAA,mBAAkB;AAC3B,SAASC,iBAAiB;AAE1B,SAASC,UAAAA,eAAc;;;ACiBhB,IAAMC,cAAc,wBAACC,QAAgBC,OAAO,oBAAe;AAChE,QAAMC,QAAQ;IAAED;IAAME,OAAO;EAAmB;AAChD,QAAMC,UAAU,wBAACC,OAAiE,IAAIC,QAAAA;AACpF,UAAM,CAACC,OAAO,GAAGC,IAAAA,IAAQF;AACzBD,OAAGE,SAAS,IAAA,GAAOC,IAAAA;EACrB,GAHgB;AAIhB,SAAO;IACLC,OAAOL,QAAQJ,OAAOS,MAAMC,KAAKV,MAAAA,CAAAA;IACjCW,MAAMP,QAAQJ,OAAOW,KAAKD,KAAKV,MAAAA,CAAAA;IAC/BY,MAAMR,QAAQJ,OAAOY,KAAKF,KAAKV,MAAAA,CAAAA;IAC/Ba,OAAOT,QAAQJ,OAAOa,MAAMH,KAAKV,MAAAA,CAAAA;IACjCc,UAAU,wBAACX,UAAAA;AACTD,YAAMC,QAAQA;IAChB,GAFU;IAGVY,UAAU,6BAAMb,MAAMC,OAAZ;IACVa,SAAS,wBAACC,MAAAA;AACRf,YAAMD,OAAOgB;IACf,GAFS;EAGX;AACF,GAnB2B;;;;;;;;;;;;;;ADuBpB,IAAMC,cAAN,MAAMA;SAAAA;;;;;;EAEFC;EAET,YACmBC,QACAC,QACjB;SAFiBD,SAAAA;SACAC,SAAAA;AAEjB,SAAKF,MAAM,IAAIG,UAAUF,OAAOG,UAAU;MAAEF,QAAQG,YAAYH,MAAAA;IAAQ,CAAA;EAC1E;;EAGAI,YAAYC,MAAkE;AAC5E,WAAO,KAAKP,IAAIQ,KAAKF,YAAYC,IAAAA;EACnC;;EAGAE,cAAcF,MAAwD;AACpE,WAAO,KAAKP,IAAIQ,KAAKE,OAAOH,IAAAA;EAC9B;;EAGAI,cAAcJ,MAAwD;AACpE,WAAO,KAAKP,IAAIQ,KAAKI,OAAOL,IAAAA;EAC9B;;EAGAM,SAASN,MAAsD;AAC7D,WAAO,KAAKP,IAAIc,MAAMC,KAAKR,IAAAA;EAC7B;;;;;;;;EASA,MAAMS,YAAYC,SAAiCC,KAA6B;AAC9E,UAAMC,SAASD,OAAO,KAAKjB,OAAOmB;AAClC,QAAI,CAACD,QAAQ;AACX,YAAM,IAAIE,WAAW,gGAAA;IACvB;AACA,UAAMC,WAAW,MAAMC,MAAMJ,QAAQ;MACnCK,QAAQ;MACRC,SAAS;QAAE,gBAAgB;MAAmB;MAC9CC,MAAMC,KAAKC,UAAUX,OAAAA;IACvB,CAAA;AACA,QAAI,CAACK,SAASO,IAAI;AAChB,YAAMH,OAAO,MAAMJ,SAASQ,KAAI,EAAGC,MAAM,MAAM,EAAA;AAC/C,WAAK7B,OAAO8B,KAAK,6CAA6C;QAAEC,QAAQX,SAASW;QAAQP;MAAK,CAAA;AAC9F,YAAM,IAAIL,WAAW,+BAA+BC,SAASW,MAAM,EAAE,EAAEC,oBAAoB;QAAED,QAAQX,SAASW;QAAQP;QAAMR,KAAKC;MAAO,CAAA;IAC1I;EACF;AACF;;;;;;;;;","names":["Injectable","SlackConfig","ServerkitError","SlackError","ServerkitError","IsSlackError","error","createHmac","timingSafeEqual","SLACK_SIGNATURE_DEFAULT_MAX_AGE_SECONDS","verifySlackSignature","input","signingSecret","rawBody","timestamp","signature","maxAgeSeconds","now","Math","floor","Date","SlackError","withInternalDetails","reason","ts","Number","isFinite","isInteger","abs","expected","createHmac","update","digest","expectedBuf","Buffer","from","providedBuf","length","timingSafeEqual","interactionRouteKey","payload","type","id","actions","action_id","undefined","view","callback_id","Injectable","Logger","SlackCommandHandlerMap","Map","SlackEventHandlerMap","SlackInteractionHandlerMap","SlackDispatcher","events","commands","interactions","logger","dispatchEvent","body","type","challenge","envelope","handler","get","event","handle","teamId","team_id","eventId","event_id","eventTime","event_time","debug","undefined","dispatchCommand","payload","command","dispatchInteraction","key","interactionRouteKey","Injectable","WebClient","Logger","adaptLogger","logger","name","state","level","forward","fn","msg","first","rest","debug","bind","info","warn","error","setLevel","getLevel","setName","n","SlackClient","web","config","logger","WebClient","botToken","adaptLogger","postMessage","args","chat","updateMessage","update","deleteMessage","delete","openView","views","open","postWebhook","payload","url","target","incomingWebhookUrl","SlackError","response","fetch","method","headers","body","JSON","stringify","ok","text","catch","warn","status","withInternalDetails"]}

package/dist/slack.command.handler.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Decoded slash-command payload Slack delivers as `application/x-www-form-urlencoded`.
+ * Field documentation: https://api.slack.com/interactivity/slash-commands#app_command_handling.
+ */
+export type SlackCommandPayload = {
+    /** Verification token (deprecated by Slack — prefer signature verification). */
+    token: string;
+    team_id: string;
+    team_domain: string;
+    enterprise_id?: string;
+    enterprise_name?: string;
+    channel_id: string;
+    channel_name: string;
+    user_id: string;
+    user_name: string;
+    /** The command keyword, including the leading slash (e.g. `/deploy`). */
+    command: string;
+    /** Everything the user typed after the command. */
+    text: string;
+    /** URL the handler can POST to within 30 minutes for follow-up responses. */
+    response_url: string;
+    /** Short-lived token usable with `views.open`. */
+    trigger_id: string;
+    api_app_id?: string;
+};
+/**
+ * Response body for a slash command. Slack accepts plain text or a Block Kit
+ * payload; the optional `response_type` controls visibility.
+ */
+export type SlackCommandResponse = {
+    /** Plain text shown to the user when no `blocks` are provided. */
+    text?: string;
+    /** Block Kit blocks. */
+    blocks?: unknown[];
+    /** `'ephemeral'` (only the invoker sees it, default) or `'in_channel'`. */
+    response_type?: 'ephemeral' | 'in_channel';
+    [key: string]: unknown;
+};
+/**
+ * Handler for one slash command keyed by its full command string (with slash,
+ * e.g. `/deploy`). Registered in {@link SlackCommandHandlerMap}.
+ *
+ * Returning a {@link SlackCommandResponse} makes Slack render it immediately;
+ * returning `void` acks with an empty 200 (the handler is responsible for any
+ * follow-up via `response_url`).
+ */
+export interface SlackCommandHandler {
+    handle(payload: SlackCommandPayload): Promise<SlackCommandResponse | void>;
+}
+//# sourceMappingURL=slack.command.handler.d.ts.map

package/dist/slack.command.handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.command.handler.d.ts","sourceRoot":"","sources":["../src/slack.command.handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,gFAAgF;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB;IACxB,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC;IACnB,2EAA2E;IAC3E,aAAa,CAAC,EAAE,WAAW,GAAG,YAAY,CAAC;IAC3C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC,CAAC;CAC5E"}

package/dist/slack.config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Configuration for the Slack package. Declared as an abstract `@Injectable()`
+ * class so it doubles as a DI token (mirrors the `Logger` pattern in
+ * `@maroonedsoftware/logger`).
+ *
+ * Consumers register a concrete value at bootstrap, typically resolved from
+ * `AppConfig`:
+ *
+ * ```ts
+ * const slackConfig = appConfig.getAs<SlackConfig>('slack');
+ * container.register(SlackConfig, { useValue: slackConfig });
+ * ```
+ *
+ * Services in this package take `SlackConfig` directly in their constructor.
+ */
+export interface SlackConfig {
+    /** Bot user OAuth token (`xoxb-...`). Required for Web API calls. */
+    botToken: string;
+    /** App-level signing secret used to verify request signatures. */
+    signingSecret: string;
+    /** Optional incoming webhook URL used as the default target for `SlackClient.postWebhook`. */
+    incomingWebhookUrl?: string;
+    /**
+     * Maximum age (in seconds) for request timestamps before signature
+     * verification rejects them as replays. Defaults to `300` (5 minutes).
+     */
+    signatureMaxAgeSeconds?: number;
+}
+export declare abstract class SlackConfig implements SlackConfig {
+}
+//# sourceMappingURL=slack.config.d.ts.map

package/dist/slack.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.config.d.ts","sourceRoot":"","sources":["../src/slack.config.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,WAAW;IAC1B,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,aAAa,EAAE,MAAM,CAAC;IACtB,8FAA8F;IAC9F,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;OAGG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,8BACsB,WAAY,YAAW,WAAW;CAAG"}

package/dist/slack.dispatcher.d.ts

@@ -0,0 +1,124 @@
+import { Logger } from '@maroonedsoftware/logger';
+import type { SlackEventCallback, SlackEventHandler } from './slack.event.handler.js';
+import type { SlackCommandHandler, SlackCommandPayload, SlackCommandResponse } from './slack.command.handler.js';
+import { SlackInteractionHandler, type SlackInteractionPayload, type SlackInteractionResponse } from './slack.interaction.handler.js';
+/**
+ * Body shape Slack POSTs to the Events API endpoint. The handshake variant
+ * (`url_verification`) is sent once during app configuration; the rest of the
+ * traffic is `event_callback` envelopes (or other future top-level types).
+ */
+export type SlackEventsRequest = {
+    type: 'url_verification';
+    challenge: string;
+    token?: string;
+} | SlackEventCallback | {
+    type: string;
+    [key: string]: unknown;
+};
+/**
+ * Response Slack expects for the `url_verification` handshake. For
+ * `event_callback` and unknown event types, the dispatcher returns
+ * `undefined` and the caller should ack with HTTP 200.
+ */
+export type SlackEventsResponse = {
+    challenge: string;
+} | undefined;
+/**
+ * Injectable map of command keyword (e.g. `/deploy`) → {@link SlackCommandHandler}.
+ *
+ * @example
+ * ```ts
+ * const commands = new SlackCommandHandlerMap();
+ * commands.set('/deploy', container.get(DeployCommandHandler));
+ * container.register(SlackCommandHandlerMap, { useValue: commands });
+ * ```
+ */
+export declare class SlackCommandHandlerMap extends Map<string, SlackCommandHandler> {
+}
+/**
+ * Injectable map of Slack event type → {@link SlackEventHandler}. Consumers
+ * register handlers at bootstrap and place an instance of this map in their
+ * DI container; {@link SlackDispatcher.dispatchEvent} resolves it per request.
+ *
+ * @example
+ * ```ts
+ * const handlers = new SlackEventHandlerMap();
+ * handlers.set('app_mention', container.get(MyAppMentionHandler));
+ * container.register(SlackEventHandlerMap, { useValue: handlers });
+ * ```
+ */
+export declare class SlackEventHandlerMap extends Map<string, SlackEventHandler> {
+}
+/**
+ * Injectable map of interaction routing keys → {@link SlackInteractionHandler}.
+ *
+ * Keys are produced by `interactionRouteKey(payload)`, which combines the
+ * payload `type` with the relevant identifier (`action_id`, `callback_id`,
+ * etc.). Register handlers under the same key shape:
+ *
+ * @example
+ * ```ts
+ * const interactions = new SlackInteractionHandlerMap();
+ * interactions.set('block_actions:approve_button', container.get(ApproveHandler));
+ * interactions.set('view_submission:create_ticket_modal', container.get(CreateTicketHandler));
+ * container.register(SlackInteractionHandlerMap, { useValue: interactions });
+ * ```
+ */
+export declare class SlackInteractionHandlerMap extends Map<string, SlackInteractionHandler> {
+}
+/**
+ * Single entry point for dispatching parsed Slack payloads to registered
+ * handlers. Transport-agnostic: the consumer is responsible for receiving
+ * the HTTP request, verifying the signature, parsing the body, calling the
+ * appropriate `dispatch*` method, and serializing the response.
+ *
+ * @example Koa route
+ * ```ts
+ * router.post('/slack/events', async (ctx) => {
+ *   const raw = await rawBody(ctx.req, { encoding: 'utf8' });
+ *   verifySlackSignature({
+ *     signingSecret: ctx.container.get(SlackConfig).signingSecret,
+ *     rawBody: raw,
+ *     timestamp: ctx.get('x-slack-request-timestamp'),
+ *     signature: ctx.get('x-slack-signature'),
+ *   });
+ *   const result = await ctx.container.get(SlackDispatcher).dispatchEvent(JSON.parse(raw));
+ *   if (result) ctx.body = result;
+ *   else { ctx.status = 200; ctx.body = ''; }
+ * });
+ * ```
+ */
+export declare class SlackDispatcher {
+    private readonly events;
+    private readonly commands;
+    private readonly interactions;
+    private readonly logger;
+    constructor(events: SlackEventHandlerMap, commands: SlackCommandHandlerMap, interactions: SlackInteractionHandlerMap, logger: Logger);
+    /**
+     * Dispatch a parsed Events API body.
+     *
+     * - Returns `{ challenge }` for `url_verification` — the caller serializes
+     *   it as the response body.
+     * - For `event_callback`, looks up a handler in {@link SlackEventHandlerMap}
+     *   keyed by `event.type` and invokes it. Returns `undefined`. Slack retries
+     *   any non-2xx so unknown event types are logged at debug and acked.
+     * - For any other top-level type, logs and returns `undefined`.
+     */
+    dispatchEvent(body: SlackEventsRequest): Promise<SlackEventsResponse>;
+    /**
+     * Dispatch a parsed slash-command payload.
+     *
+     * Looks up a handler in {@link SlackCommandHandlerMap} keyed by
+     * `payload.command` (e.g. `/deploy`). If the handler returns a response,
+     * the caller serializes it as JSON; otherwise the caller acks with `200 ''`
+     * and the handler is expected to follow up via `payload.response_url`.
+     */
+    dispatchCommand(payload: SlackCommandPayload): Promise<SlackCommandResponse | void>;
+    /**
+     * Dispatch a parsed interactive payload (block actions, view submission,
+     * shortcut, etc.). Computes a routing key via {@link interactionRouteKey}
+     * and looks it up in {@link SlackInteractionHandlerMap}.
+     */
+    dispatchInteraction(payload: SlackInteractionPayload): Promise<SlackInteractionResponse | void>;
+}
+//# sourceMappingURL=slack.dispatcher.d.ts.map

package/dist/slack.dispatcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.dispatcher.d.ts","sourceRoot":"","sources":["../src/slack.dispatcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACtF,OAAO,KAAK,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AACjH,OAAO,EAEL,uBAAuB,EACvB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,gCAAgC,CAAC;AAExC;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAC1B;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,kBAAkB,GAClB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAE7C;;;;GAIG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC;AAEpE;;;;;;;;;GASG;AACH,qBACa,sBAAuB,SAAQ,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC;CAAG;AAE/E;;;;;;;;;;;GAWG;AACH,qBACa,oBAAqB,SAAQ,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC;CAAG;AAE3E;;;;;;;;;;;;;;GAcG;AACH,qBACa,0BAA2B,SAAQ,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC;CAAG;AAEvF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBACa,eAAe;IAExB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IACzB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAHN,MAAM,EAAE,oBAAoB,EAC5B,QAAQ,EAAE,sBAAsB,EAChC,YAAY,EAAE,0BAA0B,EACxC,MAAM,EAAE,MAAM;IAGjC;;;;;;;;;OASG;IACG,aAAa,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAyB3E;;;;;;;OAOG;IACG,eAAe,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,GAAG,IAAI,CAAC;IASzF;;;;OAIG;IACG,mBAAmB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,wBAAwB,GAAG,IAAI,CAAC;CAatG"}