@cursor/july 0.1.39 → 0.1.41

package/src/channels/slack/attachments.ts

@@ -0,0 +1,635 @@
+/**
+ * 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 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> {
+  // cursorAccount transport cannot mint a Bearer for files.slack.com; the
+  // relay 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;
+
+    if (classification.kind === "image") {
+      if (!isSupportedImageFormat(mimeType)) {
+        continue;
+      }
+      imageIndex++;
+      images.push({
+        data: Buffer.from(bytes).toString("base64"),
+        mimeType,
+      });
+      annotations.push(`[Image ${imageIndex}: ${filename}]`);
+      continue;
+    }
+
+    const relativePath = `${SLACK_ATTACHMENTS_DIR}/${filename}`;
+    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}`;
+}

package/src/channels/slack/cursor-account.ts

@@ -22,6 +22,7 @@ import type {
   SlackChannelOptions,
   SlackCredentials,
   SlackMessage,
+  SlackMessageFile,
   SlackMessageHandler,
 } from "./types.js";
 
@@ -72,6 +73,12 @@ export interface CursorSlackEnvelope {
   matchedBy: "name" | "thread";
   eventId?: string;
   receivedAtMs: number;
+  /**
+   * Slack file uploads on the triggering message. When `dataBase64` is set
+   * the Cursor backend already downloaded bytes (cursorAccount has no bot
+   * token for files.slack.com).
+   */
+  files?: SlackMessageFile[];
 }
 
 /** Serve-time runtime handle for one cursor-account Slack channel. */
@@ -149,6 +156,7 @@ export async function dispatchCursorSlackEnvelope(args: {
       : {
           author: { userId: envelope.slackUserId, isBot: false },
         }),
+    files: envelope.files,
   };
 
   // DMs to @Cursor route as direct messages; everything else (explicit