@cursor/bdk 0.2.2 → 0.2.4

package/src/channels/slack/attachments.ts

@@ -1,596 +0,0 @@
-/**
- * Download and classify Slack file uploads for agent turns.
- *
- * Images become vision inputs (SDK `images`). Documents and videos land under
- * `slack-attachments/` in the session workspace so the model can Read them.
- */
-
-import { callSlackApiSoft, isSlackApiTransport } from "./api.js";
-import { tryResolveBotToken } from "./credentials.js";
-import type { SlackLog } from "./log.js";
-import type { SlackBotToken, SlackMessageFile } from "./types.js";
-
-export const SLACK_ATTACHMENTS_DIR = "slack-attachments";
-export const SLACK_ATTACHMENT_ONLY_PROMPT =
-  "The user shared Slack attachment(s) with no message text. Review the attached files.";
-
-const DEFAULT_MAX_FILE_BYTES = 15 * 1024 * 1024;
-const DEFAULT_MAX_TOTAL_BYTES = 35 * 1024 * 1024;
-const DEFAULT_MAX_FILES = 8;
-const DEFAULT_DOWNLOAD_TIMEOUT_MS = 10_000;
-
-const TEXT_SLACK_FILETYPES = new Set([
-  "text",
-  "markdown",
-  "md",
-  "diff",
-  "csv",
-  "tsv",
-  "json",
-  "xml",
-  "yaml",
-  "c",
-  "csharp",
-  "cpp",
-  "css",
-  "clojure",
-  "coffeescript",
-  "dart",
-  "dockerfile",
-  "email",
-  "erlang",
-  "fsharp",
-  "go",
-  "groovy",
-  "html",
-  "haskell",
-  "java",
-  "javascript",
-  "kotlin",
-  "latex",
-  "lisp",
-  "lua",
-  "matlab",
-  "objc",
-  "ocaml",
-  "pascal",
-  "perl",
-  "php",
-  "powershell",
-  "python",
-  "r",
-  "ruby",
-  "rust",
-  "sql",
-  "sass",
-  "scala",
-  "scheme",
-  "shell",
-  "swift",
-  "typescript",
-  "vb",
-  "vbscript",
-]);
-
-type JsonRecord = Record<string, unknown>;
-
-function asRecord(value: unknown): JsonRecord | null {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return null;
-  }
-  return value as JsonRecord;
-}
-
-function asString(value: unknown): string | undefined {
-  return typeof value === "string" ? value : undefined;
-}
-
-function asNumber(value: unknown): number | undefined {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-
-function normalizeMimeType(mimeType: string | undefined): string {
-  return (mimeType ?? "").split(";")[0].trim().toLowerCase();
-}
-
-function getLowercaseFileExtension(filename: string | undefined): string {
-  if (filename === undefined || filename.length === 0) {
-    return "";
-  }
-  const extensionStart = filename.lastIndexOf(".");
-  if (extensionStart < 0 || extensionStart === filename.length - 1) {
-    return "";
-  }
-  return filename.slice(extensionStart + 1).toLowerCase();
-}
-
-/** Keep path-safe basename pieces (mirrors cloud-agent sanitizeFilename). */
-export function sanitizeSlackFilename(name: string): string {
-  const trimmed = name.trim().replace(/[/\\?%*:|"<>]/g, "_");
-  return trimmed.length > 0 ? trimmed.slice(0, 180) : "file";
-}
-
-export function isSupportedImageFormat(mimeType: string): boolean {
-  return ["image/jpeg", "image/jpg", "image/png", "image/gif", "image/webp"].includes(
-    normalizeMimeType(mimeType),
-  );
-}
-
-export function isSupportedDocumentFormat(args: { mimeType: string; filename?: string }): boolean {
-  const mimeType = normalizeMimeType(args.mimeType);
-  const extension = getLowercaseFileExtension(args.filename);
-  const supportedExtensions = new Set([
-    "7z",
-    "bz2",
-    "doc",
-    "docx",
-    "gz",
-    "pdf",
-    "ppt",
-    "pptx",
-    "rar",
-    "tar",
-    "tbz",
-    "tbz2",
-    "tgz",
-    "txt",
-    "md",
-    "markdown",
-    "csv",
-    "xlsx",
-    "xz",
-    "json",
-    "jsonl",
-    "xml",
-    "yaml",
-    "yml",
-    "toml",
-    "txz",
-    "log",
-    "tzst",
-    "zip",
-    "zst",
-  ]);
-  const supportedMimeTypes = new Set([
-    "application/gzip",
-    "application/msword",
-    "application/pdf",
-    "application/json",
-    "application/jsonl",
-    "application/vnd.rar",
-    "application/vnd.ms-powerpoint",
-    "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    "application/xml",
-    "application/x-7z-compressed",
-    "application/x-bzip2",
-    "application/x-compressed-tar",
-    "application/x-gzip",
-    "application/x-gtar",
-    "application/x-rar-compressed",
-    "application/x-tar",
-    "application/x-xz",
-    "application/x-yaml",
-    "application/x-zip-compressed",
-    "application/yaml",
-    "application/zip",
-    "application/toml",
-    "application/zstd",
-    "application/x-zstd",
-    "text/csv",
-    "text/markdown",
-    "text/plain",
-    "text/xml",
-    "text/x-log",
-    "text/x-markdown",
-    "text/yaml",
-  ]);
-  return (
-    mimeType.startsWith("text/") ||
-    supportedMimeTypes.has(mimeType) ||
-    supportedExtensions.has(extension)
-  );
-}
-
-export function isSupportedVideoFormat(mimeType: string): boolean {
-  return normalizeMimeType(mimeType).startsWith("video/");
-}
-
-/** Raw Slack file object (message `files[]` or forwarded share). */
-export interface RawSlackFile {
-  id?: unknown;
-  mimetype?: unknown;
-  filetype?: unknown;
-  mode?: unknown;
-  name?: unknown;
-  title?: unknown;
-  size?: unknown;
-  url_private_download?: unknown;
-  dataBase64?: unknown;
-}
-
-export type SlackFileClassification =
-  | { kind: "image"; mimeType: string }
-  | { kind: "video"; mimeType: string }
-  | { kind: "document"; mimeType: string; isTextLike: boolean };
-
-function hasTextSlackHint(file: RawSlackFile): boolean {
-  if (file.mode === "snippet") {
-    return true;
-  }
-  const filetype = typeof file.filetype === "string" ? file.filetype.trim().toLowerCase() : "";
-  return TEXT_SLACK_FILETYPES.has(filetype);
-}
-
-/**
- * Classify a Slack file as image / document / video. Tolerates empty
- * `mimetype` on snippets (Slack fills it asynchronously).
- */
-export function classifySlackFile(file: RawSlackFile): SlackFileClassification | undefined {
-  const populatedMimeType =
-    typeof file.mimetype === "string" ? normalizeMimeType(file.mimetype) : "";
-  const textHint = hasTextSlackHint(file);
-  const mimeType = populatedMimeType.length > 0 ? populatedMimeType : textHint ? "text/plain" : "";
-  if (mimeType.length === 0) {
-    return undefined;
-  }
-  if (isSupportedImageFormat(mimeType)) {
-    return { kind: "image", mimeType };
-  }
-  const filename =
-    typeof file.name === "string"
-      ? file.name
-      : typeof file.title === "string"
-        ? file.title
-        : undefined;
-  const isTextLike = textHint || mimeType.startsWith("text/");
-  if (isTextLike || isSupportedDocumentFormat({ mimeType, filename })) {
-    return { kind: "document", mimeType, isTextLike };
-  }
-  if (isSupportedVideoFormat(mimeType)) {
-    return { kind: "video", mimeType };
-  }
-  return undefined;
-}
-
-function isForwardedShareAttachment(value: unknown): value is JsonRecord {
-  const record = asRecord(value);
-  return record !== null && record.is_share === true;
-}
-
-/** Top-level uploads plus files nested in forwarded `is_share` attachments. */
-export function collectSlackMessageFiles(message: unknown): RawSlackFile[] {
-  const record = asRecord(message);
-  if (record === null) {
-    return [];
-  }
-  const files: RawSlackFile[] = Array.isArray(record.files)
-    ? [...(record.files as RawSlackFile[])]
-    : [];
-  if (Array.isArray(record.attachments)) {
-    for (const attachment of record.attachments) {
-      if (isForwardedShareAttachment(attachment) && Array.isArray(attachment.files)) {
-        files.push(...(attachment.files as RawSlackFile[]));
-      }
-    }
-  }
-  return files;
-}
-
-export function parseSlackFileRefs(message: unknown): SlackMessageFile[] | undefined {
-  const files = collectSlackMessageFiles(message);
-  const refs: SlackMessageFile[] = [];
-  for (const file of files) {
-    const id = asString(file.id);
-    if (id === undefined || id.length === 0) {
-      continue;
-    }
-    refs.push({
-      id,
-      name: asString(file.name),
-      title: asString(file.title),
-      mimetype: asString(file.mimetype),
-      filetype: asString(file.filetype),
-      mode: asString(file.mode),
-      size: asNumber(file.size),
-      dataBase64: asString(file.dataBase64),
-    });
-  }
-  return refs.length > 0 ? refs : undefined;
-}
-
-export interface SlackTurnImage {
-  data: string;
-  mimeType: string;
-}
-
-/** Relative path → utf8 or base64-blob workspace entry. */
-export type SlackWorkspaceBlob = string | { encoding: "base64"; data: string; mimeType?: string };
-
-export interface PreparedSlackAttachments {
-  images: SlackTurnImage[];
-  workspaceFiles: Record<string, SlackWorkspaceBlob>;
-  /** Prompt markers like `[Image 1: shot.png]`. */
-  annotations: string[];
-}
-
-function attachmentFilename(file: SlackMessageFile): string {
-  return sanitizeSlackFilename(file.name ?? file.title ?? file.id);
-}
-
-function attachmentWorkspacePath(file: SlackMessageFile, filename: string): string {
-  return `${SLACK_ATTACHMENTS_DIR}/${sanitizeSlackFilename(file.id)}-${filename}`;
-}
-
-function looksLikeHtml(bytes: Uint8Array): boolean {
-  const head = Buffer.from(bytes.subarray(0, 100)).toString("utf8").toLowerCase();
-  return head.includes("<html");
-}
-
-function isTextLikeBytes(args: {
-  mimeType: string;
-  isTextLike: boolean;
-  bytes: Uint8Array;
-}): boolean {
-  if (args.isTextLike || args.mimeType.startsWith("text/")) {
-    return true;
-  }
-  // Reject obvious binary before attempting utf8 decode for docs.
-  for (let i = 0; i < Math.min(args.bytes.length, 512); i++) {
-    if (args.bytes[i] === 0) {
-      return false;
-    }
-  }
-  return (
-    args.mimeType === "application/json" ||
-    args.mimeType === "application/jsonl" ||
-    args.mimeType === "application/xml" ||
-    args.mimeType === "application/yaml" ||
-    args.mimeType === "application/x-yaml" ||
-    args.mimeType === "application/toml"
-  );
-}
-
-async function downloadSlackFileBytes(args: {
-  botToken: SlackBotToken | undefined;
-  fileId: string;
-  fallbackMimeType: string;
-  maxBytes: number;
-  downloadTimeoutMs: number;
-}): Promise<{ data: Uint8Array; mimeType: string; filename: string } | null> {
-  // Transport callers cannot mint a Bearer for files.slack.com; they
-  // must pre-attach `dataBase64` on the file ref instead.
-  if (isSlackApiTransport(args.botToken)) {
-    return null;
-  }
-
-  const info = await callSlackApiSoft({
-    botToken: args.botToken,
-    operation: "files.info",
-    body: { file: args.fileId },
-  });
-  if (info.ok !== true) {
-    return null;
-  }
-  const file = asRecord(info.file);
-  if (file === null) {
-    return null;
-  }
-  const downloadUrl = asString(file.url_private_download);
-  if (downloadUrl === undefined || downloadUrl.length === 0) {
-    return null;
-  }
-  const fileSize = asNumber(file.size);
-  if (fileSize !== undefined && fileSize > args.maxBytes) {
-    return null;
-  }
-
-  const botToken = await tryResolveBotToken({ botToken: args.botToken });
-  const headers: Record<string, string> = {};
-  if (botToken !== undefined && botToken.length > 0) {
-    headers.Authorization = `Bearer ${botToken}`;
-  }
-
-  let response: Response;
-  try {
-    response = await fetch(downloadUrl, {
-      headers,
-      signal: AbortSignal.timeout(args.downloadTimeoutMs),
-    });
-  } catch {
-    return null;
-  }
-  if (!response.ok) {
-    return null;
-  }
-  const contentLengthHeader = response.headers.get("content-length");
-  if (contentLengthHeader !== null && contentLengthHeader.length > 0) {
-    const contentLength = Number.parseInt(contentLengthHeader, 10);
-    if (!Number.isNaN(contentLength) && contentLength > args.maxBytes) {
-      return null;
-    }
-  }
-
-  const buffer = Buffer.from(await response.arrayBuffer());
-  if (buffer.length > args.maxBytes) {
-    return null;
-  }
-  const actualContentType = response.headers.get("content-type");
-  if (normalizeMimeType(actualContentType ?? undefined) === "text/html" || looksLikeHtml(buffer)) {
-    return null;
-  }
-  const responseMimeType = normalizeMimeType(actualContentType ?? undefined);
-  const metadataMimeType = normalizeMimeType(asString(file.mimetype) ?? args.fallbackMimeType);
-  const effectiveMimeType =
-    responseMimeType.length > 0 && responseMimeType !== "application/octet-stream"
-      ? responseMimeType
-      : metadataMimeType;
-  return {
-    data: new Uint8Array(buffer),
-    mimeType: effectiveMimeType.length > 0 ? effectiveMimeType : args.fallbackMimeType,
-    filename: sanitizeSlackFilename(asString(file.name) ?? asString(file.title) ?? args.fileId),
-  };
-}
-
-export interface PrepareSlackAttachmentsOptions {
-  botToken?: SlackBotToken;
-  files: readonly SlackMessageFile[];
-  maxFiles?: number;
-  maxFileBytes?: number;
-  maxTotalBytes?: number;
-  downloadTimeoutMs?: number;
-  log?: SlackLog;
-}
-
-/**
- * Download (or use pre-attached) Slack files and split them into vision
- * images + workspace blobs for the turn.
- */
-export async function prepareSlackAttachments(
-  options: PrepareSlackAttachmentsOptions,
-): Promise<PreparedSlackAttachments> {
-  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
-  const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
-  const maxTotalBytes = options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES;
-  const downloadTimeoutMs = options.downloadTimeoutMs ?? DEFAULT_DOWNLOAD_TIMEOUT_MS;
-
-  const loaded = await Promise.all(
-    options.files.slice(0, maxFiles).map(async file => {
-      const classification = classifySlackFile(file);
-      if (classification === undefined) {
-        return undefined;
-      }
-      if (file.size !== undefined && file.size > maxFileBytes) {
-        options.log?.info("slack attachment skipped (size)", {
-          file_id: file.id,
-          size: file.size,
-          max: maxFileBytes,
-        });
-        return undefined;
-      }
-
-      if (file.dataBase64 !== undefined && file.dataBase64.length > 0) {
-        return {
-          file,
-          classification,
-          bytes: new Uint8Array(Buffer.from(file.dataBase64, "base64")),
-          mimeType: classification.mimeType,
-          filename: attachmentFilename(file),
-        };
-      }
-
-      const downloaded = await downloadSlackFileBytes({
-        botToken: options.botToken,
-        fileId: file.id,
-        fallbackMimeType: classification.mimeType,
-        maxBytes: maxFileBytes,
-        downloadTimeoutMs,
-      });
-      if (downloaded === null) {
-        options.log?.info("slack attachment download failed", {
-          file_id: file.id,
-          kind: classification.kind,
-        });
-        return undefined;
-      }
-      return {
-        file,
-        classification,
-        bytes: downloaded.data,
-        mimeType: downloaded.mimeType,
-        filename: downloaded.filename,
-      };
-    }),
-  );
-
-  const images: SlackTurnImage[] = [];
-  const workspaceFiles: Record<string, SlackWorkspaceBlob> = {};
-  const annotations: string[] = [];
-  let totalBytes = 0;
-  let imageIndex = 0;
-  let documentIndex = 0;
-  let videoIndex = 0;
-
-  for (const item of loaded) {
-    if (item === undefined) {
-      continue;
-    }
-    const { file, classification, bytes, mimeType, filename } = item;
-    if (bytes.length === 0) {
-      options.log?.info("slack attachment download failed", {
-        file_id: file.id,
-        kind: classification.kind,
-      });
-      continue;
-    }
-    if (bytes.length > maxFileBytes || totalBytes + bytes.length > maxTotalBytes) {
-      options.log?.info("slack attachment skipped (budget)", {
-        file_id: file.id,
-        bytes: bytes.length,
-      });
-      continue;
-    }
-    totalBytes += bytes.length;
-    const relativePath = attachmentWorkspacePath(file, filename);
-
-    if (classification.kind === "image") {
-      if (!isSupportedImageFormat(mimeType)) {
-        continue;
-      }
-      imageIndex++;
-      const imagePath = `${relativePath}.base64`;
-      workspaceFiles[imagePath] = Buffer.from(bytes).toString("base64");
-      images.push({
-        data: Buffer.from(bytes).toString("base64"),
-        mimeType,
-      });
-      annotations.push(`[Image ${imageIndex}: ${filename} (${mimeType}) → ${imagePath}]`);
-      continue;
-    }
-
-    const textLike =
-      classification.kind === "document" &&
-      isTextLikeBytes({
-        mimeType,
-        isTextLike: classification.isTextLike,
-        bytes,
-      });
-
-    if (textLike) {
-      workspaceFiles[relativePath] = Buffer.from(bytes).toString("utf8");
-    } else {
-      workspaceFiles[relativePath] = {
-        encoding: "base64",
-        data: Buffer.from(bytes).toString("base64"),
-        mimeType,
-      };
-    }
-
-    if (classification.kind === "document") {
-      documentIndex++;
-      annotations.push(`[Document ${documentIndex}: ${filename} → ${relativePath}]`);
-    } else {
-      videoIndex++;
-      annotations.push(`[Video ${videoIndex}: ${filename} → ${relativePath}]`);
-    }
-  }
-
-  return { images, workspaceFiles, annotations };
-}
-
-/** Merge attachment annotations into the user prompt. */
-export function appendSlackAttachmentAnnotations(
-  prompt: string,
-  annotations: readonly string[],
-): string {
-  if (annotations.length === 0) {
-    return prompt;
-  }
-  const block = ["<slack_attachments>", ...annotations, "</slack_attachments>"].join("\n");
-  const trimmed = prompt.trim();
-  if (trimmed.length === 0) {
-    return `${block}\n\n${SLACK_ATTACHMENT_ONLY_PROMPT}`;
-  }
-  return `${block}\n\n${trimmed}`;
-}