@open-everywhere/provider-slack 0.1.0

package/dist/agent/channels/slack-web-api.js

@@ -0,0 +1,147 @@
+// slack-web-api — THE ONE place a Slack Web API call leaves this host (OPE-1211).
+//
+// WHY THIS MODULE REPLACED eve's `callSlackApi`. Every Slack write used to funnel into
+// `callSlackApi` from `eve/channels/slack`. That primitive is a bare `fetch` POST: it reads no
+// status but the 2xx/non-2xx split, and on a non-2xx it throws a `SlackApiError` carrying
+// `{ method, response, status }` — and NOT the response headers. Slack states a rate-limit delay in
+// the `Retry-After` HEADER and nowhere else, so that delay was unreadable from OE code. Honouring it
+// therefore needs OE to own the request. This module is a faithful port of eve's encoding, token
+// resolution and error posture, with the 429 backoff added around the call.
+//
+// 🔴 WHAT THIS SEAM COVERS, EXACTLY. Every Slack Web API call this repo issues DIRECTLY goes through
+// here: `slackForm`, `callSlackRead`, the `auth.test` identity probes and the wake backscroll. It
+// does NOT cover the calls that ride eve's session BINDING, because those never reach OE code:
+//   • `ctx.slack.request(...)` — slack-context.ts (`auth.test`, `conversations.history`);
+//   • `ctx.thread.postEphemeral(...)` — slack-input-response.ts;
+//   • eve's own machinery — `startTyping`, thread `refresh`, `uploadSlackFiles`.
+// Those resolve through eve's `createSlackRequester`/`postSlackEphemeral` to the same bare
+// `callSlackApi`, so they still fail on the first 429. `slack-web-api-seam-test.ts` holds that list
+// as a KNOWN-UNCOVERED inventory and fails when a NEW bypass appears, which is the honest guarantee:
+// the seam is not universal, but the set of things outside it cannot grow unnoticed.
+//
+// SEMANTICS PORTED VERBATIM from eve's primitive, because callers depend on each one:
+//   • Form encoding. Slack's JSON support is partial (`conversations.replies`/`history` want form),
+//     so form is the only safe default. A null or undefined value is dropped; a string, number or
+//     boolean is stringified; anything else is JSON-encoded.
+//   • Token resolution. An explicit token wins, otherwise `SLACK_BOT_TOKEN`. Neither ⇒ throw
+//     `SLACK_BOT_TOKEN is required.` — the same message and the same fail-loud posture. ONE
+//     DELIBERATE NARROWING: eve's `SlackBotToken` also accepts a function (the secret-manager and
+//     rotation form). No caller in this repo passes one, so this seam takes a string. Widening it
+//     back is a one-line `await` on the resolver if the multi-bot seam ever needs it.
+//   • `ok:false` PASSES THROUGH. Slack answers HTTP 200 with `ok:false` when it read the request and
+//     refused it. That is a successful transport, and the callers classify it themselves
+//     (slack-read.ts marks it not-applied; slack-post-arm.ts reads it as definitive). This module
+//     must never turn it into a throw.
+//   • A non-2xx THROWS {@link SlackWebApiError}. A request that got no usable reply stays ambiguous,
+//     which is what the post spine needs to avoid double-posting.
+//
+// WHAT IS NEW: a 429 is retried after the delay `Retry-After` names, bounded by
+// `channels/rate-limit-retry.js`. When the attempts run out the call throws `RateLimitExhaustedError`
+// — a NAMED failure. Non-429 responses are untouched.
+import { withRetryAfter } from "@open-everywhere/core/agent/adapter-api.js";
+/** Slack's Web API base. A trailing slash is required — `new URL(operation, base)` resolves the
+ *  operation against the LAST path segment otherwise. */
+const SLACK_API_BASE = "https://slack.com/api/";
+/** The failure a non-2xx Slack response produces. Mirrors eve's `SlackApiError` field-for-field, so
+ *  a caller that reads `status` or `response` off a caught error keeps reading the same thing. */
+export class SlackWebApiError extends Error {
+    method;
+    status;
+    response;
+    constructor(init) {
+        super(`Slack ${init.method} returned HTTP ${init.status}`);
+        this.name = "SlackWebApiError";
+        this.method = init.method;
+        this.status = init.status;
+        this.response = init.response;
+    }
+}
+/** Form-encode a Slack request body exactly as eve's `encodeSlackApiBody` does. */
+export function encodeSlackForm(body) {
+    const params = new URLSearchParams();
+    if (body !== null && typeof body === "object" && !Array.isArray(body)) {
+        for (const [key, value] of Object.entries(body)) {
+            if (value === null || value === undefined)
+                continue;
+            const scalar = typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+            params.set(key, scalar ? String(value) : JSON.stringify(value));
+        }
+    }
+    return params.toString();
+}
+/**
+ * Operations that are BEST-EFFORT PROBES on a latency-critical path, and their tightened policy.
+ *
+ * 🔴 WHY THIS EXISTS (OPE-1211 review finding 2). `auth.test` resolves the bot's own identity, and
+ * `slack-front.ts` awaits it BEFORE returning `OK()` on the route Slack posts events to. Slack times
+ * that ack out at 3 seconds and re-delivers; an app that keeps missing the ack gets its event
+ * subscription disabled. Under the shared defaults a workspace-wide 429 — the exact case this whole
+ * change exists for — would block that ack for up to 60 s and turn a rate-limit episode into a
+ * delivery outage. So the probe waits at most about 2 s in total, and its callers already degrade
+ * gracefully when it answers nothing.
+ *
+ * `conversations.info` and `users.info` are here for the same reason (deploy #142 batch review):
+ * the Slack front route awaits both before `OK()` — `channelFactsFor` resolves through
+ * `channelInternalAndMeta` (fails closed to `{internal:false}`) and `authorFactsFor` through
+ * `slackAuthorIsMember` (fails closed to `undefined`) — so the shared 60 s budget would hold the
+ * 3-second ack exactly like `auth.test`.
+ *
+ * `conversations.open` joined them for the SAME two reasons (OPE-1376): a GLOBAL shortcut has no
+ * conversation, so the front route awaits this call to resolve the invoker's DM before it acks, and
+ * `liveOpenDirectMessageChannel` fails closed to `undefined` (the shortcut then wakes nothing and
+ * says so). Slack's interactivity budget is 3 seconds, so the shared policy would hold the ack past
+ * it on a rate-limited workspace. It is NOT here for the governance DM-delivery arm, which makes
+ * the same call off any ack's critical path and is content with the shared budget.
+ *
+ * Only add an operation here if BOTH hold: its caller treats a failure as non-fatal, AND something
+ * time-critical waits on it.
+ *
+ * Every member is pinned by name in `scripts/slack-rate-limit-test.ts` § 4c (OPE-1242): drop one
+ * and it falls back to the shared 4-attempt / 30 s policy, which that suite asserts against.
+ */
+const PROBE_OPERATIONS = new Set(["auth.test", "conversations.info", "users.info", "conversations.open"]);
+const PROBE_MAX_ATTEMPTS = 2;
+const PROBE_CAP_MS = 2_000;
+/** An explicit token, else `SLACK_BOT_TOKEN`. Throws eve's exact message when neither is set. */
+function resolveBotToken(botToken) {
+    const token = botToken ?? process.env.SLACK_BOT_TOKEN;
+    if (!token)
+        throw new Error("SLACK_BOT_TOKEN is required.");
+    return token;
+}
+/**
+ * POST one Slack Web API method, with the 429 backoff applied.
+ *
+ * Returns Slack's parsed JSON envelope on any 2xx, `ok:false` included. Throws
+ * {@link SlackWebApiError} on a non-2xx that is not a 429, and `RateLimitExhaustedError` when a 429
+ * outlasts the bounded attempts.
+ */
+export async function callSlackWebApi(input, deps = {}) {
+    const token = resolveBotToken(input.botToken);
+    const encoded = encodeSlackForm(input.body);
+    const url = new URL(input.operation, deps.apiBase ?? SLACK_API_BASE).toString();
+    const send = () => (deps.fetch ?? globalThis.fetch)(url, {
+        body: encoded,
+        headers: { authorization: `Bearer ${token}`, "content-type": "application/x-www-form-urlencoded" },
+        method: "POST",
+    });
+    const probe = PROBE_OPERATIONS.has(input.operation);
+    const res = await withRetryAfter(send, {
+        surface: "slack",
+        operation: input.operation,
+        // An explicit dep always wins, so a test still drives the policy it wants.
+        maxAttempts: deps.maxAttempts ?? (probe ? PROBE_MAX_ATTEMPTS : undefined),
+        capMs: deps.capMs ?? (probe ? PROBE_CAP_MS : undefined),
+        totalBudgetMs: deps.totalBudgetMs,
+        sleep: deps.sleep,
+        now: deps.now,
+    });
+    // eve parses the body before the status check, so a non-2xx carries Slack's error envelope. Keep
+    // that, and keep the parse failure that a non-JSON body produces — callers already treat any throw
+    // from this seam as an ambiguous transport failure.
+    const json = (await res.json());
+    if (!res.ok)
+        throw new SlackWebApiError({ method: input.operation, status: res.status, response: json });
+    return json;
+}
+//# sourceMappingURL=slack-web-api.js.map

package/dist/agent/channels/slack-web-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-web-api.js","sourceRoot":"","sources":["../../../agent/channels/slack-web-api.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/slack-webhook-verifier.d.ts

@@ -0,0 +1,5 @@
+import { type WebhookVerifier } from "@open-everywhere/core/agent/adapter-api.js";
+/** The registry key — what a generic hook declares as its `source` to be verified as Slack. */
+export declare const SLACK_WEBHOOK_SOURCE = "slack";
+export declare const slackWebhookVerifier: WebhookVerifier;
+//# sourceMappingURL=slack-webhook-verifier.d.ts.map

package/dist/agent/channels/slack-webhook-verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-webhook-verifier.d.ts","sourceRoot":"","sources":["../../../agent/channels/slack-webhook-verifier.ts"],"names":[],"mappings":"AAuDA,OAAO,EAAyB,KAAK,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAEzG,+FAA+F;AAC/F,eAAO,MAAM,oBAAoB,UAAU,CAAC;AA0B5C,eAAO,MAAM,oBAAoB,EAAE,eA+BlC,CAAC"}

package/dist/agent/channels/slack-webhook-verifier.js

@@ -0,0 +1,112 @@
+// Slack's webhook signature scheme, as a registry entry (OPE-197) — what lets a GENERIC hook
+// (`POST /webhooks/<id>`) declare `source: "slack"` and be verified exactly the way Slack signs,
+// instead of the deployment being able to check that signature in the surface front door and
+// nowhere else.
+//
+// WHY THIS EXISTS AT ALL, in the two terms that survive. (1) `registeredWebhookVerifierSources()` is
+// printed VERBATIM in the gate's 401 (webhooks/gate.ts), so it is a live statement to a caller about
+// what this deployment can authenticate — and it was under-reporting a scheme the tree has
+// implemented and tested for as long as the Slack surface has existed. (2) Registration is the only
+// place `keyOrigin` and `signedTimestamp` get DECLARED, and those two fields are what drive
+// `acceptsMintedSecret` (webhooks/source-vocabulary.ts) and the durable single-use replay dedupe
+// (webhooks/replay-dedupe.ts). Inline in a front door, both facts are true of the code and invisible
+// to every registry that reasons about them.
+//
+// ZERO NEW CRYPTO. The basestring and digest are `channels/slack-signature.ts`'s — the SAME
+// primitive the surface front door (`verifySlackSignature`) uses, extracted for this entry rather
+// than copied, so there is one implementation of Slack's scheme in the tree and not two that can
+// drift. What this file adds is the part a registry entry needs and a boolean-returning front door
+// has no use for: the closed FAILURE vocabulary, and iteration over a rotation's key list.
+//
+// THE SCHEME (https://api.slack.com/authentication/verifying-requests-from-slack):
+//   X-Slack-Request-Timestamp: <unix seconds>
+//   X-Slack-Signature:         v0=<hex>   HMAC-SHA256 of `v0:<timestamp>:<raw body>`.
+//
+// 🔴 `keyOrigin: "vendor-issued"` (OPE-186) — the key is the app's **Signing Secret**, which SLACK
+// generates and shows on the app's Basic Information page (docs/deploy/surfaces/slack.md step 1.5:
+// *"copy the Signing Secret"*). It is read, never chosen, so a secret WE minted can never verify a
+// Slack delivery. That is what keeps `slack` OUT of the chat-mintable source vocabulary
+// (`acceptsMintedSecret` is false for it) — only an OPERATOR-DECLARED hook, whose `secretRef` the
+// operator points at the stored signing secret, can use this verifier. Registering it does NOT make
+// it chat-creatable, and that is the intended outcome, not a limitation to be fixed later.
+//
+// ⭐ `signedTimestamp: true` — and this is the substantive gain over leaving it inline. Slack's
+// basestring COVERS the timestamp, so the freshness claim is the sender's own signed one, and this
+// verifier enforces a window against it. Under `webhooks/gate.ts` that promotes the source from
+// "replay bounded by nothing" to the durable single-use 409 (webhooks/replay-dedupe.ts) — the layer
+// `github` and `notion` structurally cannot have, because they sign the body alone.
+//
+// ⚠️ THE SKEW WINDOW HERE IS THE DEPLOYMENT'S, NOT SLACK'S. The front door hard-codes Slack's own
+// documented 5 minutes because it answers a Slack Request URL; this entry reads
+// `webhookMaxSkewSeconds()` (`OE_WEBHOOK_MAX_SKEW_SECONDS`, default 300) because it answers the
+// GENERIC ingress, where an operator's one freshness bound governs every scheme. The two coincide at
+// the default on purpose and are allowed to diverge on purpose.
+//
+// NOTE this entry changes NO existing route. `/eve/v1/slack` and `/eve/v1/slack/commands` keep their
+// own inline gate, unchanged; registering here only makes the scheme available to the generic
+// ingress.
+import { createHash } from "node:crypto";
+import { SLACK_SIGNATURE_HEADER, SLACK_SIGNATURE_VERSION, SLACK_TIMESTAMP_HEADER, slackSignatureMatches, } from "./slack-signature.js";
+import { webhookMaxSkewSeconds } from "@open-everywhere/core/agent/adapter-api.js";
+/** The registry key — what a generic hook declares as its `source` to be verified as Slack. */
+export const SLACK_WEBHOOK_SOURCE = "slack";
+/** Unix seconds, as Slack sends them. Checked as TEXT before `Number()` so `"1e9"`, `" 12"` and
+ *  `"12.0"` are `malformed-timestamp` rather than silently coerced into a passing window. */
+const TIMESTAMP_RE = /^[0-9]{1,15}$/;
+/**
+ * The opaque single-use nonce for an accepted Slack delivery.
+ *
+ * 🔴 IT IS THE SIGNED CONTENT, HASHED — not a delivery id, because Slack's scheme has none: the
+ * basestring is `v0:<timestamp>:<rawBody>` and nothing else, so `(timestamp, rawBody)` IS the
+ * complete identity the sender signed. Two presentations agreeing on both are, to this scheme,
+ * indistinguishable — which is exactly what "the same delivery, twice" means here.
+ *
+ * WHAT THAT COSTS, stated rather than assumed: a byte-identical re-send from Slack inside the window
+ * is graded a replay. That is deliberate and it is nearly free, because a byte-identical re-send
+ * OUTSIDE the window already fails the skew check at 401 — so this dedupe only ever changes the
+ * verdict in the interval where the scheme itself cannot tell a legitimate re-send from a captured
+ * one. Deriving it from the SIGNATURE instead would have been wrong for a different reason: the
+ * signature is key-dependent, so it would change identity across a rotation overlap for a delivery
+ * that never changed.
+ */
+function slackReplayKey(timestamp, rawBody) {
+    return createHash("sha256").update(`${SLACK_WEBHOOK_SOURCE}:${timestamp}:${rawBody}`).digest("hex");
+}
+export const slackWebhookVerifier = {
+    source: SLACK_WEBHOOK_SOURCE,
+    // Provider-owned ⇒ routed through admitProviderRegistration: de-select the slack bundle and this
+    // row never lands, so a `source: "slack"` hook 401s instead of silently using another scheme.
+    provider: "slack",
+    keyKind: "shared-secret",
+    keyOrigin: "vendor-issued",
+    signedTimestamp: true,
+    verify({ rawBody, headers, keys, nowMs }) {
+        const signature = headers.get(SLACK_SIGNATURE_HEADER);
+        if (!signature)
+            return { ok: false, failure: "missing-signature" };
+        const timestamp = headers.get(SLACK_TIMESTAMP_HEADER);
+        // A missing timestamp is its own failure, not `missing-signature`: it is COVERED BY the
+        // signature, so without it there is no basestring to compute at all.
+        if (timestamp === null)
+            return { ok: false, failure: "missing-timestamp" };
+        if (!TIMESTAMP_RE.test(timestamp))
+            return { ok: false, failure: "malformed-timestamp" };
+        // SKEW BEFORE ANY HMAC — a stale replay must not cost a digest per configured key.
+        if (Math.abs(nowMs / 1000 - Number(timestamp)) > webhookMaxSkewSeconds())
+            return { ok: false, failure: "stale-timestamp" };
+        // A signature tagged with a version we do not implement is `unsupported-scheme`, never an
+        // attempted match: if Slack ever ships a `v1`, guessing at it is the shape of a downgrade.
+        if (!signature.startsWith(`${SLACK_SIGNATURE_VERSION}=`))
+            return { ok: false, failure: "unsupported-scheme" };
+        for (const [i, key] of keys.entries()) {
+            // Ordered, current-first: a match at i>0 is a rotation overlap and the gate audits it. Slack
+            // documents no overlap window of its own (rotating the signing secret is immediate), so
+            // `keys[]` is how an operator gets one on our side.
+            if (slackSignatureMatches(key, timestamp, rawBody, signature)) {
+                return { ok: true, keyIndex: i, replayKey: slackReplayKey(timestamp, rawBody) };
+            }
+        }
+        return { ok: false, failure: "signature-mismatch" };
+    },
+};
+//# sourceMappingURL=slack-webhook-verifier.js.map

package/dist/agent/channels/slack-webhook-verifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack-webhook-verifier.js","sourceRoot":"","sources":["../../../agent/channels/slack-webhook-verifier.ts"],"names":[],"mappings":"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"}

package/dist/agent/channels/slack.d.ts

@@ -0,0 +1,37 @@
+import { type SlackContext, type SlackMessage } from "eve/channels/slack";
+import { type OpenEverywhereSlackAuth } from "./slack-identity.js";
+/**
+ * The `chat.postMessage` form body for a channel-supervisor's host-side reply post (OPE-878).
+ *
+ * `deliverSupervisorReply`'s `post` callback bypasses the post-arm registry (slack-post-arm.ts) —
+ * it builds its own `slackForm` call rather than going through `dispatchSlackReply` — so it needs
+ * its OWN `markdownToSlackMrkdwn` conversion at the wire; that seam does not cover it. This is that
+ * ONE conversion point, extracted so a test can drive it without a live Slack call (the closure
+ * above cannot be invoked directly — it captures live session state).
+ */
+export declare function supervisorPostFormBody(channelId: string, threadTs: string | undefined, text: string): string;
+/** What eve's mention/DM hook may return. `null` (={@link DROP}) is the ONLY value that
+ *  dispatches no model turn — see {@link DROP}. */
+type InboundOutcome = {
+    readonly auth: OpenEverywhereSlackAuth | null;
+    readonly context?: readonly string[];
+} | null;
+/**
+ * THE WAKE-ADMISSION CHOKEPOINT for eve's native mention/DM door (OPE-33) — the only thing wired
+ * into `onAppMention`/`onDirectMessage`.
+ *
+ * A returned turn is a spend commitment, so this wrapper enforces the invariant that inspection
+ * kept failing to hold: **nothing is admitted unless the spend gate was consulted for THIS
+ * message**. Fail-CLOSED — an admission with no consult (a future early-return added above the
+ * gate, exactly the shape that broke it) is downgraded to a real DROP and said out loud, rather
+ * than quietly spending. A DROP passes straight through (nothing to gate: no turn, no spend).
+ *
+ * The refusal itself is posted by the gate, so a declined wake is still visible in-thread; this
+ * wrapper only decides whether a MODEL TURN follows.
+ */
+export declare function admitInbound(ctx: SlackContext, message: SlackMessage, isDm: boolean, run?: (consult: {
+    gated: boolean;
+}) => Promise<InboundOutcome>): Promise<InboundOutcome>;
+declare const _default: import("eve/channels/slack").SlackChannel;
+export default _default;
+//# sourceMappingURL=slack.d.ts.map

package/dist/agent/channels/slack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slack.d.ts","sourceRoot":"","sources":["../../../agent/channels/slack.ts"],"names":[],"mappings":"AAkBA,OAAO,EAEL,KAAK,YAAY,EAGjB,KAAK,YAAY,EAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAQL,KAAK,uBAAuB,EAC7B,MAAM,qBAAqB,CAAC;AA4K7B;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAI5G;AA+QD;mDACmD;AACnD,KAAK,cAAc,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,IAAI,CAAC;AA4OrH;;;;;;;;;;;;GAYG;AACH,wBAAsB,YAAY,CAChC,GAAG,EAAE,YAAY,EACjB,OAAO,EAAE,YAAY,EACrB,IAAI,EAAE,OAAO,EACb,GAAG,GAAE,CAAC,OAAO,EAAE;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,KAAK,OAAO,CAAC,cAAc,CAAuD,GAClH,OAAO,CAAC,cAAc,CAAC,CAYzB"}