@pinet/slack-bridge 0.1.0

package/dist/slack-scope-diagnostics.js

@@ -0,0 +1,235 @@
+import { buildSlackRequest } from "./helpers.js";
+const SCOPE_DRIFT_PROBES = [
+    {
+        key: "files_read",
+        surface: "files",
+        method: "files.info",
+        body: { file: "F0000000000" },
+        expectedScopes: ["files:read"],
+        okErrors: ["file_not_found", "invalid_arguments", "channel_canvas_deleted"],
+    },
+    {
+        key: "files_write",
+        surface: "files",
+        method: "files.completeUploadExternal",
+        body: {
+            files: [{ id: "F0000000000", title: "scope-drift-probe" }],
+            channel_id: "C0000000000",
+        },
+        expectedScopes: ["files:write"],
+        okErrors: ["file_not_found", "channel_not_found", "invalid_arguments"],
+    },
+    {
+        key: "bookmarks_read",
+        surface: "bookmarks",
+        method: "bookmarks.list",
+        body: { channel_id: "C0000000000" },
+        expectedScopes: ["bookmarks:read"],
+        okErrors: ["channel_not_found", "invalid_arguments"],
+    },
+    {
+        key: "bookmarks_write",
+        surface: "bookmarks",
+        method: "bookmarks.remove",
+        body: { channel_id: "C0000000000", bookmark_id: "Bk0000000000" },
+        expectedScopes: ["bookmarks:write"],
+        okErrors: ["channel_not_found", "not_found", "invalid_arguments"],
+    },
+    {
+        key: "pins_read",
+        surface: "pins",
+        method: "pins.list",
+        body: { channel: "C0000000000" },
+        expectedScopes: ["pins:read"],
+        okErrors: ["channel_not_found", "invalid_arguments"],
+    },
+    {
+        key: "pins_write",
+        surface: "pins",
+        method: "pins.add",
+        body: { channel: "C0000000000", timestamp: "0" },
+        expectedScopes: ["pins:write"],
+        okErrors: [
+            "channel_not_found",
+            "message_not_found",
+            "file_not_found",
+            "no_item",
+            "invalid_arguments",
+        ],
+    },
+];
+function uniqueSorted(values) {
+    return [...new Set(values)].sort();
+}
+function normalizeScopeList(raw) {
+    if (typeof raw !== "string") {
+        return [];
+    }
+    return uniqueSorted(raw
+        .split(/[\s,]+/)
+        .map((scope) => scope.trim())
+        .filter(Boolean));
+}
+function summarizeUnavailableErrors(results) {
+    const errors = uniqueSorted(results
+        .filter((result) => result.status === "unavailable")
+        .map((result) => `${result.method}: ${result.error ?? "unknown"}`));
+    return errors[0];
+}
+function formatScopeList(scopes) {
+    return scopes.join(", ");
+}
+async function readSlackProbeResult(response) {
+    try {
+        return (await response.json());
+    }
+    catch {
+        return { ok: false, error: `http_${response.status}` };
+    }
+}
+async function runSlackScopeProbe(probe, token, fetchImpl) {
+    const { url, init } = buildSlackRequest(probe.method, token, probe.body);
+    try {
+        const response = await fetchImpl(url, init);
+        if (response.status === 429) {
+            return {
+                key: probe.key,
+                surface: probe.surface,
+                method: probe.method,
+                expectedScopes: probe.expectedScopes,
+                status: "unavailable",
+                missingScopes: [],
+                error: "rate_limited",
+            };
+        }
+        const payload = await readSlackProbeResult(response);
+        if (payload.ok) {
+            return {
+                key: probe.key,
+                surface: probe.surface,
+                method: probe.method,
+                expectedScopes: probe.expectedScopes,
+                status: "ok",
+                missingScopes: [],
+            };
+        }
+        const error = typeof payload.error === "string" ? payload.error : `http_${response.status}`;
+        if (probe.okErrors.includes(error)) {
+            return {
+                key: probe.key,
+                surface: probe.surface,
+                method: probe.method,
+                expectedScopes: probe.expectedScopes,
+                status: "ok",
+                missingScopes: [],
+            };
+        }
+        if (error === "missing_scope" || error === "not_allowed_token_type") {
+            const neededScopes = normalizeScopeList(payload.needed);
+            const providedScopes = normalizeScopeList(payload.provided);
+            return {
+                key: probe.key,
+                surface: probe.surface,
+                method: probe.method,
+                expectedScopes: probe.expectedScopes,
+                status: "missing",
+                missingScopes: neededScopes.length > 0 ? neededScopes : probe.expectedScopes,
+                error,
+                ...(neededScopes.length > 0 ? { neededScopes } : {}),
+                ...(providedScopes.length > 0 ? { providedScopes } : {}),
+            };
+        }
+        return {
+            key: probe.key,
+            surface: probe.surface,
+            method: probe.method,
+            expectedScopes: probe.expectedScopes,
+            status: "unavailable",
+            missingScopes: [],
+            error,
+        };
+    }
+    catch (error) {
+        return {
+            key: probe.key,
+            surface: probe.surface,
+            method: probe.method,
+            expectedScopes: probe.expectedScopes,
+            status: "unavailable",
+            missingScopes: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+export function createUncheckedSlackScopeDiagnostics() {
+    return {
+        status: "not_checked",
+        checkedAt: null,
+        summary: "not checked",
+        surfaces: [],
+        missingScopes: [],
+        results: [],
+    };
+}
+export function createPendingSlackScopeDiagnostics() {
+    return {
+        status: "pending",
+        checkedAt: null,
+        summary: "pending",
+        surfaces: [],
+        missingScopes: [],
+        results: [],
+    };
+}
+export async function detectSlackScopeDiagnostics(options) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const now = options.now ?? (() => new Date().toISOString());
+    const checkedAt = now();
+    const results = await Promise.all(SCOPE_DRIFT_PROBES.map((probe) => runSlackScopeProbe(probe, options.token, fetchImpl)));
+    const missingScopes = uniqueSorted(results.flatMap((result) => (result.status === "missing" ? result.missingScopes : [])));
+    const surfaces = uniqueSorted(results.flatMap((result) => (result.status === "missing" ? [result.surface] : [])));
+    if (missingScopes.length > 0) {
+        return {
+            status: "drift",
+            checkedAt,
+            summary: `scope drift — missing ${formatScopeList(missingScopes)}`,
+            surfaces,
+            missingScopes,
+            results,
+        };
+    }
+    const unavailableError = summarizeUnavailableErrors(results);
+    if (unavailableError) {
+        return {
+            status: "unavailable",
+            checkedAt,
+            summary: `unavailable (${unavailableError})`,
+            surfaces: [],
+            missingScopes: [],
+            results,
+            error: unavailableError,
+        };
+    }
+    return {
+        status: "healthy",
+        checkedAt,
+        summary: "healthy",
+        surfaces: [],
+        missingScopes: [],
+        results,
+    };
+}
+export function formatSlackScopeDiagnosticsStatus(diagnostics) {
+    return diagnostics.summary;
+}
+export function buildSlackScopeDriftWarning(diagnostics) {
+    if (diagnostics.status !== "drift" || diagnostics.missingScopes.length === 0) {
+        return null;
+    }
+    const surfaceSummary = diagnostics.surfaces.length > 0 ? diagnostics.surfaces.join(", ") : "files";
+    return [
+        `Slack scope drift detected: missing ${formatScopeList(diagnostics.missingScopes)}.`,
+        `Affected Slack surfaces: ${surfaceSummary}.`,
+        "Reinstall or reapply the current slack-bridge manifest scopes in Slack, then restart the bridge.",
+    ].join(" ");
+}

package/dist/slack-socket-dedup.d.ts

@@ -0,0 +1,7 @@
+export declare const SLACK_SOCKET_DELIVERY_DEDUP_TTL_MS: number;
+export declare const SLACK_SOCKET_DELIVERY_DEDUP_MAX_SIZE = 10000;
+export declare function extractSlackEventDedupKey(evt: Record<string, unknown>): string | null;
+export declare function extractSlackBlockActionDedupKey(payload: Record<string, unknown>): string | null;
+export declare function extractSlackViewSubmissionDedupKey(payload: Record<string, unknown>): string | null;
+export declare function extractSlackInteractiveDedupKey(payload: Record<string, unknown>): string | null;
+export declare function extractSlackSocketDedupKey(frame: Record<string, unknown>): string | null;

package/dist/slack-socket-dedup.js

@@ -0,0 +1,135 @@
+import { extractSlackInteractivePayloadFromEnvelope } from "./slack-block-kit.js";
+export const SLACK_SOCKET_DELIVERY_DEDUP_TTL_MS = 10 * 60 * 1000;
+export const SLACK_SOCKET_DELIVERY_DEDUP_MAX_SIZE = 10_000;
+function asNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function buildSlackMessageDedupKey(evt) {
+    const channel = asNonEmptyString(evt.channel);
+    const ts = asNonEmptyString(evt.ts);
+    if (!channel || !ts) {
+        return null;
+    }
+    return [
+        "message",
+        channel,
+        asNonEmptyString(evt.thread_ts) ?? "",
+        ts,
+        asNonEmptyString(evt.user) ?? asNonEmptyString(evt.bot_id) ?? "",
+        asNonEmptyString(evt.subtype) ?? "",
+    ].join(":");
+}
+function buildSlackReactionDedupKey(evt) {
+    const item = evt.item;
+    if (!item || item.type !== "message" || !item.channel || !item.ts) {
+        return null;
+    }
+    return [
+        "reaction_added",
+        item.channel,
+        item.ts,
+        asNonEmptyString(evt.user) ?? "",
+        asNonEmptyString(evt.reaction) ?? "",
+        asNonEmptyString(evt.event_ts) ?? "",
+    ].join(":");
+}
+function buildSlackAssistantThreadDedupKey(kind, evt) {
+    const thread = evt.assistant_thread;
+    if (!thread?.channel_id || !thread.thread_ts) {
+        return null;
+    }
+    return [kind, thread.channel_id, thread.thread_ts, thread.user_id ?? ""].join(":");
+}
+function buildMemberJoinedDedupKey(evt) {
+    const channel = asNonEmptyString(evt.channel);
+    const user = asNonEmptyString(evt.user);
+    if (!channel || !user) {
+        return null;
+    }
+    return ["member_joined_channel", channel, user, asNonEmptyString(evt.event_ts) ?? ""].join(":");
+}
+export function extractSlackEventDedupKey(evt) {
+    const type = asNonEmptyString(evt.type);
+    if (!type) {
+        return null;
+    }
+    switch (type) {
+        case "message":
+            return buildSlackMessageDedupKey(evt);
+        case "reaction_added":
+            return buildSlackReactionDedupKey(evt);
+        case "assistant_thread_started":
+            return buildSlackAssistantThreadDedupKey("assistant_thread_started", evt);
+        case "assistant_thread_context_changed":
+            return buildSlackAssistantThreadDedupKey("assistant_thread_context_changed", evt);
+        case "member_joined_channel":
+            return buildMemberJoinedDedupKey(evt);
+        default: {
+            const eventTs = asNonEmptyString(evt.event_ts);
+            return eventTs ? [type, eventTs].join(":") : null;
+        }
+    }
+}
+export function extractSlackBlockActionDedupKey(payload) {
+    if (payload.type !== "block_actions") {
+        return null;
+    }
+    const user = payload.user;
+    const channel = payload.channel;
+    const container = payload.container;
+    const view = payload.view;
+    const actions = Array.isArray(payload.actions)
+        ? payload.actions.filter((action) => typeof action === "object" && action !== null)
+        : [];
+    const actionSignature = actions
+        .map((action) => `${action.action_id ?? ""}@${action.action_ts ?? ""}`)
+        .sort()
+        .join(",");
+    if (!actionSignature) {
+        return null;
+    }
+    const parts = [
+        "block_actions",
+        user?.id ?? "",
+        channel?.id ?? container?.channel_id ?? "",
+        container?.thread_ts ?? "",
+        container?.message_ts ?? "",
+    ];
+    if (view?.id || view?.hash) {
+        parts.push(view?.id ?? "", view?.hash ?? "");
+    }
+    parts.push(actionSignature);
+    return parts.join(":");
+}
+export function extractSlackViewSubmissionDedupKey(payload) {
+    if (payload.type !== "view_submission") {
+        return null;
+    }
+    const user = payload.user;
+    const view = payload.view;
+    if (!view?.id) {
+        return null;
+    }
+    return ["view_submission", user?.id ?? "", view.id, view.hash ?? "", view.callback_id ?? ""].join(":");
+}
+export function extractSlackInteractiveDedupKey(payload) {
+    if (payload.type === "block_actions") {
+        return extractSlackBlockActionDedupKey(payload);
+    }
+    if (payload.type === "view_submission") {
+        return extractSlackViewSubmissionDedupKey(payload);
+    }
+    return null;
+}
+export function extractSlackSocketDedupKey(frame) {
+    if (frame.type === "events_api") {
+        const payload = frame.payload;
+        const eventId = asNonEmptyString(payload?.event_id);
+        if (eventId) {
+            return `event:${eventId}`;
+        }
+        return payload?.event ? extractSlackEventDedupKey(payload.event) : null;
+    }
+    const interactivePayload = extractSlackInteractivePayloadFromEnvelope(frame);
+    return interactivePayload ? extractSlackInteractiveDedupKey(interactivePayload) : null;
+}

package/dist/slack-thread-status.d.ts

@@ -0,0 +1,41 @@
+import type { SlackCall } from "./slack-access.js";
+export declare const SLACK_THREAD_STATUS_HEARTBEAT_MS = 90000;
+export declare const SLACK_THREAD_LOADING_MESSAGES: readonly ["Schlepping...", "Combobulating...", "Vibing...", "Noodling...", "Percolating...", "Ruminating...", "Consulting the void...", "Asking the electrons...", "Reticulating splines...", "Consulting the rubber duck..."];
+export declare const DEFAULT_SLACK_THREAD_STATUS = "is thinking\u2026";
+export declare const SLACK_THREAD_SAFE_STATUSES: readonly ["is thinking…", "Reading context…", "Calling tool…", "Drafting reply…", "Checking Slack…"];
+export interface SlackThreadStatusInput {
+    slack: SlackCall;
+    token: string;
+    channelId: string;
+    threadTs: string;
+    status: string;
+    loadingMessages?: readonly string[];
+}
+export declare function setSlackThreadStatus(input: SlackThreadStatusInput): Promise<void>;
+export interface SlackThreadStatusManagerDeps {
+    slack: SlackCall;
+    getBotToken: () => string;
+    formatError: (error: unknown) => string;
+    setInterval?: typeof setInterval;
+    clearInterval?: typeof clearInterval;
+    heartbeatMs?: number;
+    logger?: Pick<Console, "error">;
+    maxActiveThreads?: number;
+    maxConsecutiveFailures?: number;
+}
+export declare function normalizeSlackThreadStatus(status: string | undefined): string;
+export declare class SlackThreadStatusManager {
+    private readonly deps;
+    private readonly active;
+    constructor(deps: SlackThreadStatusManagerDeps);
+    begin(channelId: string, threadTs: string, status?: string): Promise<void>;
+    update(channelId: string, threadTs: string, status: string, options?: {
+        startHeartbeat?: boolean;
+    }): Promise<void>;
+    clear(channelId: string, threadTs: string): Promise<void>;
+    clearAll(): Promise<void>;
+    private heartbeat;
+    private evictOldestIfNeeded;
+    private stopHeartbeat;
+    private trySet;
+}

package/dist/slack-thread-status.js

@@ -0,0 +1,156 @@
+export const SLACK_THREAD_STATUS_HEARTBEAT_MS = 90_000;
+export const SLACK_THREAD_LOADING_MESSAGES = [
+    "Schlepping...",
+    "Combobulating...",
+    "Vibing...",
+    "Noodling...",
+    "Percolating...",
+    "Ruminating...",
+    "Consulting the void...",
+    "Asking the electrons...",
+    "Reticulating splines...",
+    "Consulting the rubber duck...",
+];
+export const DEFAULT_SLACK_THREAD_STATUS = "is thinking…";
+export const SLACK_THREAD_SAFE_STATUSES = [
+    DEFAULT_SLACK_THREAD_STATUS,
+    "Reading context…",
+    "Calling tool…",
+    "Drafting reply…",
+    "Checking Slack…",
+];
+export async function setSlackThreadStatus(input) {
+    await input.slack("assistant.threads.setStatus", input.token, {
+        channel_id: input.channelId,
+        thread_ts: input.threadTs,
+        status: input.status,
+        ...(input.status.length > 0
+            ? { loading_messages: [...(input.loadingMessages ?? SLACK_THREAD_LOADING_MESSAGES)] }
+            : {}),
+    });
+}
+function statusKey(channelId, threadTs) {
+    return `${channelId}:${threadTs}`;
+}
+export function normalizeSlackThreadStatus(status) {
+    const normalized = (status ?? "")
+        .replace(/[\r\n]+/g, " ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized)
+        return DEFAULT_SLACK_THREAD_STATUS;
+    return (SLACK_THREAD_SAFE_STATUSES.find((candidate) => candidate === normalized) ??
+        DEFAULT_SLACK_THREAD_STATUS);
+}
+export class SlackThreadStatusManager {
+    deps;
+    active = new Map();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async begin(channelId, threadTs, status = DEFAULT_SLACK_THREAD_STATUS) {
+        await this.update(channelId, threadTs, status, { startHeartbeat: true });
+    }
+    async update(channelId, threadTs, status, options = {}) {
+        const normalized = normalizeSlackThreadStatus(status);
+        const key = statusKey(channelId, threadTs);
+        let entry = this.active.get(key);
+        if (!entry) {
+            this.evictOldestIfNeeded();
+            entry = {
+                channelId,
+                threadTs,
+                status: normalized,
+                timer: null,
+                heartbeatInFlight: false,
+                consecutiveFailures: 0,
+            };
+            this.active.set(key, entry);
+        }
+        else {
+            entry.status = normalized;
+        }
+        if (options.startHeartbeat && !entry.timer) {
+            const setIntervalFn = this.deps.setInterval ?? setInterval;
+            entry.timer = setIntervalFn(() => {
+                void this.heartbeat(entry);
+            }, this.deps.heartbeatMs ?? SLACK_THREAD_STATUS_HEARTBEAT_MS);
+        }
+        await this.trySet(entry, normalized);
+    }
+    async clear(channelId, threadTs) {
+        const key = statusKey(channelId, threadTs);
+        const entry = this.active.get(key);
+        if (entry?.timer) {
+            const clearIntervalFn = this.deps.clearInterval ?? clearInterval;
+            clearIntervalFn(entry.timer);
+        }
+        this.active.delete(key);
+        await this.trySet({
+            channelId,
+            threadTs,
+            status: "",
+            timer: null,
+            heartbeatInFlight: false,
+            consecutiveFailures: 0,
+        }, "");
+    }
+    async clearAll() {
+        const entries = [...this.active.values()];
+        for (const entry of entries) {
+            await this.clear(entry.channelId, entry.threadTs);
+        }
+    }
+    async heartbeat(entry) {
+        if (entry.heartbeatInFlight)
+            return;
+        entry.heartbeatInFlight = true;
+        try {
+            await this.trySet(entry, entry.status);
+        }
+        finally {
+            entry.heartbeatInFlight = false;
+        }
+    }
+    evictOldestIfNeeded() {
+        const maxActiveThreads = this.deps.maxActiveThreads ?? 100;
+        if (this.active.size < maxActiveThreads)
+            return;
+        const oldest = this.active.entries().next().value;
+        if (!oldest)
+            return;
+        const [key, entry] = oldest;
+        if (entry.timer) {
+            const clearIntervalFn = this.deps.clearInterval ?? clearInterval;
+            clearIntervalFn(entry.timer);
+        }
+        this.active.delete(key);
+    }
+    stopHeartbeat(entry) {
+        if (entry.timer) {
+            const clearIntervalFn = this.deps.clearInterval ?? clearInterval;
+            clearIntervalFn(entry.timer);
+            entry.timer = null;
+        }
+        this.active.delete(statusKey(entry.channelId, entry.threadTs));
+    }
+    async trySet(entry, status) {
+        try {
+            await setSlackThreadStatus({
+                slack: this.deps.slack,
+                token: this.deps.getBotToken(),
+                channelId: entry.channelId,
+                threadTs: entry.threadTs,
+                status,
+            });
+            entry.consecutiveFailures = 0;
+        }
+        catch (error) {
+            entry.consecutiveFailures += 1;
+            (this.deps.logger ?? console).error(`[slack-bridge] Slack thread status update failed: ${this.deps.formatError(error)}`);
+            if (status && entry.consecutiveFailures >= (this.deps.maxConsecutiveFailures ?? 3)) {
+                this.stopHeartbeat(entry);
+            }
+        }
+    }
+}

package/dist/slack-tool-policy-runtime.d.ts

@@ -0,0 +1,36 @@
+import type { InboxMessage } from "./helpers.js";
+type SlackToolPolicyMessageRef = Pick<InboxMessage, "threadTs"> & Partial<Pick<InboxMessage, "channel">>;
+import { type SecurityGuardrails } from "./guardrails.js";
+export interface SlackToolPolicyRuntimeDeps {
+    getBrokerRole: () => "broker" | "follower" | null;
+    getGuardrails: () => SecurityGuardrails;
+    requireToolPolicy: (toolName: string, threadTs: string | undefined, action: string) => void;
+    formatAction: (action: string) => string;
+    formatError: (error: unknown) => string;
+    deliverFollowUpMessage: (prompt: string) => boolean;
+    beginThreadStatus?: (channel: string, threadTs: string, status: string) => Promise<void>;
+    updateThreadStatus?: (channel: string, threadTs: string, status: string) => Promise<void>;
+    clearThreadStatus?: (channel: string, threadTs: string) => Promise<void>;
+}
+export interface SlackToolPolicyRuntime {
+    deliverTrackedSlackFollowUpMessage: (options: {
+        prompt: string;
+        messages: SlackToolPolicyMessageRef[];
+    }) => boolean;
+    onInput: (event: {
+        source?: string;
+        text: string;
+    }) => Promise<void>;
+    onTurnStart: () => Promise<void>;
+    onTurnEnd: () => Promise<void>;
+    onAgentEnd: () => Promise<void>;
+    onToolCall: (event: {
+        toolName: string;
+        input: Record<string, unknown>;
+    }) => Promise<{
+        block: true;
+        reason: string;
+    } | undefined>;
+}
+export declare function createSlackToolPolicyRuntime(deps: SlackToolPolicyRuntimeDeps): SlackToolPolicyRuntime;
+export {};