claudecode-omc 4.3.4

package/dist/notifications/__tests__/reply-config.test.js

@@ -0,0 +1,213 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+const VALID_DISCORD_USER_ID = "123456789012345678";
+const ORIGINAL_ENV = process.env;
+function mockConfigFile(rawConfig) {
+    vi.doMock("fs", () => ({
+        existsSync: vi.fn(() => rawConfig !== null),
+        readFileSync: vi.fn(() => JSON.stringify(rawConfig ?? {})),
+    }));
+}
+describe("reply config", () => {
+    beforeEach(() => {
+        vi.resetModules();
+        vi.restoreAllMocks();
+        process.env = { ...ORIGINAL_ENV };
+        delete process.env.OMC_REPLY_ENABLED;
+        delete process.env.OMC_REPLY_POLL_INTERVAL_MS;
+        delete process.env.OMC_REPLY_RATE_LIMIT;
+        delete process.env.OMC_REPLY_DISCORD_USER_IDS;
+        delete process.env.OMC_REPLY_INCLUDE_PREFIX;
+        delete process.env.OMC_DISCORD_NOTIFIER_BOT_TOKEN;
+        delete process.env.OMC_DISCORD_NOTIFIER_CHANNEL;
+        delete process.env.OMC_DISCORD_WEBHOOK_URL;
+        delete process.env.OMC_DISCORD_MENTION;
+        delete process.env.OMC_TELEGRAM_BOT_TOKEN;
+        delete process.env.OMC_TELEGRAM_NOTIFIER_BOT_TOKEN;
+        delete process.env.OMC_TELEGRAM_CHAT_ID;
+        delete process.env.OMC_TELEGRAM_NOTIFIER_CHAT_ID;
+        delete process.env.OMC_TELEGRAM_NOTIFIER_UID;
+        delete process.env.OMC_SLACK_WEBHOOK_URL;
+    });
+    afterEach(() => {
+        process.env = ORIGINAL_ENV;
+        vi.resetModules();
+        vi.restoreAllMocks();
+    });
+    it("enables reply config when reply-capable platform exists only at event level", async () => {
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                events: {
+                    "ask-user-question": {
+                        telegram: {
+                            enabled: true,
+                            botToken: "tg-token-event",
+                            chatId: "tg-chat-event",
+                        },
+                    },
+                },
+                reply: {
+                    enabled: true,
+                    rateLimitPerMinute: 12,
+                },
+            },
+        });
+        const { getReplyConfig, getNotificationConfig, getReplyListenerPlatformConfig, } = await import("../config.js");
+        const replyConfig = getReplyConfig();
+        expect(replyConfig).not.toBeNull();
+        expect(replyConfig?.rateLimitPerMinute).toBe(12);
+        const notifConfig = getNotificationConfig();
+        const runtime = getReplyListenerPlatformConfig(notifConfig);
+        expect(runtime.telegramBotToken).toBe("tg-token-event");
+        expect(runtime.telegramChatId).toBe("tg-chat-event");
+    });
+    it("returns null when reply is enabled but no reply-capable platform is configured", async () => {
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                discord: {
+                    enabled: true,
+                    webhookUrl: "https://discord.com/api/webhooks/abc/123",
+                },
+                reply: {
+                    enabled: true,
+                },
+            },
+        });
+        const { getReplyConfig } = await import("../config.js");
+        expect(getReplyConfig()).toBeNull();
+    });
+    it("warns when discord-bot is enabled but authorizedDiscordUserIds is empty", async () => {
+        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                "discord-bot": {
+                    enabled: true,
+                    botToken: "discord-token",
+                    channelId: "discord-channel",
+                },
+                reply: {
+                    enabled: true,
+                },
+            },
+        });
+        const { getReplyConfig } = await import("../config.js");
+        const replyConfig = getReplyConfig();
+        expect(replyConfig).not.toBeNull();
+        expect(replyConfig?.authorizedDiscordUserIds).toEqual([]);
+        expect(warnSpy).toHaveBeenCalledOnce();
+    });
+    it("applies environment overrides for reply settings and discord user IDs", async () => {
+        process.env.OMC_REPLY_POLL_INTERVAL_MS = "5000";
+        process.env.OMC_REPLY_RATE_LIMIT = "20";
+        process.env.OMC_REPLY_INCLUDE_PREFIX = "false";
+        process.env.OMC_REPLY_DISCORD_USER_IDS = `${VALID_DISCORD_USER_ID},invalid-id`;
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                "discord-bot": {
+                    enabled: true,
+                    botToken: "discord-token",
+                    channelId: "discord-channel",
+                },
+                reply: {
+                    enabled: true,
+                    pollIntervalMs: 1000,
+                    rateLimitPerMinute: 5,
+                    includePrefix: true,
+                    authorizedDiscordUserIds: ["999999999999999999"],
+                },
+            },
+        });
+        const { getReplyConfig } = await import("../config.js");
+        const replyConfig = getReplyConfig();
+        expect(replyConfig).not.toBeNull();
+        expect(replyConfig?.pollIntervalMs).toBe(5000);
+        expect(replyConfig?.rateLimitPerMinute).toBe(20);
+        expect(replyConfig?.includePrefix).toBe(false);
+        expect(replyConfig?.authorizedDiscordUserIds).toEqual([
+            VALID_DISCORD_USER_ID,
+        ]);
+    });
+    it("returns discordMention from top-level discord-bot config", async () => {
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                "discord-bot": {
+                    enabled: true,
+                    botToken: "discord-token",
+                    channelId: "discord-channel",
+                    mention: "<@123456789012345678>",
+                },
+                reply: {
+                    enabled: true,
+                    authorizedDiscordUserIds: [VALID_DISCORD_USER_ID],
+                },
+            },
+        });
+        const { getNotificationConfig, getReplyListenerPlatformConfig } = await import("../config.js");
+        const notifConfig = getNotificationConfig();
+        const runtime = getReplyListenerPlatformConfig(notifConfig);
+        expect(runtime.discordMention).toBe("<@123456789012345678>");
+    });
+    it("returns discordMention from env var OMC_DISCORD_MENTION", async () => {
+        process.env.OMC_DISCORD_NOTIFIER_BOT_TOKEN = "env-token";
+        process.env.OMC_DISCORD_NOTIFIER_CHANNEL = "env-channel";
+        process.env.OMC_DISCORD_MENTION = "<@987654321098765432>";
+        mockConfigFile(null);
+        const { getNotificationConfig, getReplyListenerPlatformConfig } = await import("../config.js");
+        const notifConfig = getNotificationConfig();
+        const runtime = getReplyListenerPlatformConfig(notifConfig);
+        expect(runtime.discordMention).toBe("<@987654321098765432>");
+    });
+    it("returns undefined discordMention when no mention is configured", async () => {
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                "discord-bot": {
+                    enabled: true,
+                    botToken: "discord-token",
+                    channelId: "discord-channel",
+                },
+                reply: {
+                    enabled: true,
+                    authorizedDiscordUserIds: [VALID_DISCORD_USER_ID],
+                },
+            },
+        });
+        const { getNotificationConfig, getReplyListenerPlatformConfig } = await import("../config.js");
+        const notifConfig = getNotificationConfig();
+        const runtime = getReplyListenerPlatformConfig(notifConfig);
+        expect(runtime.discordMention).toBeUndefined();
+    });
+    it("resolves discord credentials from event-level config and falls back to top-level tokens", async () => {
+        mockConfigFile({
+            notifications: {
+                enabled: true,
+                "discord-bot": {
+                    enabled: false,
+                    botToken: "top-level-token",
+                    channelId: "top-level-channel",
+                },
+                events: {
+                    "session-end": {
+                        "discord-bot": {
+                            enabled: true,
+                        },
+                    },
+                },
+                reply: {
+                    enabled: true,
+                    authorizedDiscordUserIds: [VALID_DISCORD_USER_ID],
+                },
+            },
+        });
+        const { getNotificationConfig, getReplyListenerPlatformConfig } = await import("../config.js");
+        const notifConfig = getNotificationConfig();
+        const runtime = getReplyListenerPlatformConfig(notifConfig);
+        expect(runtime.discordBotToken).toBe("top-level-token");
+        expect(runtime.discordChannelId).toBe("top-level-channel");
+    });
+});
+//# sourceMappingURL=reply-config.test.js.map

package/dist/notifications/__tests__/reply-config.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-config.test.js","sourceRoot":"","sources":["../../../src/notifications/__tests__/reply-config.test.ts"],"names":[],"mappings":"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"}

package/dist/notifications/__tests__/reply-listener.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reply-listener.test.d.ts.map

package/dist/notifications/__tests__/reply-listener.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reply-listener.test.d.ts","sourceRoot":"","sources":["../../../src/notifications/__tests__/reply-listener.test.ts"],"names":[],"mappings":""}

package/dist/notifications/__tests__/reply-listener.test.js

@@ -0,0 +1,423 @@
+import { describe, it, expect } from "vitest";
+import { sanitizeReplyInput } from "../reply-listener.js";
+describe("reply-listener", () => {
+    describe("sanitizeReplyInput", () => {
+        it("strips control characters", () => {
+            // Control characters \x00-\x08, \x0b, \x0c, \x0e-\x1f, \x7f are stripped
+            const input = "hello\x00\x01\x02world\x7f";
+            const expected = "helloworld";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("replaces newlines with spaces", () => {
+            const input = "line1\nline2\r\nline3";
+            const expected = "line1 line2 line3";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("escapes backticks", () => {
+            const input = "echo `whoami`";
+            const expected = "echo \\`whoami\\`";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("escapes command substitution $()", () => {
+            const input = "echo $(whoami)";
+            const expected = "echo \\$(whoami)";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("escapes command substitution ${}", () => {
+            const input = "echo ${USER}";
+            const expected = "echo \\${USER}";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("escapes backslashes", () => {
+            const input = "path\\to\\file";
+            const expected = "path\\\\to\\\\file";
+            const sanitized = sanitizeReplyInput(input);
+            expect(sanitized).toBe(expected);
+        });
+        it("applies all sanitizations in correct order", () => {
+            const input = "hello\nworld `cmd` $(sub) ${var} \x00test\\path";
+            const result = sanitizeReplyInput(input);
+            expect(result).toContain('hello world');
+            expect(result).toContain('\\`cmd\\`');
+            expect(result).toContain('\\$(sub)');
+            expect(result).toContain('\\${var}');
+            expect(result).not.toContain('\x00');
+        });
+    });
+    describe("Discord filtering", () => {
+        it("requires message_reference field", () => {
+            const messageWithoutReference = {
+                id: "123",
+                author: { id: "456" },
+                content: "reply text",
+            };
+            expect(messageWithoutReference.message_reference).toBeUndefined();
+        });
+        it("requires message_reference.message_id", () => {
+            const messageWithReference = {
+                id: "123",
+                author: { id: "456" },
+                content: "reply text",
+                message_reference: { message_id: "789" },
+            };
+            expect(messageWithReference.message_reference.message_id).toBe("789");
+        });
+        it("requires authorized user ID", () => {
+            const authorizedUserIds = ["456", "789"];
+            const authorId = "456";
+            expect(authorizedUserIds.includes(authorId)).toBe(true);
+            expect(authorizedUserIds.includes("999")).toBe(false);
+        });
+        it("skips processing when authorizedDiscordUserIds is empty", () => {
+            const authorizedUserIds = [];
+            // Discord reply listening is disabled when array is empty
+            expect(authorizedUserIds.length).toBe(0);
+        });
+    });
+    describe("Telegram filtering", () => {
+        it("requires reply_to_message field", () => {
+            const messageWithoutReply = {
+                message_id: 123,
+                chat: { id: 456 },
+                text: "reply text",
+            };
+            expect(messageWithoutReply.reply_to_message).toBeUndefined();
+        });
+        it("requires reply_to_message.message_id", () => {
+            const messageWithReply = {
+                message_id: 123,
+                chat: { id: 456 },
+                text: "reply text",
+                reply_to_message: { message_id: 789 },
+            };
+            expect(messageWithReply.reply_to_message.message_id).toBe(789);
+        });
+        it("requires matching chat.id", () => {
+            const configuredChatId = "123456789";
+            const messageChatId = "123456789";
+            expect(String(messageChatId)).toBe(configuredChatId);
+            expect(String(987654321)).not.toBe(configuredChatId);
+        });
+    });
+    describe("Rate limiting", () => {
+        it("allows N messages per minute", () => {
+            const maxPerMinute = 10;
+            const timestamps = [];
+            const windowMs = 60 * 1000;
+            const now = Date.now();
+            // Add 10 messages
+            for (let i = 0; i < maxPerMinute; i++) {
+                timestamps.push(now + i * 100);
+            }
+            expect(timestamps.length).toBe(maxPerMinute);
+            // 11th message should be rejected
+            const filtered = timestamps.filter(t => now - t < windowMs);
+            expect(filtered.length).toBe(maxPerMinute);
+        });
+        it("drops excess messages", () => {
+            const maxPerMinute = 10;
+            const windowMs = 60 * 1000;
+            const now = Date.now();
+            // Simulate sliding window
+            let timestamps = Array.from({ length: maxPerMinute }, (_, i) => now - i * 1000);
+            // Remove old timestamps
+            timestamps = timestamps.filter(t => now - t < windowMs);
+            // Check if can proceed (would be false if at limit)
+            const canProceed = timestamps.length < maxPerMinute;
+            expect(canProceed).toBe(false);
+        });
+    });
+    describe("Pane verification", () => {
+        it("skips injection when confidence < 0.4", () => {
+            const analysis = {
+                hasClaudeCode: false,
+                hasRateLimitMessage: false,
+                isBlocked: false,
+                confidence: 0.3,
+            };
+            expect(analysis.confidence).toBeLessThan(0.4);
+        });
+        it("proceeds with injection when confidence >= 0.4", () => {
+            const analysis = {
+                hasClaudeCode: true,
+                hasRateLimitMessage: false,
+                isBlocked: false,
+                confidence: 0.5,
+            };
+            expect(analysis.confidence).toBeGreaterThanOrEqual(0.4);
+        });
+    });
+    describe("Visual prefix", () => {
+        it("prepends prefix when includePrefix is true", () => {
+            const config = { includePrefix: true };
+            const platform = "discord";
+            const text = "user message";
+            const prefix = config.includePrefix ? `[reply:${platform}] ` : '';
+            const result = prefix + text;
+            expect(result).toBe("[reply:discord] user message");
+        });
+        it("omits prefix when includePrefix is false", () => {
+            const config = { includePrefix: false };
+            const platform = "telegram";
+            const text = "user message";
+            const prefix = config.includePrefix ? `[reply:${platform}] ` : '';
+            const result = prefix + text;
+            expect(result).toBe("user message");
+        });
+    });
+    describe("At-most-once delivery", () => {
+        it("updates state offset before injection", () => {
+            const state = {
+                discordLastMessageId: null,
+                telegramLastUpdateId: null,
+            };
+            // Discord: update before processing
+            const newDiscordMessageId = "123456";
+            state.discordLastMessageId = newDiscordMessageId;
+            expect(state.discordLastMessageId).toBe("123456");
+            // Telegram: update before processing
+            const newTelegramUpdateId = 789;
+            state.telegramLastUpdateId = newTelegramUpdateId;
+            expect(state.telegramLastUpdateId).toBe(789);
+        });
+        it("prevents duplicate injection on restart", () => {
+            // If state is written before injection and crash occurs,
+            // the message won't be re-processed on restart
+            const processedMessageIds = new Set();
+            const messageId = "123";
+            processedMessageIds.add(messageId);
+            // On restart, this message would be skipped
+            const alreadyProcessed = processedMessageIds.has(messageId);
+            expect(alreadyProcessed).toBe(true);
+        });
+    });
+    describe("Daemon lifecycle", () => {
+        it("creates PID file on start", () => {
+            const pid = 12345;
+            expect(pid).toBeGreaterThan(0);
+        });
+        it("removes PID file on stop", () => {
+            // PID file should be removed when daemon stops
+            expect(true).toBe(true);
+        });
+        it("detects stale PID file", () => {
+            const pid = 99999; // Non-existent process
+            // isProcessRunning would return false
+            let isRunning = false;
+            try {
+                process.kill(pid, 0);
+                isRunning = true;
+            }
+            catch {
+                isRunning = false;
+            }
+            expect(isRunning).toBe(false);
+        });
+    });
+    describe("Configuration", () => {
+        it("daemon derives config from getNotificationConfig, not separate file", () => {
+            // No reply-listener-config.json should be needed
+            // The daemon calls buildDaemonConfig() which uses getNotificationConfig()
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Should use buildDaemonConfig, not readDaemonConfig
+            expect(source).toContain("buildDaemonConfig");
+            expect(source).not.toContain("readDaemonConfig");
+            expect(source).not.toContain("writeDaemonConfig");
+            // Should import from config.js
+            expect(source).toContain("getNotificationConfig");
+            expect(source).toContain("getReplyConfig");
+            expect(source).toContain("getReplyListenerPlatformConfig");
+        });
+        it("forwards OMC_* env vars to daemon process", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Should forward OMC_* env vars for getNotificationConfig()
+            expect(source).toContain("OMC_");
+            expect(source).toContain("startsWith('OMC_')");
+        });
+        it("uses minimal env allowlist for daemon", () => {
+            const allowlist = [
+                'PATH', 'HOME', 'TMUX', 'TMUX_PANE', 'TERM',
+            ];
+            // Only allowlisted vars should be passed to daemon
+            expect(allowlist.includes('PATH')).toBe(true);
+            expect(allowlist.includes('ANTHROPIC_API_KEY')).toBe(false);
+        });
+    });
+    describe("Injection feedback", () => {
+        it("Discord sends checkmark reaction on successful injection", () => {
+            const channelId = "123456";
+            const messageId = "789012";
+            const expectedUrl = `https://discord.com/api/v10/channels/${channelId}/messages/${messageId}/reactions/%E2%9C%85/@me`;
+            expect(expectedUrl).toContain("/reactions/%E2%9C%85/@me");
+            expect(expectedUrl).toContain(channelId);
+            expect(expectedUrl).toContain(messageId);
+        });
+        it("Discord sends channel notification as reply to user message", () => {
+            const channelId = "123456";
+            const userMessageId = "999888777";
+            const expectedUrl = `https://discord.com/api/v10/channels/${channelId}/messages`;
+            const expectedBody = {
+                content: "Injected into Claude Code session.",
+                message_reference: { message_id: userMessageId },
+                allowed_mentions: { parse: [] },
+            };
+            expect(expectedUrl).toContain(`/channels/${channelId}/messages`);
+            expect(expectedUrl).not.toContain("reactions");
+            expect(expectedBody.message_reference.message_id).toBe(userMessageId);
+        });
+        it("Discord feedback includes message_reference in source code", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // The injection feedback POST should include message_reference
+            expect(source).toContain("message_reference: { message_id: msg.id }");
+        });
+        it("Telegram sends reply confirmation on successful injection", () => {
+            const chatId = "123456";
+            const messageId = 789;
+            const expectedBody = {
+                chat_id: chatId,
+                text: "Injected into Claude Code session.",
+                reply_to_message_id: messageId,
+            };
+            expect(expectedBody.text).toBe("Injected into Claude Code session.");
+            expect(expectedBody.reply_to_message_id).toBe(messageId);
+        });
+        it("feedback is non-critical and wrapped in try/catch", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Reaction is in try/catch
+            expect(source).toContain("Failed to add confirmation reaction");
+            // Channel notification is in try/catch
+            expect(source).toContain("Failed to send injection channel notification");
+            // Telegram confirmation is in try/catch
+            expect(source).toContain("Failed to send confirmation reply");
+        });
+        it("feedback uses 5-second timeout", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Discord reaction + channel notification use AbortSignal.timeout(5000)
+            const abortTimeoutMatches = source.match(/AbortSignal\.timeout\(5000\)/g);
+            expect(abortTimeoutMatches).not.toBeNull();
+            expect(abortTimeoutMatches.length).toBeGreaterThanOrEqual(2);
+            // Telegram confirmation uses httpsRequest timeout: 5000
+            expect(source).toContain("timeout: 5000");
+        });
+        it("Discord channel notification uses parseMentionAllowedMentions for mention-aware allowed_mentions", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Channel notification uses parseMentionAllowedMentions to build allowed_mentions
+            expect(source).toContain("parseMentionAllowedMentions");
+            // Falls back to { parse: [] } when no mention is configured
+            expect(source).toContain("parse: [] as string[]");
+        });
+        it("does not send feedback on failed injection", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Confirmation/feedback code is inside "if (success)" blocks
+            // The else blocks only increment error counters
+            const successBlocks = source.match(/if \(success\) \{[\s\S]*?messagesInjected/g);
+            expect(successBlocks).not.toBeNull();
+            expect(successBlocks.length).toBe(2); // one for Discord, one for Telegram
+        });
+    });
+    describe("Injection feedback mention", () => {
+        it("prefixes Discord feedback with mention when discordMention is set", () => {
+            const mention = "<@123456789012345678>";
+            const mentionPrefix = mention ? `${mention} ` : '';
+            const content = `${mentionPrefix}Injected into Claude Code session.`;
+            expect(content).toBe("<@123456789012345678> Injected into Claude Code session.");
+        });
+        it("omits mention prefix when discordMention is undefined", () => {
+            const mention = undefined;
+            const mentionPrefix = mention ? `${mention} ` : '';
+            const content = `${mentionPrefix}Injected into Claude Code session.`;
+            expect(content).toBe("Injected into Claude Code session.");
+        });
+        it("builds allowed_mentions for user mention", () => {
+            // Inline equivalent of parseMentionAllowedMentions for user mention
+            const mention = "<@123456789012345678>";
+            const userMatch = mention.match(/^<@!?(\d{17,20})>$/);
+            const allowedMentions = userMatch ? { users: [userMatch[1]] } : {};
+            expect(allowedMentions).toEqual({ users: ["123456789012345678"] });
+        });
+        it("builds allowed_mentions for role mention", () => {
+            const mention = "<@&123456789012345678>";
+            const roleMatch = mention.match(/^<@&(\d{17,20})>$/);
+            const allowedMentions = roleMatch ? { roles: [roleMatch[1]] } : {};
+            expect(allowedMentions).toEqual({ roles: ["123456789012345678"] });
+        });
+        it("falls back to suppressing mentions when no discordMention", () => {
+            const mention = undefined;
+            const allowedMentions = mention
+                ? { users: ["123"] }
+                : { parse: [] };
+            expect(allowedMentions).toEqual({ parse: [] });
+        });
+        it("ReplyListenerDaemonConfig includes discordMention field", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            expect(source).toContain("discordMention?: string");
+        });
+        it("buildDaemonConfig passes discordMention from notification config", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // buildDaemonConfig spreads platformConfig which now includes discordMention
+            expect(source).toContain("getReplyListenerPlatformConfig");
+            expect(source).toContain("...platformConfig");
+        });
+        it("getReplyListenerPlatformConfig returns discordMention", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const configSource = fs.readFileSync(path.join(__dirname, "..", "config.ts"), "utf-8");
+            expect(configSource).toContain("discordMention");
+            // Should read mention from discordBotConfig
+            expect(configSource).toContain("discordBotConfig?.mention");
+        });
+        it("Telegram feedback does not include Discord mention", () => {
+            const fs = require("fs");
+            const path = require("path");
+            const source = fs.readFileSync(path.join(__dirname, "..", "reply-listener.ts"), "utf-8");
+            // Telegram sendMessage body should not reference discordMention
+            // Find the Telegram reply body - it uses a simple text string
+            const telegramReplyMatch = source.match(/text:\s*['"]Injected into Claude Code session\.['"]/g);
+            expect(telegramReplyMatch).not.toBeNull();
+            // Should have exactly 1 match (Telegram only; Discord now uses template)
+            expect(telegramReplyMatch.length).toBe(1);
+        });
+    });
+    describe("Error handling", () => {
+        it("logs errors without blocking", () => {
+            // Errors should be logged but not throw
+            expect(true).toBe(true);
+        });
+        it("continues processing after failed injection", () => {
+            // Failed injection should increment error counter
+            const state = { errors: 0 };
+            state.errors++;
+            expect(state.errors).toBe(1);
+        });
+        it("backs off on repeated errors", () => {
+            // After error, wait 2x poll interval before next poll
+            const pollIntervalMs = 3000;
+            const backoffMs = pollIntervalMs * 2;
+            expect(backoffMs).toBe(6000);
+        });
+    });
+});
+//# sourceMappingURL=reply-listener.test.js.map