opencode-router 0.11.128 → 0.11.130

package/README.md

@@ -75,6 +75,8 @@ Slack support uses Socket Mode and replies in threads when @mentioned in channel
    - `chat:write`
    - `app_mentions:read`
    - `im:history`
+   - `files:read`
+   - `files:write`
 4) Subscribe to events (bot events):
    - `app_mention`
    - `message.im`
@@ -115,6 +117,33 @@ curl -sS "http://127.0.0.1:${OPENCODE_ROUTER_HEALTH_PORT:-3005}/send" \
   -d '{"channel":"telegram","directory":"/path/to/workdir","text":"hello"}'
 ```
 
+Send text + media in one request:
+
+```bash
+curl -sS "http://127.0.0.1:${OPENCODE_ROUTER_HEALTH_PORT:-3005}/send" \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channel":"slack",
+    "peerId":"D12345678",
+    "text":"Here is the export",
+    "parts":[
+      {"type":"file","filePath":"./artifacts/report.pdf"},
+      {"type":"image","filePath":"./artifacts/plot.png","caption":"latest trend"}
+    ]
+  }'
+```
+
+Supported media part types:
+- `image`
+- `audio`
+- `file`
+
+Each media part accepts:
+- `filePath` (absolute path, or relative to the send directory/workspace root)
+- optional `caption`
+- optional `filename`
+- optional `mimeType`
+
 ## Commands
 
 ```bash
@@ -129,6 +158,10 @@ opencode-router slack add <xoxb> <xapp> --id default
 
 opencode-router bindings list
 opencode-router bindings set --channel telegram --identity default --peer <chatId> --dir /path/to/workdir
+
+opencode-router send --channel telegram --identity default --to <chatId> --message "hello"
+opencode-router send --channel telegram --identity default --to <chatId> --image ./plot.png --caption "plot"
+opencode-router send --channel slack --identity default --to D123 --file ./report.pdf
 ```
 
 ## Defaults

package/dist/bridge.js

@@ -4,8 +4,11 @@ import { readFile, stat } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { readConfigFile, writeConfigFile } from "./config.js";
 import { BridgeStore } from "./db.js";
+import { classifyDeliveryError } from "./delivery.js";
 import { normalizeEvent } from "./events.js";
 import { startHealthServer } from "./health.js";
+import { normalizeOutboundParts, summarizeInboundPartsForPrompt, summarizeInboundPartsForReporter, textFromInboundParts } from "./media.js";
+import { MediaStore } from "./media-store.js";
 import { buildPermissionRules, createClient } from "./opencode.js";
 import { chunkText, formatInputSummary, truncateText } from "./text.js";
 import { createSlackAdapter } from "./slack.js";
@@ -128,6 +131,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
     const clients = new Map();
     const defaultDirectory = config.opencodeDirectory;
     const workspaceRoot = resolve(defaultDirectory || process.cwd());
+    const mediaStore = new MediaStore(join(workspaceRoot, ".opencode-router", "media"));
+    await mediaStore.ensureReady();
     const workspaceAgentFilePath = join(workspaceRoot, OPENCODE_ROUTER_AGENT_FILE_RELATIVE_PATH);
     const agentPromptCache = new Map();
     let latestAgentConfig = {
@@ -276,7 +281,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
         for (const bot of enabledTelegram) {
             const key = adapterKey("telegram", bot.id);
             logger.debug({ identityId: bot.id }, "telegram adapter enabled");
-            const base = createTelegramAdapter(bot, config, logger, handleInbound);
+            const base = createTelegramAdapter(bot, config, logger, handleInbound, mediaStore);
             adapters.set(key, { ...base, key });
         }
         const enabledSlack = config.slackApps.filter((app) => app.enabled !== false);
@@ -287,7 +292,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
         for (const app of enabledSlack) {
             const key = adapterKey("slack", app.id);
             logger.debug({ identityId: app.id }, "slack adapter enabled");
-            const base = createSlackAdapter(app, config, logger, handleInbound);
+            const base = createSlackAdapter(app, config, logger, handleInbound, undefined, mediaStore);
             adapters.set(key, { ...base, key });
         }
     }
@@ -448,6 +453,120 @@ export async function startBridge(config, logger, reporter, deps = {}) {
         lastOutboundAt = now;
     };
     await loadMessagingAgentConfig();
+    const outboundMediaMaxBytesRaw = Number.parseInt(process.env.OPENCODE_ROUTER_MAX_MEDIA_BYTES ?? "", 10);
+    const outboundMediaMaxBytes = Number.isFinite(outboundMediaMaxBytesRaw) && outboundMediaMaxBytesRaw > 0
+        ? outboundMediaMaxBytesRaw
+        : 50 * 1024 * 1024;
+    const resolveOutboundParts = async (baseDirectory, input) => {
+        const normalized = normalizeOutboundParts(input);
+        if (normalized.length === 0) {
+            const error = new Error("text or parts is required");
+            error.status = 400;
+            throw error;
+        }
+        const resolved = [];
+        for (const part of normalized) {
+            if (part.type === "text") {
+                resolved.push(part);
+                continue;
+            }
+            const file = await mediaStore.resolveOutboundFile({
+                filePath: part.filePath,
+                baseDirectory,
+                maxBytes: outboundMediaMaxBytes,
+            });
+            resolved.push({
+                ...part,
+                filePath: file.filePath,
+                ...(part.filename ? {} : { filename: file.filename }),
+            });
+        }
+        return resolved;
+    };
+    const deliverParts = async (channel, identityId, peerId, parts, options = {}) => {
+        const adapter = adapters.get(adapterKey(channel, identityId));
+        if (!adapter) {
+            return {
+                attemptedParts: parts.length,
+                sentParts: 0,
+                partResults: parts.map((part, index) => ({
+                    index,
+                    type: part.type,
+                    sent: false,
+                    error: "Adapter not running",
+                    code: "not_found",
+                    retryable: false,
+                })),
+            };
+        }
+        const kind = options.kind ?? "system";
+        if (options.display !== false) {
+            for (const part of parts) {
+                const preview = part.type === "text"
+                    ? truncateText(part.text, 240)
+                    : `[${part.type}] ${part.filename || part.filePath}`;
+                reporter?.onOutbound?.({ channel, identityId, peerId, text: preview, kind });
+            }
+        }
+        recordOutboundActivity(Date.now());
+        if (adapter.sendMessage) {
+            try {
+                return await adapter.sendMessage(peerId, { parts });
+            }
+            catch (error) {
+                const classified = classifyDeliveryError(error);
+                return {
+                    attemptedParts: parts.length,
+                    sentParts: 0,
+                    partResults: parts.map((part, index) => ({
+                        index,
+                        type: part.type,
+                        sent: false,
+                        error: classified.message,
+                        code: classified.code,
+                        retryable: classified.retryable,
+                    })),
+                };
+            }
+        }
+        const partResults = [];
+        let sentParts = 0;
+        for (let index = 0; index < parts.length; index += 1) {
+            const part = parts[index];
+            try {
+                if (part.type === "text") {
+                    const chunks = chunkText(part.text, adapter.maxTextLength);
+                    for (const chunk of chunks) {
+                        await adapter.sendText(peerId, chunk);
+                    }
+                }
+                else if (adapter.sendFile) {
+                    await adapter.sendFile(peerId, part.filePath, part.caption);
+                }
+                else {
+                    throw new Error(`Adapter does not support ${part.type} media`);
+                }
+                sentParts += 1;
+                partResults.push({ index, type: part.type, sent: true });
+            }
+            catch (error) {
+                const classified = classifyDeliveryError(error);
+                partResults.push({
+                    index,
+                    type: part.type,
+                    sent: false,
+                    error: classified.message,
+                    code: classified.code,
+                    retryable: classified.retryable,
+                });
+            }
+        }
+        return {
+            attemptedParts: parts.length,
+            sentParts,
+            partResults,
+        };
+    };
     let stopHealthServer = null;
     if (!deps.disableHealthServer && config.healthPort) {
         stopHealthServer = await startHealthServer(config.healthPort, () => ({
@@ -662,7 +781,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     ...(runtimeAccess === "private" && runtimePairingCodeHash
                         ? { pairingCodeHash: runtimePairingCodeHash }
                         : {}),
-                }, config, logger, handleInbound);
+                }, config, logger, handleInbound, mediaStore);
                 const adapter = { ...base, key };
                 adapters.set(key, adapter);
                 const startResult = await startAdapterBounded(adapter, {
@@ -840,7 +959,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     }
                     adapters.delete(key);
                 }
-                const base = createSlackAdapter({ id, botToken, appToken, enabled, ...(directoryInput ? { directory: directoryInput } : {}) }, config, logger, handleInbound);
+                const base = createSlackAdapter({ id, botToken, appToken, enabled, ...(directoryInput ? { directory: directoryInput } : {}) }, config, logger, handleInbound, undefined, mediaStore);
                 const adapter = { ...base, key };
                 adapters.set(key, adapter);
                 const startResult = await startAdapterBounded(adapter, {
@@ -977,10 +1096,6 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                 const directoryInput = (input.directory ?? "").trim();
                 const peerId = (input.peerId ?? "").trim();
                 const autoBind = input.autoBind === true;
-                const text = input.text ?? "";
-                if (!text.trim()) {
-                    throw new Error("text is required");
-                }
                 if (!directoryInput && !peerId) {
                     throw new Error("directory or peerId is required");
                 }
@@ -996,6 +1111,27 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     }
                     return scoped.directory;
                 })() : "";
+                const baseDirectory = normalizedDir || workspaceRoot;
+                const outboundParts = await resolveOutboundParts(baseDirectory, {
+                    text: input.text,
+                    parts: input.parts,
+                });
+                const makeTargetError = (targetIdentityId, targetPeerId, errorMessage, errorCode = "not_found") => ({
+                    identityId: targetIdentityId,
+                    peerId: targetPeerId,
+                    attemptedParts: outboundParts.length,
+                    sentParts: 0,
+                    partResults: outboundParts.map((part, index) => ({
+                        index,
+                        type: part.type,
+                        sent: false,
+                        error: errorMessage,
+                        code: errorCode,
+                        retryable: false,
+                    })),
+                });
+                const deliveryFailed = (delivery) => delivery.attemptedParts > 0 && delivery.sentParts < delivery.attemptedParts;
+                const primaryFailureMessage = (delivery) => delivery.partResults.find((part) => !part.sent)?.error || "Delivery failed";
                 const resolveSendIdentityId = () => {
                     if (identityId)
                         return identityId;
@@ -1022,11 +1158,13 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                         attempted: 0,
                         sent: 0,
                         reason: `No ${channel} adapter is running for direct send`,
+                        targets: [],
                     };
                 }
                 if (peerId && targetIdentityId) {
                     const adapter = adapters.get(adapterKey(channel, targetIdentityId));
                     if (!adapter) {
+                        const target = makeTargetError(targetIdentityId, peerId, "Adapter not running");
                         return {
                             channel,
                             directory: normalizedDir || workspaceRootNormalized,
@@ -1035,6 +1173,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                             attempted: 1,
                             sent: 0,
                             failures: [{ identityId: targetIdentityId, peerId, error: "Adapter not running" }],
+                            targets: [target],
                         };
                     }
                     if (autoBind && normalizedDir) {
@@ -1042,32 +1181,39 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                         store.deleteSession(channel, targetIdentityId, peerId);
                         ensureEventSubscription(normalizedDir);
                     }
-                    try {
-                        await sendText(channel, targetIdentityId, peerId, text, { kind: "system", display: false });
-                        return {
-                            channel,
-                            directory: normalizedDir || workspaceRootNormalized,
-                            identityId: targetIdentityId,
-                            peerId,
-                            attempted: 1,
-                            sent: 1,
-                        };
-                    }
-                    catch (error) {
-                        return {
-                            channel,
-                            directory: normalizedDir || workspaceRootNormalized,
-                            identityId: targetIdentityId,
-                            peerId,
-                            attempted: 1,
-                            sent: 0,
-                            failures: [{
-                                    identityId: targetIdentityId,
-                                    peerId,
-                                    error: error instanceof Error ? error.message : String(error),
-                                }],
-                        };
-                    }
+                    const delivery = await deliverParts(channel, targetIdentityId, peerId, outboundParts, {
+                        kind: "system",
+                        display: false,
+                    });
+                    const failed = deliveryFailed(delivery);
+                    return {
+                        channel,
+                        directory: normalizedDir || workspaceRootNormalized,
+                        identityId: targetIdentityId,
+                        peerId,
+                        attempted: 1,
+                        sent: failed ? 0 : 1,
+                        ...(failed
+                            ? {
+                                failures: [
+                                    {
+                                        identityId: targetIdentityId,
+                                        peerId,
+                                        error: primaryFailureMessage(delivery),
+                                    },
+                                ],
+                            }
+                            : {}),
+                        targets: [
+                            {
+                                identityId: targetIdentityId,
+                                peerId,
+                                attemptedParts: delivery.attemptedParts,
+                                sentParts: delivery.sentParts,
+                                partResults: delivery.partResults,
+                            },
+                        ],
+                    };
                 }
                 const bindings = store.listBindings({
                     channel,
@@ -1082,9 +1228,11 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                         attempted: 0,
                         sent: 0,
                         reason: `No bound conversations for ${channel}${identityId ? `/${identityId}` : ""} at directory ${normalizedDir}`,
+                        targets: [],
                     };
                 }
                 const failures = [];
+                const targets = [];
                 let attempted = 0;
                 let sent = 0;
                 for (const binding of bindings) {
@@ -1092,6 +1240,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     if (channel === "telegram" && !isTelegramPeerId(binding.peer_id)) {
                         store.deleteBinding(channel, binding.identity_id, binding.peer_id);
                         store.deleteSession(channel, binding.identity_id, binding.peer_id);
+                        const target = makeTargetError(binding.identity_id, binding.peer_id, "Invalid Telegram peerId binding removed (expected numeric chat_id)", "invalid_target");
+                        targets.push(target);
                         failures.push({
                             identityId: binding.identity_id,
                             peerId: binding.peer_id,
@@ -1101,6 +1251,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     }
                     const adapter = adapters.get(adapterKey(channel, binding.identity_id));
                     if (!adapter) {
+                        const target = makeTargetError(binding.identity_id, binding.peer_id, "Adapter not running");
+                        targets.push(target);
                         failures.push({
                             identityId: binding.identity_id,
                             peerId: binding.peer_id,
@@ -1108,17 +1260,27 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                         });
                         continue;
                     }
-                    try {
-                        await sendText(channel, binding.identity_id, binding.peer_id, text, { kind: "system", display: false });
-                        sent += 1;
-                    }
-                    catch (error) {
+                    const delivery = await deliverParts(channel, binding.identity_id, binding.peer_id, outboundParts, {
+                        kind: "system",
+                        display: false,
+                    });
+                    targets.push({
+                        identityId: binding.identity_id,
+                        peerId: binding.peer_id,
+                        attemptedParts: delivery.attemptedParts,
+                        sentParts: delivery.sentParts,
+                        partResults: delivery.partResults,
+                    });
+                    if (deliveryFailed(delivery)) {
                         failures.push({
                             identityId: binding.identity_id,
                             peerId: binding.peer_id,
-                            error: error instanceof Error ? error.message : String(error),
+                            error: primaryFailureMessage(delivery),
                         });
                     }
+                    else {
+                        sent += 1;
+                    }
                 }
                 return {
                     channel,
@@ -1127,6 +1289,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     attempted,
                     sent,
                     ...(failures.length ? { failures } : {}),
+                    targets,
                 };
             },
         });
@@ -1246,27 +1409,13 @@ export async function startBridge(config, logger, reporter, deps = {}) {
     };
     ensureEventSubscription(defaultDirectory);
     async function sendText(channel, identityId, peerId, text, options = {}) {
-        const adapter = adapters.get(adapterKey(channel, identityId));
-        if (!adapter)
-            return;
-        recordOutboundActivity(Date.now());
-        const kind = options.kind ?? "system";
-        logger.debug({ channel, identityId, peerId, kind, length: text.length }, "sendText requested");
-        if (options.display !== false) {
-            reporter?.onOutbound?.({ channel, identityId, peerId, text, kind });
-        }
-        // CHECK IF IT'S A FILE COMMAND
-        if (text.startsWith("FILE:")) {
-            const filePath = text.substring(5).trim();
-            if (adapter.sendFile) {
-                await adapter.sendFile(peerId, filePath);
-                return; // Stop here, don't send text
-            }
-        }
-        const chunks = chunkText(text, adapter.maxTextLength);
-        for (const chunk of chunks) {
-            logger.info({ channel, peerId, length: chunk.length }, "sending message");
-            await adapter.sendText(peerId, chunk);
+        const parts = text.startsWith("FILE:") && text.substring(5).trim()
+            ? [{ type: "file", filePath: text.substring(5).trim() }]
+            : [{ type: "text", text }];
+        const delivery = await deliverParts(channel, identityId, peerId, parts, options);
+        if (delivery.sentParts < delivery.attemptedParts) {
+            const message = delivery.partResults.find((part) => !part.sent)?.error || "Failed to send message";
+            throw new Error(message);
         }
     }
     async function handleTelegramPairingGate(input) {
@@ -1318,16 +1467,35 @@ export async function startBridge(config, logger, reporter, deps = {}) {
         if (!adapter)
             return;
         recordInboundActivity(Date.now());
-        let inbound = message;
+        const normalizedParts = Array.isArray(message.parts) && message.parts.length
+            ? message.parts
+            : message.text.trim()
+                ? [{ type: "text", text: message.text }]
+                : [];
+        const inboundText = textFromInboundParts(normalizedParts, message.text).trim();
+        let inbound = {
+            ...message,
+            text: inboundText,
+            ...(normalizedParts.length ? { parts: normalizedParts } : {}),
+        };
+        if (inbound.fromMe) {
+            logger.debug({
+                channel: inbound.channel,
+                identityId: inbound.identityId,
+                peerId: inbound.peerId,
+            }, "inbound ignored (self-authored)");
+            return;
+        }
+        const reporterInboundText = inbound.text || summarizeInboundPartsForReporter(inbound.parts) || "[empty message]";
         logger.debug({
             channel: inbound.channel,
             identityId: inbound.identityId,
             peerId: inbound.peerId,
             fromMe: inbound.fromMe,
-            length: inbound.text.length,
-            preview: truncateText(inbound.text.trim(), 120),
+            length: reporterInboundText.length,
+            preview: truncateText(reporterInboundText.trim(), 120),
         }, "inbound received");
-        logger.info({ channel: inbound.channel, identityId: inbound.identityId, peerId: inbound.peerId, length: inbound.text.length }, "received message");
+        logger.info({ channel: inbound.channel, identityId: inbound.identityId, peerId: inbound.peerId, length: reporterInboundText.length }, "received message");
         const peerKey = inbound.peerId;
         const trimmedText = inbound.text.trim();
         let binding = store.getBinding(inbound.channel, inbound.identityId, peerKey);
@@ -1356,7 +1524,7 @@ export async function startBridge(config, logger, reporter, deps = {}) {
             channel: inbound.channel,
             identityId: inbound.identityId,
             peerId: inbound.peerId,
-            text: inbound.text,
+            text: reporterInboundText,
             fromMe: inbound.fromMe,
         });
         const identityDirectory = resolveIdentityDirectory(inbound.channel, inbound.identityId);
@@ -1416,6 +1584,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     .map((value) => value.trim())
                     .filter(Boolean)
                     .join("\n\n");
+                const attachmentSummary = summarizeInboundPartsForPrompt(inbound.parts);
+                const incomingText = inbound.text || "(no text; user sent media)";
                 const promptText = [
                     "You are handling a Slack/Telegram message via OpenWork.",
                     `Workspace agent file: ${messagingAgent.filePath}`,
@@ -1424,7 +1594,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                     effectiveInstructions,
                     "",
                     "Incoming user message:",
-                    inbound.text,
+                    incomingText,
+                    ...(attachmentSummary.length ? ["", "Incoming attachments:", ...attachmentSummary] : []),
                 ].join("\n");
                 logger.debug({
                     sessionID,
@@ -1700,7 +1871,8 @@ export async function startBridge(config, logger, reporter, deps = {}) {
                 channel: message.channel,
                 identityId,
                 peerId: message.peerId,
-                text: message.text,
+                text: message.text ?? "",
+                ...(Array.isArray(message.parts) ? { parts: message.parts } : {}),
                 raw: message.raw ?? null,
                 fromMe: message.fromMe,
             });

package/dist/cli.js

@@ -1,7 +1,9 @@
 #!/usr/bin/env bun
 import fs from "node:fs";
+import { readFile as readFileAsync } from "node:fs/promises";
+import path from "node:path";
 import { Command } from "commander";
-import { Bot } from "grammy";
+import { Bot, InputFile } from "grammy";
 import { WebClient } from "@slack/web-api";
 import { startBridge } from "./bridge.js";
 import { loadConfig, readConfigFile, writeConfigFile, } from "./config.js";
@@ -489,11 +491,15 @@ bindings
 // -----------------------------------------------------------------------------
 program
     .command("send")
-    .description("Send a test message")
+    .description("Send a test message and/or media")
     .requiredOption("--channel <channel>", "telegram or slack")
     .requiredOption("--identity <id>", "Identity id")
     .requiredOption("--to <recipient>", "Recipient ID (chat ID or peerId)")
-    .requiredOption("--message <text>", "Message text to send")
+    .option("--message <text>", "Message text to send")
+    .option("--image <path>", "Image file path")
+    .option("--audio <path>", "Audio file path")
+    .option("--file <path>", "File path")
+    .option("--caption <text>", "Caption for media upload")
     .action(async (opts) => {
     const useJson = program.opts().json;
     const channelRaw = opts.channel.trim().toLowerCase();
@@ -503,14 +509,46 @@ program
     const config = loadConfig(process.env, { requireOpencode: false });
     const identityId = normalizeIdentityId(opts.identity);
     const to = opts.to.trim();
-    const message = opts.message;
+    const message = typeof opts.message === "string" ? opts.message : "";
+    const media = [
+        ...(opts.image?.trim() ? [{ type: "image", filePath: path.resolve(opts.image.trim()) }] : []),
+        ...(opts.audio?.trim() ? [{ type: "audio", filePath: path.resolve(opts.audio.trim()) }] : []),
+        ...(opts.file?.trim() ? [{ type: "file", filePath: path.resolve(opts.file.trim()) }] : []),
+    ];
+    const caption = typeof opts.caption === "string" ? opts.caption.trim() : "";
+    if (!message.trim() && media.length === 0) {
+        outputError("Provide at least one of --message, --image, --audio, or --file.");
+    }
     try {
         if (channelRaw === "telegram") {
             const bot = config.telegramBots.find((b) => b.id === identityId);
             if (!bot)
                 throw new Error(`Telegram identity not found: ${identityId}`);
             const tg = new Bot(bot.token);
-            await tg.api.sendMessage(Number(to), message);
+            const chatId = Number(to);
+            if (!Number.isFinite(chatId)) {
+                throw new Error("Telegram recipient must be numeric chat_id.");
+            }
+            if (message.trim()) {
+                await tg.api.sendMessage(chatId, message);
+            }
+            for (const item of media) {
+                if (item.type === "image") {
+                    await tg.api.sendPhoto(chatId, new InputFile(item.filePath), {
+                        ...(caption ? { caption } : {}),
+                    });
+                }
+                else if (item.type === "audio") {
+                    await tg.api.sendAudio(chatId, new InputFile(item.filePath), {
+                        ...(caption ? { caption } : {}),
+                    });
+                }
+                else {
+                    await tg.api.sendDocument(chatId, new InputFile(item.filePath), {
+                        ...(caption ? { caption } : {}),
+                    });
+                }
+            }
         }
         else {
             const app = config.slackApps.find((a) => a.id === identityId);
@@ -520,14 +558,32 @@ program
             const peer = parseSlackPeerId(to);
             if (!peer.channelId)
                 throw new Error("Invalid recipient for Slack.");
-            await web.chat.postMessage({
-                channel: peer.channelId,
-                text: message,
-                ...(peer.threadTs ? { thread_ts: peer.threadTs } : {}),
-            });
+            if (message.trim()) {
+                await web.chat.postMessage({
+                    channel: peer.channelId,
+                    text: message,
+                    ...(peer.threadTs ? { thread_ts: peer.threadTs } : {}),
+                });
+            }
+            for (const item of media) {
+                const fileData = await readFileAsync(item.filePath);
+                await web.files.uploadV2({
+                    channel_id: peer.channelId,
+                    file: fileData,
+                    filename: path.basename(item.filePath),
+                    ...(peer.threadTs ? { thread_ts: peer.threadTs } : {}),
+                    ...(caption ? { initial_comment: caption } : {}),
+                });
+            }
         }
         if (useJson)
-            outputJson({ success: true });
+            outputJson({
+                success: true,
+                sent: {
+                    text: Boolean(message.trim()),
+                    media: media.map((item) => ({ type: item.type, filePath: item.filePath })),
+                },
+            });
         else
             console.log("Message sent.");
         process.exit(0);