@cuylabs/channel-slack 0.5.0 → 0.6.0

package/dist/{assistant.js → assistant/index.js}

@@ -1,10 +1,10 @@
 import {
   extractSlackActionToken
-} from "./chunk-TWJGVDA2.js";
+} from "../chunk-TWJGVDA2.js";
 import {
   resolveSlackChannelType,
   stripLeadingMentions
-} from "./chunk-FPCE5V5Y.js";
+} from "../chunk-FPCE5V5Y.js";
 
 // src/assistant/thread-context-store.ts
 var ASSISTANT_THREAD_CONTEXT_EVENT_TYPE = "assistant_thread_context";

package/dist/auth/index.d.ts

@@ -0,0 +1,56 @@
+import { e as SlackDirectAuthOptions, i as SlackOAuthAuthOptions, c as SlackCustomAuthorizeAuthOptions, h as SlackInstallationStore, f as SlackInstallation, g as SlackInstallationQuery, S as SlackAuthorizeFn } from '../types-B9NfCVrk.js';
+export { a as SlackAuthorizeResult, b as SlackAuthorizeSource, d as SlackDirectAuthMode, j as SlackOAuthCallbackOptions, k as SlackOAuthError, l as SlackOAuthInstallPathOptions, m as SlackSingleWorkspaceAuthOptions, n as SlackStateStore } from '../types-B9NfCVrk.js';
+import 'node:http';
+
+/**
+ * Auth-mode resolver for direct Slack Bolt helpers.
+ *
+ * Picks between single-workspace, OAuth, and custom-authorize modes from the
+ * caller's auth options, validating env-var fallbacks and
+ * returning a normalized shape consumable by the Bolt `ExpressReceiver` /
+ * `App` constructors.
+ */
+
+interface ResolveDirectAuthOptions {
+    auth?: SlackDirectAuthOptions;
+    botToken?: string;
+}
+type ResolvedSingleWorkspaceAuth = {
+    mode: "single-workspace";
+    botToken: string;
+    botId?: string;
+    botUserId?: string;
+};
+type ResolvedOAuthAuth = SlackOAuthAuthOptions & {
+    mode: "oauth";
+    clientId: string;
+    clientSecret: string;
+};
+type ResolvedDirectAuth = ResolvedSingleWorkspaceAuth | ResolvedOAuthAuth | SlackCustomAuthorizeAuthOptions;
+declare function resolveDirectAuth(options: ResolveDirectAuthOptions): ResolvedDirectAuth;
+declare function normalizeSlackEventsPath(path: string): string;
+declare function trimToUndefined(value: string | undefined): string | undefined;
+
+declare class InMemorySlackInstallationStore implements SlackInstallationStore {
+    private devDB;
+    storeInstallation(installation: SlackInstallation): Promise<void>;
+    fetchInstallation(query: SlackInstallationQuery): Promise<SlackInstallation>;
+    deleteInstallation(query: SlackInstallationQuery): Promise<void>;
+}
+declare function createInMemorySlackInstallationStore(): SlackInstallationStore;
+declare class JsonFileSlackInstallationStore implements SlackInstallationStore {
+    private readonly filePath;
+    private pending;
+    constructor(filePath: string);
+    storeInstallation(installation: SlackInstallation): Promise<void>;
+    fetchInstallation(query: SlackInstallationQuery): Promise<SlackInstallation>;
+    deleteInstallation(query: SlackInstallationQuery): Promise<void>;
+    private withLock;
+    private readInstallations;
+    private writeInstallations;
+}
+declare function createJsonFileSlackInstallationStore(filePath: string): SlackInstallationStore;
+declare function createSlackInstallationStoreAuthorize(store: SlackInstallationStore): SlackAuthorizeFn;
+declare function getSlackInstallationKey(input: SlackInstallation | SlackInstallationQuery): string;
+
+export { InMemorySlackInstallationStore, JsonFileSlackInstallationStore, type ResolveDirectAuthOptions, type ResolvedDirectAuth, type ResolvedOAuthAuth, type ResolvedSingleWorkspaceAuth, SlackAuthorizeFn, SlackCustomAuthorizeAuthOptions, SlackDirectAuthOptions, SlackInstallation, SlackInstallationQuery, SlackInstallationStore, SlackOAuthAuthOptions, createInMemorySlackInstallationStore, createJsonFileSlackInstallationStore, createSlackInstallationStoreAuthorize, getSlackInstallationKey, normalizeSlackEventsPath, resolveDirectAuth, trimToUndefined };

package/dist/auth/index.js

@@ -0,0 +1,168 @@
+import {
+  normalizeSlackEventsPath,
+  resolveDirectAuth,
+  trimToUndefined
+} from "../chunk-S3SWPYXJ.js";
+
+// src/auth/installation-store.ts
+import fs from "fs/promises";
+import { dirname } from "path";
+var InMemorySlackInstallationStore = class {
+  devDB = {};
+  async storeInstallation(installation) {
+    const key = getSlackInstallationKey(installation);
+    this.devDB[key] = installation;
+  }
+  async fetchInstallation(query) {
+    const key = getSlackInstallationKey(query);
+    const installation = this.devDB[key];
+    if (!installation) {
+      throw new Error(`No Slack installation found for key: ${key}`);
+    }
+    return installation;
+  }
+  async deleteInstallation(query) {
+    const key = getSlackInstallationKey(query);
+    delete this.devDB[key];
+  }
+};
+function createInMemorySlackInstallationStore() {
+  return new InMemorySlackInstallationStore();
+}
+var JsonFileSlackInstallationStore = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  pending = Promise.resolve();
+  async storeInstallation(installation) {
+    await this.withLock(async () => {
+      const installations = await this.readInstallations();
+      installations[getSlackInstallationKey(installation)] = installation;
+      await this.writeInstallations(installations);
+    });
+  }
+  async fetchInstallation(query) {
+    return await this.withLock(async () => {
+      const key = getSlackInstallationKey(query);
+      const installations = await this.readInstallations();
+      const installation = installations[key];
+      if (!installation) {
+        throw new Error(`No Slack installation found for key: ${key}`);
+      }
+      return installation;
+    });
+  }
+  async deleteInstallation(query) {
+    await this.withLock(async () => {
+      const key = getSlackInstallationKey(query);
+      const installations = await this.readInstallations();
+      delete installations[key];
+      await this.writeInstallations(installations);
+    });
+  }
+  async withLock(operation) {
+    const run = this.pending.then(operation, operation);
+    this.pending = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return await run;
+  }
+  async readInstallations() {
+    let contents;
+    try {
+      contents = await fs.readFile(this.filePath, "utf8");
+    } catch (error) {
+      if (isNodeErrorCode(error, "ENOENT")) {
+        return {};
+      }
+      throw error;
+    }
+    if (!contents.trim()) {
+      return {};
+    }
+    const parsed = JSON.parse(contents);
+    const record = asRecord(parsed);
+    const installations = asRecord(record?.installations) ?? record;
+    if (!installations) {
+      return {};
+    }
+    const output = {};
+    for (const [key, value] of Object.entries(installations)) {
+      if (asRecord(value)) {
+        output[key] = value;
+      }
+    }
+    return output;
+  }
+  async writeInstallations(installations) {
+    await fs.mkdir(dirname(this.filePath), { recursive: true });
+    const tempPath = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+    const payload = JSON.stringify({ version: 1, installations }, null, 2);
+    await fs.writeFile(tempPath, `${payload}
+`, "utf8");
+    await fs.rename(tempPath, this.filePath);
+  }
+};
+function createJsonFileSlackInstallationStore(filePath) {
+  return new JsonFileSlackInstallationStore(filePath);
+}
+function createSlackInstallationStoreAuthorize(store) {
+  return async (source) => {
+    const installation = await store.fetchInstallation({
+      teamId: source.teamId,
+      enterpriseId: source.enterpriseId,
+      userId: source.userId,
+      conversationId: source.conversationId,
+      isEnterpriseInstall: source.isEnterpriseInstall
+    });
+    const botToken = installation.bot?.token;
+    if (!botToken) {
+      throw new Error(
+        "Slack OAuth installation is missing a bot token. Reinstall the Slack app with bot scopes."
+      );
+    }
+    return {
+      botToken,
+      botId: installation.bot?.id,
+      botUserId: installation.bot?.userId,
+      teamId: installation.team?.id ?? source.teamId,
+      enterpriseId: installation.enterprise?.id ?? source.enterpriseId,
+      userId: installation.user.id,
+      userToken: installation.user.token
+    };
+  };
+}
+function getSlackInstallationKey(input) {
+  if (input.isEnterpriseInstall && "enterprise" in input && input.enterprise?.id) {
+    return `enterprise:${input.enterprise.id}`;
+  }
+  if (input.isEnterpriseInstall && "enterpriseId" in input && input.enterpriseId) {
+    return `enterprise:${input.enterpriseId}`;
+  }
+  if ("team" in input && input.team?.id) {
+    return `team:${input.team.id}`;
+  }
+  if ("teamId" in input && input.teamId) {
+    return `team:${input.teamId}`;
+  }
+  throw new Error("Slack installation is missing a team or enterprise id.");
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : void 0;
+}
+function isNodeErrorCode(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+export {
+  InMemorySlackInstallationStore,
+  JsonFileSlackInstallationStore,
+  createInMemorySlackInstallationStore,
+  createJsonFileSlackInstallationStore,
+  createSlackInstallationStoreAuthorize,
+  getSlackInstallationKey,
+  normalizeSlackEventsPath,
+  resolveDirectAuth,
+  trimToUndefined
+};

package/dist/{chunk-IDVDMJ5U.js → chunk-6JSGIVQH.js}

@@ -269,8 +269,8 @@ async function resolveDiagnosticsClient(options) {
   return { tokenSource: "none" };
 }
 async function createSlackWebClient(token) {
-  const { WebClient } = await import("@slack/web-api");
-  return new WebClient(token);
+  const { WebClient: WebClient2 } = await import("@slack/web-api");
+  return new WebClient2(token);
 }
 async function withRequestTimeout(operation, timeoutMs, method) {
   if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
@@ -651,6 +651,111 @@ function collectJsonKeyPathsInternal(value, {
   return paths;
 }
 
+// src/diagnostics/readiness.ts
+import { WebClient } from "@slack/web-api";
+var SlackStartupReadinessError = class extends Error {
+  issues;
+  constructor(issues) {
+    super(`Slack startup readiness failed: ${issues.join("; ")}`);
+    this.name = "SlackStartupReadinessError";
+    this.issues = issues;
+  }
+};
+async function runSlackStartupReadiness({
+  clientFactory = createSlackAuthTestClient,
+  config,
+  logger
+}) {
+  if (!config.enabled) {
+    logger?.debug?.("Slack startup readiness skipped", {
+      reason: "disabled"
+    });
+    return {
+      authMode: config.authMode,
+      identityCheck: "disabled",
+      transport: config.transport
+    };
+  }
+  const socketModeRuntimePolicy = config.transport === "socket" ? config.socketModeRuntimePolicy : void 0;
+  if (socketModeRuntimePolicy) {
+    logger?.info?.("Slack Socket Mode runtime policy selected", {
+      policy: socketModeRuntimePolicy
+    });
+    if (socketModeRuntimePolicy === "external-coordination") {
+      logger?.warn?.(
+        "Slack Socket Mode depends on external runtime coordination",
+        { policy: socketModeRuntimePolicy }
+      );
+    }
+  }
+  if (config.authMode !== "single-workspace") {
+    logger?.info?.("Slack identity validation skipped", {
+      reason: "install-based-auth",
+      transport: config.transport
+    });
+    return {
+      authMode: config.authMode,
+      identityCheck: "skipped",
+      ...socketModeRuntimePolicy ? { socketModeRuntimePolicy } : {},
+      transport: config.transport
+    };
+  }
+  if (!config.botToken?.trim()) {
+    throw new SlackStartupReadinessError([
+      "Slack single-workspace identity validation requires a bot token"
+    ]);
+  }
+  const identity = await resolveSlackIdentity({
+    botToken: config.botToken,
+    clientFactory
+  });
+  const issues = formatSlackIdentityMismatches(
+    compareSlackIdentity(identity, config)
+  );
+  if (issues.length > 0) {
+    throw new SlackStartupReadinessError(issues);
+  }
+  logger?.info?.("Slack identity validation passed", {
+    botIdResolved: Boolean(identity.botId),
+    botUserIdResolved: Boolean(identity.botUserId),
+    expectedBotIdConfigured: Boolean(config.botId),
+    expectedBotUserIdConfigured: Boolean(config.botUserId),
+    expectedTeamIdConfigured: Boolean(config.teamId),
+    teamIdResolved: Boolean(identity.teamId),
+    teamNameResolved: Boolean(identity.team),
+    transport: config.transport
+  });
+  return {
+    authMode: config.authMode,
+    identity,
+    identityCheck: "passed",
+    ...socketModeRuntimePolicy ? { socketModeRuntimePolicy } : {},
+    transport: config.transport
+  };
+}
+async function resolveSlackIdentity({
+  botToken,
+  clientFactory
+}) {
+  try {
+    const response = await clientFactory(botToken).auth.test();
+    if (response.ok === false) {
+      throw new Error(response.error ?? "Slack auth.test returned ok=false");
+    }
+    return normalizeSlackAuthTestIdentity(response);
+  } catch (error) {
+    throw new SlackStartupReadinessError([
+      `Slack bot identity lookup failed: ${formatReadinessError(error)}`
+    ]);
+  }
+}
+function createSlackAuthTestClient(botToken) {
+  return new WebClient(botToken);
+}
+function formatReadinessError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 export {
   inspectSlackConnection,
   inspectSlackTokenScopes,
@@ -662,5 +767,7 @@ export {
   selectSlackBodyForDebug,
   redactSlackDebugValue,
   collectJsonKeyPaths,
-  findJsonKeyPaths
+  findJsonKeyPaths,
+  SlackStartupReadinessError,
+  runSlackStartupReadiness
 };

package/dist/chunk-6WHFQUYQ.js

@@ -0,0 +1,54 @@
+// 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;
+}
+
+export {
+  resolveSlackMessageFormatter,
+  markdownToSlackMrkdwn
+};