@cuylabs/channel-slack 0.4.0 → 0.5.0

package/dist/{chunk-FX2JOVX5.js → chunk-IDVDMJ5U.js}

@@ -200,6 +200,48 @@ async function inspectSlackTokenScopes(options = {}) {
     errors
   };
 }
+function normalizeSlackAuthTestIdentity(payload) {
+  const record = readRecord(payload);
+  const identity = {};
+  const url = readString(record?.url);
+  const team = readString(record?.team);
+  const teamId = readString(record?.team_id) ?? readString(record?.teamId);
+  const userId = readString(record?.user_id) ?? readString(record?.userId);
+  const botUserId = readString(record?.botUserId) ?? userId;
+  const botId = readString(record?.bot_id) ?? readString(record?.botId);
+  if (url) identity.url = url;
+  if (team) identity.team = team;
+  if (teamId) identity.teamId = teamId;
+  if (userId) identity.userId = userId;
+  if (botUserId) identity.botUserId = botUserId;
+  if (botId) identity.botId = botId;
+  return identity;
+}
+function compareSlackIdentity(identity, expected) {
+  const mismatches = [];
+  addIdentityMismatch(mismatches, {
+    actual: identity.teamId,
+    expected: expected.teamId,
+    field: "teamId",
+    label: "team"
+  });
+  addIdentityMismatch(mismatches, {
+    actual: identity.botUserId ?? identity.userId,
+    expected: expected.botUserId,
+    field: "botUserId",
+    label: "bot user"
+  });
+  addIdentityMismatch(mismatches, {
+    actual: identity.botId,
+    expected: expected.botId,
+    field: "botId",
+    label: "bot"
+  });
+  return mismatches;
+}
+function formatSlackIdentityMismatches(mismatches) {
+  return mismatches.map((mismatch) => mismatch.message);
+}
 async function resolveDiagnosticsClient(options) {
   const explicitToken = normalizeToken(options.token);
   if (options.client) {
@@ -398,8 +440,227 @@ function readBoolean(value) {
 function elapsed(startedAt) {
   return Date.now() - startedAt;
 }
+function addIdentityMismatch(mismatches, {
+  actual,
+  expected,
+  field,
+  label
+}) {
+  if (!expected || expected === actual) {
+    return;
+  }
+  mismatches.push({
+    actual,
+    expected,
+    field,
+    label,
+    message: `Expected Slack ${label} identity ${expected}, but the token resolved ${actual ?? "no value"}`
+  });
+}
+
+// src/diagnostics/payload-debug.ts
+function summarizeSlackPayloadDebug({
+  rawArgs,
+  slackActivity,
+  threadContext
+}) {
+  const selectedRawArgs = selectSlackRawArgsForDebug(rawArgs);
+  return {
+    slackActivity: redactSlackDebugValue(slackActivity),
+    threadContext: redactSlackDebugValue(threadContext),
+    rawArgs: redactSlackDebugValue(selectedRawArgs),
+    rawArgsKeyPaths: collectJsonKeyPaths(selectedRawArgs),
+    rawArgsActionTokenPaths: findJsonKeyPaths(
+      selectedRawArgs,
+      (key) => ["action_token", "actiontoken"].includes(key.toLowerCase())
+    ),
+    rawArgsTokenLikePaths: findJsonKeyPaths(
+      selectedRawArgs,
+      (key) => key.toLowerCase().includes("token")
+    )
+  };
+}
+function selectSlackRawArgsForDebug(rawArgs) {
+  const raw = rawArgs;
+  return {
+    body: selectSlackBodyForDebug(raw?.body),
+    payload: raw?.payload,
+    event: raw?.event,
+    message: raw?.message,
+    context: raw?.context
+  };
+}
+function selectSlackBodyForDebug(body) {
+  const raw = body;
+  return {
+    type: raw?.type,
+    team_id: raw?.team_id,
+    enterprise_id: raw?.enterprise_id,
+    api_app_id: raw?.api_app_id,
+    event: raw?.event,
+    event_id: raw?.event_id,
+    event_time: raw?.event_time,
+    event_context: raw?.event_context
+  };
+}
+function redactSlackDebugValue(value, depth = 0) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    return { type: "string", length: value.length };
+  }
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return {
+      type: "array",
+      length: value.length,
+      sample: value.slice(0, 3).map((entry) => redactSlackDebugValue(entry, depth + 1))
+    };
+  }
+  if (typeof value !== "object") {
+    return { type: typeof value };
+  }
+  const entries = Object.entries(value);
+  if (depth >= 4) {
+    return {
+      type: "object",
+      keys: entries.map(([key]) => key)
+    };
+  }
+  return Object.fromEntries(
+    entries.map(([key, entry]) => [
+      key,
+      redactSlackDebugEntry(key, entry, depth)
+    ])
+  );
+}
+function collectJsonKeyPaths(value) {
+  return collectJsonKeyPathsInternal(value, {
+    maxDepth: 7,
+    maxPaths: 300
+  });
+}
+function findJsonKeyPaths(value, predicate) {
+  return collectJsonKeyPathsInternal(value, {
+    maxDepth: 8,
+    maxPaths: 100,
+    predicate
+  });
+}
+function redactSlackDebugEntry(key, value, depth) {
+  const normalized = key.toLowerCase();
+  if (normalized.includes("token") || normalized.includes("secret") || normalized.includes("authorization") || normalized.includes("password")) {
+    return {
+      present: typeof value === "string" ? value.length > 0 : value !== void 0,
+      redacted: true
+    };
+  }
+  if (normalized === "text" || normalized === "markdown_text") {
+    return {
+      type: typeof value,
+      length: typeof value === "string" ? value.length : void 0,
+      redacted: true
+    };
+  }
+  if (typeof value === "string" && STRUCTURAL_SLACK_DEBUG_KEYS.has(normalized)) {
+    return value;
+  }
+  return redactSlackDebugValue(value, depth + 1);
+}
+var STRUCTURAL_SLACK_DEBUG_KEYS = /* @__PURE__ */ new Set([
+  "app_id",
+  "api_app_id",
+  "bot_id",
+  "botid",
+  "channel",
+  "channel_id",
+  "channelid",
+  "channel_type",
+  "channeltype",
+  "enterprise_id",
+  "enterpriseid",
+  "event_ts",
+  "eventts",
+  "messagets",
+  "team",
+  "team_id",
+  "teamid",
+  "thread_ts",
+  "threadts",
+  "ts",
+  "type",
+  "subtype",
+  "user",
+  "user_id",
+  "userid"
+]);
+function collectJsonKeyPathsInternal(value, {
+  maxDepth,
+  maxPaths,
+  predicate
+}) {
+  const paths = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  function visit(current, prefix, depth) {
+    if (paths.length >= maxPaths || current === null || current === void 0) {
+      return;
+    }
+    if (typeof current !== "object") {
+      return;
+    }
+    if (seen.has(current)) {
+      return;
+    }
+    seen.add(current);
+    if (Array.isArray(current)) {
+      if (current.length === 0) {
+        const path = `${prefix}[]`;
+        if (!predicate) {
+          paths.push(path);
+        }
+        return;
+      }
+      if (depth >= maxDepth) {
+        return;
+      }
+      for (const entry of current.slice(0, 3)) {
+        visit(entry, `${prefix}[]`, depth + 1);
+      }
+      return;
+    }
+    if (depth >= maxDepth) {
+      return;
+    }
+    for (const [key, entry] of Object.entries(
+      current
+    )) {
+      if (paths.length >= maxPaths) {
+        return;
+      }
+      const path = prefix ? `${prefix}.${key}` : key;
+      if (!predicate || predicate(key)) {
+        paths.push(path);
+      }
+      visit(entry, path, depth + 1);
+    }
+  }
+  visit(value, "", 0);
+  return paths;
+}
 
 export {
   inspectSlackConnection,
-  inspectSlackTokenScopes
+  inspectSlackTokenScopes,
+  normalizeSlackAuthTestIdentity,
+  compareSlackIdentity,
+  formatSlackIdentityMismatches,
+  summarizeSlackPayloadDebug,
+  selectSlackRawArgsForDebug,
+  selectSlackBodyForDebug,
+  redactSlackDebugValue,
+  collectJsonKeyPaths,
+  findJsonKeyPaths
 };

package/dist/diagnostics.d.ts

@@ -1,105 +1,22 @@
-type SlackScopeInspectionMethod = "auth.test" | "auth.scopes" | "apps.permissions.info";
-type SlackConnectionInspectionFindingSeverity = "info" | "warning" | "error";
-type SlackTokenSource = "provided" | "environment" | "client" | "none";
-interface SlackDiagnosticsClient {
-    auth: {
-        test(args?: {
-            token?: string;
-        }): Promise<unknown>;
-    };
-    apiCall(method: string, args?: Record<string, unknown>): Promise<unknown>;
-}
-interface SlackApiInspectionError {
-    message: string;
-    code?: string;
-    method?: string;
-    needed?: string;
-    providedScopes?: string[];
-    acceptedScopes?: string[];
-    statusCode?: number;
-}
-interface SlackScopeInspectionMethodError {
-    method: SlackScopeInspectionMethod;
-    error: SlackApiInspectionError;
-}
-interface SlackScopeInspection {
-    ok: boolean;
-    scopes: string[];
-    source?: SlackScopeInspectionMethod;
-    errors: SlackScopeInspectionMethodError[];
-}
-interface SlackConnectionInspectionFinding {
-    severity: SlackConnectionInspectionFindingSeverity;
-    code: string;
-    message: string;
-}
-interface SlackConnectionAuthInfo {
-    ok: boolean;
-    url?: string;
-    team?: string;
-    teamId?: string;
-    user?: string;
-    userId?: string;
-    botId?: string;
-    enterpriseId?: string;
-    isEnterpriseInstall?: boolean;
-}
-interface SlackConnectionInspection {
-    ok: boolean;
-    tokenSource: SlackTokenSource;
-    elapsedMs: number;
-    auth?: SlackConnectionAuthInfo;
-    scopes?: SlackScopeInspection;
-    requiredScopes: string[];
-    optionalScopes: string[];
-    missingRequiredScopes: string[];
-    missingOptionalScopes: string[];
-    findings: SlackConnectionInspectionFinding[];
-    error?: SlackApiInspectionError;
-}
-interface InspectSlackTokenScopesOptions {
-    /**
-     * Slack bot or user OAuth token. When omitted, the injected client is used
-     * as-is and no token override is passed to Slack API calls.
-     */
-    token?: string;
-    /** Inject a preconfigured Slack Web API client, useful for OAuth stores/tests. */
-    client?: SlackDiagnosticsClient;
-    /**
-     * Maximum time for each Slack API request in milliseconds. Set `0` to
-     * disable the local timeout wrapper.
-     *
-     * @default 2500
-     */
-    requestTimeoutMs?: number;
-    /**
-     * Scope-bearing methods to try in order.
-     *
-     * @default ["auth.test", "auth.scopes", "apps.permissions.info"]
-     */
-    methods?: readonly SlackScopeInspectionMethod[];
-}
-interface InspectSlackConnectionOptions extends Omit<InspectSlackTokenScopesOptions, "methods"> {
-    /**
-     * Slack OAuth scopes that must be present for this installation to be
-     * considered usable by the caller.
-     */
-    requiredScopes?: readonly string[];
-    /**
-     * Slack OAuth scopes that are useful but not mandatory. Missing optional
-     * scopes are returned as warnings.
-     */
-    optionalScopes?: readonly string[];
-    /**
-     * Whether to inspect token scopes after `auth.test` succeeds.
-     *
-     * @default true
-     */
-    inspectScopes?: boolean;
-    /** Override the scope-inspection method order. */
-    scopeMethods?: readonly SlackScopeInspectionMethod[];
-}
-declare function inspectSlackConnection(options?: InspectSlackConnectionOptions): Promise<SlackConnectionInspection>;
-declare function inspectSlackTokenScopes(options?: InspectSlackTokenScopesOptions): Promise<SlackScopeInspection>;
+export { I as InspectSlackConnectionOptions, a as InspectSlackTokenScopesOptions, S as SlackApiInspectionError, b as SlackAuthTestIdentity, c as SlackConnectionInspection, d as SlackConnectionInspectionFinding, e as SlackConnectionInspectionFindingSeverity, f as SlackDiagnosticsClient, g as SlackIdentityExpectations, h as SlackIdentityMismatch, i as SlackScopeInspection, j as SlackScopeInspectionMethod, k as SlackScopeInspectionMethodError, l as SlackTokenSource, m as compareSlackIdentity, n as formatSlackIdentityMismatches, o as inspectSlackConnection, p as inspectSlackTokenScopes, q as normalizeSlackAuthTestIdentity } from './inspect-BpY5JA0K.js';
+
+interface SlackPayloadDebugSummary {
+    rawArgs: unknown;
+    rawArgsActionTokenPaths: string[];
+    rawArgsKeyPaths: string[];
+    rawArgsTokenLikePaths: string[];
+    slackActivity: unknown;
+    threadContext: unknown;
+}
+declare function summarizeSlackPayloadDebug({ rawArgs, slackActivity, threadContext, }: {
+    rawArgs?: unknown;
+    slackActivity: unknown;
+    threadContext: unknown;
+}): SlackPayloadDebugSummary;
+declare function selectSlackRawArgsForDebug(rawArgs: unknown): unknown;
+declare function selectSlackBodyForDebug(body: unknown): unknown;
+declare function redactSlackDebugValue(value: unknown, depth?: number): unknown;
+declare function collectJsonKeyPaths(value: unknown): string[];
+declare function findJsonKeyPaths(value: unknown, predicate: (key: string) => boolean): string[];
 
-export { type InspectSlackConnectionOptions, type InspectSlackTokenScopesOptions, type SlackApiInspectionError, type SlackConnectionInspection, type SlackConnectionInspectionFinding, type SlackConnectionInspectionFindingSeverity, type SlackDiagnosticsClient, type SlackScopeInspection, type SlackScopeInspectionMethod, type SlackScopeInspectionMethodError, type SlackTokenSource, inspectSlackConnection, inspectSlackTokenScopes };
+export { type SlackPayloadDebugSummary, collectJsonKeyPaths, findJsonKeyPaths, redactSlackDebugValue, selectSlackBodyForDebug, selectSlackRawArgsForDebug, summarizeSlackPayloadDebug };

package/dist/diagnostics.js

@@ -1,8 +1,26 @@
 import {
+  collectJsonKeyPaths,
+  compareSlackIdentity,
+  findJsonKeyPaths,
+  formatSlackIdentityMismatches,
   inspectSlackConnection,
-  inspectSlackTokenScopes
-} from "./chunk-FX2JOVX5.js";
+  inspectSlackTokenScopes,
+  normalizeSlackAuthTestIdentity,
+  redactSlackDebugValue,
+  selectSlackBodyForDebug,
+  selectSlackRawArgsForDebug,
+  summarizeSlackPayloadDebug
+} from "./chunk-IDVDMJ5U.js";
 export {
+  collectJsonKeyPaths,
+  compareSlackIdentity,
+  findJsonKeyPaths,
+  formatSlackIdentityMismatches,
   inspectSlackConnection,
-  inspectSlackTokenScopes
+  inspectSlackTokenScopes,
+  normalizeSlackAuthTestIdentity,
+  redactSlackDebugValue,
+  selectSlackBodyForDebug,
+  selectSlackRawArgsForDebug,
+  summarizeSlackPayloadDebug
 };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { S as SlackActivityInfo, a as SlackChannelType, b as SlackUserIdentity } from './activity-ByrD9Ftr.js';
 export { ExtractSlackMessageTextOptions, RawSlackActionTokenPayload, RawSlackAppMentionPayload, RawSlackAssistantThreadPayload, RawSlackMessagePayload, SlackAmbientTurnContext, SlackApprovalRequest, SlackAssistantStatusUpdate, SlackAssistantSuggestedPrompt, SlackAssistantSuggestedPrompts, SlackAssistantTaskDisplayMode, SlackAssistantThreadContext, SlackAssistantUtilities, SlackAuthContext, SlackChatStreamStartArgs, SlackEventInteractiveRequestHandler, SlackHumanInputRequest, SlackInteractiveMessage, SlackInteractiveMessageRef, SlackInteractiveRequest, SlackInteractiveRequestBaseContext, SlackInteractiveRequestContext, SlackInteractiveRequestHandler, SlackInteractiveRequestKind, SlackInteractiveResponder, SlackMessageAuthorshipOptions, SlackMessageFormatter, SlackMessageFormattingOptions, SlackMessageTextPayload, SlackThreadStatusSetter, SlackTurnPreparation, SlackTurnRequestContext, currentSlackTurnContext, extractSlackActionToken, extractSlackAttachmentsText, extractSlackAuthContext, extractSlackBlocksText, extractSlackMessageText, extractSlackUserIdentity, formatSlackAttributedFollowUp, isProcessableMessage, markdownToSlackMrkdwn, parseSlackMentionActivity, parseSlackMessageActivity, resolveSlackChannelType, resolveSlackMessageFormatter, resolveThreadAwareSlackSessionId, runWithSlackTurnContext, stripLeadingMentions } from './core.js';
-export { SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackSyncMessagePolicyStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, shouldRegisterSlackPassiveChannelMessages } from './policy.js';
+export { PostgresSlackMessagePolicyPruneResult, PostgresSlackMessagePolicyStateStore, PostgresSlackMessagePolicyStateStoreOptions, SlackAsyncMessagePolicyConfig, SlackAsyncMessagePolicyResolver, SlackChannelMessagePolicy, SlackMentionedThreadState, SlackMessagePolicyAcceptReason, SlackMessagePolicyAcceptedDecision, SlackMessagePolicyConfig, SlackMessagePolicyDecision, SlackMessagePolicyPostgresClient, SlackMessagePolicyRejectReason, SlackMessagePolicyRejectedDecision, SlackMessagePolicyResolver, SlackMessagePolicyStateContext, SlackMessagePolicyStateStore, SlackSyncMessagePolicyStateStore, SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages } from './policy.js';
 export { L as Logger } from './logging-Bl3HfcC8.js';

package/dist/index.js

@@ -25,14 +25,18 @@ import {
 import {
   createAsyncSlackMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createPostgresSlackMessagePolicyStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
+  initializePostgresSlackMessagePolicyState,
+  prunePostgresSlackMessagePolicyState,
   shouldRegisterSlackPassiveChannelMessages
-} from "./chunk-BODPT4I6.js";
+} from "./chunk-CMR6B76C.js";
 export {
   createAsyncSlackMessagePolicyResolver,
   createInMemorySlackMessagePolicyStateStore,
+  createPostgresSlackMessagePolicyStateStore,
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyResolver,
   createSlackMessagePolicyThreadKey,
@@ -44,10 +48,12 @@ export {
   extractSlackMessageText,
   extractSlackUserIdentity,
   formatSlackAttributedFollowUp,
+  initializePostgresSlackMessagePolicyState,
   isProcessableMessage,
   markdownToSlackMrkdwn,
   parseSlackMentionActivity,
   parseSlackMessageActivity,
+  prunePostgresSlackMessagePolicyState,
   resolveSlackChannelType,
   resolveSlackMessageFormatter,
   resolveThreadAwareSlackSessionId,

package/dist/inspect-BpY5JA0K.d.ts

@@ -0,0 +1,128 @@
+type SlackScopeInspectionMethod = "auth.test" | "auth.scopes" | "apps.permissions.info";
+type SlackConnectionInspectionFindingSeverity = "info" | "warning" | "error";
+type SlackTokenSource = "provided" | "environment" | "client" | "none";
+interface SlackDiagnosticsClient {
+    auth: {
+        test(args?: {
+            token?: string;
+        }): Promise<unknown>;
+    };
+    apiCall(method: string, args?: Record<string, unknown>): Promise<unknown>;
+}
+interface SlackApiInspectionError {
+    message: string;
+    code?: string;
+    method?: string;
+    needed?: string;
+    providedScopes?: string[];
+    acceptedScopes?: string[];
+    statusCode?: number;
+}
+interface SlackScopeInspectionMethodError {
+    method: SlackScopeInspectionMethod;
+    error: SlackApiInspectionError;
+}
+interface SlackScopeInspection {
+    ok: boolean;
+    scopes: string[];
+    source?: SlackScopeInspectionMethod;
+    errors: SlackScopeInspectionMethodError[];
+}
+interface SlackConnectionInspectionFinding {
+    severity: SlackConnectionInspectionFindingSeverity;
+    code: string;
+    message: string;
+}
+interface SlackConnectionAuthInfo {
+    ok: boolean;
+    url?: string;
+    team?: string;
+    teamId?: string;
+    user?: string;
+    userId?: string;
+    botId?: string;
+    enterpriseId?: string;
+    isEnterpriseInstall?: boolean;
+}
+interface SlackAuthTestIdentity {
+    botId?: string;
+    botUserId?: string;
+    team?: string;
+    teamId?: string;
+    url?: string;
+    userId?: string;
+}
+interface SlackIdentityExpectations {
+    botId?: string;
+    botUserId?: string;
+    teamId?: string;
+}
+interface SlackIdentityMismatch {
+    actual?: string;
+    expected: string;
+    field: "botId" | "botUserId" | "teamId";
+    label: string;
+    message: string;
+}
+interface SlackConnectionInspection {
+    ok: boolean;
+    tokenSource: SlackTokenSource;
+    elapsedMs: number;
+    auth?: SlackConnectionAuthInfo;
+    scopes?: SlackScopeInspection;
+    requiredScopes: string[];
+    optionalScopes: string[];
+    missingRequiredScopes: string[];
+    missingOptionalScopes: string[];
+    findings: SlackConnectionInspectionFinding[];
+    error?: SlackApiInspectionError;
+}
+interface InspectSlackTokenScopesOptions {
+    /**
+     * Slack bot or user OAuth token. When omitted, the injected client is used
+     * as-is and no token override is passed to Slack API calls.
+     */
+    token?: string;
+    /** Inject a preconfigured Slack Web API client, useful for OAuth stores/tests. */
+    client?: SlackDiagnosticsClient;
+    /**
+     * Maximum time for each Slack API request in milliseconds. Set `0` to
+     * disable the local timeout wrapper.
+     *
+     * @default 2500
+     */
+    requestTimeoutMs?: number;
+    /**
+     * Scope-bearing methods to try in order.
+     *
+     * @default ["auth.test", "auth.scopes", "apps.permissions.info"]
+     */
+    methods?: readonly SlackScopeInspectionMethod[];
+}
+interface InspectSlackConnectionOptions extends Omit<InspectSlackTokenScopesOptions, "methods"> {
+    /**
+     * Slack OAuth scopes that must be present for this installation to be
+     * considered usable by the caller.
+     */
+    requiredScopes?: readonly string[];
+    /**
+     * Slack OAuth scopes that are useful but not mandatory. Missing optional
+     * scopes are returned as warnings.
+     */
+    optionalScopes?: readonly string[];
+    /**
+     * Whether to inspect token scopes after `auth.test` succeeds.
+     *
+     * @default true
+     */
+    inspectScopes?: boolean;
+    /** Override the scope-inspection method order. */
+    scopeMethods?: readonly SlackScopeInspectionMethod[];
+}
+declare function inspectSlackConnection(options?: InspectSlackConnectionOptions): Promise<SlackConnectionInspection>;
+declare function inspectSlackTokenScopes(options?: InspectSlackTokenScopesOptions): Promise<SlackScopeInspection>;
+declare function normalizeSlackAuthTestIdentity(payload: unknown): SlackAuthTestIdentity;
+declare function compareSlackIdentity(identity: SlackAuthTestIdentity, expected: SlackIdentityExpectations): SlackIdentityMismatch[];
+declare function formatSlackIdentityMismatches(mismatches: readonly SlackIdentityMismatch[]): string[];
+
+export { type InspectSlackConnectionOptions as I, type SlackApiInspectionError as S, type InspectSlackTokenScopesOptions as a, type SlackAuthTestIdentity as b, type SlackConnectionInspection as c, type SlackConnectionInspectionFinding as d, type SlackConnectionInspectionFindingSeverity as e, type SlackDiagnosticsClient as f, type SlackIdentityExpectations as g, type SlackIdentityMismatch as h, type SlackScopeInspection as i, type SlackScopeInspectionMethod as j, type SlackScopeInspectionMethodError as k, type SlackTokenSource as l, compareSlackIdentity as m, formatSlackIdentityMismatches as n, inspectSlackConnection as o, inspectSlackTokenScopes as p, normalizeSlackAuthTestIdentity as q };

package/dist/policy.d.ts

@@ -118,6 +118,52 @@ declare function createAsyncSlackMessagePolicyResolver(config?: SlackAsyncMessag
 declare function createSlackMessagePolicyMessageKey(activity: SlackActivityInfo): string | undefined;
 declare function createSlackMessagePolicyThreadKey(activity: SlackActivityInfo): string;
 
+interface SlackMessagePolicyPostgresClient {
+    end?: () => Promise<void>;
+    query<T = unknown>(sql: string, values?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount?: number | null;
+    }>;
+}
+interface PostgresSlackMessagePolicyStateStoreOptions {
+    acceptedMessageRetentionMs?: number;
+    acceptedMessagesTableName?: string;
+    client?: SlackMessagePolicyPostgresClient;
+    connectionString?: string;
+    ensureSchema?: boolean;
+    mentionedThreadRetentionMs?: number;
+    mentionedThreadsTableName?: string;
+    onPruneError?: (error: unknown) => void;
+    pruneBatchSize?: number;
+    pruneIntervalMs?: number;
+    schema?: string;
+}
+interface PostgresSlackMessagePolicyStateStore extends SlackMessagePolicyStateStore {
+    close(): Promise<void>;
+    prune(): Promise<PostgresSlackMessagePolicyPruneResult>;
+}
+interface PostgresSlackMessagePolicyPruneResult {
+    acceptedMessagesDeleted: number;
+    mentionedThreadsDeleted: number;
+}
+declare function createPostgresSlackMessagePolicyStateStore({ acceptedMessageRetentionMs, acceptedMessagesTableName, client, connectionString, ensureSchema, mentionedThreadRetentionMs, mentionedThreadsTableName, onPruneError, pruneBatchSize, pruneIntervalMs, schema, }: PostgresSlackMessagePolicyStateStoreOptions): PostgresSlackMessagePolicyStateStore;
+declare function initializePostgresSlackMessagePolicyState({ acceptedMessagesTableName, client, ensureSchema, mentionedThreadsTableName, schema, }: {
+    acceptedMessagesTableName?: string;
+    client: SlackMessagePolicyPostgresClient;
+    ensureSchema?: boolean;
+    mentionedThreadsTableName?: string;
+    schema?: string;
+}): Promise<void>;
+declare function prunePostgresSlackMessagePolicyState({ acceptedMessageRetentionMs, acceptedMessagesTableName, client, mentionedThreadRetentionMs, mentionedThreadsTableName, pruneBatchSize, schema, }: {
+    acceptedMessageRetentionMs?: number;
+    acceptedMessagesTableName?: string;
+    client: SlackMessagePolicyPostgresClient;
+    mentionedThreadRetentionMs?: number;
+    mentionedThreadsTableName?: string;
+    pruneBatchSize?: number;
+    schema?: string;
+}): Promise<PostgresSlackMessagePolicyPruneResult>;
+
 declare function shouldRegisterSlackPassiveChannelMessages(config?: SlackMessagePolicyConfig): boolean;
 
 declare function createSlackMessagePolicyResolver(config?: SlackMessagePolicyConfig): SlackMessagePolicyResolver;
@@ -127,4 +173,4 @@ declare function createInMemorySlackMessagePolicyStateStore({ maxAcceptedMessage
     maxMentionedThreads?: number;
 }): SlackSyncMessagePolicyStateStore;
 
-export { type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackSyncMessagePolicyStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, shouldRegisterSlackPassiveChannelMessages };
+export { type PostgresSlackMessagePolicyPruneResult, type PostgresSlackMessagePolicyStateStore, type PostgresSlackMessagePolicyStateStoreOptions, type SlackAsyncMessagePolicyConfig, type SlackAsyncMessagePolicyResolver, type SlackChannelMessagePolicy, type SlackMentionedThreadState, type SlackMessagePolicyAcceptReason, type SlackMessagePolicyAcceptedDecision, type SlackMessagePolicyConfig, type SlackMessagePolicyDecision, type SlackMessagePolicyPostgresClient, type SlackMessagePolicyRejectReason, type SlackMessagePolicyRejectedDecision, type SlackMessagePolicyResolver, type SlackMessagePolicyStateContext, type SlackMessagePolicyStateStore, type SlackSyncMessagePolicyStateStore, type SlackThreadReplyPolicy, createAsyncSlackMessagePolicyResolver, createInMemorySlackMessagePolicyStateStore, createPostgresSlackMessagePolicyStateStore, createSlackMessagePolicyMessageKey, createSlackMessagePolicyResolver, createSlackMessagePolicyThreadKey, initializePostgresSlackMessagePolicyState, prunePostgresSlackMessagePolicyState, shouldRegisterSlackPassiveChannelMessages };