@integrity-labs/agt-cli 0.8.9 → 0.9.1

package/mcp/slack-channel.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * Slack channel MCP server for Claude Code persistent sessions.
+ *
+ * Declares `claude/channel` capability so inbound Slack messages are pushed
+ * directly into the Claude Code session. Uses Socket Mode (WebSocket) — no
+ * public URL needed.
+ *
+ * Env vars (passed via .mcp.json env block, per-agent):
+ *   SLACK_BOT_TOKEN  — Bot User OAuth Token (xoxb-...)
+ *   SLACK_APP_TOKEN  — App-Level Token for Socket Mode (xapp-...)
+ *   SLACK_ALLOWED_USERS — Comma-separated Slack user IDs for sender gating (optional)
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { ListToolsRequestSchema, CallToolRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+const BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
+const APP_TOKEN = process.env.SLACK_APP_TOKEN;
+const ALLOWED_USERS = new Set((process.env.SLACK_ALLOWED_USERS ?? '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean));
+if (!BOT_TOKEN || !APP_TOKEN) {
+    console.error('slack-channel: Missing SLACK_BOT_TOKEN or SLACK_APP_TOKEN. Cannot start.');
+    process.exit(1);
+}
+// ---------------------------------------------------------------------------
+// MCP Server with channel capability
+// ---------------------------------------------------------------------------
+const mcp = new Server({ name: 'slack', version: '0.1.0' }, {
+    capabilities: {
+        experimental: { 'claude/channel': {} },
+        tools: {},
+    },
+    instructions: [
+        'Messages from Slack arrive as <channel source="slack" user="..." channel="..." thread_ts="...">.',
+        'Reply using the slack.reply tool, passing channel and thread_ts from the tag.',
+        'For threaded replies, always include thread_ts so the response appears in the same thread.',
+        'When someone @mentions you in a channel, respond helpfully in that thread.',
+        'For DMs, respond directly.',
+    ].join(' '),
+});
+// ---------------------------------------------------------------------------
+// Reply tool — Claude calls this to send messages back to Slack
+// ---------------------------------------------------------------------------
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: 'slack.reply',
+            description: 'Send a message back to a Slack channel or thread',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    channel: {
+                        type: 'string',
+                        description: 'Slack channel ID (from the channel attribute in the <channel> tag)',
+                    },
+                    text: { type: 'string', description: 'The message to send' },
+                    thread_ts: {
+                        type: 'string',
+                        description: 'Thread timestamp for threaded replies (from the thread_ts attribute)',
+                    },
+                },
+                required: ['channel', 'text'],
+            },
+        },
+        {
+            name: 'slack.react',
+            description: 'Add an emoji reaction to a Slack message',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    channel: { type: 'string', description: 'Slack channel ID' },
+                    timestamp: { type: 'string', description: 'Message timestamp to react to' },
+                    emoji: { type: 'string', description: 'Emoji name without colons (e.g. "thumbsup")' },
+                },
+                required: ['channel', 'timestamp', 'emoji'],
+            },
+        },
+    ],
+}));
+mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    if (name === 'slack.reply') {
+        const { channel, text, thread_ts } = args;
+        try {
+            const res = await fetch('https://slack.com/api/chat.postMessage', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${BOT_TOKEN}`,
+                },
+                body: JSON.stringify({
+                    channel,
+                    text,
+                    ...(thread_ts ? { thread_ts } : {}),
+                }),
+            });
+            const data = (await res.json());
+            if (!data.ok) {
+                return {
+                    content: [{ type: 'text', text: `Slack error: ${data.error}` }],
+                    isError: true,
+                };
+            }
+            return { content: [{ type: 'text', text: 'sent' }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed: ${err.message}` }],
+                isError: true,
+            };
+        }
+    }
+    if (name === 'slack.react') {
+        const { channel, timestamp, emoji } = args;
+        try {
+            const res = await fetch('https://slack.com/api/reactions.add', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${BOT_TOKEN}`,
+                },
+                body: JSON.stringify({ channel, timestamp, name: emoji }),
+            });
+            const data = (await res.json());
+            if (!data.ok && data.error !== 'already_reacted') {
+                return {
+                    content: [{ type: 'text', text: `Slack error: ${data.error}` }],
+                    isError: true,
+                };
+            }
+            return { content: [{ type: 'text', text: 'reacted' }] };
+        }
+        catch (err) {
+            return {
+                content: [{ type: 'text', text: `Failed: ${err.message}` }],
+                isError: true,
+            };
+        }
+    }
+    throw new Error(`Unknown tool: ${name}`);
+});
+// ---------------------------------------------------------------------------
+// Connect MCP to Claude Code
+// ---------------------------------------------------------------------------
+await mcp.connect(new StdioServerTransport());
+// ---------------------------------------------------------------------------
+// Socket Mode — connect to Slack and forward events
+// ---------------------------------------------------------------------------
+// Resolve bot user ID so we can filter self-messages
+let botUserId = null;
+async function getBotUserId() {
+    try {
+        const res = await fetch('https://slack.com/api/auth.test', {
+            headers: { Authorization: `Bearer ${BOT_TOKEN}` },
+        });
+        const data = (await res.json());
+        return data.ok ? data.user_id ?? null : null;
+    }
+    catch {
+        return null;
+    }
+}
+// Socket Mode connection using raw WebSocket
+// (avoids heavy @slack/bolt dependency in the MCP server)
+async function connectSocketMode() {
+    // Get WebSocket URL
+    const res = await fetch('https://slack.com/api/apps.connections.open', {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${APP_TOKEN}` },
+    });
+    const data = (await res.json());
+    if (!data.ok || !data.url) {
+        process.stderr.write(`slack-channel: Socket Mode connection failed: ${data.error}\n`);
+        // Retry after 10s
+        setTimeout(connectSocketMode, 10_000);
+        return;
+    }
+    const ws = new WebSocket(data.url);
+    ws.onopen = () => {
+        process.stderr.write('slack-channel: Socket Mode connected\n');
+    };
+    ws.onmessage = async (event) => {
+        try {
+            const msg = JSON.parse(String(event.data));
+            // Acknowledge all envelope messages
+            if (msg.envelope_id) {
+                ws.send(JSON.stringify({ envelope_id: msg.envelope_id }));
+            }
+            // Only process event callbacks
+            if (msg.type !== 'events_api' || !msg.payload?.event)
+                return;
+            const evt = msg.payload.event;
+            // Skip bot's own messages
+            if (evt.user === botUserId)
+                return;
+            // Skip non-message events
+            if (evt.type !== 'app_mention' && evt.type !== 'message')
+                return;
+            // For message events in channels (not DMs), only process app_mention
+            // to avoid responding to every message in a channel
+            if (evt.type === 'message' && evt.channel && !evt.channel.startsWith('D'))
+                return;
+            // Sender gating
+            if (ALLOWED_USERS.size > 0 && evt.user && !ALLOWED_USERS.has(evt.user))
+                return;
+            const text = evt.text ?? '';
+            const channel = evt.channel ?? '';
+            const ts = evt.ts ?? '';
+            const threadTs = evt.thread_ts ?? ts;
+            const user = evt.user ?? 'unknown';
+            // Ack: add eyes reaction immediately so the user knows we saw it
+            if (channel && ts) {
+                fetch('https://slack.com/api/reactions.add', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        Authorization: `Bearer ${BOT_TOKEN}`,
+                    },
+                    body: JSON.stringify({ channel, timestamp: ts, name: 'eyes' }),
+                }).catch(() => { }); // fire-and-forget, don't block
+            }
+            // Push to Claude session as a channel notification
+            await mcp.notification({
+                method: 'notifications/claude/channel',
+                params: {
+                    content: text,
+                    meta: {
+                        user,
+                        channel,
+                        thread_ts: threadTs,
+                        event_type: evt.type,
+                    },
+                },
+            });
+        }
+        catch (err) {
+            process.stderr.write(`slack-channel: Event error: ${err.message}\n`);
+        }
+    };
+    ws.onclose = () => {
+        process.stderr.write('slack-channel: Socket Mode disconnected, reconnecting...\n');
+        setTimeout(connectSocketMode, 5_000);
+    };
+    ws.onerror = (err) => {
+        process.stderr.write(`slack-channel: WebSocket error: ${err}\n`);
+    };
+}
+// Start
+botUserId = await getBotUserId();
+process.stderr.write(`slack-channel: Bot user ID: ${botUserId}\n`);
+connectSocketMode();
+//# sourceMappingURL=slack-channel.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@integrity-labs/agt-cli",
-  "version": "0.8.9",
+  "version": "0.9.1",
   "description": "Augmented CLI — agent provisioning and management",
   "type": "module",
   "bin": {
@@ -12,14 +12,15 @@
     "directory": "apps/cli"
   },
   "files": [
-    "dist"
+    "dist",
+    "mcp"
   ],
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
     "access": "public"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && mkdir -p mcp && cp ../../packages/mcp/dist/index.js mcp/index.js && cp ../../packages/mcp/dist/slack-channel.js mcp/slack-channel.js",
     "dev": "tsx watch src/bin/agt.ts",
     "test": "vitest run",
     "typecheck": "tsc --noEmit",