@cuylabs/channel-slack 0.1.0

package/dist/chunk-FX2JOVX5.js

@@ -0,0 +1,405 @@
+// src/diagnostics/inspect.ts
+var DEFAULT_REQUEST_TIMEOUT_MS = 2500;
+var DEFAULT_SCOPE_METHODS = [
+  "auth.test",
+  "auth.scopes",
+  "apps.permissions.info"
+];
+async function inspectSlackConnection(options = {}) {
+  const startedAt = Date.now();
+  const resolved = await resolveDiagnosticsClient(options);
+  const requiredScopes = normalizeScopes(options.requiredScopes ?? []);
+  const optionalScopes = normalizeScopes(options.optionalScopes ?? []);
+  const base = {
+    tokenSource: resolved.tokenSource,
+    requiredScopes,
+    optionalScopes,
+    missingRequiredScopes: [],
+    missingOptionalScopes: [],
+    findings: []
+  };
+  if (!resolved.client) {
+    return {
+      ...base,
+      ok: false,
+      elapsedMs: elapsed(startedAt),
+      missingRequiredScopes: requiredScopes,
+      findings: [
+        {
+          severity: "error",
+          code: "missing-token",
+          message: "Slack token is missing. Pass `token`, inject `client`, or set SLACK_BOT_TOKEN."
+        }
+      ],
+      error: { message: "Slack token is missing.", code: "missing-token" }
+    };
+  }
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const tokenArgs = resolved.token ? { token: resolved.token } : void 0;
+  let authPayload;
+  try {
+    authPayload = await withRequestTimeout(
+      () => resolved.client.auth.test(tokenArgs),
+      requestTimeoutMs,
+      "auth.test"
+    );
+  } catch (error) {
+    const apiError = toSlackApiInspectionError(error, "auth.test");
+    return {
+      ...base,
+      ok: false,
+      elapsedMs: elapsed(startedAt),
+      missingRequiredScopes: requiredScopes,
+      findings: [
+        {
+          severity: "error",
+          code: "auth-test-failed",
+          message: apiError.message
+        }
+      ],
+      error: apiError
+    };
+  }
+  const authError = slackPayloadError(authPayload, "auth.test");
+  if (authError) {
+    return {
+      ...base,
+      ok: false,
+      elapsedMs: elapsed(startedAt),
+      missingRequiredScopes: requiredScopes,
+      auth: normalizeAuthInfo(authPayload),
+      findings: [
+        {
+          severity: "error",
+          code: "auth-test-failed",
+          message: authError.message
+        }
+      ],
+      error: authError
+    };
+  }
+  const auth = normalizeAuthInfo(authPayload);
+  const findings = [];
+  let scopes;
+  let missingRequiredScopes = [];
+  let missingOptionalScopes = [];
+  if (options.inspectScopes !== false) {
+    scopes = await inspectSlackTokenScopes({
+      token: resolved.token,
+      client: resolved.client,
+      requestTimeoutMs,
+      methods: options.scopeMethods
+    });
+    if (scopes.ok) {
+      missingRequiredScopes = missingScopes(requiredScopes, scopes.scopes);
+      missingOptionalScopes = missingScopes(optionalScopes, scopes.scopes);
+    } else if (requiredScopes.length > 0) {
+      missingRequiredScopes = requiredScopes;
+    }
+    if (!scopes.ok) {
+      findings.push({
+        severity: requiredScopes.length > 0 ? "error" : "warning",
+        code: "scope-inspection-unavailable",
+        message: requiredScopes.length > 0 ? "Slack token scopes could not be inspected, so required scopes could not be verified." : "Slack token scopes could not be inspected."
+      });
+    }
+  }
+  if (missingRequiredScopes.length > 0) {
+    findings.push({
+      severity: "error",
+      code: "missing-required-scopes",
+      message: `Slack token is missing required scope(s): ${missingRequiredScopes.join(
+        ", "
+      )}.`
+    });
+  }
+  if (missingOptionalScopes.length > 0) {
+    findings.push({
+      severity: "warning",
+      code: "missing-optional-scopes",
+      message: `Slack token is missing optional scope(s): ${missingOptionalScopes.join(
+        ", "
+      )}.`
+    });
+  }
+  return {
+    ...base,
+    ok: findings.every((finding) => finding.severity !== "error"),
+    elapsedMs: elapsed(startedAt),
+    auth,
+    ...scopes ? { scopes } : {},
+    missingRequiredScopes,
+    missingOptionalScopes,
+    findings
+  };
+}
+async function inspectSlackTokenScopes(options = {}) {
+  const resolved = await resolveDiagnosticsClient(options);
+  if (!resolved.client) {
+    return {
+      ok: false,
+      scopes: [],
+      errors: [
+        {
+          method: "auth.test",
+          error: {
+            message: "Slack token is missing. Pass `token`, inject `client`, or set SLACK_BOT_TOKEN.",
+            code: "missing-token",
+            method: "auth.test"
+          }
+        }
+      ]
+    };
+  }
+  const methods = options.methods ?? DEFAULT_SCOPE_METHODS;
+  const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+  const args = resolved.token ? { token: resolved.token } : void 0;
+  const errors = [];
+  for (const method of methods) {
+    try {
+      const payload = await withRequestTimeout(
+        () => resolved.client.apiCall(method, args),
+        requestTimeoutMs,
+        method
+      );
+      const payloadError = slackPayloadError(payload, method);
+      if (payloadError) {
+        errors.push({
+          method,
+          error: payloadError
+        });
+        continue;
+      }
+      const scopes = extractScopes(payload);
+      if (scopes.length > 0) {
+        return {
+          ok: true,
+          scopes,
+          source: method,
+          errors
+        };
+      }
+      errors.push({
+        method,
+        error: {
+          message: `${method} did not return scope data.`,
+          code: "no-scope-data",
+          method
+        }
+      });
+    } catch (error) {
+      errors.push({
+        method,
+        error: toSlackApiInspectionError(error, method)
+      });
+    }
+  }
+  return {
+    ok: false,
+    scopes: [],
+    errors
+  };
+}
+async function resolveDiagnosticsClient(options) {
+  const explicitToken = normalizeToken(options.token);
+  if (options.client) {
+    return {
+      client: options.client,
+      token: explicitToken,
+      tokenSource: explicitToken ? "provided" : "client"
+    };
+  }
+  if (explicitToken) {
+    return {
+      client: await createSlackWebClient(explicitToken),
+      token: explicitToken,
+      tokenSource: "provided"
+    };
+  }
+  const envToken = normalizeToken(process.env.SLACK_BOT_TOKEN);
+  if (envToken) {
+    return {
+      client: await createSlackWebClient(envToken),
+      token: envToken,
+      tokenSource: "environment"
+    };
+  }
+  return { tokenSource: "none" };
+}
+async function createSlackWebClient(token) {
+  const { WebClient } = await import("@slack/web-api");
+  return new WebClient(token);
+}
+async function withRequestTimeout(operation, timeoutMs, method) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    return await operation();
+  }
+  let timeoutId;
+  try {
+    return await Promise.race([
+      operation(),
+      new Promise((_resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          const error = new Error(`${method} timed out after ${timeoutMs}ms.`);
+          error.code = "timeout";
+          reject(error);
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+}
+function normalizeAuthInfo(payload) {
+  const record = readRecord(payload);
+  const auth = {
+    ok: readBoolean(record?.ok) ?? false
+  };
+  const url = readString(record?.url);
+  const team = readString(record?.team);
+  const teamId = readString(record?.team_id);
+  const user = readString(record?.user);
+  const userId = readString(record?.user_id);
+  const botId = readString(record?.bot_id);
+  const enterpriseId = readString(record?.enterprise_id);
+  if (url) auth.url = url;
+  if (team) auth.team = team;
+  if (teamId) auth.teamId = teamId;
+  if (user) auth.user = user;
+  if (userId) auth.userId = userId;
+  if (botId) auth.botId = botId;
+  if (enterpriseId) auth.enterpriseId = enterpriseId;
+  const isEnterpriseInstall = readBoolean(record?.is_enterprise_install);
+  if (isEnterpriseInstall !== void 0) {
+    auth.isEnterpriseInstall = isEnterpriseInstall;
+  }
+  return auth;
+}
+function slackPayloadError(payload, method) {
+  const record = readRecord(payload);
+  if (!record || record.ok !== false) {
+    return void 0;
+  }
+  const code = readString(record.error);
+  return {
+    message: `${method} failed${code ? `: ${code}` : ""}.`,
+    ...code ? { code } : {},
+    method,
+    ...readScopeErrorDetails(record)
+  };
+}
+function toSlackApiInspectionError(error, method) {
+  if (error instanceof Error) {
+    const record = error;
+    const data = readRecord(record.data);
+    const dataCode = data ? readString(data.error) : void 0;
+    const code = dataCode ?? readString(record.code);
+    return {
+      message: error.message || `${method} failed.`,
+      ...code ? { code } : {},
+      method,
+      ...typeof record.statusCode === "number" ? { statusCode: record.statusCode } : {},
+      ...data ? readScopeErrorDetails(data) : {}
+    };
+  }
+  return {
+    message: typeof error === "string" ? error : `${method} failed.`,
+    method
+  };
+}
+function readScopeErrorDetails(record) {
+  const responseMetadata = readRecord(record.response_metadata);
+  const providedScopes = extractScopes(responseMetadata?.scopes);
+  const acceptedScopes = extractScopes(responseMetadata?.acceptedScopes);
+  const needed = readString(record.needed);
+  return {
+    ...needed ? { needed } : {},
+    ...providedScopes.length > 0 ? { providedScopes } : {},
+    ...acceptedScopes.length > 0 ? { acceptedScopes } : {}
+  };
+}
+function extractScopes(payload) {
+  const scopes = [];
+  if (typeof payload === "string" || Array.isArray(payload)) {
+    collectScopes(payload, scopes);
+  }
+  const record = readRecord(payload);
+  if (record) {
+    collectScopes(record.scopes, scopes);
+    collectScopes(record.scope, scopes);
+    const responseMetadata = readRecord(record.response_metadata);
+    collectScopes(responseMetadata?.scopes, scopes);
+    const info = readRecord(record.info);
+    collectScopes(info?.scopes, scopes);
+    collectScopes(info?.scope, scopes);
+    collectScopes(info?.user_scopes, scopes);
+    collectScopes(info?.bot_scopes, scopes);
+  }
+  return normalizeScopes(scopes);
+}
+function collectScopes(value, into) {
+  if (!value) {
+    return;
+  }
+  if (typeof value === "string") {
+    for (const entry of value.split(/[,\s]+/)) {
+      const normalized = entry.trim();
+      if (normalized) {
+        into.push(normalized);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      collectScopes(entry, into);
+    }
+    return;
+  }
+  const record = readRecord(value);
+  if (!record) {
+    return;
+  }
+  for (const entry of Object.values(record)) {
+    if (typeof entry === "string" || Array.isArray(entry)) {
+      collectScopes(entry, into);
+    }
+  }
+}
+function normalizeScopes(scopes) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const scope of scopes) {
+    const trimmed = scope.trim();
+    if (trimmed) {
+      unique.set(trimmed.toLowerCase(), trimmed);
+    }
+  }
+  return [...unique.values()].sort((a, b) => a.localeCompare(b));
+}
+function missingScopes(expected, actual) {
+  const actualSet = new Set(actual.map((scope) => scope.toLowerCase()));
+  return expected.filter((scope) => !actualSet.has(scope.toLowerCase()));
+}
+function normalizeToken(token) {
+  const trimmed = token?.trim();
+  return trimmed || void 0;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function elapsed(startedAt) {
+  return Date.now() - startedAt;
+}
+
+export {
+  inspectSlackConnection,
+  inspectSlackTokenScopes
+};

package/dist/chunk-JZG4IETE.js

@@ -0,0 +1,141 @@
+// 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();
+function currentSlackTurnContext() {
+  return store.getStore();
+}
+function runWithSlackTurnContext(value, fn) {
+  return Promise.resolve(store.run({ ...value }, fn));
+}
+
+// src/shared/follow-up.ts
+function formatSlackAttributedFollowUp(message) {
+  const slack = currentSlackTurnContext();
+  if (!slack) {
+    return message;
+  }
+  const sender = formatSlackSender(slack);
+  const conversation = formatSlackConversation(slack);
+  if (!sender && !conversation) {
+    return message;
+  }
+  const lines = ["Additional Slack follow-up for the running request."];
+  if (sender) {
+    lines.push(`Sender: ${sender}`);
+  }
+  if (conversation) {
+    lines.push(`Conversation: ${conversation}`);
+  }
+  lines.push("Message:", message);
+  return lines.join("\n");
+}
+function formatSlackSender(slack) {
+  const userId = slack.slackActivity.userId || slack.user.userId;
+  const displayName = readPreparedSlackDisplayName(slack.context) ?? slack.user.userName;
+  if (displayName && userId) {
+    return `${displayName} (${userId})`;
+  }
+  return displayName ?? userId ?? "unknown Slack user";
+}
+function formatSlackConversation(slack) {
+  const activity = slack.slackActivity;
+  const surface = formatSlackSurface(activity.channelType);
+  const parts = [
+    activity.teamId ? `team ${activity.teamId}` : void 0,
+    activity.channelId ? `channel ${activity.channelId}` : void 0,
+    activity.threadTs ? `thread ${activity.threadTs}` : activity.messageTs ? `message ${activity.messageTs}` : void 0
+  ].filter((part) => Boolean(part));
+  return parts.length > 0 ? `${surface} (${parts.join(", ")})` : surface;
+}
+function formatSlackSurface(channelType) {
+  switch (channelType) {
+    case "dm":
+      return "private Slack DM";
+    case "thread":
+      return "shared Slack thread";
+    case "channel":
+      return "shared Slack channel";
+    case "group":
+      return "shared Slack group conversation";
+    default:
+      return "Slack conversation";
+  }
+}
+function readPreparedSlackDisplayName(context) {
+  const slack = context?.slack;
+  if (!slack || typeof slack !== "object") {
+    return void 0;
+  }
+  const value = slack.userDisplayName;
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/shared/session.ts
+function resolveThreadAwareSlackSessionId(info) {
+  if (info.channelType === "dm") {
+    return info.channelId;
+  }
+  if (info.threadTs) {
+    return `${info.channelId}:${info.threadTs}`;
+  }
+  return `${info.channelId}:${info.messageTs ?? info.channelId}`;
+}
+
+export {
+  resolveSlackMessageFormatter,
+  markdownToSlackMrkdwn,
+  currentSlackTurnContext,
+  runWithSlackTurnContext,
+  formatSlackAttributedFollowUp,
+  resolveThreadAwareSlackSessionId
+};

package/dist/chunk-TWJGVDA2.js

@@ -0,0 +1,108 @@
+import {
+  extractSlackMessageText,
+  resolveSlackChannelType
+} from "./chunk-FPCE5V5Y.js";
+
+// src/shared/activity/parse.ts
+function extractSlackActionToken(payload) {
+  const direct = asNonEmptyString(payload?.action_token);
+  if (direct) return direct;
+  const assistantThread = payload?.assistant_thread;
+  if (!assistantThread || typeof assistantThread !== "object") {
+    return void 0;
+  }
+  return asNonEmptyString(
+    assistantThread.action_token
+  );
+}
+function parseSlackMessageActivity(payload) {
+  const channelId = payload.channel ?? "unknown";
+  const userId = payload.user ?? "unknown";
+  const messageTs = payload.ts;
+  const threadTs = payload.thread_ts;
+  const isThread = !!threadTs && threadTs !== messageTs;
+  const channelType = resolveSlackChannelType(channelId, threadTs, isThread);
+  const text = extractSlackMessageText(payload, {
+    stripLeadingMentions: channelType !== "dm"
+  });
+  return {
+    channelId,
+    channelType,
+    userId,
+    teamId: payload.team,
+    threadTs: isThread ? threadTs : void 0,
+    messageTs,
+    parentUserId: payload.parent_user_id,
+    actionToken: extractSlackActionToken(payload),
+    text,
+    isMention: false
+  };
+}
+function parseSlackMentionActivity(payload) {
+  const channelId = payload.channel ?? "unknown";
+  const userId = payload.user ?? "unknown";
+  const messageTs = payload.ts;
+  const threadTs = payload.thread_ts;
+  const isThread = !!threadTs && threadTs !== messageTs;
+  const channelType = resolveSlackChannelType(channelId, threadTs, isThread);
+  const text = extractSlackMessageText(payload, {
+    stripLeadingMentions: true
+  });
+  return {
+    channelId,
+    channelType,
+    userId,
+    teamId: payload.team,
+    threadTs: isThread ? threadTs : void 0,
+    messageTs,
+    parentUserId: payload.parent_user_id,
+    actionToken: extractSlackActionToken(payload),
+    text,
+    isMention: true
+  };
+}
+function asNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+
+// src/shared/activity/identity.ts
+function extractSlackUserIdentity(info) {
+  return {
+    userId: info.userId,
+    channelId: info.channelId,
+    teamId: info.teamId,
+    threadTs: info.threadTs,
+    messageTs: info.messageTs
+  };
+}
+function extractSlackAuthContext(context, eventUserId) {
+  const ctx = context && typeof context === "object" ? context : {};
+  const pickString = (key) => {
+    const value = ctx[key];
+    return typeof value === "string" && value.length > 0 ? value : void 0;
+  };
+  const auth = {};
+  const botToken = pickString("botToken");
+  if (botToken) auth.botToken = botToken;
+  const userToken = pickString("userToken");
+  if (userToken) auth.userToken = userToken;
+  const teamId = pickString("teamId");
+  if (teamId) auth.teamId = teamId;
+  const enterpriseId = pickString("enterpriseId");
+  if (enterpriseId) auth.enterpriseId = enterpriseId;
+  const botUserId = pickString("botUserId");
+  if (botUserId) auth.botUserId = botUserId;
+  const botId = pickString("botId");
+  if (botId) auth.botId = botId;
+  const userId = pickString("userId") ?? eventUserId;
+  if (userId) auth.userId = userId;
+  return auth;
+}
+
+export {
+  extractSlackActionToken,
+  parseSlackMessageActivity,
+  parseSlackMentionActivity,
+  extractSlackUserIdentity,
+  extractSlackAuthContext
+};