@pinet/slack-bridge 0.1.2 → 0.2.1

package/dist/slack-tools.js

@@ -7,7 +7,9 @@ import { findSlackPresenceDirectoryUser, formatSlackPresenceLine, formatSlackPre
 import { buildSlackThreadExport, filterSlackExportMessagesByRange, parseSlackExportBoundaryTs, } from "./slack-export.js";
 import { normalizeReactionName } from "./reaction-triggers.js";
 import { resolveScheduledWakeupFireAt } from "./scheduled-wakeups.js";
-import { performSlackUpload, prepareSlackUpload } from "./slack-upload.js";
+import { fetchSlackFileToCache } from "./slack-file-access.js";
+import { extractSlackMessageFileMetadata } from "./slack-message-context.js";
+import { performSlackUpload, performSlackUploads, prepareSlackUpload } from "./slack-upload.js";
 import { TtlCache } from "./ttl-cache.js";
 import { DEFAULT_SLACK_THREAD_STATUS, normalizeSlackThreadStatus, setSlackThreadStatus, SLACK_THREAD_LOADING_MESSAGES, } from "./slack-thread-status.js";
 const SLACK_OUTPUT_OPTION_PARAMETERS = {
@@ -20,6 +22,14 @@ const SLACK_OUTPUT_OPTION_PARAMETERS = {
     })),
 };
 const SLACK_ACTIONS_WITH_FORMAT_ARG = new Set(["export"]);
+const SLACK_LOCAL_FILE_ATTACHMENT_PARAMETERS = Type.Array(Type.Object({
+    path: Type.String({
+        description: "Local file path to attach. For safety, only files inside the current working directory or system temp directory are allowed.",
+    }),
+    filename: Type.Optional(Type.String({ description: "Optional Slack filename override" })),
+    title: Type.Optional(Type.String({ description: "Optional Slack title" })),
+    filetype: Type.Optional(Type.String({ description: "Optional Slack filetype override" })),
+}), { description: "Optional local files to attach to the same Slack message as text." });
 const SLACK_DISPATCHER_EXAMPLES = {
     react: [{ action: "react", args: { emoji: "👀", thread_ts: "1712345678.000100" } }],
     read: [{ action: "read", args: { thread_ts: "1712345678.000100", limit: 20 } }],
@@ -34,6 +44,16 @@ const SLACK_DISPATCHER_EXAMPLES = {
             },
         },
     ],
+    file: [
+        {
+            action: "file",
+            args: {
+                op: "download",
+                file_id: "F0123456789",
+                thread_ts: "1712345678.000100",
+            },
+        },
+    ],
     schedule: [
         {
             action: "schedule",
@@ -51,6 +71,14 @@ const SLACK_DISPATCHER_EXAMPLES = {
             action: "post_channel",
             args: { channel: "#deployments", text: "Deploy complete" },
         },
+        {
+            action: "post_channel",
+            args: {
+                channel: "#deployments",
+                text: "Deploy evidence attached",
+                files: [{ path: "/tmp/evidence.png", filename: "evidence.png" }],
+            },
+        },
     ],
     read_channel: [{ action: "read_channel", args: { channel: "#deployments", limit: 20 } }],
     confirm_action: [
@@ -167,6 +195,7 @@ function isPinetDeliveryFallbackError(error) {
         lower.includes("socket") ||
         lower.includes("no transport source") ||
         lower.includes("no transport channel") ||
+        lower.includes("only allows local file paths") ||
         lower.includes("no adapter") ||
         lower.includes("identity is unavailable"));
 }
@@ -387,7 +416,7 @@ function buildSlackInboxPromptGuidelines() {
         "Use slack_send for direct assistant-thread replies. Use the slack dispatcher for non-hot Slack actions such as reactions, reads, uploads, schedules, channel posts, pins, bookmarks, canvases, modals, presence, exports, and confirmations.",
         "Call slack with action='help' for the cold-action catalogue, or action='help' with args.topic for a specific action schema and examples.",
         "Security guardrails may be active for Slack-triggered actions. Cold Slack actions are checked with slack:<action> guardrail names.",
-        "Reaction-triggered requests may arrive as structured 'Reaction trigger from Slack:' messages — treat them as explicit user instructions attached to the referenced Slack message or thread.",
+        "Slack emoji reactions are ignored by default. Only treat opt-in structured 'Reaction trigger from Slack:' inbox messages from authorized Pinet threads as user instructions tied to the referenced Slack message or thread; never infer work from a plain emoji reaction alone.",
     ];
 }
 function buildSlackSendPromptGuidelines() {
@@ -477,6 +506,26 @@ function asTrimmedSlackString(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : undefined;
 }
+function extractSlackUploadMessageTs(response, channelId) {
+    const files = Array.isArray(response.files) ? response.files : [];
+    for (const fileValue of files) {
+        const file = asSlackObject(fileValue);
+        const shares = asSlackObject(file?.shares);
+        for (const shareKind of ["public", "private"]) {
+            const shareByChannel = asSlackObject(shares?.[shareKind]);
+            const channelShares = shareByChannel?.[channelId];
+            if (!Array.isArray(channelShares))
+                continue;
+            for (const shareValue of channelShares) {
+                const share = asSlackObject(shareValue);
+                const ts = asTrimmedSlackString(share?.ts);
+                if (ts)
+                    return ts;
+            }
+        }
+    }
+    return undefined;
+}
 function extractSlackCanvasPermalink(response) {
     const direct = asTrimmedSlackString(response.permalink) ??
         asTrimmedSlackString(response.url) ??
@@ -510,8 +559,39 @@ function isPiAgentSlackMessage(message, botUserId, agentOwnerToken) {
     }
     return eventPayload.agent_owner === agentOwnerToken;
 }
+/**
+ * Build the canonical guarded action string for a Slack delete.
+ *
+ * This must be derived from RESOLVED values (resolved channel ID, normalized
+ * ts list) — never raw caller params — so that the string quoted in guardrail
+ * errors, registered via confirm_action, and re-checked on the post-approval
+ * retry always agree regardless of how the caller phrased the request (#814).
+ */
 function summarizeSlackDeleteAction(input) {
-    return `channel=${input.channel ?? input.defaultChannel ?? ""} | thread_ts=${input.threadTs ?? ""} | ts=${input.ts} | thread=${input.thread ?? false}`;
+    return `channel=${input.channel} | thread_ts=${input.threadTs ?? ""} | ts=${input.tsList.join(",")} | thread=${input.thread ?? false}`;
+}
+/**
+ * Normalize the delete `ts` input into a deterministic target list.
+ *
+ * Multiple comma/whitespace-separated timestamps are allowed for single-message
+ * deletes so one explicit approval can cover one batch of bot-authored cleanup
+ * messages in the same thread (#814). The list is trimmed, deduplicated, and
+ * sorted so the canonical action string is stable across caller phrasings.
+ */
+function parseSlackDeleteTsInput(ts, deleteThread) {
+    const tsList = [
+        ...new Set(ts
+            .split(/[\s,]+/)
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0)),
+    ].sort();
+    if (tsList.length === 0) {
+        throw new Error("ts is required.");
+    }
+    if (deleteThread && tsList.length > 1) {
+        throw new Error("When thread=true, ts must be a single thread root timestamp.");
+    }
+    return tsList;
 }
 export function registerSlackTools(pi, deps) {
     const { getBotToken, getDefaultChannel, getSecurityPrompt, inbox, slack, getAgentName, getAgentEmoji, getAgentOwnerToken, getLastDmChannel, updateBadge, resolveUser, threadContext, resolveChannel, rememberChannel, requireToolPolicy: requireToolPolicyForName, registerConfirmationRequest, getBotUserId, pinetDelivery, } = deps;
@@ -553,6 +633,7 @@ export function registerSlackTools(pi, deps) {
                         channel: input.channel,
                         text: input.text,
                         ...(blocks ? { blocks } : {}),
+                        ...(input.files ? { files: input.files } : {}),
                     });
                     return {
                         threadTs: input.threadTs,
@@ -570,6 +651,34 @@ export function registerSlackTools(pi, deps) {
                 fallbackReason = getErrorMessage(error);
             }
         }
+        if (input.files && input.files.length > 0) {
+            if (blocks && blocks.length > 0) {
+                throw new Error("Slack text+file replies use Slack's external upload flow, which does not support Block Kit blocks in the same upload message. Omit blocks or send a separate block-only message.");
+            }
+            const uploads = await Promise.all(input.files.map((file) => prepareSlackUpload({
+                path: file.path,
+                ...(file.filename ? { filename: file.filename } : {}),
+                ...(file.title ? { title: file.title } : {}),
+                ...(file.filetype ? { filetype: file.filetype } : {}),
+            }, process.cwd(), os.tmpdir())));
+            const uploadResult = await performSlackUploads({
+                uploads,
+                channelId: input.channel,
+                ...(input.threadTs ? { threadTs: input.threadTs } : {}),
+                initialComment: input.text,
+                slack,
+                token: getBotToken(),
+            });
+            const uploadTs = extractSlackUploadMessageTs(uploadResult.response, input.channel);
+            return {
+                ...(uploadTs ? { ts: uploadTs } : {}),
+                threadTs: input.threadTs ?? uploadTs,
+                channel: input.channel,
+                blocksCount: blocks?.length ?? 0,
+                delivery: "slack",
+                ...(fallbackReason ? { fallbackReason } : {}),
+            };
+        }
         const body = {
             channel: input.channel,
             text: input.text,
@@ -584,9 +693,10 @@ export function registerSlackTools(pi, deps) {
         if (input.threadTs)
             body.thread_ts = input.threadTs;
         const response = await slack("chat.postMessage", getBotToken(), body);
-        const ts = response.message.ts;
+        const message = isRecord(response.message) ? response.message : null;
+        const ts = typeof message?.ts === "string" ? message.ts : undefined;
         return {
-            ts,
+            ...(ts ? { ts } : {}),
             channel: input.channel,
             blocksCount: blocks?.length ?? 0,
             delivery: "slack",
@@ -650,7 +760,7 @@ export function registerSlackTools(pi, deps) {
     pi.registerTool({
         name: "slack",
         label: "Slack",
-        description: "Dispatcher for non-hot Slack actions: react, read, upload, schedule, presence, export, post_channel, read_channel, confirm_action, delete, pin, bookmark, create_channel, project_create, canvas_comments_read, canvas_create, canvas_update, modal_open, modal_push, modal_update, and help. Use slack_inbox and slack_send for hot-path inbox/reply work.",
+        description: "Dispatcher for non-hot Slack actions: react, read, upload, file, schedule, presence, export, post_channel, read_channel, confirm_action, delete, pin, bookmark, create_channel, project_create, canvas_comments_read, canvas_create, canvas_update, modal_open, modal_push, modal_update, and help. Use slack_inbox and slack_send for hot-path inbox/reply work.",
         promptSnippet: "Run non-hot Slack actions through a compact dispatcher. Use action='help' for the action catalogue or args.topic for a specific schema. Defaults to compact cli output; pass args.format='json' (or args.response_format='json' when the action owns format) or args.full=true for structured/full details.",
         promptGuidelines: [
             "Use slack_inbox and slack_send for the hot path. Use this dispatcher for every other Slack action.",
@@ -660,7 +770,7 @@ export function registerSlackTools(pi, deps) {
         ],
         parameters: Type.Object({
             action: Type.String({
-                description: "Action name: help | react | read | upload | schedule | presence | export | post_channel | read_channel | confirm_action | delete | pin | bookmark | create_channel | project_create | canvas_comments_read | canvas_create | canvas_update | modal_open | modal_push | modal_update",
+                description: "Action name: help | react | read | upload | file | schedule | presence | export | post_channel | read_channel | confirm_action | delete | pin | bookmark | create_channel | project_create | canvas_comments_read | canvas_create | canvas_update | modal_open | modal_push | modal_update",
             }),
             args: Type.Optional(Type.Record(Type.String(), Type.Unknown(), {
                 description: "Action arguments. Call slack with action='help' and args.topic='<action>' for the exact JSON schema and examples. Add format='cli'|'json' and full=true for explicit presentation control; use response_format when the action already has a format field.",
@@ -862,20 +972,20 @@ export function registerSlackTools(pi, deps) {
         return messages;
     }
     async function resolveSlackDeleteTargets(input) {
-        const channelId = await resolveSlackTargetChannel(input.threadTs, input.channel);
-        const targetTs = input.ts.trim();
+        const { channelId } = input;
+        const targetTs = input.tsList[0];
         if (!targetTs) {
             throw new Error("ts is required.");
         }
         if (!input.thread) {
-            return { channelId, messageTsList: [targetTs] };
+            return { channelId, messageTsList: input.tsList };
         }
         const messages = await fetchSlackThreadMessages(channelId, targetTs, undefined, undefined, true);
         const threadRootTs = messages.length > 0 && typeof messages[0]?.ts === "string"
             ? messages[0].ts
             : undefined;
         if (!threadRootTs) {
-            throw new Error(`Slack did not return a thread rooted at ${targetTs} in channel ${input.channel ?? channelId}.`);
+            throw new Error(`Slack did not return a thread rooted at ${targetTs} in channel ${channelId}.`);
         }
         if (threadRootTs !== targetTs) {
             throw new Error("When thread=true, ts must be the thread root timestamp.");
@@ -929,16 +1039,12 @@ export function registerSlackTools(pi, deps) {
                 authorName,
                 text: typeof message.text === "string" ? message.text : "",
                 files: rawFiles.map((file) => ({
+                    id: typeof file.id === "string" ? file.id : undefined,
                     name: typeof file.name === "string" ? file.name : undefined,
                     title: typeof file.title === "string" ? file.title : undefined,
                     mimetype: typeof file.mimetype === "string" ? file.mimetype : undefined,
                     filetype: typeof file.filetype === "string" ? file.filetype : undefined,
                     permalink: typeof file.permalink === "string" ? file.permalink : undefined,
-                    urlPrivate: typeof file.url_private_download === "string"
-                        ? file.url_private_download
-                        : typeof file.url_private === "string"
-                            ? file.url_private
-                            : undefined,
                     preview: typeof file.preview === "string" ? file.preview : undefined,
                 })),
             };
@@ -1328,9 +1434,10 @@ export function registerSlackTools(pi, deps) {
             blocks: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()), {
                 description: "Optional Slack Block Kit blocks JSON array",
             })),
+            files: Type.Optional(SLACK_LOCAL_FILE_ATTACHMENT_PARAMETERS),
         }),
         async execute(_id, params) {
-            requireToolPolicy("slack_send", params.thread_ts, `thread_ts=${params.thread_ts ?? ""} | text=${params.text} | blocks=${summarizeSlackBlocksForPolicy(params.blocks)}`);
+            requireToolPolicy("slack_send", params.thread_ts, `thread_ts=${params.thread_ts ?? ""} | text=${params.text} | blocks=${summarizeSlackBlocksForPolicy(params.blocks)} | files=${Array.isArray(params.files) ? params.files.length : 0}`);
             const channel = await resolveSlackSendChannel(params.thread_ts);
             if (!channel) {
                 throw new Error(params.thread_ts
@@ -1342,6 +1449,7 @@ export function registerSlackTools(pi, deps) {
                 text: params.text,
                 ...(params.thread_ts ? { threadTs: params.thread_ts } : {}),
                 ...(params.blocks ? { blocks: params.blocks } : {}),
+                ...(params.files ? { files: params.files } : {}),
             });
             const ts = delivery.ts;
             const threadTs = params.thread_ts ?? delivery.threadTs;
@@ -1368,6 +1476,7 @@ export function registerSlackTools(pi, deps) {
                     channel,
                     blocksCount: delivery.blocksCount,
                     delivery: delivery.delivery,
+                    filesCount: Array.isArray(params.files) ? params.files.length : 0,
                     ...(delivery.adapter ? { adapter: delivery.adapter } : {}),
                     ...(delivery.messageId ? { messageId: delivery.messageId } : {}),
                     ...(delivery.fallbackReason ? { fallbackReason: delivery.fallbackReason } : {}),
@@ -1491,6 +1600,50 @@ export function registerSlackTools(pi, deps) {
             };
         },
     });
+    registerSlackAction({
+        name: "slack_file",
+        label: "Slack File Access",
+        description: "Download a Slack-hosted file from a known file ID, optionally verified against a thread/message, into controlled local temp cache storage without exposing private Slack URLs.",
+        promptSnippet: "Use slack action=file with op=download to turn a Slack-hosted file_id from slackFiles metadata into a safe local file descriptor/path. Private Slack download URLs are never returned.",
+        parameters: Type.Object({
+            op: Type.String({ description: "Operation. Currently only download is supported." }),
+            file_id: Type.String({ description: "Slack file ID, for example F0123456789." }),
+            thread_ts: Type.Optional(Type.String({
+                description: "Optional Slack thread timestamp. When provided, the file must appear in that thread.",
+            })),
+            message_ts: Type.Optional(Type.String({
+                description: "Optional Slack message timestamp inside the thread. When provided, the file must appear on that exact message.",
+            })),
+            channel: Type.Optional(Type.String({
+                description: "Optional channel name or ID. Omit when thread_ts is tracked by the Slack bridge.",
+            })),
+        }),
+        async execute(_id, params) {
+            if (params.op !== "download") {
+                throw new Error("slack file op must be download.");
+            }
+            requireToolPolicy("slack_file", params.thread_ts, `op=download | file_id=${params.file_id} | thread_ts=${params.thread_ts ?? ""} | message_ts=${params.message_ts ?? ""} | channel=${params.channel ?? ""}`);
+            const channelId = params.thread_ts
+                ? await resolveSlackTargetChannel(params.thread_ts, params.channel)
+                : params.channel
+                    ? await resolveChannel(params.channel)
+                    : undefined;
+            const descriptor = await fetchSlackFileToCache(params.file_id, {
+                ...(channelId ? { channelId } : {}),
+                ...(params.thread_ts ? { threadTs: params.thread_ts } : {}),
+                ...(params.message_ts ? { messageTs: params.message_ts } : {}),
+            }, { slack, token: getBotToken() });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Downloaded Slack file ${descriptor.fileId} to ${descriptor.path}.`,
+                    },
+                ],
+                details: descriptor,
+            };
+        },
+    });
     registerSlackAction({
         name: "slack_read",
         label: "Slack Read",
@@ -1499,10 +1652,13 @@ export function registerSlackTools(pi, deps) {
         parameters: Type.Object({
             thread_ts: Type.String({ description: "Thread to read." }),
             limit: Type.Optional(Type.Number({ description: "Max messages (default 20)" })),
+            download_files: Type.Optional(Type.Boolean({
+                description: "Download attached Slack-hosted files to the local temp cache and return safe descriptors. Defaults to true.",
+            })),
             ...SLACK_OUTPUT_OPTION_PARAMETERS,
         }),
         async execute(_id, params) {
-            requireToolPolicy("slack_read", params.thread_ts, `thread_ts=${params.thread_ts} | limit=${params.limit ?? 20}`);
+            requireToolPolicy("slack_read", params.thread_ts, `thread_ts=${params.thread_ts} | limit=${params.limit ?? 20} | download_files=${params.download_files !== false}`);
             const channel = (await resolveTrackedThreadChannel(params.thread_ts)) ?? getLastDmChannel();
             if (!channel) {
                 throw new Error("Unknown thread.");
@@ -1514,37 +1670,126 @@ export function registerSlackTools(pi, deps) {
             });
             const messages = response.messages;
             const full = params.full === true;
+            const shouldDownloadFiles = params.download_files !== false;
+            const downloadFile = async (fileId, messageTs) => fetchSlackFileToCache(fileId, { channelId: channel, threadTs: params.thread_ts, messageTs }, { slack, token: getBotToken() });
             const formattedMessages = await Promise.all(messages.map(async (message) => {
                 const userId = message.user;
                 const name = userId ? await resolveUser(userId) : "bot";
                 const text = message.text ?? "";
                 const ts = message.ts;
-                return { ts, name, text, preview: truncateSlackText(text) };
+                const files = await Promise.all(extractSlackMessageFileMetadata(message.files).map(async (file) => {
+                    const fileId = file.id;
+                    if (!fileId) {
+                        return {
+                            messageTs: ts,
+                            ...(file.name ? { filename: file.name } : {}),
+                            ...(file.mimetype ? { mimetype: file.mimetype } : {}),
+                            ...(file.filetype ? { filetype: file.filetype } : {}),
+                            ...(file.prettyType ? { prettyType: file.prettyType } : {}),
+                            ...(file.size != null ? { size: file.size } : {}),
+                            downloadStatus: "metadata-only",
+                        };
+                    }
+                    const base = {
+                        fileId,
+                        messageTs: ts,
+                        ...(file.name ? { filename: file.name } : {}),
+                        ...(file.mimetype ? { mimetype: file.mimetype } : {}),
+                        ...(file.filetype ? { filetype: file.filetype } : {}),
+                        ...(file.prettyType ? { prettyType: file.prettyType } : {}),
+                        ...(file.size != null ? { size: file.size } : {}),
+                    };
+                    if (!shouldDownloadFiles) {
+                        return {
+                            ...base,
+                            downloadStatus: "metadata-only",
+                        };
+                    }
+                    try {
+                        const descriptor = await downloadFile(fileId, ts);
+                        return {
+                            ...base,
+                            filename: descriptor.filename,
+                            ...(descriptor.mimetype ? { mimetype: descriptor.mimetype } : {}),
+                            ...(descriptor.filetype ? { filetype: descriptor.filetype } : {}),
+                            ...(descriptor.prettyType ? { prettyType: descriptor.prettyType } : {}),
+                            size: descriptor.size,
+                            path: descriptor.path,
+                            sha256: descriptor.sha256,
+                            cacheDir: descriptor.cacheDir,
+                            expiresAt: descriptor.expiresAt,
+                            downloadStatus: "downloaded",
+                        };
+                    }
+                    catch (error) {
+                        return {
+                            ...base,
+                            downloadStatus: "failed",
+                            error: getErrorMessage(error),
+                        };
+                    }
+                }));
+                return { ts, name, text, preview: truncateSlackText(text), files };
             }));
-            const lines = formattedMessages.map((message) => full
-                ? `[${message.ts}] ${message.name}: ${message.text}`
-                : `[${message.ts}] ${message.name}: ${message.preview}`);
+            const lines = formattedMessages.flatMap((message) => {
+                const messageLine = full
+                    ? `[${message.ts}] ${message.name}: ${message.text}`
+                    : `[${message.ts}] ${message.name}: ${message.preview}`;
+                const fileLines = message.files.map((file) => {
+                    const filename = file.filename ? ` ${file.filename}` : "";
+                    const type = file.prettyType ?? file.filetype ?? file.mimetype ?? "file";
+                    if (file.downloadStatus === "downloaded") {
+                        return `  [file downloaded] ${file.fileId}${filename} (${type}) -> ${file.path}`;
+                    }
+                    if (file.downloadStatus === "failed") {
+                        return `  [file metadata] ${file.fileId}${filename} (${type}) download failed: ${file.error}`;
+                    }
+                    return `  [file metadata] ${"fileId" in file ? file.fileId : "unknown-file"}${filename} (${type})`;
+                });
+                return [messageLine, ...fileLines];
+            });
+            const downloadedFilesCount = formattedMessages.reduce((count, message) => count + message.files.filter((file) => file.downloadStatus === "downloaded").length, 0);
+            const failedFilesCount = formattedMessages.reduce((count, message) => count + message.files.filter((file) => file.downloadStatus === "failed").length, 0);
             if (!full && messages.length > 0) {
                 lines.push("", "Use args.full=true for exact message text.");
             }
+            if (downloadedFilesCount > 0 || failedFilesCount > 0) {
+                lines.push("", `File attachments: ${downloadedFilesCount} downloaded to the local temp cache${failedFilesCount > 0 ? `; ${failedFilesCount} failed and returned metadata only` : ""}.`);
+            }
             return {
                 content: [{ type: "text", text: lines.join("\n") || "(no messages)" }],
                 details: full
-                    ? { count: messages.length }
+                    ? {
+                        count: messages.length,
+                        downloadedFilesCount,
+                        failedFilesCount,
+                        messages: formattedMessages.map((message) => ({
+                            ts: message.ts,
+                            user: message.name,
+                            text: message.text,
+                            files: message.files,
+                        })),
+                    }
                     : {
                         count: messages.length,
+                        downloadedFilesCount,
+                        failedFilesCount,
                         messages: formattedMessages.map((message) => ({
                             ts: message.ts,
                             user: message.name,
                             preview: message.preview,
+                            files: message.files,
                         })),
                     },
                 fullDetails: {
                     count: messages.length,
+                    downloadedFilesCount,
+                    failedFilesCount,
                     messages: formattedMessages.map((message) => ({
                         ts: message.ts,
                         user: message.name,
                         text: message.text,
+                        files: message.files,
                     })),
                 },
             };
@@ -1903,9 +2148,10 @@ export function registerSlackTools(pi, deps) {
             blocks: Type.Optional(Type.Array(Type.Record(Type.String(), Type.Unknown()), {
                 description: "Optional Slack Block Kit blocks JSON array",
             })),
+            files: Type.Optional(SLACK_LOCAL_FILE_ATTACHMENT_PARAMETERS),
         }),
         async execute(_id, params) {
-            requireToolPolicy("slack_post_channel", params.thread_ts, `channel=${params.channel ?? getDefaultChannel() ?? ""} | thread_ts=${params.thread_ts ?? ""} | text=${params.text} | blocks=${summarizeSlackBlocksForPolicy(params.blocks)}`);
+            requireToolPolicy("slack_post_channel", params.thread_ts, `channel=${params.channel ?? getDefaultChannel() ?? ""} | thread_ts=${params.thread_ts ?? ""} | text=${params.text} | blocks=${summarizeSlackBlocksForPolicy(params.blocks)} | files=${Array.isArray(params.files) ? params.files.length : 0}`);
             const resolvedThreadChannel = await resolveTrackedThreadChannel(params.thread_ts);
             const channelInput = params.channel ?? getDefaultChannel();
             let channelId = params.channel ? await resolveChannel(params.channel) : resolvedThreadChannel;
@@ -1920,6 +2166,7 @@ export function registerSlackTools(pi, deps) {
                 text: params.text,
                 ...(params.thread_ts ? { threadTs: params.thread_ts } : {}),
                 ...(params.blocks ? { blocks: params.blocks } : {}),
+                ...(params.files ? { files: params.files } : {}),
             });
             const ts = delivery.ts;
             const threadTs = params.thread_ts ?? delivery.threadTs;
@@ -1944,6 +2191,7 @@ export function registerSlackTools(pi, deps) {
                     channel: channelId,
                     blocksCount: delivery.blocksCount,
                     delivery: delivery.delivery,
+                    filesCount: Array.isArray(params.files) ? params.files.length : 0,
                     ...(delivery.adapter ? { adapter: delivery.adapter } : {}),
                     ...(delivery.messageId ? { messageId: delivery.messageId } : {}),
                     ...(delivery.fallbackReason ? { fallbackReason: delivery.fallbackReason } : {}),
@@ -1958,7 +2206,7 @@ export function registerSlackTools(pi, deps) {
         promptSnippet: "Delete a bot-posted Slack message. This is destructive — set confirm=true, and prefer explicit approval before deleting whole threads.",
         parameters: Type.Object({
             ts: Type.String({
-                description: "Timestamp (ts) of the message to delete. When thread=true, this must be the thread root timestamp.",
+                description: "Timestamp (ts) of the message to delete, or a comma-separated list of bot-posted message timestamps to delete in one confirmed batch. When thread=true, this must be a single thread root timestamp.",
             }),
             channel: Type.Optional(Type.String({
                 description: "Channel name or ID. Omit to use the current thread channel, active DM, or defaultChannel.",
@@ -1977,18 +2225,22 @@ export function registerSlackTools(pi, deps) {
             if (params.confirm !== true) {
                 throw new Error("Deleting Slack messages is irreversible. Re-run with confirm=true once you've verified the target.");
             }
+            const deleteThread = params.thread === true;
+            const requestedTsList = parseSlackDeleteTsInput(params.ts, deleteThread);
+            // Resolve the actual deletion channel BEFORE the guardrail check so the
+            // canonical action quoted in errors, registered via confirm_action, and
+            // enforced on the post-approval retry is identical regardless of how the
+            // caller phrased channel/ts (#814).
+            const channelId = await resolveSlackTargetChannel(params.thread_ts, params.channel);
             requireToolPolicy("slack_delete", params.thread_ts, summarizeSlackDeleteAction({
-                channel: params.channel,
-                defaultChannel: getDefaultChannel(),
+                channel: channelId,
                 threadTs: params.thread_ts,
-                ts: params.ts,
-                thread: params.thread,
+                tsList: requestedTsList,
+                thread: deleteThread,
             }));
-            const deleteThread = params.thread === true;
-            const { channelId, messageTsList } = await resolveSlackDeleteTargets({
-                channel: params.channel,
-                threadTs: params.thread_ts,
-                ts: params.ts,
+            const { messageTsList } = await resolveSlackDeleteTargets({
+                channelId,
+                tsList: requestedTsList,
                 thread: deleteThread,
             });
             for (const messageTs of messageTsList) {
@@ -1997,7 +2249,7 @@ export function registerSlackTools(pi, deps) {
                     ts: messageTs,
                 });
             }
-            const targetTs = params.ts.trim();
+            const targetTs = requestedTsList[0];
             const deletedCount = messageTsList.length;
             const channelLabel = params.channel ?? channelId;
             return {
@@ -2006,7 +2258,9 @@ export function registerSlackTools(pi, deps) {
                         type: "text",
                         text: deleteThread
                             ? `Deleted thread rooted at ${targetTs} in channel ${channelLabel} (${deletedCount} message${deletedCount === 1 ? "" : "s"}).`
-                            : `Deleted message ${targetTs} from channel ${channelLabel}.`,
+                            : deletedCount === 1
+                                ? `Deleted message ${targetTs} from channel ${channelLabel}.`
+                                : `Deleted ${deletedCount} messages (${messageTsList.join(", ")}) from channel ${channelLabel}.`,
                     },
                 ],
                 details: {

package/dist/slack-upload.d.ts

@@ -26,11 +26,22 @@ export interface PerformSlackUploadOptions extends SlackUploadDeps {
     upload: PreparedSlackUpload;
     channelId: string;
     threadTs?: string;
+    initialComment?: string;
+}
+export interface PerformSlackUploadsOptions extends SlackUploadDeps {
+    uploads: readonly PreparedSlackUpload[];
+    channelId: string;
+    threadTs?: string;
+    initialComment?: string;
 }
 export interface CompletedSlackUpload {
     fileId: string;
     response: SlackResult;
 }
+export interface CompletedSlackUploads {
+    fileIds: string[];
+    response: SlackResult;
+}
 interface PrepareSlackUploadFs {
     readFileImpl?: typeof readFile;
     realpathImpl?: typeof realpath;
@@ -45,5 +56,6 @@ export declare function chooseSlackSnippetType(upload: {
 }): string | undefined;
 export declare function resolveSlackUploadPath(inputPath: string, cwd: string, tmpdir: string, fsDeps?: PrepareSlackUploadFs): Promise<string>;
 export declare function prepareSlackUpload(params: SlackUploadParams, cwd: string, tmpdir: string, fsDeps?: PrepareSlackUploadFs): Promise<PreparedSlackUpload>;
-export declare function performSlackUpload({ upload, channelId, threadTs, slack, token, fetchImpl, }: PerformSlackUploadOptions): Promise<CompletedSlackUpload>;
+export declare function performSlackUploads({ uploads, channelId, threadTs, initialComment, slack, token, fetchImpl, }: PerformSlackUploadsOptions): Promise<CompletedSlackUploads>;
+export declare function performSlackUpload({ upload, channelId, threadTs, initialComment, slack, token, fetchImpl, }: PerformSlackUploadOptions): Promise<CompletedSlackUpload>;
 export {};

package/dist/slack-upload.js

@@ -162,7 +162,7 @@ export async function prepareSlackUpload(params, cwd, tmpdir, fsDeps = {}) {
         ...(resolvedPath ? { resolvedPath } : {}),
     };
 }
-export async function performSlackUpload({ upload, channelId, threadTs, slack, token, fetchImpl = fetch, }) {
+async function reserveAndUploadSlackFile(upload, slack, token, fetchImpl) {
     let getUploadResponse;
     try {
         getUploadResponse = await slack("files.getUploadURLExternal", token, buildUploadMetadataPayload(upload, true));
@@ -215,10 +215,37 @@ export async function performSlackUpload({ upload, channelId, threadTs, slack, t
         const hint = isProxyOrFirewallFailure ? " [possible outbound proxy/firewall block]" : "";
         throw new Error(`Slack raw upload failed (HTTP ${rawUploadResponse.status}${statusTextForHeader})${withDetails ? ` ${withDetails}` : ""}${hint}; host=${uploadHost}; filename=${upload.filename} byte_length=${upload.byteLength}`);
     }
+    return { fileId, title: upload.title };
+}
+export async function performSlackUploads({ uploads, channelId, threadTs, initialComment, slack, token, fetchImpl = fetch, }) {
+    if (uploads.length === 0) {
+        throw new Error("At least one upload is required.");
+    }
+    const files = [];
+    for (const upload of uploads) {
+        files.push(await reserveAndUploadSlackFile(upload, slack, token, fetchImpl));
+    }
     const response = await slack("files.completeUploadExternal", token, {
-        files: [{ id: fileId, title: upload.title }],
+        files: files.map((file) => ({ id: file.fileId, title: file.title })),
         channel_id: channelId,
         ...(threadTs ? { thread_ts: threadTs } : {}),
+        ...(initialComment ? { initial_comment: initialComment } : {}),
     });
+    return { fileIds: files.map((file) => file.fileId), response };
+}
+export async function performSlackUpload({ upload, channelId, threadTs, initialComment, slack, token, fetchImpl = fetch, }) {
+    const { fileIds, response } = await performSlackUploads({
+        uploads: [upload],
+        channelId,
+        ...(threadTs ? { threadTs } : {}),
+        ...(initialComment ? { initialComment } : {}),
+        slack,
+        token,
+        fetchImpl,
+    });
+    const fileId = fileIds[0];
+    if (!fileId) {
+        throw new Error("Slack upload did not return a file ID.");
+    }
     return { fileId, response };
 }