@cuylabs/channel-slack 0.5.0 → 0.6.0

package/dist/{chunk-CMR6B76C.js → chunk-DNVSH7H5.js}

@@ -651,6 +651,406 @@ function createSlackMessagePolicyResolver(config = {}) {
   };
 }
 
+// src/policy/thread-participation.ts
+var DEFAULT_MAX_THREADS = 1e4;
+var DEFAULT_POSTGRES_TABLE = "channel_slack_thread_participation";
+var DEFAULT_POSTGRES_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var DEFAULT_POSTGRES_PRUNE_BATCH_SIZE = 1e3;
+var DEFAULT_POSTGRES_PRUNE_INTERVAL_MS = 6 * 60 * 60 * 1e3;
+function resolveSlackThreadParticipationEligibility({
+  activity,
+  policy,
+  stateStore
+}) {
+  if (!stateStore) {
+    return { available: false, reason: "state-store-unavailable" };
+  }
+  if (activity.channelType === "dm") {
+    return { available: false, reason: "direct-message" };
+  }
+  if (activity.channelType !== "channel" && activity.channelType !== "thread") {
+    return { available: false, reason: "unsupported-channel-type" };
+  }
+  if (policy.messagePolicy !== "mentioned-threads") {
+    return {
+      available: false,
+      reason: "message-policy-not-mentioned-threads"
+    };
+  }
+  if (policy.threadReplyPolicy === "mention-required") {
+    return {
+      available: false,
+      reason: "thread-replies-require-mention"
+    };
+  }
+  const threadTs = activity.threadTs ?? activity.messageTs;
+  if (!threadTs) {
+    return { available: false, reason: "missing-thread-timestamp" };
+  }
+  return {
+    available: true,
+    threadKey: createSlackMessagePolicyThreadKey(activity),
+    threadTs
+  };
+}
+function createInMemorySlackThreadParticipationStateStore({
+  maxThreads = DEFAULT_MAX_THREADS,
+  now = () => /* @__PURE__ */ new Date()
+} = {}) {
+  const states = /* @__PURE__ */ new Map();
+  const order = [];
+  const resolvedMaxThreads = Math.max(1, maxThreads);
+  function rememberKey(key) {
+    if (!states.has(key)) {
+      order.push(key);
+    }
+    while (order.length > resolvedMaxThreads) {
+      const oldest = order.shift();
+      if (oldest !== void 0) {
+        states.delete(oldest);
+      }
+    }
+  }
+  return {
+    async get(key) {
+      return states.get(key);
+    },
+    async setQuiet(key, state) {
+      rememberKey(key);
+      states.set(key, {
+        ...state,
+        mode: "quiet",
+        updatedAt: now().toISOString()
+      });
+    },
+    async clear(key) {
+      states.delete(key);
+      const index = order.indexOf(key);
+      if (index >= 0) {
+        order.splice(index, 1);
+      }
+    },
+    async prune() {
+      return { quietThreadsDeleted: 0 };
+    }
+  };
+}
+function createPostgresSlackThreadParticipationStateStore({
+  client,
+  connectionString,
+  ensureSchema = true,
+  onPruneError,
+  pruneBatchSize = DEFAULT_POSTGRES_PRUNE_BATCH_SIZE,
+  pruneIntervalMs = DEFAULT_POSTGRES_PRUNE_INTERVAL_MS,
+  retentionMs = DEFAULT_POSTGRES_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  let activeClient = client;
+  let ownsClient = false;
+  let initialized;
+  let pruneTimer;
+  async function getClient() {
+    if (activeClient) {
+      return activeClient;
+    }
+    if (!connectionString) {
+      throw new Error(
+        "connectionString is required when a Postgres Slack thread participation client is not provided"
+      );
+    }
+    const Pool = await importPostgresPoolConstructor2();
+    activeClient = new Pool({ connectionString });
+    ownsClient = true;
+    return activeClient;
+  }
+  async function ensureInitialized() {
+    const currentClient = await getClient();
+    initialized ??= initializePostgresSlackThreadParticipationState({
+      client: currentClient,
+      ensureSchema,
+      schema,
+      tableName
+    });
+    await initialized;
+    startPruneTimer();
+    return currentClient;
+  }
+  function startPruneTimer() {
+    if (pruneTimer || pruneIntervalMs <= 0) {
+      return;
+    }
+    pruneTimer = setInterval(() => {
+      void prune().catch((error) => {
+        onPruneError?.(error);
+      });
+    }, pruneIntervalMs);
+    pruneTimer.unref?.();
+  }
+  async function prune() {
+    const currentClient = await ensureInitialized();
+    return prunePostgresSlackThreadParticipationState({
+      client: currentClient,
+      pruneBatchSize,
+      retentionMs,
+      schema,
+      tableName
+    });
+  }
+  return {
+    async get(key) {
+      const currentClient = await ensureInitialized();
+      const result = await currentClient.query(
+        `SELECT
+          mode,
+          reason,
+          source_message_ts,
+          updated_at,
+          updated_by_user_id
+        FROM ${qualifiedTableName2({ schema, tableName })}
+        WHERE key = $1::text`,
+        [key]
+      );
+      const row = result.rows[0];
+      if (!row || row.mode !== "quiet") {
+        return void 0;
+      }
+      return {
+        mode: "quiet",
+        ...row.reason ? { reason: row.reason } : {},
+        ...row.source_message_ts ? { sourceMessageTs: row.source_message_ts } : {},
+        updatedAt: row.updated_at instanceof Date ? row.updated_at.toISOString() : String(row.updated_at),
+        ...row.updated_by_user_id ? { updatedByUserId: row.updated_by_user_id } : {}
+      };
+    },
+    async setQuiet(key, state, context) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `INSERT INTO ${qualifiedTableName2({ schema, tableName })} (
+          key,
+          team_id,
+          channel_id,
+          thread_ts,
+          mode,
+          reason,
+          updated_by_user_id,
+          source_message_ts,
+          updated_at
+        )
+        VALUES ($1::text, $2::text, $3::text, $4::text, 'quiet', $5::text, $6::text, $7::text, now())
+        ON CONFLICT (key) DO UPDATE SET
+          team_id = EXCLUDED.team_id,
+          channel_id = EXCLUDED.channel_id,
+          thread_ts = EXCLUDED.thread_ts,
+          mode = 'quiet',
+          reason = EXCLUDED.reason,
+          updated_by_user_id = EXCLUDED.updated_by_user_id,
+          source_message_ts = EXCLUDED.source_message_ts,
+          updated_at = now()`,
+        [
+          key,
+          context.activity.teamId ?? null,
+          context.activity.channelId,
+          context.activity.threadTs ?? context.activity.messageTs ?? null,
+          state.reason ?? null,
+          state.updatedByUserId ?? null,
+          state.sourceMessageTs ?? context.activity.messageTs ?? null
+        ]
+      );
+    },
+    async clear(key) {
+      const currentClient = await ensureInitialized();
+      await currentClient.query(
+        `DELETE FROM ${qualifiedTableName2({ schema, tableName })}
+        WHERE key = $1::text`,
+        [key]
+      );
+    },
+    prune,
+    async close() {
+      if (pruneTimer) {
+        clearInterval(pruneTimer);
+        pruneTimer = void 0;
+      }
+      if (ownsClient) {
+        await activeClient?.end?.();
+      }
+    }
+  };
+}
+async function initializePostgresSlackThreadParticipationState({
+  client,
+  ensureSchema = true,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  if (schema && ensureSchema) {
+    await client.query(
+      `CREATE SCHEMA IF NOT EXISTS ${quoteIdentifier2(schema)}`
+    );
+  }
+  const table = qualifiedTableName2({ schema, tableName });
+  await client.query(`
+    CREATE TABLE IF NOT EXISTS ${table} (
+      key text PRIMARY KEY,
+      team_id text,
+      channel_id text NOT NULL,
+      thread_ts text,
+      mode text NOT NULL CHECK (mode IN ('quiet')),
+      reason text,
+      updated_by_user_id text,
+      source_message_ts text,
+      updated_at timestamptz NOT NULL DEFAULT now()
+    )
+  `);
+  const indexPrefix = slackThreadParticipationIndexPrefix({
+    schema,
+    tableName
+  });
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier2(
+      `${indexPrefix}_updated_idx`
+    )} ON ${table} (updated_at DESC)`
+  );
+  await client.query(
+    `CREATE INDEX IF NOT EXISTS ${quoteIdentifier2(
+      `${indexPrefix}_channel_thread_idx`
+    )} ON ${table} (channel_id, thread_ts)`
+  );
+}
+async function prunePostgresSlackThreadParticipationState({
+  client,
+  pruneBatchSize = DEFAULT_POSTGRES_PRUNE_BATCH_SIZE,
+  retentionMs = DEFAULT_POSTGRES_RETENTION_MS,
+  schema,
+  tableName = DEFAULT_POSTGRES_TABLE
+}) {
+  if (retentionMs <= 0) {
+    return { quietThreadsDeleted: 0 };
+  }
+  const batchSize = Math.max(1, Math.floor(pruneBatchSize));
+  const table = qualifiedTableName2({ schema, tableName });
+  const result = await client.query(
+    `WITH expired AS (
+      SELECT key
+      FROM ${table}
+      WHERE updated_at < now() - ($1::bigint * interval '1 millisecond')
+      ORDER BY updated_at ASC
+      LIMIT $2::integer
+    )
+    DELETE FROM ${table} target
+    USING expired
+    WHERE target.key = expired.key`,
+    [Math.max(1, Math.floor(retentionMs)), batchSize]
+  );
+  return { quietThreadsDeleted: result.rowCount ?? 0 };
+}
+function qualifiedTableName2({
+  schema,
+  tableName
+}) {
+  return schema ? `${quoteIdentifier2(schema)}.${quoteIdentifier2(tableName)}` : quoteIdentifier2(tableName);
+}
+function quoteIdentifier2(value) {
+  return `"${value.replace(/"/g, '""')}"`;
+}
+function slackThreadParticipationIndexPrefix({
+  schema,
+  tableName
+}) {
+  const raw = [schema, tableName].filter(Boolean).join("_");
+  return raw.replace(/[^A-Za-z0-9_]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "channel_slack_thread_participation";
+}
+async function importPostgresPoolConstructor2() {
+  const dynamicImport = new Function(
+    "specifier",
+    "return import(specifier)"
+  );
+  try {
+    const pg = await dynamicImport("pg");
+    return pg.Pool;
+  } catch (error) {
+    throw new Error(
+      `The "pg" package is required when using connectionString with createPostgresSlackThreadParticipationStateStore. Install pg or pass a client. ${formatImportError2(
+        error
+      )}`
+    );
+  }
+}
+function formatImportError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/policy/thread-message-policy.ts
+function createAsyncSlackThreadAwareMessagePolicyResolver(config = {}) {
+  const { threadParticipationStore, ...messagePolicyConfig } = config;
+  const resolver = createAsyncSlackMessagePolicyResolver(messagePolicyConfig);
+  async function resolve(activity) {
+    const threadParticipation = await resolveThreadParticipationState({
+      activity,
+      config,
+      stateStore: threadParticipationStore
+    });
+    if (threadParticipation?.quiet) {
+      if (!activity.isMention) {
+        return {
+          accepted: false,
+          activity,
+          reason: "quiet-thread",
+          threadKey: threadParticipation.key,
+          ...threadParticipation.reason ? { threadParticipationReason: threadParticipation.reason } : {},
+          ...threadParticipation.threadTs ? { threadTs: threadParticipation.threadTs } : {}
+        };
+      }
+      await threadParticipationStore?.clear(threadParticipation.key, {
+        activity,
+        key: threadParticipation.key
+      });
+    }
+    const decision = await resolver.resolve(activity);
+    if (!threadParticipation?.quiet || !activity.isMention) {
+      return decision;
+    }
+    return {
+      ...decision,
+      reactivatedThreadParticipation: {
+        threadKey: threadParticipation.key,
+        ...threadParticipation.reason ? { reason: threadParticipation.reason } : {},
+        ...threadParticipation.threadTs ? { threadTs: threadParticipation.threadTs } : {}
+      }
+    };
+  }
+  return {
+    resolve,
+    async resolveMessage(activity) {
+      const decision = await resolve(activity);
+      return decision.accepted ? decision.text : void 0;
+    }
+  };
+}
+async function resolveThreadParticipationState({
+  activity,
+  config,
+  stateStore
+}) {
+  const eligibility = resolveSlackThreadParticipationEligibility({
+    activity,
+    policy: config,
+    stateStore
+  });
+  if (!eligibility.available || !eligibility.threadKey || !stateStore) {
+    return void 0;
+  }
+  const key = eligibility.threadKey;
+  const state = await stateStore.get(key, { activity, key });
+  return state?.mode === "quiet" ? {
+    key,
+    quiet: true,
+    ...state.reason ? { reason: state.reason } : {},
+    ...eligibility.threadTs ? { threadTs: eligibility.threadTs } : {}
+  } : void 0;
+}
+
 export {
   createSlackMessagePolicyMessageKey,
   createSlackMessagePolicyThreadKey,
@@ -660,5 +1060,11 @@ export {
   initializePostgresSlackMessagePolicyState,
   prunePostgresSlackMessagePolicyState,
   shouldRegisterSlackPassiveChannelMessages,
-  createSlackMessagePolicyResolver
+  createSlackMessagePolicyResolver,
+  resolveSlackThreadParticipationEligibility,
+  createInMemorySlackThreadParticipationStateStore,
+  createPostgresSlackThreadParticipationStateStore,
+  initializePostgresSlackThreadParticipationState,
+  prunePostgresSlackThreadParticipationState,
+  createAsyncSlackThreadAwareMessagePolicyResolver
 };

package/dist/chunk-QJYCHWN6.js

@@ -0,0 +1,76 @@
+import {
+  normalizeSlackEventsPath,
+  resolveDirectAuth,
+  trimToUndefined
+} from "./chunk-S3SWPYXJ.js";
+
+// src/transports/http/bolt-app.ts
+async function createSlackBoltApp(options = {}) {
+  const boltModule = await import("@slack/bolt");
+  const routePath = normalizeSlackEventsPath(options.path ?? "/slack/events");
+  const signingSecret = trimToUndefined(
+    options.signingSecret ?? process.env.SLACK_SIGNING_SECRET
+  );
+  if (!signingSecret) {
+    throw new Error(
+      "Slack signing secret is required. Pass `signingSecret` or set SLACK_SIGNING_SECRET."
+    );
+  }
+  const auth = resolveDirectAuth(options);
+  const receiver = new boltModule.ExpressReceiver({
+    ...options.receiverOptions,
+    signingSecret,
+    endpoints: routePath,
+    processBeforeResponse: options.processBeforeResponse,
+    signatureVerification: options.signatureVerification,
+    // Bolt is typed against Express 4 while this repo uses Express 5 types.
+    // The runtime contract is compatible; keep the cast localized here.
+    app: options.app,
+    ...auth.mode === "oauth" ? {
+      clientId: auth.clientId,
+      clientSecret: auth.clientSecret,
+      stateSecret: auth.stateSecret,
+      installationStore: auth.installationStore,
+      redirectUri: auth.redirectUri,
+      scopes: auth.scopes,
+      installerOptions: {
+        stateStore: auth.stateStore,
+        stateVerification: auth.stateVerification,
+        legacyStateVerification: auth.legacyStateVerification,
+        stateCookieName: auth.stateCookieName,
+        stateCookieExpirationSeconds: auth.stateCookieExpirationSeconds,
+        metadata: auth.metadata,
+        userScopes: auth.userScopes,
+        installPath: auth.installPath,
+        redirectUriPath: auth.callbackPath,
+        renderHtmlForInstallPath: auth.renderHtmlForInstallPath,
+        installPathOptions: auth.installPathOptions,
+        callbackOptions: auth.callbackOptions,
+        directInstall: auth.directInstall,
+        authVersion: auth.authVersion,
+        authorizationUrl: auth.authorizationUrl
+      }
+    } : {}
+  });
+  const boltApp = new boltModule.App({
+    ...options.boltAppOptions,
+    receiver,
+    ...auth.mode === "single-workspace" ? {
+      token: auth.botToken,
+      botId: auth.botId,
+      botUserId: auth.botUserId
+    } : {},
+    ...auth.mode === "authorize" ? { authorize: auth.authorize } : {}
+  });
+  return {
+    boltApp,
+    receiver,
+    app: options.app ?? receiver.app,
+    authMode: auth.mode,
+    routePath
+  };
+}
+
+export {
+  createSlackBoltApp
+};

package/dist/chunk-S3SWPYXJ.js

@@ -0,0 +1,81 @@
+// src/auth/resolve.ts
+function resolveDirectAuth(options) {
+  const provided = options.auth;
+  if (!provided || provided.mode === void 0 || provided.mode === "single-workspace") {
+    const singleWorkspace = provided;
+    const botToken = firstNonEmptyString(
+      singleWorkspace?.botToken,
+      options.botToken,
+      process.env.SLACK_BOT_TOKEN
+    );
+    if (!botToken) {
+      throw new Error(
+        'Slack bot token is required for single-workspace mode. Pass `botToken`, use `auth: { mode: "oauth", ... }`, or use `auth: { mode: "authorize", ... }`.'
+      );
+    }
+    return {
+      mode: "single-workspace",
+      botToken,
+      botId: singleWorkspace?.botId,
+      botUserId: singleWorkspace?.botUserId
+    };
+  }
+  if (provided.mode === "authorize") {
+    return provided;
+  }
+  const oauth = provided;
+  const clientId = firstNonEmptyString(
+    oauth.clientId,
+    process.env.SLACK_CLIENT_ID
+  );
+  const clientSecret = firstNonEmptyString(
+    oauth.clientSecret,
+    process.env.SLACK_CLIENT_SECRET
+  );
+  if (!clientId || !clientSecret) {
+    throw new Error(
+      "Slack OAuth mode requires `clientId` and `clientSecret` or SLACK_CLIENT_ID / SLACK_CLIENT_SECRET."
+    );
+  }
+  if (oauth.stateVerification !== false && !trimToUndefined(oauth.stateSecret) && !oauth.stateStore && !trimToUndefined(process.env.SLACK_STATE_SECRET)) {
+    throw new Error(
+      "Slack OAuth mode requires `stateSecret` or a custom `stateStore` when state verification is enabled."
+    );
+  }
+  return {
+    ...oauth,
+    mode: "oauth",
+    clientId,
+    clientSecret,
+    stateSecret: firstNonEmptyString(
+      oauth.stateSecret,
+      process.env.SLACK_STATE_SECRET
+    )
+  };
+}
+function normalizeSlackEventsPath(path) {
+  const trimmed = path.trim();
+  if (!trimmed) {
+    throw new Error("Slack events path must not be empty.");
+  }
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function trimToUndefined(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+function firstNonEmptyString(...values) {
+  for (const value of values) {
+    const trimmed = trimToUndefined(value);
+    if (trimmed) {
+      return trimmed;
+    }
+  }
+  return void 0;
+}
+
+export {
+  resolveDirectAuth,
+  normalizeSlackEventsPath,
+  trimToUndefined
+};

package/dist/{chunk-JZG4IETE.js → chunk-X4WBBBYM.js}

@@ -1,53 +1,3 @@
-// src/shared/formatting.ts
-function resolveSlackMessageFormatter(options) {
-  if (options.formatMessageText) {
-    return options.formatMessageText;
-  }
-  if (options.formatChatMarkdown === false) {
-    return identity;
-  }
-  return markdownToSlackMrkdwn;
-}
-function markdownToSlackMrkdwn(markdown) {
-  if (!markdown) {
-    return markdown;
-  }
-  const fences = [];
-  const withoutFences = markdown.replace(
-    /```[^\n`]*\n([\s\S]*?)```/g,
-    (_match, code) => {
-      const index = fences.push(`\`\`\`
-${code}\`\`\``) - 1;
-      return `@@SLACK_FENCE_${index}@@`;
-    }
-  );
-  const boldSegments = [];
-  const withBoldPlaceholders = withoutFences.split("\n").map(formatMarkdownLine).join("\n").replace(/\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g, "<$2|$1>").replace(/\*\*([^*\n]+)\*\*/g, (_match, text) => {
-    const index = boldSegments.push(`*${text}*`) - 1;
-    return `@@SLACK_BOLD_${index}@@`;
-  }).replace(/__([^_\n]+)__/g, (_match, text) => {
-    const index = boldSegments.push(`*${text}*`) - 1;
-    return `@@SLACK_BOLD_${index}@@`;
-  });
-  const converted = withBoldPlaceholders.replace(
-    /(^|[\s([{"'])\*([^*\n][^*\n]*?)\*(?=[\s.,;:!?)}\]'"]|$)/g,
-    "$1_$2_"
-  );
-  return converted.replace(/@@SLACK_BOLD_(\d+)@@/g, (_match, rawIndex) => {
-    const index = Number(rawIndex);
-    return boldSegments[index] ?? "";
-  }).replace(/@@SLACK_FENCE_(\d+)@@/g, (_match, rawIndex) => {
-    const index = Number(rawIndex);
-    return fences[index] ?? "";
-  });
-}
-function formatMarkdownLine(line) {
-  return line.replace(/^(\s*)#{1,6}\s+(.+?)\s*#*\s*$/, "$1**$2**");
-}
-function identity(text) {
-  return text;
-}
-
 // src/shared/turn-context.ts
 import { AsyncLocalStorage } from "async_hooks";
 var store = new AsyncLocalStorage();
@@ -132,8 +82,6 @@ function resolveThreadAwareSlackSessionId(info) {
 }
 
 export {
-  resolveSlackMessageFormatter,
-  markdownToSlackMrkdwn,
   currentSlackTurnContext,
   runWithSlackTurnContext,
   formatSlackAttributedFollowUp,

package/dist/core.js

@@ -1,11 +1,13 @@
 import {
   currentSlackTurnContext,
   formatSlackAttributedFollowUp,
-  markdownToSlackMrkdwn,
-  resolveSlackMessageFormatter,
   resolveThreadAwareSlackSessionId,
   runWithSlackTurnContext
-} from "./chunk-JZG4IETE.js";
+} from "./chunk-X4WBBBYM.js";
+import {
+  markdownToSlackMrkdwn,
+  resolveSlackMessageFormatter
+} from "./chunk-6WHFQUYQ.js";
 import {
   extractSlackActionToken,
   extractSlackAuthContext,