tide-commander 1.62.0 → 1.63.0

package/dist/src/packages/server/integrations/slack/slack-routes.js

@@ -4,11 +4,14 @@
  * Mounted at /api/slack/ by the integration registry.
  */
 import { Router } from 'express';
+import multer from 'multer';
 import * as slackClient from './slack-client.js';
 import { loadConfig } from './slack-config.js';
 import { createLogger } from '../../utils/logger.js';
 const log = createLogger('SlackRoutes');
 const router = Router();
+// 50 MB cap matches other integrations (docx). Slack's own limit is higher but this keeps memory sane.
+const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
 // POST /api/slack/send — Send a message
 router.post('/send', async (req, res) => {
     try {
@@ -159,6 +162,134 @@ router.post('/dm', async (req, res) => {
         res.status(500).json({ error: `Failed to send DM: ${err instanceof Error ? err.message : err}` });
     }
 });
+// POST /api/slack/upload — Upload a file (multipart/form-data)
+// Fields: file (binary, required), channelId?, title?, initialComment?, threadTs?
+router.post('/upload', upload.single('file'), async (req, res) => {
+    try {
+        if (!req.file) {
+            res.status(400).json({ error: 'No file uploaded. Use multipart/form-data with field name "file".' });
+            return;
+        }
+        const filename = req.body.filename || req.file.originalname || 'upload.bin';
+        const channelId = req.body.channelId;
+        const title = req.body.title;
+        const initialComment = req.body.initialComment;
+        const threadTs = req.body.threadTs;
+        const result = await slackClient.uploadFile({
+            filename,
+            bytes: req.file.buffer,
+            channelId,
+            title,
+            initialComment,
+            threadTs,
+        });
+        res.json({ success: true, fileId: result.fileId, file: result.file });
+    }
+    catch (err) {
+        log.error(`Slack upload error: ${err}`);
+        res.status(500).json({ error: `Failed to upload file: ${err instanceof Error ? err.message : err}` });
+    }
+});
+// POST /api/slack/upload-base64 — Upload a file via JSON (base64-encoded bytes).
+// Body: { filename, contentBase64, channelId?, title?, initialComment?, threadTs? }
+router.post('/upload-base64', async (req, res) => {
+    try {
+        const { filename, contentBase64, channelId, title, initialComment, threadTs } = req.body;
+        if (!filename || !contentBase64) {
+            res.status(400).json({ error: 'filename and contentBase64 are required' });
+            return;
+        }
+        const bytes = Buffer.from(contentBase64, 'base64');
+        if (!bytes.length) {
+            res.status(400).json({ error: 'contentBase64 decoded to 0 bytes' });
+            return;
+        }
+        const result = await slackClient.uploadFile({
+            filename,
+            bytes,
+            channelId,
+            title,
+            initialComment,
+            threadTs,
+        });
+        res.json({ success: true, fileId: result.fileId, file: result.file });
+    }
+    catch (err) {
+        log.error(`Slack upload-base64 error: ${err}`);
+        res.status(500).json({ error: `Failed to upload file: ${err instanceof Error ? err.message : err}` });
+    }
+});
+// GET /api/slack/files — List files (optional filters: channelId, userId, tsFrom, tsTo, types, count, page)
+router.get('/files', async (req, res) => {
+    try {
+        const count = req.query.count ? parseInt(req.query.count, 10) : undefined;
+        const page = req.query.page ? parseInt(req.query.page, 10) : undefined;
+        const files = await slackClient.listFiles({
+            channelId: req.query.channelId,
+            userId: req.query.userId,
+            tsFrom: req.query.tsFrom,
+            tsTo: req.query.tsTo,
+            types: req.query.types,
+            count,
+            page,
+        });
+        res.json({ files });
+    }
+    catch (err) {
+        log.error(`Slack files list error: ${err}`);
+        res.status(500).json({ error: `Failed to list files: ${err instanceof Error ? err.message : err}` });
+    }
+});
+// GET /api/slack/files/:id — Get file metadata
+router.get('/files/:id', async (req, res) => {
+    try {
+        const file = await slackClient.getFileInfo(req.params.id);
+        res.json({ file });
+    }
+    catch (err) {
+        log.error(`Slack file info error: ${err}`);
+        res.status(500).json({ error: `Failed to get file info: ${err instanceof Error ? err.message : err}` });
+    }
+});
+// GET /api/slack/files/:id/content — Proxy the file's binary content (bot token added server-side)
+router.get('/files/:id/content', async (req, res) => {
+    try {
+        const { buffer, contentType, contentDisposition, contentLength } = await slackClient.fetchFileBytes(req.params.id);
+        if (contentType)
+            res.setHeader('Content-Type', contentType);
+        if (contentDisposition)
+            res.setHeader('Content-Disposition', contentDisposition);
+        if (contentLength)
+            res.setHeader('Content-Length', contentLength);
+        res.status(200).send(buffer);
+    }
+    catch (err) {
+        log.error(`Slack file content error: ${err}`);
+        res.status(500).json({ error: `Failed to fetch file content: ${err instanceof Error ? err.message : err}` });
+    }
+});
+// POST /api/slack/files/:id/download — Server-side download to outputPath on the local filesystem
+router.post('/files/:id/download', async (req, res) => {
+    try {
+        const { outputPath } = req.body;
+        if (!outputPath) {
+            res.status(400).json({ error: 'outputPath is required' });
+            return;
+        }
+        const result = await slackClient.downloadFile(req.params.id, outputPath);
+        res.json({
+            success: true,
+            path: result.path,
+            bytes: result.bytes,
+            filename: result.filename,
+            mimeType: result.mimeType,
+        });
+    }
+    catch (err) {
+        log.error(`Slack file download error: ${err}`);
+        res.status(500).json({ error: `Failed to download file: ${err instanceof Error ? err.message : err}` });
+    }
+});
 // GET /api/slack/status — Get connection status
 router.get('/status', (_req, res) => {
     const config = loadConfig();

package/dist/src/packages/server/integrations/slack/slack-skill.js

@@ -95,6 +95,80 @@ curl -s http://localhost:5174/api/slack/channels
 curl -s http://localhost:5174/api/slack/users/U0123456789
 \`\`\`
 
+## Upload / Images
+
+Upload a file or image to Slack. Uses Slack's new two-step files API (files.upload is deprecated since Nov 2025).
+The bot token must have the **\`files:write\`** scope.
+
+**Multipart (upload a file from disk):**
+\`\`\`bash
+curl -s -F "file=@image.png" \\
+     -F "channelId=C0123456789" \\
+     -F "initialComment=Here's the chart" \\
+     http://localhost:5174/api/slack/upload
+\`\`\`
+
+**JSON / base64 (useful for in-memory images like generated charts):**
+\`\`\`bash
+curl -s -X POST http://localhost:5174/api/slack/upload-base64 \\
+  -H "Content-Type: application/json" \\
+  -d '{
+    "filename":"chart.png",
+    "contentBase64":"iVBORw0KGgoAAAANSUhEUg...",
+    "channelId":"C0123456789",
+    "initialComment":"Here is today\\'s report",
+    "threadTs":"1234567890.123456"
+  }'
+\`\`\`
+
+Fields (both variants):
+- \`file\` or \`contentBase64\` — the bytes (required)
+- \`filename\` — required for base64; multipart uses the uploaded file's original name if omitted
+- \`channelId\` — optional; if omitted the file is uploaded but not shared to a channel
+- \`title\` — optional display title (defaults to filename)
+- \`initialComment\` — optional message posted with the file
+- \`threadTs\` — optional thread timestamp to post the file as a reply
+
+Response: \`{"success":true,"fileId":"F0123...","file":{"id","name","title","mimetype","size","permalink","url_private",...}}\`.
+
+## Read / Download Files
+
+Inspect and download files shared in Slack. Requires the bot token to have **\`files:read\`**.
+
+**List files (optional filters):**
+\`\`\`bash
+# All recent files
+curl -s http://localhost:5174/api/slack/files
+
+# Images shared in a specific channel
+curl -s "http://localhost:5174/api/slack/files?channelId=C0123456789&types=images&count=20"
+\`\`\`
+Filters: \`channelId\`, \`userId\`, \`tsFrom\`, \`tsTo\`, \`types\` (Slack type string like \`images\`, \`pdfs\`, \`spaces\`), \`count\`, \`page\`.
+
+**Get a single file's metadata:**
+\`\`\`bash
+curl -s http://localhost:5174/api/slack/files/F0123ABCD
+\`\`\`
+Returns \`{ "file": { "id","name","title","mimetype","size","permalink","url_private","url_private_download" } }\`.
+
+**Download a file (binary proxy, auth added server-side):**
+\`\`\`bash
+curl -s http://localhost:5174/api/slack/files/F0123ABCD/content -o /tmp/attachment.bin
+\`\`\`
+Preserves upstream \`Content-Type\` and \`Content-Disposition\` from Slack's CDN.
+
+**Server-side save to a filesystem path:**
+\`\`\`bash
+curl -s -X POST http://localhost:5174/api/slack/files/F0123ABCD/download \\
+  -H "Content-Type: application/json" \\
+  -d '{"outputPath":"/tmp/slack/F0123ABCD.png"}'
+\`\`\`
+Returns \`{ "success":true, "path":"/tmp/slack/F0123ABCD.png", "bytes": 12345, "filename":"chart.png", "mimeType":"image/png" }\`.
+
+Messages returned by \`/messages\` and \`/thread\` now include an optional \`files: [...]\` array on each message when attachments exist — use the file ids there as input to the endpoints above.
+
+**Pitfall — do NOT \`curl\` \`url_private\` directly.** Slack's \`url_private\` (and \`url_private_download\`) only return the actual file bytes when the request sends \`Authorization: Bearer <bot-token>\`; without it Slack serves an HTML sign-in page. Use the proxy endpoints above — they attach the bot token server-side so agents never need to handle the token.
+
 ## Check Connection Status
 
 \`\`\`bash

package/dist/src/packages/server/integrations/slack/slack-trigger-handler.js

@@ -46,16 +46,24 @@ export const slackTriggerHandler = {
     extractVariables(trigger, event) {
         const msg = event.data;
         void trigger; // trigger config not needed for basic extraction
+        const files = msg.files ?? [];
         return {
             'slack.user': msg.userName,
             'slack.userId': msg.userId,
             'slack.message': msg.text,
             'slack.channel': msg.channel,
             'slack.threadTs': msg.threadTs || msg.ts,
+            'slack.fileCount': String(files.length),
+            'slack.fileIds': files.map((f) => f.id).join(','),
+            'slack.fileNames': files.map((f) => f.name ?? '').filter(Boolean).join(','),
         };
     },
     formatEventForLLM(event) {
         const msg = event.data;
-        return `Slack message from @${msg.userName} (${msg.userId}) in #${msg.channel}:\n"${msg.text}"`;
+        const files = msg.files ?? [];
+        const filesLine = files.length
+            ? `\nAttachments (${files.length}): ${files.map((f) => `${f.name ?? f.id} [${f.mimetype ?? 'unknown'}]`).join(', ')}`
+            : '';
+        return `Slack message from @${msg.userName} (${msg.userId}) in #${msg.channel}:\n"${msg.text}"${filesLine}`;
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.62.0",
+  "version": "1.63.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",