profclaw 0.0.1-beta.1

package/dist/chat/providers/slack/index.js

@@ -0,0 +1,477 @@
+/**
+ * Slack Provider
+ *
+ * Full implementation of the ChatProvider interface for Slack.
+ * Supports slash commands, interactive components, webhooks, and OAuth.
+ */
+import { z } from 'zod';
+import { createHmac, timingSafeEqual } from 'crypto';
+import { logger } from '../../../utils/logger.js';
+import { chunkForPlatform } from '../../format/chunk.js';
+// CONFIGURATION
+const SlackAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('slack'),
+    mode: z.enum(['socket', 'http']).default('http'),
+    botToken: z.string().optional(),
+    appToken: z.string().optional(),
+    signingSecret: z.string().optional(),
+    webhookUrl: z.string().optional(),
+    teamId: z.string().optional(),
+    teamName: z.string().optional(),
+});
+// CONSTANTS
+const SLACK_API_BASE = 'https://slack.com/api';
+const SLACK_OAUTH_AUTHORIZE = 'https://slack.com/oauth/v2/authorize';
+const SLACK_OAUTH_TOKEN = 'https://slack.com/api/oauth.v2.access';
+// Environment variables
+const SLACK_CLIENT_ID = process.env.SLACK_CLIENT_ID || '';
+const SLACK_CLIENT_SECRET = process.env.SLACK_CLIENT_SECRET || '';
+const SLACK_REDIRECT_URI = process.env.SLACK_REDIRECT_URI || '';
+const SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN || '';
+const SLACK_SIGNING_SECRET = process.env.SLACK_SIGNING_SECRET || '';
+// METADATA
+const meta = {
+    id: 'slack',
+    name: 'Slack',
+    description: 'Slack workspace integration with slash commands and interactive components',
+    icon: '💬',
+    docsUrl: 'https://api.slack.com/docs',
+    order: 1,
+    color: '#4A154B',
+};
+// CAPABILITIES
+const capabilities = {
+    chatTypes: ['direct', 'channel', 'thread'],
+    send: true,
+    receive: true,
+    slashCommands: true,
+    interactiveComponents: true,
+    reactions: true,
+    edit: true,
+    delete: true,
+    threads: true,
+    media: true,
+    richBlocks: true,
+    oauth: true,
+    webhooks: true,
+    realtime: true, // Socket Mode
+};
+// AUTH ADAPTER
+const authAdapter = {
+    getAuthUrl(state, scopes) {
+        if (!SLACK_CLIENT_ID) {
+            throw new Error('SLACK_CLIENT_ID not configured');
+        }
+        const defaultScopes = [
+            'commands',
+            'chat:write',
+            'chat:write.public',
+            'channels:read',
+            'groups:read',
+            'im:read',
+            'mpim:read',
+            'users:read',
+            'reactions:write',
+            'reactions:read',
+        ];
+        const params = new URLSearchParams({
+            client_id: SLACK_CLIENT_ID,
+            scope: (scopes || defaultScopes).join(','),
+            redirect_uri: SLACK_REDIRECT_URI,
+            state,
+        });
+        return `${SLACK_OAUTH_AUTHORIZE}?${params}`;
+    },
+    async exchangeCode(code) {
+        if (!SLACK_CLIENT_ID || !SLACK_CLIENT_SECRET) {
+            throw new Error('Slack OAuth not configured');
+        }
+        const response = await fetch(SLACK_OAUTH_TOKEN, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: new URLSearchParams({
+                client_id: SLACK_CLIENT_ID,
+                client_secret: SLACK_CLIENT_SECRET,
+                code,
+                redirect_uri: SLACK_REDIRECT_URI,
+            }),
+        });
+        const data = (await response.json());
+        if (!data.ok) {
+            throw new Error(`Slack OAuth error: ${data.error}`);
+        }
+        return {
+            accessToken: data.access_token || '',
+            refreshToken: data.refresh_token,
+            expiresIn: data.expires_in,
+            teamId: data.team?.id,
+            teamName: data.team?.name,
+            botUserId: data.bot_user_id,
+        };
+    },
+    verifyWebhook(signature, timestamp, body) {
+        const signingSecret = SLACK_SIGNING_SECRET;
+        if (!signingSecret || !signature || !timestamp) {
+            return false;
+        }
+        // Check timestamp is within 5 minutes
+        const fiveMinutesAgo = Math.floor(Date.now() / 1000) - 60 * 5;
+        if (parseInt(timestamp, 10) < fiveMinutesAgo) {
+            logger.warn('[Slack] Request timestamp too old');
+            return false;
+        }
+        const sigBasestring = `v0:${timestamp}:${body}`;
+        const expectedSignature = `v0=${createHmac('sha256', signingSecret)
+            .update(sigBasestring)
+            .digest('hex')}`;
+        try {
+            return timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature));
+        }
+        catch {
+            return false;
+        }
+    },
+};
+// OUTBOUND ADAPTER
+const outboundAdapter = {
+    async send(message) {
+        const botToken = SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { success: false, error: 'Slack bot token not configured' };
+        }
+        try {
+            const textChunks = message.text
+                ? chunkForPlatform(message.text, 'slack', { mode: 'newline' }).chunks
+                : [];
+            const chunks = textChunks.length > 0 ? textChunks : [undefined];
+            let firstResponse;
+            let firstMessageId;
+            let threadId = message.threadId;
+            for (const [index, chunk] of chunks.entries()) {
+                const payload = {
+                    channel: message.to,
+                };
+                if (chunk !== undefined) {
+                    payload.text = chunk;
+                }
+                if (message.blocks && index === 0) {
+                    payload.blocks = message.blocks;
+                }
+                if (threadId) {
+                    payload.thread_ts = threadId;
+                }
+                const endpoint = message.ephemeral
+                    ? `${SLACK_API_BASE}/chat.postEphemeral`
+                    : `${SLACK_API_BASE}/chat.postMessage`;
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Bearer ${botToken}`,
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(payload),
+                });
+                const data = (await response.json());
+                if (!data.ok) {
+                    return { success: false, error: data.error, raw: data };
+                }
+                if (!firstResponse) {
+                    firstResponse = data;
+                    firstMessageId = data.ts;
+                    threadId = data.message?.thread_ts || data.ts || threadId;
+                }
+            }
+            return {
+                success: true,
+                messageId: firstMessageId,
+                threadId,
+                raw: {
+                    ...(firstResponse ?? {}),
+                    chunkCount: chunks.length,
+                },
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            logger.error('[Slack] Failed to send message', { error: message });
+            return { success: false, error: message };
+        }
+    },
+    async edit(messageId, channelId, content) {
+        const botToken = SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { success: false, error: 'Slack bot token not configured' };
+        }
+        try {
+            const payload = {
+                channel: channelId,
+                ts: messageId,
+            };
+            if (content.text) {
+                payload.text = content.text;
+            }
+            if (content.blocks) {
+                payload.blocks = content.blocks;
+            }
+            const response = await fetch(`${SLACK_API_BASE}/chat.update`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+            const data = (await response.json());
+            if (!data.ok) {
+                return { success: false, error: data.error, raw: data };
+            }
+            return { success: true, messageId: data.ts, raw: data };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async delete(messageId, channelId) {
+        const botToken = SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { success: false, error: 'Slack bot token not configured' };
+        }
+        try {
+            const response = await fetch(`${SLACK_API_BASE}/chat.delete`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ channel: channelId, ts: messageId }),
+            });
+            const data = (await response.json());
+            return { success: data.ok, error: data.error };
+        }
+        catch (error) {
+            return { success: false, error: error instanceof Error ? error.message : String(error) };
+        }
+    },
+    async react(messageId, channelId, emoji) {
+        const botToken = SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { success: false };
+        }
+        try {
+            const response = await fetch(`${SLACK_API_BASE}/reactions.add`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    channel: channelId,
+                    timestamp: messageId,
+                    name: emoji.replace(/:/g, ''),
+                }),
+            });
+            const data = (await response.json());
+            return { success: data.ok };
+        }
+        catch {
+            return { success: false };
+        }
+    },
+    async unreact(messageId, channelId, emoji) {
+        const botToken = SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { success: false };
+        }
+        try {
+            const response = await fetch(`${SLACK_API_BASE}/reactions.remove`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    channel: channelId,
+                    timestamp: messageId,
+                    name: emoji.replace(/:/g, ''),
+                }),
+            });
+            const data = (await response.json());
+            return { success: data.ok };
+        }
+        catch {
+            return { success: false };
+        }
+    },
+};
+// INBOUND ADAPTER
+const inboundAdapter = {
+    parseMessage(payload) {
+        const data = payload;
+        // Handle event callback
+        if (data.type === 'event_callback') {
+            const event = data.event;
+            if (event?.type !== 'message' || event.subtype) {
+                return null; // Not a regular message
+            }
+            return {
+                id: event.ts,
+                provider: 'slack',
+                accountId: data.team_id || 'default',
+                senderId: event.user,
+                senderName: '', // Would need API call to resolve
+                chatType: event.channel_type === 'im' ? 'direct' : 'channel',
+                chatId: event.channel,
+                threadId: event.thread_ts,
+                text: event.text,
+                timestamp: new Date(parseFloat(event.ts) * 1000),
+                rawContent: payload,
+            };
+        }
+        return null;
+    },
+    parseCommand(payload) {
+        const data = payload;
+        // Slack sends slash commands as form-encoded data
+        if (!data.command) {
+            return null;
+        }
+        const channelType = data.channel_name === 'directmessage'
+            ? 'direct'
+            : data.channel_name?.startsWith('G')
+                ? 'group'
+                : 'channel';
+        return {
+            provider: 'slack',
+            accountId: data.team_id || 'default',
+            command: data.command,
+            text: data.text || '',
+            userId: data.user_id,
+            userName: data.user_name,
+            channelId: data.channel_id,
+            channelName: data.channel_name,
+            chatType: channelType,
+            responseUrl: data.response_url,
+            triggerId: data.trigger_id,
+            raw: payload,
+        };
+    },
+    parseAction(payload) {
+        const data = payload;
+        if (data.type !== 'block_actions' && data.type !== 'view_submission') {
+            return null;
+        }
+        const actions = data.actions;
+        const action = actions?.[0];
+        const user = data.user;
+        const channel = data.channel;
+        const message = data.message;
+        return {
+            provider: 'slack',
+            accountId: data.team?.id || 'default',
+            type: action?.type === 'button' ? 'button' : 'select',
+            actionId: action?.action_id,
+            value: action?.value,
+            userId: user?.id,
+            userName: user?.name || user?.username,
+            channelId: channel?.id,
+            messageId: message?.ts,
+            threadId: message?.thread_ts,
+            responseUrl: data.response_url,
+            triggerId: data.trigger_id,
+            raw: payload,
+        };
+    },
+    buildCommandResponse(response) {
+        const slackResponse = {
+            response_type: response.responseType,
+        };
+        if (response.text) {
+            slackResponse.text = response.text;
+        }
+        if (response.blocks) {
+            slackResponse.blocks = response.blocks;
+        }
+        if (response.attachments) {
+            slackResponse.attachments = response.attachments;
+        }
+        return slackResponse;
+    },
+    buildActionResponse(response) {
+        return this.buildCommandResponse(response);
+    },
+};
+// STATUS ADAPTER
+const statusAdapter = {
+    isConfigured(config) {
+        // Need either bot token or OAuth configured
+        return !!(config.botToken ||
+            SLACK_BOT_TOKEN ||
+            (SLACK_CLIENT_ID && SLACK_CLIENT_SECRET));
+    },
+    async checkHealth(config) {
+        const botToken = config.botToken || SLACK_BOT_TOKEN;
+        if (!botToken) {
+            return { connected: false, error: 'No bot token configured' };
+        }
+        const startTime = Date.now();
+        try {
+            const response = await fetch(`${SLACK_API_BASE}/auth.test`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${botToken}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            const latencyMs = Date.now() - startTime;
+            const data = (await response.json());
+            if (!data.ok) {
+                return {
+                    connected: false,
+                    latencyMs,
+                    error: data.error,
+                    details: { team: data.team, user: data.user },
+                };
+            }
+            return {
+                connected: true,
+                latencyMs,
+                details: {
+                    team: data.team,
+                    teamId: data.team_id,
+                    user: data.user,
+                    userId: data.user_id,
+                    botId: data.bot_id,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                connected: false,
+                latencyMs: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+};
+// PROVIDER EXPORT
+export const slackProvider = {
+    meta,
+    capabilities,
+    defaultConfig: {
+        provider: 'slack',
+        mode: 'http',
+        enabled: true,
+    },
+    configSchema: SlackAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+// HELPER EXPORTS
+export { SlackAccountConfigSchema };
+//# sourceMappingURL=index.js.map

package/dist/chat/providers/synology/index.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Synology Chat Provider - Synology Chat via incoming and outgoing webhooks
+ * Docs: https://kb.synology.com/en-global/DSM/help/Chat/chat_integration
+ */
+import { z } from 'zod';
+import type { ChatProvider, SynologyAccountConfig } from '../types.js';
+export interface SynologyOutgoingWebhook {
+    token: string;
+    user_id: string;
+    username: string;
+    text: string;
+    channel_id: string;
+    channel_name?: string;
+    timestamp: number;
+    trigger_word?: string;
+}
+export declare const SynologyAccountConfigSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    isDefault: z.ZodOptional<z.ZodBoolean>;
+    provider: z.ZodLiteral<"synology">;
+    serverUrl: z.ZodOptional<z.ZodString>;
+    incomingWebhookUrl: z.ZodOptional<z.ZodString>;
+    outgoingWebhookToken: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    provider: "synology";
+    enabled: boolean;
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    serverUrl?: string | undefined;
+    incomingWebhookUrl?: string | undefined;
+    outgoingWebhookToken?: string | undefined;
+}, {
+    id: string;
+    provider: "synology";
+    name?: string | undefined;
+    isDefault?: boolean | undefined;
+    enabled?: boolean | undefined;
+    serverUrl?: string | undefined;
+    incomingWebhookUrl?: string | undefined;
+    outgoingWebhookToken?: string | undefined;
+}>;
+type SynologyConfig = z.infer<typeof SynologyAccountConfigSchema>;
+export declare function setSynologyConfig(config: SynologyConfig): void;
+export declare function clearSynologyConfig(): void;
+export declare const synologyProvider: ChatProvider<SynologyAccountConfig>;
+export type { SynologyConfig };
+//# sourceMappingURL=index.d.ts.map

package/dist/chat/providers/synology/index.js

@@ -0,0 +1,138 @@
+/**
+ * Synology Chat Provider - Synology Chat via incoming and outgoing webhooks
+ * Docs: https://kb.synology.com/en-global/DSM/help/Chat/chat_integration
+ */
+import { z } from 'zod';
+import { logger } from '../../../utils/logger.js';
+// --- Schema ---
+export const SynologyAccountConfigSchema = z.object({
+    id: z.string(),
+    name: z.string().optional(),
+    enabled: z.boolean().default(true),
+    isDefault: z.boolean().optional(),
+    provider: z.literal('synology'),
+    serverUrl: z.string().url().optional(),
+    incomingWebhookUrl: z.string().url().optional(),
+    outgoingWebhookToken: z.string().optional(),
+});
+// --- State ---
+let currentConfig = null;
+// --- HTTP helper ---
+async function postToWebhook(webhookUrl, text) {
+    try {
+        const payload = JSON.stringify({ text });
+        const res = await fetch(webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+            body: `payload=${encodeURIComponent(payload)}`,
+        });
+        if (!res.ok)
+            return { ok: false, error: `HTTP ${res.status}` };
+        return { ok: true };
+    }
+    catch (error) {
+        logger.error('[Synology] Incoming webhook POST failed:', error instanceof Error ? error : undefined);
+        return { ok: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+}
+// --- Adapters ---
+const authAdapter = {
+    getAuthUrl(_state, _scopes) {
+        throw new Error('Synology Chat uses webhook URLs from the Synology Chat integration settings.');
+    },
+    async exchangeCode(_code) {
+        throw new Error('Synology Chat does not use OAuth. Configure incomingWebhookUrl in the settings.');
+    },
+    verifyWebhook(token, _timestamp, _body) {
+        const expected = currentConfig?.outgoingWebhookToken;
+        if (!expected) {
+            logger.warn('[Synology] verifyWebhook: outgoingWebhookToken not configured');
+            return false;
+        }
+        return token === expected;
+    },
+};
+const outboundAdapter = {
+    async send(message) {
+        const webhookUrl = currentConfig?.incomingWebhookUrl;
+        if (!webhookUrl)
+            return { success: false, error: 'incomingWebhookUrl not configured' };
+        const result = await postToWebhook(webhookUrl, message.text ?? '');
+        return result.ok
+            ? { success: true }
+            : { success: false, error: result.error ?? 'Failed to post to Synology webhook' };
+    },
+};
+const inboundAdapter = {
+    parseMessage(payload) {
+        const event = payload;
+        if (!event || !event.user_id || !event.text)
+            return null;
+        return {
+            id: `synology-${event.user_id}-${event.timestamp}`,
+            provider: 'synology',
+            accountId: currentConfig?.id ?? 'default',
+            senderId: event.user_id,
+            senderName: event.username ?? event.user_id,
+            senderUsername: event.username ?? event.user_id,
+            chatType: event.channel_id ? 'channel' : 'direct',
+            chatId: event.channel_id ?? event.user_id,
+            chatName: event.channel_name,
+            threadId: undefined,
+            replyToId: undefined,
+            text: event.text,
+            rawContent: event,
+            timestamp: event.timestamp ? new Date(event.timestamp * 1000) : new Date(),
+            attachments: undefined,
+        };
+    },
+    parseCommand(_payload) { return null; },
+    parseAction(_payload) { return null; },
+    buildCommandResponse(response) { return { text: response.text ?? '' }; },
+    buildActionResponse(response) { return { text: response.text ?? '' }; },
+};
+const statusAdapter = {
+    isConfigured(config) {
+        return !!(config.incomingWebhookUrl);
+    },
+    async checkHealth(config) {
+        if (!config.incomingWebhookUrl) {
+            return { connected: false, error: 'incomingWebhookUrl is required' };
+        }
+        // Synology incoming webhooks have no ping endpoint - verify config presence only.
+        return {
+            connected: true,
+            details: {
+                incomingWebhookConfigured: true,
+                outgoingTokenConfigured: !!(config.outgoingWebhookToken),
+                serverUrl: config.serverUrl ?? 'not set',
+            },
+        };
+    },
+};
+// --- Config management ---
+export function setSynologyConfig(config) { currentConfig = config; }
+export function clearSynologyConfig() { currentConfig = null; }
+// --- Provider export ---
+export const synologyProvider = {
+    meta: {
+        id: 'synology', name: 'Synology Chat',
+        description: 'Synology Chat self-hosted messaging via incoming and outgoing webhooks',
+        icon: 'Synology icon',
+        docsUrl: 'https://kb.synology.com/en-global/DSM/help/Chat/chat_integration',
+        order: 22, color: '#4B8EC6',
+    },
+    capabilities: {
+        chatTypes: ['direct', 'channel'],
+        send: true, receive: true, slashCommands: false, interactiveComponents: false,
+        reactions: false, edit: false, delete: false, threads: false,
+        media: false, richBlocks: false, oauth: false, webhooks: true, realtime: false,
+    },
+    defaultConfig: { provider: 'synology', enabled: true },
+    configSchema: SynologyAccountConfigSchema,
+    auth: authAdapter,
+    outbound: outboundAdapter,
+    inbound: inboundAdapter,
+    status: statusAdapter,
+};
+//# sourceMappingURL=index.js.map