claudecode-omc 4.9.4 → 5.0.0

package/dist/notifications/reply-listener.js

@@ -1,965 +0,0 @@
-/**
- * Reply Listener Daemon
- *
- * Background daemon that polls Discord and Telegram for replies to notification messages,
- * listens for Slack messages via Socket Mode, sanitizes input, verifies the target pane,
- * and injects reply text via sendToPane().
- *
- * Security considerations:
- * - State/PID/log files use restrictive permissions (0600)
- * - Bot tokens stored in state file, NOT in environment variables
- * - Two-layer input sanitization (sanitizeReplyInput + sanitizeForTmux)
- * - Pane verification via empty-content check before every injection
- * - Authorization: only configured user IDs (Discord) / chat ID (Telegram) can inject
- * - Rate limiting to prevent spam/abuse
- *
- * Follows the daemon pattern from src/features/rate-limit-wait/daemon.ts
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, chmodSync, statSync, appendFileSync, renameSync } from 'fs';
-import { join } from 'path';
-import { fileURLToPath } from 'url';
-import { spawn } from 'child_process';
-import { request as httpsRequest } from 'https';
-import { resolveDaemonModulePath } from '../utils/daemon-module-path.js';
-import { getGlobalOmcStateRoot } from '../utils/paths.js';
-import { capturePaneContent, sendToPane, isTmuxAvailable, } from '../features/rate-limit-wait/tmux-detector.js';
-import { lookupByMessageId, removeMessagesByPane, pruneStale, } from './session-registry.js';
-import { parseMentionAllowedMentions } from './config.js';
-import { redactTokens } from './redact.js';
-import { isProcessAlive } from '../platform/index.js';
-import { validateSlackMessage, } from './slack-socket.js';
-// ESM compatibility: __filename is not available in ES modules
-const __filename = fileURLToPath(import.meta.url);
-// ============================================================================
-// Constants and Types
-// ============================================================================
-/** Restrictive file permissions (owner read/write only) */
-const SECURE_FILE_MODE = 0o600;
-/** Maximum log file size before rotation (1MB) */
-const MAX_LOG_SIZE_BYTES = 1 * 1024 * 1024;
-/**
- * Allowlist of environment variables safe to pass to daemon child process.
- * This prevents leaking sensitive variables like ANTHROPIC_API_KEY, GITHUB_TOKEN, etc.
- * OMC_* notification env vars are forwarded so the daemon can call getNotificationConfig().
- */
-const DAEMON_ENV_ALLOWLIST = [
-    'PATH', 'HOME', 'USERPROFILE',
-    'USER', 'USERNAME', 'LOGNAME',
-    'LANG', 'LC_ALL', 'LC_CTYPE',
-    'TERM', 'TMUX', 'TMUX_PANE',
-    'TMPDIR', 'TMP', 'TEMP',
-    'XDG_RUNTIME_DIR', 'XDG_DATA_HOME', 'XDG_CONFIG_HOME',
-    'SHELL',
-    'NODE_ENV',
-    'HTTP_PROXY', 'HTTPS_PROXY', 'http_proxy', 'https_proxy', 'NO_PROXY', 'no_proxy',
-    'SystemRoot', 'SYSTEMROOT', 'windir', 'COMSPEC',
-];
-/** Default paths */
-const DEFAULT_STATE_DIR = getGlobalOmcStateRoot();
-const PID_FILE_PATH = join(DEFAULT_STATE_DIR, 'reply-listener.pid');
-const STATE_FILE_PATH = join(DEFAULT_STATE_DIR, 'reply-listener-state.json');
-const LOG_FILE_PATH = join(DEFAULT_STATE_DIR, 'reply-listener.log');
-// ============================================================================
-// Utility Functions
-// ============================================================================
-/**
- * Create a minimal environment for daemon child processes.
- * Only includes allowlisted variables to prevent credential leakage.
- */
-function createMinimalDaemonEnv() {
-    const env = {};
-    for (const key of DAEMON_ENV_ALLOWLIST) {
-        if (process.env[key] !== undefined) {
-            env[key] = process.env[key];
-        }
-    }
-    // Forward OMC_* env vars so the daemon can call getNotificationConfig()
-    for (const key of Object.keys(process.env)) {
-        if (key.startsWith('OMC_')) {
-            env[key] = process.env[key];
-        }
-    }
-    return env;
-}
-/**
- * Ensure state directory exists with secure permissions
- */
-function ensureStateDir() {
-    if (!existsSync(DEFAULT_STATE_DIR)) {
-        mkdirSync(DEFAULT_STATE_DIR, { recursive: true, mode: 0o700 });
-    }
-}
-/**
- * Write file with secure permissions (0600 - owner read/write only)
- */
-function writeSecureFile(filePath, content) {
-    ensureStateDir();
-    writeFileSync(filePath, content, { mode: SECURE_FILE_MODE });
-    try {
-        chmodSync(filePath, SECURE_FILE_MODE);
-    }
-    catch {
-        // Ignore permission errors (e.g., on Windows)
-    }
-}
-/**
- * Rotate log file if it exceeds maximum size
- */
-function rotateLogIfNeeded(logPath) {
-    try {
-        if (!existsSync(logPath))
-            return;
-        const stats = statSync(logPath);
-        if (stats.size > MAX_LOG_SIZE_BYTES) {
-            const backupPath = `${logPath}.old`;
-            if (existsSync(backupPath)) {
-                unlinkSync(backupPath);
-            }
-            renameSync(logPath, backupPath);
-        }
-    }
-    catch {
-        // Ignore rotation errors
-    }
-}
-/**
- * Log message to daemon log file with rotation
- */
-function log(message) {
-    try {
-        ensureStateDir();
-        rotateLogIfNeeded(LOG_FILE_PATH);
-        const timestamp = new Date().toISOString();
-        const logLine = `[${timestamp}] ${redactTokens(message)}\n`;
-        appendFileSync(LOG_FILE_PATH, logLine, { mode: SECURE_FILE_MODE });
-    }
-    catch {
-        // Ignore log write errors
-    }
-}
-/**
- * Read daemon state from disk
- */
-function readDaemonState() {
-    try {
-        if (!existsSync(STATE_FILE_PATH)) {
-            return null;
-        }
-        const content = readFileSync(STATE_FILE_PATH, 'utf-8');
-        const state = JSON.parse(content);
-        return state;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write daemon state to disk with secure permissions
- */
-function writeDaemonState(state) {
-    writeSecureFile(STATE_FILE_PATH, JSON.stringify(state, null, 2));
-}
-/**
- * Build daemon config from notification config.
- * Derives bot tokens, channel IDs, and reply settings from getNotificationConfig().
- */
-export async function buildDaemonConfig() {
-    try {
-        const { getReplyConfig, getNotificationConfig, getReplyListenerPlatformConfig } = await import('./config.js');
-        const replyConfig = getReplyConfig();
-        if (!replyConfig)
-            return null;
-        const notifConfig = getNotificationConfig();
-        const platformConfig = getReplyListenerPlatformConfig(notifConfig);
-        return { ...replyConfig, ...platformConfig };
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Read PID file
- */
-function readPidFile() {
-    try {
-        if (!existsSync(PID_FILE_PATH)) {
-            return null;
-        }
-        const content = readFileSync(PID_FILE_PATH, 'utf-8');
-        return parseInt(content.trim(), 10);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Write PID file with secure permissions
- */
-function writePidFile(pid) {
-    writeSecureFile(PID_FILE_PATH, String(pid));
-}
-/**
- * Remove PID file
- */
-function removePidFile() {
-    if (existsSync(PID_FILE_PATH)) {
-        unlinkSync(PID_FILE_PATH);
-    }
-}
-/**
- * Check if daemon is currently running
- */
-export function isDaemonRunning() {
-    const pid = readPidFile();
-    if (pid === null) {
-        return false;
-    }
-    if (!isProcessAlive(pid)) {
-        removePidFile();
-        return false;
-    }
-    return true;
-}
-// ============================================================================
-// Input Sanitization
-// ============================================================================
-/**
- * Sanitize reply input from Discord/Telegram before tmux injection.
- * Applied BEFORE sendToPane()'s own sanitizeForTmux().
- *
- * Defenses:
- * - Newlines replaced with spaces (prevents multi-command injection)
- * - Backticks escaped (prevents command substitution in some shells)
- * - $() and ${} patterns escaped (prevents command substitution)
- * - Backslashes escaped (prevents escape sequence injection)
- * - Control characters stripped
- */
-export function sanitizeReplyInput(text) {
-    return text
-        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '') // Strip control chars (keep \n, \r, \t)
-        .replace(/[\u202a-\u202e\u2066-\u2069]/g, '') // Strip bidi override characters
-        .replace(/\r?\n/g, ' ') // Newlines -> spaces
-        .replace(/\\/g, '\\\\') // Escape backslashes
-        .replace(/`/g, '\\`') // Escape backticks
-        .replace(/\$\(/g, '\\$(') // Escape $()
-        .replace(/\$\{/g, '\\${') // Escape ${}
-        .trim();
-}
-// ============================================================================
-// Rate Limiting
-// ============================================================================
-class RateLimiter {
-    maxPerMinute;
-    timestamps = [];
-    windowMs = 60 * 1000; // 1 minute
-    constructor(maxPerMinute) {
-        this.maxPerMinute = maxPerMinute;
-    }
-    canProceed() {
-        const now = Date.now();
-        // Remove timestamps outside the window
-        this.timestamps = this.timestamps.filter(t => now - t < this.windowMs);
-        if (this.timestamps.length >= this.maxPerMinute) {
-            return false;
-        }
-        this.timestamps.push(now);
-        return true;
-    }
-    reset() {
-        this.timestamps = [];
-    }
-}
-// ============================================================================
-// Injection
-// ============================================================================
-/**
- * Inject reply text into a tmux pane after verification and sanitization.
- *
- * Returns true if injection succeeded, false otherwise.
- */
-function injectReply(paneId, text, platform, config) {
-    // 1. Verify pane has content (non-empty pane = active session per registry)
-    const content = capturePaneContent(paneId, 15);
-    if (!content.trim()) {
-        log(`WARN: Pane ${paneId} appears empty. Skipping injection, removing stale mapping.`);
-        removeMessagesByPane(paneId);
-        return false;
-    }
-    // 2. Build prefixed text if configured
-    const prefix = config.includePrefix ? `[reply:${platform}] ` : '';
-    // 3. Sanitize the reply text
-    const sanitized = sanitizeReplyInput(prefix + text);
-    // 4. Truncate to max length
-    const truncated = sanitized.slice(0, config.maxMessageLength);
-    // 5. Inject via sendToPane (which applies its own sanitizeForTmux)
-    const success = sendToPane(paneId, truncated, true);
-    if (success) {
-        log(`Injected reply from ${platform} into pane ${paneId}: "${truncated.slice(0, 50)}${truncated.length > 50 ? '...' : ''}"`);
-    }
-    else {
-        log(`ERROR: Failed to inject reply into pane ${paneId}`);
-    }
-    return success;
-}
-// ============================================================================
-// Discord Polling
-// ============================================================================
-/** Track when to back off Discord polling due to rate limits */
-let discordBackoffUntil = 0;
-/**
- * Poll Discord for new replies and inject them.
- */
-async function pollDiscord(config, state, rateLimiter) {
-    if (!config.discordBotToken || !config.discordChannelId) {
-        return;
-    }
-    if (config.authorizedDiscordUserIds.length === 0) {
-        // Discord reply listening disabled when no authorized users
-        return;
-    }
-    // Rate limit backoff
-    if (Date.now() < discordBackoffUntil) {
-        return;
-    }
-    try {
-        const after = state.discordLastMessageId ? `?after=${state.discordLastMessageId}&limit=10` : '?limit=10';
-        const url = `https://discord.com/api/v10/channels/${config.discordChannelId}/messages${after}`;
-        const response = await fetch(url, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bot ${config.discordBotToken}`,
-            },
-            signal: AbortSignal.timeout(10000),
-        });
-        // Read rate limit headers and back off when remaining < 2
-        const remaining = response.headers.get('x-ratelimit-remaining');
-        const reset = response.headers.get('x-ratelimit-reset');
-        if (remaining !== null && parseInt(remaining, 10) < 2) {
-            const resetTime = reset ? parseFloat(reset) * 1000 : Date.now() + 10_000;
-            discordBackoffUntil = resetTime;
-            log(`WARN: Discord rate limit low (remaining: ${remaining}), backing off until ${new Date(resetTime).toISOString()}`);
-        }
-        if (!response.ok) {
-            log(`Discord API error: HTTP ${response.status}`);
-            return;
-        }
-        const messages = await response.json();
-        if (!Array.isArray(messages) || messages.length === 0)
-            return;
-        // Process messages in chronological order (oldest first; Discord returns newest first)
-        const sorted = [...messages].reverse();
-        for (const msg of sorted) {
-            // Filter: message has message_reference (it's a reply)
-            if (!msg.message_reference?.message_id) {
-                // Still advance the offset
-                state.discordLastMessageId = msg.id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Filter: author is in authorizedDiscordUserIds
-            if (!config.authorizedDiscordUserIds.includes(msg.author.id)) {
-                state.discordLastMessageId = msg.id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Filter: referenced message exists in session registry
-            const mapping = lookupByMessageId('discord-bot', msg.message_reference.message_id);
-            if (!mapping) {
-                state.discordLastMessageId = msg.id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Rate limiting
-            if (!rateLimiter.canProceed()) {
-                log(`WARN: Rate limit exceeded, dropping Discord message ${msg.id}`);
-                state.discordLastMessageId = msg.id;
-                writeDaemonState(state);
-                state.errors++;
-                continue;
-            }
-            // AT-MOST-ONCE: persist offset BEFORE injection
-            state.discordLastMessageId = msg.id;
-            writeDaemonState(state);
-            // Inject reply
-            const success = injectReply(mapping.tmuxPaneId, msg.content, 'discord', config);
-            if (success) {
-                state.messagesInjected++;
-                // Send confirmation reaction (non-critical)
-                try {
-                    await fetch(`https://discord.com/api/v10/channels/${config.discordChannelId}/messages/${msg.id}/reactions/%E2%9C%85/@me`, {
-                        method: 'PUT',
-                        headers: { 'Authorization': `Bot ${config.discordBotToken}` },
-                        signal: AbortSignal.timeout(5000),
-                    });
-                }
-                catch (e) {
-                    log(`WARN: Failed to add confirmation reaction: ${e}`);
-                }
-                // Send injection notification to channel (non-critical)
-                try {
-                    const mentionPrefix = config.discordMention ? `${config.discordMention} ` : '';
-                    const feedbackAllowedMentions = config.discordMention
-                        ? parseMentionAllowedMentions(config.discordMention)
-                        : { parse: [] };
-                    await fetch(`https://discord.com/api/v10/channels/${config.discordChannelId}/messages`, {
-                        method: 'POST',
-                        headers: {
-                            'Authorization': `Bot ${config.discordBotToken}`,
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            content: `${mentionPrefix}Injected into Claude Code session.`,
-                            message_reference: { message_id: msg.id },
-                            allowed_mentions: feedbackAllowedMentions,
-                        }),
-                        signal: AbortSignal.timeout(5000),
-                    });
-                }
-                catch (e) {
-                    log(`WARN: Failed to send injection channel notification: ${e}`);
-                }
-            }
-            else {
-                state.errors++;
-            }
-        }
-    }
-    catch (error) {
-        state.errors++;
-        state.lastError = redactTokens(error instanceof Error ? error.message : String(error));
-        log(`Discord polling error: ${state.lastError}`);
-    }
-}
-// ============================================================================
-// Telegram Polling
-// ============================================================================
-/**
- * Poll Telegram for new replies and inject them.
- * Uses httpsRequest with family:4 to match sendTelegram() pattern.
- */
-async function pollTelegram(config, state, rateLimiter) {
-    if (!config.telegramBotToken || !config.telegramChatId) {
-        return;
-    }
-    try {
-        const offset = state.telegramLastUpdateId ? state.telegramLastUpdateId + 1 : 0;
-        const path = `/bot${config.telegramBotToken}/getUpdates?offset=${offset}&timeout=0`;
-        const updates = await new Promise((resolve, reject) => {
-            const req = httpsRequest({
-                hostname: 'api.telegram.org',
-                path,
-                method: 'GET',
-                family: 4, // Force IPv4
-                timeout: 10000,
-            }, (res) => {
-                const chunks = [];
-                res.on('data', (chunk) => chunks.push(chunk));
-                res.on('end', () => {
-                    try {
-                        const body = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-                        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-                            resolve(body.result || []);
-                        }
-                        else {
-                            reject(new Error(`HTTP ${res.statusCode}`));
-                        }
-                    }
-                    catch (e) {
-                        reject(e);
-                    }
-                });
-            });
-            req.on('error', reject);
-            req.on('timeout', () => {
-                req.destroy();
-                reject(new Error('Request timeout'));
-            });
-            req.end();
-        });
-        for (const update of updates) {
-            const msg = update.message;
-            if (!msg) {
-                // Always advance offset even for non-message updates
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Filter: message has reply_to_message
-            if (!msg.reply_to_message?.message_id) {
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Filter: chat.id matches configured chatId
-            if (String(msg.chat.id) !== config.telegramChatId) {
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Filter: referenced message exists in session registry
-            const mapping = lookupByMessageId('telegram', String(msg.reply_to_message.message_id));
-            if (!mapping) {
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                continue;
-            }
-            const text = msg.text || '';
-            if (!text) {
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                continue;
-            }
-            // Rate limiting
-            if (!rateLimiter.canProceed()) {
-                log(`WARN: Rate limit exceeded, dropping Telegram message ${msg.message_id}`);
-                state.telegramLastUpdateId = update.update_id;
-                writeDaemonState(state);
-                state.errors++;
-                continue;
-            }
-            // AT-MOST-ONCE: persist offset BEFORE injection
-            state.telegramLastUpdateId = update.update_id;
-            writeDaemonState(state);
-            // Inject reply
-            const success = injectReply(mapping.tmuxPaneId, text, 'telegram', config);
-            if (success) {
-                state.messagesInjected++;
-                // Send confirmation reply (non-critical)
-                try {
-                    const replyBody = JSON.stringify({
-                        chat_id: config.telegramChatId,
-                        text: 'Injected into Claude Code session.',
-                        reply_to_message_id: msg.message_id,
-                    });
-                    await new Promise((resolve) => {
-                        const replyReq = httpsRequest({
-                            hostname: 'api.telegram.org',
-                            path: `/bot${config.telegramBotToken}/sendMessage`,
-                            method: 'POST',
-                            family: 4,
-                            headers: {
-                                'Content-Type': 'application/json',
-                                'Content-Length': Buffer.byteLength(replyBody),
-                            },
-                            timeout: 5000,
-                        }, (res) => {
-                            res.resume(); // Drain response
-                            resolve();
-                        });
-                        replyReq.on('error', () => resolve());
-                        replyReq.on('timeout', () => {
-                            replyReq.destroy();
-                            resolve();
-                        });
-                        replyReq.write(replyBody);
-                        replyReq.end();
-                    });
-                }
-                catch (e) {
-                    log(`WARN: Failed to send confirmation reply: ${e}`);
-                }
-            }
-            else {
-                state.errors++;
-            }
-        }
-    }
-    catch (error) {
-        state.errors++;
-        state.lastError = redactTokens(error instanceof Error ? error.message : String(error));
-        log(`Telegram polling error: ${state.lastError}`);
-    }
-}
-// ============================================================================
-// Main Daemon Loop
-// ============================================================================
-/** Prune stale registry entries every hour */
-const PRUNE_INTERVAL_MS = 60 * 60 * 1000;
-/**
- * Main daemon polling loop
- */
-async function pollLoop() {
-    log('Reply listener daemon starting poll loop');
-    const config = await buildDaemonConfig();
-    if (!config) {
-        log('ERROR: No notification config found for reply listener, exiting');
-        process.exit(1);
-    }
-    const state = readDaemonState() || {
-        isRunning: true,
-        pid: process.pid,
-        startedAt: new Date().toISOString(),
-        lastPollAt: null,
-        telegramLastUpdateId: null,
-        discordLastMessageId: null,
-        messagesInjected: 0,
-        errors: 0,
-    };
-    state.isRunning = true;
-    state.pid = process.pid;
-    const rateLimiter = new RateLimiter(config.rateLimitPerMinute);
-    let lastPruneAt = Date.now();
-    // Start Slack Socket Mode listener if configured
-    let slackSocket = null;
-    if (config.slackAppToken && config.slackBotToken && config.slackChannelId) {
-        if (typeof WebSocket === 'undefined') {
-            log('WARN: WebSocket not available (requires Node 20.10+), Slack Socket Mode disabled');
-        }
-        else {
-            try {
-                const { SlackSocketClient, addSlackReaction } = await import('./slack-socket.js');
-                const slackChannelId = config.slackChannelId;
-                const slackBotToken = config.slackBotToken;
-                slackSocket = new SlackSocketClient({
-                    appToken: config.slackAppToken,
-                    botToken: slackBotToken,
-                    channelId: slackChannelId,
-                }, async (event) => {
-                    // Authorization: fail-closed — reject when no authorized users configured
-                    if (!config.authorizedSlackUserIds || config.authorizedSlackUserIds.length === 0) {
-                        log('WARN: No authorized Slack user IDs configured, rejecting all messages (fail-closed)');
-                        return;
-                    }
-                    if (!config.authorizedSlackUserIds.includes(event.user)) {
-                        log(`REJECTED Slack message from unauthorized user ${event.user}`);
-                        return;
-                    }
-                    // Rate limiting
-                    if (!rateLimiter.canProceed()) {
-                        log(`WARN: Rate limit exceeded, dropping Slack message ${event.ts}`);
-                        state.errors++;
-                        return;
-                    }
-                    // Find target pane for injection
-                    let targetPaneId = null;
-                    // Thread replies: look up parent message in session registry
-                    if (event.thread_ts && event.thread_ts !== event.ts) {
-                        const mapping = lookupByMessageId('slack-bot', event.thread_ts);
-                        if (mapping) {
-                            targetPaneId = mapping.tmuxPaneId;
-                        }
-                    }
-                    // No thread match: skip injection to avoid sending to an unrelated session.
-                    // Discord and Telegram already skip when no match is found.
-                    if (!targetPaneId) {
-                        log('WARN: No target pane found for Slack message, skipping');
-                        return;
-                    }
-                    // Inject reply
-                    const success = injectReply(targetPaneId, event.text, 'slack', config);
-                    if (success) {
-                        state.messagesInjected++;
-                        writeDaemonState(state);
-                        // Send confirmation reaction (non-critical)
-                        try {
-                            await addSlackReaction(slackBotToken, slackChannelId, event.ts);
-                        }
-                        catch (e) {
-                            log(`WARN: Failed to add Slack reaction: ${e}`);
-                        }
-                    }
-                    else {
-                        state.errors++;
-                        writeDaemonState(state);
-                    }
-                }, log);
-                await slackSocket.start();
-                log('Slack Socket Mode listener started');
-            }
-            catch (e) {
-                log(`ERROR: Failed to start Slack Socket Mode: ${e instanceof Error ? e.message : String(e)}`);
-                slackSocket = null;
-            }
-        }
-    }
-    // Graceful shutdown handlers
-    const shutdown = () => {
-        log('Shutdown signal received');
-        state.isRunning = false;
-        if (slackSocket) {
-            slackSocket.stop();
-            slackSocket = null;
-        }
-        writeDaemonState(state);
-        removePidFile();
-        process.exit(0);
-    };
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-    // Prune stale registry entries on startup
-    try {
-        pruneStale();
-        log('Pruned stale registry entries');
-    }
-    catch (e) {
-        log(`WARN: Failed to prune stale entries: ${e}`);
-    }
-    while (state.isRunning) {
-        try {
-            state.lastPollAt = new Date().toISOString();
-            // Poll platforms sequentially (shared state, avoid race conditions)
-            await pollDiscord(config, state, rateLimiter);
-            await pollTelegram(config, state, rateLimiter);
-            // Periodic prune (every hour)
-            if (Date.now() - lastPruneAt > PRUNE_INTERVAL_MS) {
-                try {
-                    pruneStale();
-                    lastPruneAt = Date.now();
-                    log('Pruned stale registry entries');
-                }
-                catch (e) {
-                    log(`WARN: Prune failed: ${e instanceof Error ? e.message : String(e)}`);
-                }
-            }
-            writeDaemonState(state);
-            // Wait for next poll
-            await new Promise((resolve) => setTimeout(resolve, config.pollIntervalMs));
-        }
-        catch (error) {
-            state.errors++;
-            state.lastError = redactTokens(error instanceof Error ? error.message : String(error));
-            log(`Poll error: ${state.lastError}`);
-            writeDaemonState(state);
-            // Back off on repeated errors
-            await new Promise((resolve) => setTimeout(resolve, config.pollIntervalMs * 2));
-        }
-    }
-    log('Poll loop ended');
-}
-// ============================================================================
-// Daemon Control
-// ============================================================================
-/**
- * Start the reply listener daemon.
- *
- * Forks a daemon process that derives its config from getNotificationConfig().
- * OMC_* env vars are forwarded so the daemon can read both file and env config.
- *
- * Idempotent: if daemon is already running, returns success.
- *
- * @param config - Daemon config (used only for validation, daemon reads config independently)
- */
-export function startReplyListener(_config) {
-    // Check if already running (idempotent)
-    if (isDaemonRunning()) {
-        const state = readDaemonState();
-        return {
-            success: true,
-            message: 'Reply listener daemon is already running',
-            state: state ?? undefined,
-        };
-    }
-    // Check for tmux
-    if (!isTmuxAvailable()) {
-        return {
-            success: false,
-            message: 'tmux not available - reply injection requires tmux',
-        };
-    }
-    ensureStateDir();
-    // Fork a new process for the daemon
-    const modulePath = resolveDaemonModulePath(__filename, ['notifications', 'reply-listener.js']);
-    const daemonScript = `
-    import('${modulePath}').then(({ pollLoop }) => {
-      return pollLoop();
-    }).catch((err) => { console.error('[reply-listener] Fatal:', err instanceof Error ? err.message : 'unknown error'); process.exit(1); });
-  `;
-    try {
-        const child = spawn('node', ['-e', daemonScript], {
-            detached: true,
-            stdio: 'ignore',
-            cwd: process.cwd(),
-            env: createMinimalDaemonEnv(),
-        });
-        child.unref();
-        const pid = child.pid;
-        if (pid) {
-            writePidFile(pid);
-            const state = {
-                isRunning: true,
-                pid,
-                startedAt: new Date().toISOString(),
-                lastPollAt: null,
-                telegramLastUpdateId: null,
-                discordLastMessageId: null,
-                messagesInjected: 0,
-                errors: 0,
-            };
-            writeDaemonState(state);
-            log(`Reply listener daemon started with PID ${pid}`);
-            return {
-                success: true,
-                message: `Reply listener daemon started with PID ${pid}`,
-                state,
-            };
-        }
-        return {
-            success: false,
-            message: 'Failed to start daemon process',
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: 'Failed to start daemon',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Stop the reply listener daemon
- */
-export function stopReplyListener() {
-    const pid = readPidFile();
-    if (pid === null) {
-        return {
-            success: true,
-            message: 'Reply listener daemon is not running',
-        };
-    }
-    if (!isProcessAlive(pid)) {
-        removePidFile();
-        return {
-            success: true,
-            message: 'Reply listener daemon was not running (cleaned up stale PID file)',
-        };
-    }
-    try {
-        process.kill(pid, 'SIGTERM');
-        removePidFile();
-        const state = readDaemonState();
-        if (state) {
-            state.isRunning = false;
-            state.pid = null;
-            writeDaemonState(state);
-        }
-        log(`Reply listener daemon stopped (PID ${pid})`);
-        return {
-            success: true,
-            message: `Reply listener daemon stopped (PID ${pid})`,
-            state: state ?? undefined,
-        };
-    }
-    catch (error) {
-        return {
-            success: false,
-            message: 'Failed to stop daemon',
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-/**
- * Get daemon status
- */
-export function getReplyListenerStatus() {
-    const state = readDaemonState();
-    const running = isDaemonRunning();
-    if (!running && !state) {
-        return {
-            success: true,
-            message: 'Reply listener daemon has never been started',
-        };
-    }
-    if (!running && state) {
-        return {
-            success: true,
-            message: 'Reply listener daemon is not running',
-            state: { ...state, isRunning: false, pid: null },
-        };
-    }
-    return {
-        success: true,
-        message: 'Reply listener daemon is running',
-        state: state ?? undefined,
-    };
-}
-// ============================================================================
-// Slack WebSocket Message Validation Gate
-// ============================================================================
-/**
- * Validate and process an incoming Slack WebSocket message before session injection.
- *
- * This function is the security gate for Slack Socket Mode messages.
- * All Slack messages MUST pass through this function before reaching injectReply().
- *
- * Validation steps:
- * 1. Slack message validation (envelope, signing secret, connection state)
- * 2. Rate limiting
- * 3. Session registry lookup
- * 4. Pane verification and injection
- *
- * @param rawMessage - Raw WebSocket message string
- * @param connectionState - Slack connection state tracker
- * @param paneId - Target tmux pane ID (from session registry lookup by caller)
- * @param config - Daemon configuration
- * @param state - Daemon state (mutated: errors/messagesInjected counters)
- * @param rateLimiter - Rate limiter instance
- * @param signature - Slack request signature header (x-slack-signature)
- * @param timestamp - Slack request timestamp header (x-slack-request-timestamp)
- * @returns Object with injection result and validation details
- */
-export function processSlackSocketMessage(rawMessage, connectionState, paneId, config, state, rateLimiter, signature, timestamp) {
-    // 1. Validate the Slack message
-    const validation = validateSlackMessage(rawMessage, connectionState, config.slackSigningSecret, signature, timestamp);
-    if (!validation.valid) {
-        log(`REJECTED Slack message: ${validation.reason}`);
-        state.errors++;
-        return { injected: false, validation };
-    }
-    // 2. Must have a target pane
-    if (!paneId) {
-        log('REJECTED Slack message: no target pane ID');
-        state.errors++;
-        return {
-            injected: false,
-            validation: { valid: false, reason: 'No target pane ID' },
-        };
-    }
-    // 3. Rate limiting
-    if (!rateLimiter.canProceed()) {
-        log('WARN: Rate limit exceeded, dropping Slack message');
-        state.errors++;
-        return {
-            injected: false,
-            validation: { valid: false, reason: 'Rate limit exceeded' },
-        };
-    }
-    // 4. Extract text from the validated message
-    let text;
-    try {
-        const parsed = JSON.parse(rawMessage);
-        const payload = parsed.payload;
-        text = payload?.event?.text || payload?.text || '';
-    }
-    catch {
-        log('REJECTED Slack message: failed to extract text from validated message');
-        state.errors++;
-        return {
-            injected: false,
-            validation: { valid: false, reason: 'Failed to extract message text' },
-        };
-    }
-    if (!text) {
-        log('REJECTED Slack message: empty message text');
-        return {
-            injected: false,
-            validation: { valid: false, reason: 'Empty message text' },
-        };
-    }
-    // 5. Inject reply (applies sanitization + pane verification)
-    const success = injectReply(paneId, text, 'slack', config);
-    if (success) {
-        state.messagesInjected++;
-    }
-    else {
-        state.errors++;
-    }
-    return { injected: success, validation };
-}
-// Re-export for Slack integration
-export { SlackConnectionStateTracker } from './slack-socket.js';
-// Export RateLimiter for external use (e.g., Slack Socket Mode handler)
-export { RateLimiter };
-// Export pollLoop for use by the daemon subprocess
-export { pollLoop };
-//# sourceMappingURL=reply-listener.js.map