@crewhaus/channel-adapter-slack 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -88,14 +88,59 @@ export type ParsedInbound = {
 } | {
     readonly kind: "skip";
 };
+/**
+ * An UNSIGNED, GET-based subscription handshake — the shape Meta (WhatsApp)
+ * uses to verify a callback URL before it will deliver any webhook. There is
+ * no body and no HMAC header to check, so the gateway cannot route it through
+ * `verify()`/`parseInbound()`; instead the platform proves itself with a
+ * shared verify token carried in the query string.
+ *
+ * The gateway hands the parsed request URL (query string included) plus the
+ * headers; the adapter decides. Slack and Discord verify inside a signed POST
+ * body (`{kind:"challenge"}` from `parseInbound`) and leave `handshake`
+ * undefined — for them the gateway's behaviour is unchanged.
+ */
+export type HandshakeRequest = {
+    readonly headers: Headers;
+    readonly url: URL;
+};
+/**
+ * `{kind:"challenge"}` ⇒ the gateway echoes `challenge` back with 200; any
+ * other outcome ⇒ 403. An adapter that cannot authenticate the caller (bad
+ * token, missing params, or no verify token configured on this daemon) MUST
+ * return `{kind:"reject"}` — echoing an unauthenticated challenge would let
+ * anyone bind their own Meta app to this daemon's callback URL.
+ */
+export type HandshakeResult = {
+    readonly kind: "challenge";
+    readonly challenge: string;
+} | {
+    readonly kind: "reject";
+};
 export interface ChannelAdapter {
     readonly id: string;
     verify(req: RawRequest): boolean;
     parseInbound(req: RawRequest): ParsedInbound;
+    /**
+     * Answer an unsigned GET subscription handshake (Meta's `hub.challenge`
+     * flow). Optional — adapters whose platform has no such handshake leave it
+     * undefined and the gateway falls through to the normal signed path.
+     */
+    handshake?(req: HandshakeRequest): HandshakeResult;
+    /**
+     * D40 — post the reply; when the channel API returns a post receipt, the
+     * adapter surfaces the posted message's ts as `{ messageTs }` so the
+     * generated session-router can append its outbound-ts reaction join
+     * (exact-turn 👍/👎 attribution). Resolving void stays legal — an adapter
+     * without a receipt simply produces no join line, and reactions on its
+     * replies take the router's per-key fallback.
+     */
     sendReply(args: {
         event: InboundEvent;
         text: string;
-    }): Promise<void>;
+    }): Promise<{
+        messageTs?: string;
+    } | void>;
     setTyping(args: {
         event: InboundEvent;
     }): Promise<void>;

package/dist/index.js

@@ -171,6 +171,10 @@ export function createSlackAdapter(config, opts = {}) {
                 if (body.ok === false) {
                     throw new SlackAdapterError(`chat.postMessage error: ${body.error ?? "unknown"}`);
                 }
+                // D40 — surface the posted message's ts (mirroring postApproval's
+                // receipt) so the session-router can record the outbound-ts → turn
+                // join for exact-turn reaction attribution.
+                return typeof body.ts === "string" ? { messageTs: body.ts } : undefined;
             }
         },
         async setTyping(_args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crewhaus/channel-adapter-slack",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "type": "module",
   "description": "Slack channel adapter: webhook signature verification, event parsing, reply-to-thread (Section 12)",
   "main": "dist/index.js",
@@ -15,7 +15,7 @@
     "test": "bun test src"
   },
   "dependencies": {
-    "@crewhaus/errors": "0.4.0"
+    "@crewhaus/errors": "0.4.2"
   },
   "license": "Apache-2.0",
   "author": {