claudecode-omc 4.9.5 → 5.1.0

package/dist/notifications/dispatcher.js

@@ -1,672 +0,0 @@
-/**
- * Notification Dispatcher
- *
- * Sends notifications to configured platforms (Discord, Telegram, Slack, webhook).
- * All sends are non-blocking with timeouts. Failures are swallowed to avoid
- * blocking hooks.
- */
-import { request as httpsRequest } from "https";
-import { parseMentionAllowedMentions, validateSlackMention, validateSlackChannel, validateSlackUsername, } from "./config.js";
-/** Per-request timeout for individual platform sends */
-const SEND_TIMEOUT_MS = 10_000;
-/** Overall dispatch timeout for all platforms combined. Must be >= SEND_TIMEOUT_MS */
-const DISPATCH_TIMEOUT_MS = 15_000;
-/** Discord maximum content length */
-const DISCORD_MAX_CONTENT_LENGTH = 2000;
-/**
- * Compose Discord message content with mention prefix.
- * Enforces the 2000-char Discord content limit by truncating the message body.
- * Returns { content, allowed_mentions } ready for the Discord API.
- */
-function composeDiscordContent(message, mention) {
-    const mentionParsed = parseMentionAllowedMentions(mention);
-    const allowed_mentions = {
-        parse: [], // disable implicit @everyone/@here
-        users: mentionParsed.users,
-        roles: mentionParsed.roles,
-    };
-    let content;
-    if (mention) {
-        const prefix = `${mention}\n`;
-        const maxBody = DISCORD_MAX_CONTENT_LENGTH - prefix.length;
-        const body = message.length > maxBody
-            ? message.slice(0, maxBody - 1) + "\u2026"
-            : message;
-        content = `${prefix}${body}`;
-    }
-    else {
-        content =
-            message.length > DISCORD_MAX_CONTENT_LENGTH
-                ? message.slice(0, DISCORD_MAX_CONTENT_LENGTH - 1) + "\u2026"
-                : message;
-    }
-    return { content, allowed_mentions };
-}
-/**
- * Validate Discord webhook URL.
- * Must be HTTPS from discord.com or discordapp.com.
- */
-function validateDiscordUrl(webhookUrl) {
-    try {
-        const url = new URL(webhookUrl);
-        const allowedHosts = ["discord.com", "discordapp.com"];
-        if (!allowedHosts.some((host) => url.hostname === host || url.hostname.endsWith(`.${host}`))) {
-            return false;
-        }
-        return url.protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Validate Telegram bot token format (digits:alphanumeric).
- */
-function validateTelegramToken(token) {
-    return /^[0-9]+:[A-Za-z0-9_-]+$/.test(token);
-}
-/**
- * Validate Slack webhook URL.
- * Must be HTTPS from hooks.slack.com.
- */
-function validateSlackUrl(webhookUrl) {
-    try {
-        const url = new URL(webhookUrl);
-        return (url.protocol === "https:" &&
-            (url.hostname === "hooks.slack.com" ||
-                url.hostname.endsWith(".hooks.slack.com")));
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Validate generic webhook URL. Must be HTTPS.
- */
-function validateWebhookUrl(url) {
-    try {
-        const parsed = new URL(url);
-        return parsed.protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Send notification via Discord webhook.
- */
-export async function sendDiscord(config, payload) {
-    if (!config.enabled || !config.webhookUrl) {
-        return { platform: "discord", success: false, error: "Not configured" };
-    }
-    if (!validateDiscordUrl(config.webhookUrl)) {
-        return {
-            platform: "discord",
-            success: false,
-            error: "Invalid webhook URL",
-        };
-    }
-    try {
-        const { content, allowed_mentions } = composeDiscordContent(payload.message, config.mention);
-        const body = { content, allowed_mentions };
-        if (config.username) {
-            body.username = config.username;
-        }
-        const response = await fetch(config.webhookUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            return {
-                platform: "discord",
-                success: false,
-                error: `HTTP ${response.status}`,
-            };
-        }
-        return { platform: "discord", success: true };
-    }
-    catch (error) {
-        return {
-            platform: "discord",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Send notification via Discord Bot API (token + channel ID).
- * Bot token and channel ID should be resolved in config layer.
- */
-export async function sendDiscordBot(config, payload) {
-    if (!config.enabled) {
-        return { platform: "discord-bot", success: false, error: "Not enabled" };
-    }
-    const botToken = config.botToken;
-    const channelId = config.channelId;
-    if (!botToken || !channelId) {
-        return {
-            platform: "discord-bot",
-            success: false,
-            error: "Missing botToken or channelId",
-        };
-    }
-    try {
-        const { content, allowed_mentions } = composeDiscordContent(payload.message, config.mention);
-        const url = `https://discord.com/api/v10/channels/${channelId}/messages`;
-        const response = await fetch(url, {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                Authorization: `Bot ${botToken}`,
-            },
-            body: JSON.stringify({ content, allowed_mentions }),
-            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            return {
-                platform: "discord-bot",
-                success: false,
-                error: `HTTP ${response.status}`,
-            };
-        }
-        // NEW: Parse response to extract message ID
-        let messageId;
-        try {
-            const data = (await response.json());
-            messageId = data?.id;
-        }
-        catch {
-            // Non-fatal: message was sent, we just can't track it
-        }
-        return { platform: "discord-bot", success: true, messageId };
-    }
-    catch (error) {
-        return {
-            platform: "discord-bot",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Send notification via Telegram bot API.
- * Uses native https module with IPv4 to avoid fetch/undici IPv6 connectivity issues.
- */
-export async function sendTelegram(config, payload) {
-    if (!config.enabled || !config.botToken || !config.chatId) {
-        return { platform: "telegram", success: false, error: "Not configured" };
-    }
-    if (!validateTelegramToken(config.botToken)) {
-        return {
-            platform: "telegram",
-            success: false,
-            error: "Invalid bot token format",
-        };
-    }
-    try {
-        const body = JSON.stringify({
-            chat_id: config.chatId,
-            text: payload.message,
-            parse_mode: config.parseMode || "Markdown",
-        });
-        const result = await new Promise((resolve) => {
-            const req = httpsRequest({
-                hostname: "api.telegram.org",
-                path: `/bot${config.botToken}/sendMessage`,
-                method: "POST",
-                family: 4, // Force IPv4 - fetch/undici has IPv6 issues on some systems
-                headers: {
-                    "Content-Type": "application/json",
-                    "Content-Length": Buffer.byteLength(body),
-                },
-                timeout: SEND_TIMEOUT_MS,
-            }, (res) => {
-                // Collect response chunks to parse message_id
-                const chunks = [];
-                res.on("data", (chunk) => chunks.push(chunk));
-                res.on("end", () => {
-                    if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                        // Parse response to extract message_id
-                        let messageId;
-                        try {
-                            const body = JSON.parse(Buffer.concat(chunks).toString("utf-8"));
-                            if (body?.result?.message_id !== undefined) {
-                                messageId = String(body.result.message_id);
-                            }
-                        }
-                        catch {
-                            // Non-fatal: message was sent, we just can't track it
-                        }
-                        resolve({ platform: "telegram", success: true, messageId });
-                    }
-                    else {
-                        resolve({
-                            platform: "telegram",
-                            success: false,
-                            error: `HTTP ${res.statusCode}`,
-                        });
-                    }
-                });
-            });
-            req.on("error", (e) => {
-                resolve({ platform: "telegram", success: false, error: e.message });
-            });
-            req.on("timeout", () => {
-                req.destroy();
-                resolve({
-                    platform: "telegram",
-                    success: false,
-                    error: "Request timeout",
-                });
-            });
-            req.write(body);
-            req.end();
-        });
-        return result;
-    }
-    catch (error) {
-        return {
-            platform: "telegram",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Compose Slack message text with mention prefix.
- * Slack mentions use formats like <@U12345678>, <!channel>, <!here>, <!everyone>,
- * or <!subteam^S12345> for user groups.
- *
- * Defense-in-depth: re-validates mention at point of use (config layer validates
- * at read time, but we validate again here to guard against untrusted config).
- */
-function composeSlackText(message, mention) {
-    const validatedMention = validateSlackMention(mention);
-    if (validatedMention) {
-        return `${validatedMention}\n${message}`;
-    }
-    return message;
-}
-/**
- * Send notification via Slack incoming webhook.
- */
-export async function sendSlack(config, payload) {
-    if (!config.enabled || !config.webhookUrl) {
-        return { platform: "slack", success: false, error: "Not configured" };
-    }
-    if (!validateSlackUrl(config.webhookUrl)) {
-        return { platform: "slack", success: false, error: "Invalid webhook URL" };
-    }
-    try {
-        const text = composeSlackText(payload.message, config.mention);
-        const body = { text };
-        // Defense-in-depth: validate channel/username at point of use to guard
-        // against crafted config values containing shell metacharacters or
-        // path traversal sequences.
-        const validatedChannel = validateSlackChannel(config.channel);
-        if (validatedChannel) {
-            body.channel = validatedChannel;
-        }
-        const validatedUsername = validateSlackUsername(config.username);
-        if (validatedUsername) {
-            body.username = validatedUsername;
-        }
-        const response = await fetch(config.webhookUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(body),
-            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            return {
-                platform: "slack",
-                success: false,
-                error: `HTTP ${response.status}`,
-            };
-        }
-        return { platform: "slack", success: true };
-    }
-    catch (error) {
-        return {
-            platform: "slack",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Send notification via Slack Bot Web API (chat.postMessage).
- * Returns message timestamp (ts) as messageId for reply correlation.
- */
-export async function sendSlackBot(config, payload) {
-    if (!config.enabled) {
-        return { platform: "slack-bot", success: false, error: "Not enabled" };
-    }
-    const botToken = config.botToken;
-    const channelId = config.channelId;
-    if (!botToken || !channelId) {
-        return {
-            platform: "slack-bot",
-            success: false,
-            error: "Missing botToken or channelId",
-        };
-    }
-    try {
-        const text = composeSlackText(payload.message, config.mention);
-        const response = await fetch("https://slack.com/api/chat.postMessage", {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${botToken}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ channel: channelId, text }),
-            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            return {
-                platform: "slack-bot",
-                success: false,
-                error: `HTTP ${response.status}`,
-            };
-        }
-        const data = await response.json();
-        if (!data.ok) {
-            return {
-                platform: "slack-bot",
-                success: false,
-                error: data.error || "Slack API error",
-            };
-        }
-        return { platform: "slack-bot", success: true, messageId: data.ts };
-    }
-    catch (error) {
-        return {
-            platform: "slack-bot",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Send notification via generic webhook (POST JSON).
- */
-export async function sendWebhook(config, payload) {
-    if (!config.enabled || !config.url) {
-        return { platform: "webhook", success: false, error: "Not configured" };
-    }
-    if (!validateWebhookUrl(config.url)) {
-        return {
-            platform: "webhook",
-            success: false,
-            error: "Invalid URL (HTTPS required)",
-        };
-    }
-    try {
-        const headers = {
-            "Content-Type": "application/json",
-            ...config.headers,
-        };
-        const response = await fetch(config.url, {
-            method: config.method || "POST",
-            headers,
-            body: JSON.stringify({
-                event: payload.event,
-                session_id: payload.sessionId,
-                message: payload.message,
-                timestamp: payload.timestamp,
-                tmux_session: payload.tmuxSession,
-                project_name: payload.projectName,
-                project_path: payload.projectPath,
-                modes_used: payload.modesUsed,
-                duration_ms: payload.durationMs,
-                reason: payload.reason,
-                active_mode: payload.activeMode,
-                question: payload.question,
-                ...(payload.replyChannel && { channel: payload.replyChannel }),
-                ...(payload.replyTarget && { to: payload.replyTarget }),
-                ...(payload.replyThread && { thread_id: payload.replyThread }),
-            }),
-            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
-        });
-        if (!response.ok) {
-            return {
-                platform: "webhook",
-                success: false,
-                error: `HTTP ${response.status}`,
-            };
-        }
-        return { platform: "webhook", success: true };
-    }
-    catch (error) {
-        return {
-            platform: "webhook",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}
-/**
- * Get the effective platform config for an event.
- * Event-level config overrides top-level defaults.
- */
-function getEffectivePlatformConfig(platform, config, event) {
-    const topLevel = config[platform];
-    const eventConfig = config.events?.[event];
-    const eventPlatform = eventConfig?.[platform];
-    // Event-level override merged with top-level defaults.
-    // This ensures fields like `mention` are inherited from top-level
-    // when the event-level config omits them.
-    if (eventPlatform &&
-        typeof eventPlatform === "object" &&
-        "enabled" in eventPlatform) {
-        if (topLevel && typeof topLevel === "object") {
-            return { ...topLevel, ...eventPlatform };
-        }
-        return eventPlatform;
-    }
-    // Top-level default
-    return topLevel;
-}
-/**
- * Dispatch notifications to all enabled platforms for an event.
- *
- * Runs all sends in parallel with an overall timeout.
- * Individual failures don't block other platforms.
- */
-export async function dispatchNotifications(config, event, payload, platformMessages) {
-    const promises = [];
-    /** Get payload for a platform, using per-platform message if available. */
-    const payloadFor = (platform) => platformMessages?.has(platform)
-        ? { ...payload, message: platformMessages.get(platform) }
-        : payload;
-    // Discord
-    const discordConfig = getEffectivePlatformConfig("discord", config, event);
-    if (discordConfig?.enabled) {
-        promises.push(sendDiscord(discordConfig, payloadFor("discord")));
-    }
-    // Telegram
-    const telegramConfig = getEffectivePlatformConfig("telegram", config, event);
-    if (telegramConfig?.enabled) {
-        promises.push(sendTelegram(telegramConfig, payloadFor("telegram")));
-    }
-    // Slack
-    const slackConfig = getEffectivePlatformConfig("slack", config, event);
-    if (slackConfig?.enabled) {
-        promises.push(sendSlack(slackConfig, payloadFor("slack")));
-    }
-    // Webhook
-    const webhookConfig = getEffectivePlatformConfig("webhook", config, event);
-    if (webhookConfig?.enabled) {
-        promises.push(sendWebhook(webhookConfig, payloadFor("webhook")));
-    }
-    // Discord Bot
-    const discordBotConfig = getEffectivePlatformConfig("discord-bot", config, event);
-    if (discordBotConfig?.enabled) {
-        promises.push(sendDiscordBot(discordBotConfig, payloadFor("discord-bot")));
-    }
-    // Slack Bot
-    const slackBotConfig = getEffectivePlatformConfig("slack-bot", config, event);
-    if (slackBotConfig?.enabled) {
-        promises.push(sendSlackBot(slackBotConfig, payloadFor("slack-bot")));
-    }
-    if (promises.length === 0) {
-        return { event, results: [], anySuccess: false };
-    }
-    // Race all sends against a timeout. Timer is cleared when allSettled wins.
-    let timer;
-    try {
-        const results = await Promise.race([
-            Promise.allSettled(promises).then((settled) => settled.map((s) => s.status === "fulfilled"
-                ? s.value
-                : {
-                    platform: "unknown",
-                    success: false,
-                    error: String(s.reason),
-                })),
-            new Promise((resolve) => {
-                timer = setTimeout(() => resolve([
-                    {
-                        platform: "unknown",
-                        success: false,
-                        error: "Dispatch timeout",
-                    },
-                ]), DISPATCH_TIMEOUT_MS);
-            }),
-        ]);
-        return {
-            event,
-            results,
-            anySuccess: results.some((r) => r.success),
-        };
-    }
-    catch (error) {
-        return {
-            event,
-            results: [
-                {
-                    platform: "unknown",
-                    success: false,
-                    error: String(error),
-                },
-            ],
-            anySuccess: false,
-        };
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-// ============================================================================
-// CUSTOM INTEGRATION DISPATCH (Added for Notification Refactor)
-// ============================================================================
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { interpolateTemplate } from "./template-engine.js";
-import { getCustomIntegrationsForEvent } from "./config.js";
-const execFileAsync = promisify(execFile);
-/**
- * Send a webhook notification for a custom integration.
- */
-export async function sendCustomWebhook(integration, payload) {
-    const config = integration.config;
-    try {
-        // Interpolate template variables
-        const url = interpolateTemplate(config.url, payload);
-        const body = interpolateTemplate(config.bodyTemplate, payload);
-        // Prepare headers
-        const headers = {};
-        for (const [key, value] of Object.entries(config.headers)) {
-            headers[key] = interpolateTemplate(value, payload);
-        }
-        // Use native fetch (Node.js 18+)
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), config.timeout);
-        try {
-            const response = await fetch(url, {
-                method: config.method,
-                headers,
-                body: config.method !== 'GET' ? body : undefined,
-                signal: controller.signal,
-            });
-            if (!response.ok) {
-                return {
-                    platform: "webhook",
-                    success: false,
-                    error: `HTTP ${response.status}: ${response.statusText}`,
-                };
-            }
-            return {
-                platform: "webhook",
-                success: true,
-            };
-        }
-        finally {
-            clearTimeout(timeout);
-        }
-    }
-    catch (error) {
-        return {
-            platform: "webhook",
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Execute a CLI command for a custom integration.
- * Uses execFile (not shell) for security.
- */
-export async function sendCustomCli(integration, payload) {
-    const config = integration.config;
-    try {
-        // Interpolate template variables into arguments
-        const args = config.args.map((arg) => interpolateTemplate(arg, payload));
-        // Execute using execFile (array args, no shell injection possible)
-        await execFileAsync(config.command, args, {
-            timeout: config.timeout,
-            killSignal: "SIGTERM",
-        });
-        return {
-            platform: "webhook", // Group with webhooks in results
-            success: true,
-        };
-    }
-    catch (error) {
-        return {
-            platform: "webhook",
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Dispatch notifications for custom integrations.
- */
-export async function dispatchCustomIntegrations(event, payload) {
-    const integrations = getCustomIntegrationsForEvent(event);
-    if (integrations.length === 0)
-        return [];
-    const results = [];
-    for (const integration of integrations) {
-        let result;
-        if (integration.type === "webhook") {
-            result = await sendCustomWebhook(integration, payload);
-        }
-        else if (integration.type === "cli") {
-            result = await sendCustomCli(integration, payload);
-        }
-        else {
-            result = {
-                platform: "webhook",
-                success: false,
-                error: `Unknown integration type: ${integration.type}`,
-            };
-        }
-        results.push(result);
-    }
-    return results;
-}
-//# sourceMappingURL=dispatcher.js.map