tide-commander 1.87.0 → 1.89.0

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

@@ -1,660 +1,102 @@
 /**
- * Slack Client
- * Manages Slack Web API + Socket Mode connection, message sending/receiving,
- * channel/user lookup, and long-poll reply waiting.
+ * Slack Client (single-instance facade)
+ *
+ * Thin re-export layer over the `default` SlackInstance. Existing callers
+ * (slack-routes, slack-trigger-handler, slack/index.ts) keep using these
+ * exports unchanged. Multi-instance plumbing lives in slack-instance.ts and
+ * gets surfaced in chunk 2.
  */
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { WebClient } from '@slack/web-api';
-import { SocketModeClient } from '@slack/socket-mode';
-import { loadConfig, updateConfig } from './slack-config.js';
-// Subtypes we never want to trigger on: edits, deletions, channel housekeeping, bot echoes.
-// NOTE: `file_share` (legacy) and undefined (modern file-share) MUST NOT be in this set.
-const SKIP_MESSAGE_SUBTYPES = new Set([
-    'bot_message',
-    'message_changed',
-    'message_deleted',
-    'message_replied',
-    'channel_join',
-    'channel_leave',
-    'channel_topic',
-    'channel_purpose',
-    'channel_name',
-    'channel_archive',
-    'channel_unarchive',
-    'group_join',
-    'group_leave',
-    'group_topic',
-    'group_purpose',
-    'group_name',
-    'group_archive',
-    'group_unarchive',
-    'pinned_item',
-    'unpinned_item',
-]);
-// ─── State ───
-let webClient = null;
-let socketClient = null;
-let ctx = null;
-// Caches
-const userCache = new Map();
-const channelNameCache = new Map();
-// Message listeners (for trigger system)
-const messageListeners = new Set();
-const replyWaiters = new Set();
+import { getInstance, listInstances, clearInstances, } from './slack-instance.js';
 // ─── Init / Shutdown ───
 export async function init(integrationCtx) {
-    ctx = integrationCtx;
-    const botToken = ctx.secrets.get('SLACK_BOT_TOKEN');
-    const appToken = ctx.secrets.get('SLACK_APP_TOKEN');
-    const config = loadConfig();
-    if (!config.enabled || !botToken || !appToken) {
-        ctx.log.info('Slack integration disabled or missing tokens, skipping connection');
-        return;
-    }
-    await connect(botToken, appToken);
+    const inst = getInstance();
+    inst.setContext(integrationCtx);
+    await inst.init();
 }
 export async function shutdown() {
-    await disconnect();
-    userCache.clear();
-    channelNameCache.clear();
-    messageListeners.clear();
-    // Cancel all pending waiters
-    for (const waiter of replyWaiters) {
-        clearTimeout(waiter.timer);
-        waiter.resolve(null);
+    // Shut down every loaded instance (only `default` exists in chunk 1).
+    for (const inst of listInstances()) {
+        await inst.shutdown();
     }
-    replyWaiters.clear();
+    clearInstances();
 }
 // ─── Connection Management ───
-async function connect(botToken, appToken) {
-    updateConfig({ status: 'connecting', lastError: undefined });
-    try {
-        webClient = new WebClient(botToken);
-        socketClient = new SocketModeClient({ appToken });
-        // Test auth and get bot info
-        const authResult = await webClient.auth.test();
-        const botUserId = authResult.user_id;
-        const botName = authResult.user || 'tide-bot';
-        updateConfig({
-            status: 'connected',
-            botUserId,
-            botName,
-            connectedAt: Date.now(),
-        });
-        // Set up Socket Mode event handling
-        setupSocketHandlers();
-        // Start Socket Mode connection
-        await socketClient.start();
-        ctx?.log.info(`Slack connected as @${botName} (${botUserId})`);
-    }
-    catch (err) {
-        const errorMsg = err instanceof Error ? err.message : String(err);
-        updateConfig({ status: 'error', lastError: errorMsg });
-        ctx?.log.error(`Slack connection failed: ${errorMsg}`);
-        webClient = null;
-        socketClient = null;
-        throw err;
-    }
-}
 export async function reconnect() {
-    if (!ctx)
-        throw new Error('Slack not initialized');
-    await disconnect();
-    const botToken = ctx.secrets.get('SLACK_BOT_TOKEN');
-    const appToken = ctx.secrets.get('SLACK_APP_TOKEN');
-    if (!botToken || !appToken) {
-        throw new Error('Missing Slack tokens');
-    }
-    await connect(botToken, appToken);
+    await getInstance().reconnect();
 }
 export async function disconnect() {
-    if (socketClient) {
-        try {
-            await socketClient.disconnect();
-        }
-        catch {
-            // Ignore disconnect errors
-        }
-        socketClient = null;
-    }
-    webClient = null;
-    updateConfig({ status: 'disconnected', connectedAt: undefined });
-}
-function setupSocketHandlers() {
-    if (!socketClient)
-        return;
-    socketClient.on('message', async ({ event, ack }) => {
-        await ack();
-        if (!event)
-            return;
-        // Drop non-trigger-worthy subtypes (edits, joins, bot echoes, topic changes, etc.).
-        // Modern file-share messages have NO subtype; legacy ones use `file_share` — both must pass.
-        if (event.subtype && SKIP_MESSAGE_SUBTYPES.has(event.subtype))
-            return;
-        const hasFiles = Array.isArray(event.files) && event.files.length > 0;
-        const text = event.text ?? '';
-        // Require either text or attached files — otherwise there's nothing useful to trigger on.
-        if (!text && !hasFiles)
-            return;
-        // Skip bot's own messages
-        const config = loadConfig();
-        if (event.user === config.botUserId)
-            return;
-        // Resolve username
-        const user = await resolveUser(event.user);
-        const userName = user?.displayName || user?.name || event.user;
-        const files = hasFiles
-            ? event.files.map((f) => normalizeSlackFile(f))
-            : undefined;
-        const message = {
-            ts: event.ts,
-            threadTs: event.thread_ts,
-            channel: event.channel,
-            userId: event.user,
-            userName,
-            text,
-            timestamp: parseSlackTs(event.ts),
-            files,
-        };
-        // Log to SQLite
-        ctx?.eventDb.logSlackMessage({
-            ts: event.ts,
-            threadTs: event.thread_ts,
-            channelId: event.channel,
-            channelName: channelNameCache.get(event.channel),
-            userId: event.user,
-            userName,
-            text,
-            direction: 'inbound',
-            rawEvent: event,
-            receivedAt: Date.now(),
-        });
-        // Broadcast to WS clients
-        ctx?.broadcast({
-            type: 'slack_message_received',
-            payload: {
-                channel: event.channel,
-                userName,
-                text,
-                ts: event.ts,
-                fileCount: files?.length ?? 0,
-            },
-        });
-        // Notify trigger listeners
-        for (const listener of messageListeners) {
-            try {
-                listener(message);
-            }
-            catch (err) {
-                ctx?.log.error(`Slack message listener error: ${err}`);
-            }
-        }
-        // Check reply waiters
-        for (const waiter of replyWaiters) {
-            if (waiter.channel !== message.channel)
-                continue;
-            if (waiter.threadTs !== message.threadTs && waiter.threadTs !== message.ts)
-                continue;
-            if (waiter.fromUsers?.length && !waiter.fromUsers.includes(message.userId))
-                continue;
-            if (waiter.messagePattern && !new RegExp(waiter.messagePattern).test(message.text))
-                continue;
-            clearTimeout(waiter.timer);
-            replyWaiters.delete(waiter);
-            waiter.resolve(message);
-        }
-    });
-    socketClient.on('disconnect', () => {
-        ctx?.log.warn('Slack Socket Mode disconnected');
-        updateConfig({ status: 'disconnected' });
-    });
-    socketClient.on('unable_to_socket_mode_start', (err) => {
-        ctx?.log.error(`Slack Socket Mode start failed: ${err}`);
-        updateConfig({ status: 'error', lastError: String(err) });
-    });
+    await getInstance().disconnect();
 }
+// ─── Sending ───
 export async function sendMessage(params) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.chat.postMessage({
-        channel: params.channel,
-        text: params.text,
-        thread_ts: params.threadTs,
-    });
-    const ts = result.ts;
-    const channel = result.channel;
-    const config = loadConfig();
-    // Log outbound message to SQLite
-    ctx?.eventDb.logSlackMessage({
-        ts,
-        threadTs: params.threadTs,
-        channelId: channel,
-        channelName: channelNameCache.get(channel),
-        userId: config.botUserId || '',
-        userName: config.botName || 'tide-bot',
-        text: params.text,
-        direction: 'outbound',
-        agentId: params.agentId,
-        workflowInstanceId: params.workflowInstanceId,
-        receivedAt: Date.now(),
-    });
-    return { ts, channel };
+    return getInstance().sendMessage(params);
 }
-/**
- * Add an emoji reaction to a message. Requires `reactions:write`.
- * `already_reacted` responses are swallowed silently.
- */
+// ─── Reactions ───
 export async function addReaction(params) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const name = normalizeEmojiName(params.name);
-    try {
-        await webClient.reactions.add({
-            channel: params.channel,
-            timestamp: params.ts,
-            name,
-        });
-    }
-    catch (err) {
-        const slackErr = err.data?.error;
-        if (slackErr === 'already_reacted')
-            return;
-        throw err;
-    }
-}
-/** Map raw emoji chars to Slack slugs; strip surrounding colons if caller passed `:eyes:`. */
-function normalizeEmojiName(input) {
-    const trimmed = input.trim().replace(/^:|:$/g, '');
-    // Any eye-related emoji char collapses to the common `eyes` slug.
-    if (trimmed === '👁' || trimmed === '👁️' || trimmed === '👀')
-        return 'eyes';
-    return trimmed;
+    return getInstance().addReaction(params);
 }
+// ─── Reading ───
 export async function getChannelMessages(params) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.conversations.history({
-        channel: params.channel,
-        limit: params.limit || 20,
-        oldest: params.oldest,
-        latest: params.latest,
-    });
-    return Promise.all((result.messages || []).map((msg) => slackApiMessageToSlackMessage(msg, params.channel)));
+    return getInstance().getChannelMessages(params);
 }
 export async function getThreadReplies(params) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.conversations.replies({
-        channel: params.channel,
-        ts: params.threadTs,
-        limit: params.limit || 50,
-    });
-    return Promise.all((result.messages || []).map((msg) => slackApiMessageToSlackMessage(msg, params.channel)));
+    return getInstance().getThreadReplies(params);
 }
+// ─── Wait For Reply (Long-Poll) ───
 export function waitForReply(params) {
-    const timeout = params.timeoutMs || 300000; // 5 min default
-    return new Promise((resolve) => {
-        const timer = setTimeout(() => {
-            replyWaiters.delete(waiter);
-            resolve(null);
-        }, timeout);
-        const waiter = {
-            channel: params.channel,
-            threadTs: params.threadTs,
-            fromUsers: params.fromUsers,
-            messagePattern: params.messagePattern,
-            resolve,
-            timer,
-        };
-        replyWaiters.add(waiter);
-    });
+    return getInstance().waitForReply(params);
 }
 // ─── Channel Management ───
 export async function joinChannel(channel) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.conversations.join({ channel });
-    const ch = result.channel;
-    if (!ch)
-        throw new Error(`Failed to join channel ${channel}`);
-    // Update cache
-    channelNameCache.set(ch.id, ch.name);
-    return { id: ch.id, name: ch.name };
+    return getInstance().joinChannel(channel);
 }
 // ─── Lookup ───
 export async function listChannels() {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const channels = [];
-    let cursor;
-    do {
-        const result = await webClient.conversations.list({
-            types: 'public_channel,private_channel',
-            limit: 200,
-            cursor,
-        });
-        for (const ch of result.channels || []) {
-            const channel = {
-                id: ch.id,
-                name: ch.name,
-                isPrivate: ch.is_private,
-                isMember: ch.is_member,
-                topic: ch.topic?.value,
-                purpose: ch.purpose?.value,
-            };
-            channels.push(channel);
-            channelNameCache.set(channel.id, channel.name);
-        }
-        cursor = result.response_metadata?.next_cursor || undefined;
-    } while (cursor);
-    return channels;
+    return getInstance().listChannels();
 }
 export async function resolveUser(userId) {
-    // Check cache
-    const cached = userCache.get(userId);
-    if (cached)
-        return cached;
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.users.info({ user: userId });
-    const u = result.user;
-    if (!u)
-        throw new Error(`User not found: ${userId}`);
-    const user = {
-        id: u.id,
-        name: u.name,
-        realName: u.real_name || '',
-        displayName: u.profile?.display_name || u.name,
-        email: u.profile?.email,
-        isBot: u.is_bot,
-    };
-    userCache.set(userId, user);
-    return user;
+    return getInstance().resolveUser(userId);
 }
 export async function findUserByEmail(email) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    try {
-        const result = await webClient.users.lookupByEmail({ email });
-        const u = result.user;
-        if (!u)
-            return null;
-        const user = {
-            id: u.id,
-            name: u.name,
-            realName: u.real_name || '',
-            displayName: u.profile?.display_name || u.name,
-            email: u.profile?.email,
-            isBot: u.is_bot,
-        };
-        userCache.set(user.id, user);
-        return user;
-    }
-    catch {
-        return null;
-    }
+    return getInstance().findUserByEmail(email);
 }
 export async function findUserByName(displayName) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.users.list({ limit: 500 });
-    const lower = displayName.toLowerCase();
-    for (const u of result.members || []) {
-        const profile = u.profile;
-        if (u.name?.toLowerCase() === lower ||
-            u.real_name?.toLowerCase() === lower ||
-            profile?.display_name?.toLowerCase() === lower) {
-            const user = {
-                id: u.id,
-                name: u.name,
-                realName: u.real_name || '',
-                displayName: profile?.display_name || u.name,
-                email: u.profile?.email,
-                isBot: u.is_bot,
-            };
-            userCache.set(user.id, user);
-            return user;
-        }
-    }
-    return null;
+    return getInstance().findUserByName(displayName);
+}
+export async function searchUsers(query) {
+    return getInstance().searchUsers(query);
 }
 // ─── Direct Messages ───
 export async function openDmChannel(userId) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.conversations.open({ users: userId });
-    const channelId = result.channel?.id;
-    if (!channelId)
-        throw new Error(`Failed to open DM channel with user ${userId}`);
-    return channelId;
+    return getInstance().openDmChannel(userId);
 }
 export async function sendDm(params) {
-    const dmChannel = await openDmChannel(params.userId);
-    return sendMessage({
-        channel: dmChannel,
-        text: params.text,
-        agentId: params.agentId,
-        workflowInstanceId: params.workflowInstanceId,
-    });
+    return getInstance().sendDm(params);
 }
-/**
- * Upload a file to Slack via the new two-step flow:
- *   1. files.getUploadURLExternal (filename, length) → { upload_url, file_id }
- *   2. PUT raw bytes to upload_url
- *   3. files.completeUploadExternal (files[], channel_id?, initial_comment?, thread_ts?)
- * Requires the bot token to have the `files:write` scope.
- */
+// ─── File Upload / Read / Download ───
 export async function uploadFile(params) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const length = params.bytes instanceof Buffer ? params.bytes.length : params.bytes.byteLength;
-    if (!length)
-        throw new Error('uploadFile: bytes is empty');
-    // Step 1: get an external upload URL
-    const step1 = await webClient.files.getUploadURLExternal({
-        filename: params.filename,
-        length,
-    });
-    if (!step1.ok || !step1.upload_url || !step1.file_id) {
-        throw new Error(`Slack files.getUploadURLExternal failed: ${step1.error ?? 'unknown error'}`);
-    }
-    // Step 2: POST the raw bytes to the signed upload URL (no Slack auth on this call).
-    // Node's global fetch accepts Buffer/Uint8Array at runtime; BodyInit types require a cast.
-    const bodyBytes = params.bytes instanceof Buffer
-        ? new Uint8Array(params.bytes.buffer, params.bytes.byteOffset, params.bytes.byteLength)
-        : params.bytes;
-    const putResp = await fetch(step1.upload_url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/octet-stream' },
-        body: bodyBytes,
-    });
-    if (!putResp.ok) {
-        const detail = await putResp.text().catch(() => '');
-        throw new Error(`Slack upload_url POST failed (${putResp.status}): ${detail}`);
-    }
-    // Step 3: finalize and (optionally) share
-    const files = [
-        { id: step1.file_id, title: params.title ?? params.filename },
-    ];
-    const step3 = params.channelId
-        ? await webClient.files.completeUploadExternal({
-            files,
-            channel_id: params.channelId,
-            initial_comment: params.initialComment,
-            thread_ts: params.threadTs,
-        })
-        : await webClient.files.completeUploadExternal({ files });
-    if (!step3.ok) {
-        throw new Error(`Slack files.completeUploadExternal failed: ${step3.error ?? 'unknown error'}`);
-    }
-    const file = (step3.files?.[0] ?? { id: step1.file_id });
-    return { fileId: step1.file_id, file };
+    return getInstance().uploadFile(params);
 }
-/**
- * List files visible to the bot, optionally filtered by channel/user/time/type.
- * Requires the bot token to have `files:read`.
- */
 export async function listFiles(params = {}) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.files.list({
-        channel: params.channelId,
-        user: params.userId,
-        ts_from: params.tsFrom,
-        ts_to: params.tsTo,
-        types: params.types,
-        count: params.count ?? 50,
-        page: params.page,
-    });
-    return (result.files ?? []).map((f) => normalizeSlackFile(f));
+    return getInstance().listFiles(params);
 }
-/** Fetch metadata for a single file (title, permalink, url_private, mimetype, size, ...). */
 export async function getFileInfo(fileId) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.files.info({ file: fileId });
-    if (!result.ok || !result.file) {
-        throw new Error(`Slack files.info failed for ${fileId}: ${result.error ?? 'unknown error'}`);
-    }
-    return normalizeSlackFile(result.file);
+    return getInstance().getFileInfo(fileId);
 }
-/**
- * Fetch a file's raw bytes using the bot token Bearer auth.
- * Slack's `url_private` redirects to the CDN but requires the bot token on the initial request.
- */
 export async function fetchFileBytes(fileId) {
-    const token = ctx?.secrets.get('SLACK_BOT_TOKEN');
-    if (!token)
-        throw new Error('Slack bot token is not configured');
-    const info = await getFileInfo(fileId);
-    const url = info.url_private_download || info.url_private;
-    if (!url)
-        throw new Error(`Slack file ${fileId} has no url_private`);
-    const response = await fetch(url, {
-        method: 'GET',
-        headers: {
-            Authorization: `Bearer ${token}`,
-            Accept: '*/*',
-        },
-        redirect: 'follow',
-    });
-    if (!response.ok) {
-        const detail = await response.text().catch(() => '');
-        throw new Error(`Slack file download failed for ${fileId} (${response.status}): ${detail}`);
-    }
-    return {
-        buffer: Buffer.from(await response.arrayBuffer()),
-        contentType: response.headers.get('content-type'),
-        contentDisposition: response.headers.get('content-disposition'),
-        contentLength: response.headers.get('content-length'),
-        filename: info.name,
-    };
+    return getInstance().fetchFileBytes(fileId);
 }
-/**
- * Download a Slack file to disk. Accepts a file id or a full {@link SlackFile} object.
- * Parent directory is created if missing; filename collisions overwrite.
- */
 export async function downloadFile(file, outputPath) {
-    const fileId = typeof file === 'string' ? file : file.id;
-    const { buffer, filename, contentType } = await fetchFileBytes(fileId);
-    await fs.mkdir(path.dirname(path.resolve(outputPath)), { recursive: true });
-    await fs.writeFile(outputPath, buffer);
-    return {
-        path: outputPath,
-        bytes: buffer.byteLength,
-        filename,
-        mimeType: contentType ?? undefined,
-    };
-}
-function normalizeSlackFile(f) {
-    return {
-        id: f.id,
-        name: f.name,
-        title: f.title,
-        mimetype: f.mimetype,
-        size: f.size,
-        permalink: f.permalink,
-        permalink_public: f.permalink_public,
-        url_private: f.url_private,
-        url_private_download: f.url_private_download,
-    };
-}
-export async function searchUsers(query) {
-    if (!webClient)
-        throw new Error('Slack not connected');
-    const result = await webClient.users.list({ limit: 500 });
-    const lower = query.toLowerCase();
-    const matches = [];
-    for (const u of result.members || []) {
-        if (u.deleted || u.is_bot)
-            continue;
-        const profile = u.profile;
-        const name = u.name || '';
-        const realName = u.real_name || '';
-        const displayName = profile?.display_name || '';
-        const email = profile?.email || '';
-        if (name.toLowerCase().includes(lower) ||
-            realName.toLowerCase().includes(lower) ||
-            displayName.toLowerCase().includes(lower) ||
-            email.toLowerCase().includes(lower)) {
-            const user = {
-                id: u.id,
-                name,
-                realName,
-                displayName: displayName || name,
-                email,
-                isBot: false,
-            };
-            userCache.set(user.id, user);
-            matches.push(user);
-        }
-    }
-    return matches;
+    return getInstance().downloadFile(file, outputPath);
 }
 // ─── Event Subscription (for triggers) ───
 export function onMessage(callback) {
-    messageListeners.add(callback);
-    return () => { messageListeners.delete(callback); };
+    return getInstance().onMessage(callback);
 }
 // ─── Status ───
 export function getStatus() {
-    const config = loadConfig();
-    return {
-        connected: config.status === 'connected',
-        lastChecked: Date.now(),
-        error: config.lastError,
-    };
+    return getInstance().getStatus();
 }
 export function isConnected() {
-    return loadConfig().status === 'connected' && webClient !== null;
-}
-// ─── Helpers ───
-function parseSlackTs(ts) {
-    return Math.floor(parseFloat(ts) * 1000);
-}
-async function slackApiMessageToSlackMessage(msg, channel) {
-    const userId = msg.user || '';
-    let userName = userId;
-    try {
-        if (userId) {
-            const user = await resolveUser(userId);
-            userName = user.displayName || user.name;
-        }
-    }
-    catch {
-        // Use userId as fallback
-    }
-    const rawFiles = msg.files;
-    const files = rawFiles?.length ? rawFiles.map(normalizeSlackFile) : undefined;
-    return {
-        ts: msg.ts,
-        threadTs: msg.thread_ts,
-        channel,
-        userId,
-        userName,
-        text: msg.text || '',
-        timestamp: parseSlackTs(msg.ts),
-        files,
-    };
+    return getInstance().isConnected();
 }