@jstn-sdk/rcs 0.1.0 → 0.1.1

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

@@ -1,723 +0,0 @@
-import { afterEach, describe, it } from 'node:test';
-import assert from 'node:assert/strict';
-import { spawn } from 'node:child_process';
-import { PassThrough } from 'node:stream';
-import { RateLimiter, captureReplyAcknowledgementSummary, formatReplyAcknowledgement, redactSensitiveTokens, sanitizeReplyInput, isReplyListenerProcess, normalizeReplyListenerConfig, pollDiscordOnce, pollTelegramOnce, resetReplyListenerTransientState, } from '../reply-listener.js';
-import { NO_TRACKED_SESSION_MESSAGE } from '../session-status.js';
-function createBaseConfig(overrides = {}) {
-    return {
-        enabled: true,
-        pollIntervalMs: 3000,
-        maxMessageLength: 500,
-        rateLimitPerMinute: 10,
-        includePrefix: true,
-        authorizedDiscordUserIds: ['discord-user-1'],
-        discordEnabled: true,
-        discordBotToken: 'discord-token',
-        discordChannelId: 'discord-channel',
-        telegramEnabled: true,
-        telegramBotToken: '123456:telegram-token',
-        telegramChatId: '777',
-        ...overrides,
-    };
-}
-function createBaseState() {
-    return {
-        isRunning: true,
-        pid: 123,
-        startedAt: '2026-03-20T00:00:00.000Z',
-        lastPollAt: null,
-        telegramLastUpdateId: null,
-        discordLastMessageId: null,
-        messagesInjected: 0,
-        errors: 0,
-    };
-}
-function cloneState(state) {
-    return JSON.parse(JSON.stringify(state));
-}
-function createMapping(platform) {
-    return {
-        platform,
-        messageId: platform === 'discord-bot' ? 'orig-discord-msg' : '222',
-        sessionId: 'session-1',
-        tmuxPaneId: '%9',
-        tmuxSessionName: 'rcs-session',
-        event: 'session-idle',
-        createdAt: '2026-03-20T00:00:00.000Z',
-        projectPath: '/tmp/project',
-    };
-}
-function jsonResponse(body, init = {}) {
-    const headers = new Headers(init.headers);
-    if (!headers.has('content-type')) {
-        headers.set('content-type', 'application/json');
-    }
-    return new Response(JSON.stringify(body), { ...init, headers });
-}
-function createHttpsRequestMock(routes) {
-    return ((options, callback) => {
-        const listeners = new Map();
-        let requestBody = '';
-        const emit = (event, value) => {
-            for (const handler of listeners.get(event) ?? []) {
-                handler(value);
-            }
-        };
-        const request = {
-            on(event, handler) {
-                listeners.set(event, [...(listeners.get(event) ?? []), handler]);
-                return request;
-            },
-            write(chunk) {
-                requestBody += Buffer.isBuffer(chunk) ? chunk.toString('utf-8') : chunk;
-                return true;
-            },
-            end() {
-                queueMicrotask(() => {
-                    try {
-                        const key = `${options.method ?? 'GET'} ${options.path ?? ''}`;
-                        const route = routes[key];
-                        assert.ok(route, `Unexpected https request: ${key}`);
-                        const result = route(requestBody, options);
-                        const response = new PassThrough();
-                        response.statusCode = result.statusCode;
-                        callback?.(response);
-                        if (result.body !== undefined) {
-                            response.write(typeof result.body === 'string'
-                                ? result.body
-                                : JSON.stringify(result.body));
-                        }
-                        response.end();
-                    }
-                    catch (error) {
-                        emit('error', error);
-                    }
-                });
-                return request;
-            },
-            destroy() {
-                return request;
-            },
-        };
-        return request;
-    });
-}
-describe('sanitizeReplyInput', () => {
-    it('passes through normal text', () => {
-        assert.equal(sanitizeReplyInput('hello world'), 'hello world');
-    });
-    it('strips control characters', () => {
-        assert.equal(sanitizeReplyInput('hello\x00world'), 'helloworld');
-        assert.equal(sanitizeReplyInput('test\x07bell'), 'testbell');
-        assert.equal(sanitizeReplyInput('test\x1bescseq'), 'testescseq');
-    });
-    it('replaces newlines with spaces', () => {
-        assert.equal(sanitizeReplyInput('line1\nline2'), 'line1 line2');
-        assert.equal(sanitizeReplyInput('line1\r\nline2'), 'line1 line2');
-    });
-    it('escapes backslashes', () => {
-        assert.equal(sanitizeReplyInput('path\\to\\file'), 'path\\\\to\\\\file');
-    });
-    it('escapes backticks', () => {
-        assert.equal(sanitizeReplyInput('run `cmd`'), 'run \\`cmd\\`');
-    });
-    it('escapes $( command substitution', () => {
-        assert.equal(sanitizeReplyInput('$(whoami)'), '\\$(whoami)');
-    });
-    it('escapes ${ variable expansion', () => {
-        assert.equal(sanitizeReplyInput('${HOME}'), '\\${HOME}');
-    });
-    it('trims whitespace', () => {
-        assert.equal(sanitizeReplyInput('  hello  '), 'hello');
-    });
-    it('handles empty string', () => {
-        assert.equal(sanitizeReplyInput(''), '');
-    });
-    it('handles whitespace-only string', () => {
-        assert.equal(sanitizeReplyInput('   '), '');
-    });
-    it('handles combined dangerous patterns', () => {
-        const input = '$(rm -rf /) && `evil` ${PATH}\nmore';
-        const result = sanitizeReplyInput(input);
-        assert.ok(!result.includes('\n'));
-        assert.ok(result.includes('\\$('));
-        assert.ok(result.includes('\\${'));
-        assert.ok(result.includes('\\`'));
-    });
-    it('preserves normal special characters', () => {
-        assert.equal(sanitizeReplyInput('hello! @user #tag'), 'hello! @user #tag');
-    });
-    it('handles unicode text', () => {
-        const result = sanitizeReplyInput('Hello world');
-        assert.ok(result.length > 0);
-    });
-});
-describe('isReplyListenerProcess', () => {
-    const originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform');
-    afterEach(() => {
-        if (originalPlatform)
-            Object.defineProperty(process, 'platform', originalPlatform);
-    });
-    it('returns false for the current process (test runner has no daemon marker)', () => {
-        assert.equal(isReplyListenerProcess(process.pid), false);
-    });
-    it('returns false on native Windows instead of shelling out to ps', (_, done) => {
-        Object.defineProperty(process, 'platform', { value: 'win32', configurable: true });
-        const child = spawn(process.execPath, ['-e', 'const pollLoop = () => {}; setInterval(pollLoop, 60000);'], { stdio: 'ignore' });
-        child.once('spawn', () => {
-            const pid = child.pid;
-            const result = isReplyListenerProcess(pid);
-            child.kill();
-            assert.equal(result, false);
-            done();
-        });
-        child.once('error', (err) => {
-            done(err);
-        });
-    });
-    it('returns true for a process whose command line contains the daemon marker', (_, done) => {
-        const child = spawn(process.execPath, ['-e', 'const pollLoop = () => {}; setInterval(pollLoop, 60000);'], { stdio: 'ignore' });
-        child.once('spawn', () => {
-            const pid = child.pid;
-            const result = isReplyListenerProcess(pid);
-            child.kill();
-            assert.equal(result, true);
-            done();
-        });
-        child.once('error', (err) => {
-            done(err);
-        });
-    });
-    it('returns false for a process whose command line lacks the daemon marker', (_, done) => {
-        const child = spawn(process.execPath, ['-e', 'setInterval(() => {}, 60000);'], { stdio: 'ignore' });
-        child.once('spawn', () => {
-            const pid = child.pid;
-            const result = isReplyListenerProcess(pid);
-            child.kill();
-            assert.equal(result, false);
-            done();
-        });
-        child.once('error', (err) => {
-            done(err);
-        });
-    });
-    it('returns false for a non-existent PID', () => {
-        assert.equal(isReplyListenerProcess(0), false);
-    });
-    it('returns false on Windows when ps is unavailable', () => {
-        const result = isReplyListenerProcess(123, {
-            platform: 'win32',
-            env: {
-                PATH: '',
-                PATHEXT: '.EXE;.CMD;.PS1',
-            },
-            spawnImpl: (() => ({
-                pid: 0,
-                output: [null, '', ''],
-                stdout: '',
-                stderr: '',
-                status: null,
-                signal: null,
-                error: Object.assign(new Error('spawnSync ps ENOENT'), { code: 'ENOENT' }),
-            })),
-        });
-        assert.equal(result, false);
-    });
-});
-describe('normalizeReplyListenerConfig', () => {
-    it('clamps invalid runtime numeric values and sanitizes authorized users', () => {
-        const normalized = normalizeReplyListenerConfig({
-            enabled: true,
-            pollIntervalMs: 0,
-            maxMessageLength: -10,
-            rateLimitPerMinute: -1,
-            includePrefix: false,
-            authorizedDiscordUserIds: ['123', '', '  ', '456'],
-            discordEnabled: true,
-            discordBotToken: 'bot-token',
-            discordChannelId: 'channel-id',
-        });
-        assert.equal(normalized.pollIntervalMs, 500);
-        assert.equal(normalized.maxMessageLength, 1);
-        assert.equal(normalized.rateLimitPerMinute, 1);
-        assert.equal(normalized.includePrefix, false);
-        assert.deepEqual(normalized.authorizedDiscordUserIds, ['123', '456']);
-    });
-    it('infers enabled flags from credentials when omitted', () => {
-        const normalized = normalizeReplyListenerConfig({
-            enabled: true,
-            pollIntervalMs: 3000,
-            maxMessageLength: 500,
-            rateLimitPerMinute: 10,
-            includePrefix: true,
-            authorizedDiscordUserIds: [],
-            telegramBotToken: 'tg-token',
-            telegramChatId: 'tg-chat',
-        });
-        assert.equal(normalized.telegramEnabled, true);
-        assert.equal(normalized.discordEnabled, false);
-    });
-});
-describe('captureReplyAcknowledgementSummary', () => {
-    it('captures a cleaned recent-output summary via tmux-tail parsing', () => {
-        const summary = captureReplyAcknowledgementSummary('%9', {
-            capturePaneContentImpl: (paneId, lines) => {
-                assert.equal(paneId, '%9');
-                assert.equal(lines, 200);
-                return [
-                    '● spinner',
-                    'Meaningful output line',
-                    '  continuation line',
-                    '',
-                ].join('\n');
-            },
-        });
-        assert.equal(summary, 'Meaningful output line\n  continuation line');
-    });
-    it('returns null when the captured pane tail has no meaningful lines', () => {
-        const summary = captureReplyAcknowledgementSummary('%9', {
-            capturePaneContentImpl: () => '● spinner\nctrl+o to expand',
-        });
-        assert.equal(summary, null);
-    });
-    it('truncates oversized summaries without cutting the acknowledgment prefix logic', () => {
-        const longLine = 'x'.repeat(900);
-        const summary = captureReplyAcknowledgementSummary('%9', {
-            capturePaneContentImpl: () => longLine,
-            parseTmuxTailImpl: () => longLine,
-        });
-        assert.equal(summary?.length, 700);
-        assert.ok(summary?.endsWith('…'));
-    });
-});
-describe('formatReplyAcknowledgement', () => {
-    it('includes recent output when a summary is available', () => {
-        const message = formatReplyAcknowledgement('Line 1\nLine 2');
-        assert.equal(message, 'Injected into Codex CLI session.\n\nRecent output:\nLine 1\nLine 2');
-    });
-    it('falls back when no summary is available', () => {
-        const message = formatReplyAcknowledgement(null);
-        assert.equal(message, 'Injected into Codex CLI session.\n\nRecent output summary unavailable.');
-    });
-});
-describe('redactSensitiveTokens', () => {
-    it('redacts OpenAI-style API keys', () => {
-        assert.equal(redactSensitiveTokens('export OPENAI_API_KEY=sk-proj-abc123def456'), 'export OPENAI_API_KEY=[REDACTED]');
-    });
-    it('redacts GitHub PAT tokens', () => {
-        assert.equal(redactSensitiveTokens('token: ghp_1234567890abcdefABCDEF'), 'token: [REDACTED]');
-    });
-    it('redacts generic key=value secrets', () => {
-        const result = redactSensitiveTokens('api_key=mysecretvalue123 other text');
-        assert.equal(result.includes('mysecretvalue123'), false);
-    });
-    it('redacts multi-part authorization header values', () => {
-        assert.equal(redactSensitiveTokens('authorization: Bearer mysecrettoken'), 'authorization: [REDACTED]');
-    });
-    it('redacts quoted JSON secret fields', () => {
-        assert.equal(redactSensitiveTokens('{"api_key":"mysecret","safe":true}'), '{"api_key":"[REDACTED]","safe":true}');
-    });
-    it('preserves text without secrets', () => {
-        const input = 'npm run build\n33 tests passed\nno errors found';
-        assert.equal(redactSensitiveTokens(input), input);
-    });
-});
-describe('captureReplyAcknowledgementSummary redaction', () => {
-    it('redacts secrets from captured tmux output', () => {
-        const summary = captureReplyAcknowledgementSummary('%99', {
-            capturePaneContentImpl: () => 'export OPENAI_API_KEY=sk-proj-abc123\n$ codex chat',
-            parseTmuxTailImpl: (raw) => raw,
-        });
-        assert.ok(summary);
-        assert.equal(summary.includes('sk-proj-abc123'), false, 'API key must be redacted');
-        assert.ok(summary.includes('[REDACTED]'));
-    });
-});
-describe('pollDiscordOnce', () => {
-    it('treats exact-match status replies as read-only Discord session lookups', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig();
-        const state = createBaseState();
-        const fetchCalls = [];
-        let injectCalled = false;
-        const fetchImpl = async (input, init) => {
-            const url = String(input);
-            fetchCalls.push({ url, init });
-            if (url.endsWith('/messages?limit=10')) {
-                return jsonResponse([
-                    {
-                        id: 'discord-status-1',
-                        author: { id: 'discord-user-1' },
-                        content: '  STATUS  ',
-                        message_reference: { message_id: 'orig-discord-msg' },
-                    },
-                ]);
-            }
-            if (url.endsWith('/messages')) {
-                return jsonResponse({ id: 'status-reply-1' });
-            }
-            throw new Error(`Unexpected fetch url: ${url}`);
-        };
-        await pollDiscordOnce(config, state, new RateLimiter(10), {
-            fetchImpl,
-            lookupByMessageIdImpl: () => createMapping('discord-bot'),
-            buildSessionStatusReplyImpl: async (mapping) => {
-                assert.equal(mapping.sessionId, 'session-1');
-                return 'Tracked RCS session status';
-            },
-            injectReplyImpl: () => {
-                injectCalled = true;
-                return true;
-            },
-        });
-        assert.equal(injectCalled, false);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 0);
-        assert.equal(state.discordLastMessageId, 'discord-status-1');
-        assert.equal(fetchCalls.length, 2);
-        const replyBody = JSON.parse(String(fetchCalls[1].init?.body));
-        assert.equal(replyBody.content, 'Tracked RCS session status');
-        assert.deepEqual(replyBody.message_reference, { message_id: 'discord-status-1' });
-        assert.deepEqual(replyBody.allowed_mentions, { parse: [] });
-    });
-    it('uses the latest correlated session when a Discord notification message id is reused', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig();
-        const state = createBaseState();
-        const statusSessionIds = [];
-        await pollDiscordOnce(config, state, new RateLimiter(10), {
-            fetchImpl: async (input) => {
-                const url = String(input);
-                if (url.endsWith('/messages?limit=10')) {
-                    return jsonResponse([
-                        {
-                            id: 'discord-status-reused-id',
-                            author: { id: 'discord-user-1' },
-                            content: 'status',
-                            message_reference: { message_id: 'orig-discord-msg' },
-                        },
-                    ]);
-                }
-                if (url.endsWith('/messages')) {
-                    return jsonResponse({ id: 'status-reply-reused-id' });
-                }
-                throw new Error(`Unexpected fetch url: ${url}`);
-            },
-            lookupByMessageIdImpl: () => ({
-                ...createMapping('discord-bot'),
-                messageId: 'orig-discord-msg',
-                sessionId: 'session-newer',
-                tmuxPaneId: '%10',
-                tmuxSessionName: 'latest-session',
-            }),
-            buildSessionStatusReplyImpl: async (mapping) => {
-                statusSessionIds.push(mapping.sessionId);
-                return `Tracked RCS session status\nSession: ${mapping.sessionId}`;
-            },
-            injectReplyImpl: () => {
-                throw new Error('injectReply should not run for exact-match status probes');
-            },
-        });
-        assert.deepEqual(statusSessionIds, ['session-newer']);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 0);
-        assert.equal(state.discordLastMessageId, 'discord-status-reused-id');
-    });
-    it('injects authorized replies and posts a threaded acknowledgement with recent output', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig({ discordMention: '<@123>' });
-        const state = createBaseState();
-        const writes = [];
-        const fetchCalls = [];
-        const fetchImpl = async (input, init) => {
-            const url = String(input);
-            fetchCalls.push({ url, init });
-            if (url.endsWith('/messages?limit=10')) {
-                return jsonResponse([
-                    {
-                        id: 'discord-reply-1',
-                        author: { id: 'discord-user-1' },
-                        content: 'run status',
-                        message_reference: { message_id: 'orig-discord-msg' },
-                    },
-                ]);
-            }
-            if (url.includes('/reactions/')) {
-                return new Response(null, { status: 204 });
-            }
-            if (url.endsWith('/messages')) {
-                return jsonResponse({ id: 'ack-1' });
-            }
-            throw new Error(`Unexpected fetch url: ${url}`);
-        };
-        await pollDiscordOnce(config, state, new RateLimiter(10), {
-            fetchImpl,
-            lookupByMessageIdImpl: () => createMapping('discord-bot'),
-            injectReplyImpl: (paneId, text, platform, activeConfig) => {
-                assert.equal(paneId, '%9');
-                assert.equal(text, 'run status');
-                assert.equal(platform, 'discord');
-                assert.equal(activeConfig, config);
-                return true;
-            },
-            captureReplyAcknowledgementSummaryImpl: () => 'Recent pane output',
-            parseMentionAllowedMentionsImpl: (mention) => {
-                assert.equal(mention, '<@123>');
-                return { users: ['123'] };
-            },
-            writeDaemonStateImpl: (nextState) => {
-                writes.push(cloneState(nextState));
-            },
-        });
-        assert.equal(state.messagesInjected, 1);
-        assert.equal(state.errors, 0);
-        assert.equal(state.discordLastMessageId, 'discord-reply-1');
-        assert.ok(writes.length >= 1);
-        assert.equal(fetchCalls.length, 3);
-        const acknowledgementCall = fetchCalls[2];
-        assert.ok(acknowledgementCall.url.endsWith('/messages'));
-        const acknowledgementBody = JSON.parse(String(acknowledgementCall.init?.body));
-        assert.equal(acknowledgementBody.content, 'Injected into Codex CLI session.\n\nRecent output:\nRecent pane output');
-        assert.deepEqual(acknowledgementBody.message_reference, { message_id: 'discord-reply-1' });
-        assert.deepEqual(acknowledgementBody.allowed_mentions, { users: ['123'] });
-    });
-    it('ignores unauthorized Discord replies while still advancing the last message id', async () => {
-        resetReplyListenerTransientState();
-        const state = createBaseState();
-        await pollDiscordOnce(createBaseConfig(), state, new RateLimiter(10), {
-            fetchImpl: async () => jsonResponse([
-                {
-                    id: 'discord-reply-2',
-                    author: { id: 'intruder' },
-                    content: 'malicious',
-                    message_reference: { message_id: 'orig-discord-msg' },
-                },
-            ]),
-            lookupByMessageIdImpl: () => {
-                throw new Error('lookup should not be called for unauthorized replies');
-            },
-            injectReplyImpl: () => {
-                throw new Error('injectReply should not be called for unauthorized replies');
-            },
-        });
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 0);
-        assert.equal(state.discordLastMessageId, 'discord-reply-2');
-    });
-    it('does not return status data for unauthorized status replies', async () => {
-        resetReplyListenerTransientState();
-        const state = createBaseState();
-        const fetchCalls = [];
-        await pollDiscordOnce(createBaseConfig(), state, new RateLimiter(10), {
-            fetchImpl: async (input) => {
-                fetchCalls.push(String(input));
-                return jsonResponse([
-                    {
-                        id: 'discord-reply-unauthorized-status',
-                        author: { id: 'intruder' },
-                        content: 'status',
-                        message_reference: { message_id: 'orig-discord-msg' },
-                    },
-                ]);
-            },
-            lookupByMessageIdImpl: () => {
-                throw new Error('lookup should not run for unauthorized status replies');
-            },
-            injectReplyImpl: () => {
-                throw new Error('injectReply should not run for unauthorized status replies');
-            },
-        });
-        assert.deepEqual(fetchCalls, ['https://discord.com/api/v10/channels/discord-channel/messages?limit=10']);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 0);
-        assert.equal(state.discordLastMessageId, 'discord-reply-unauthorized-status');
-    });
-    it('replies with a bounded failure when status has no tracked correlation and does not inject', async () => {
-        resetReplyListenerTransientState();
-        const state = createBaseState();
-        const fetchCalls = [];
-        let injectCalled = false;
-        await pollDiscordOnce(createBaseConfig(), state, new RateLimiter(10), {
-            fetchImpl: async (input, init) => {
-                const url = String(input);
-                fetchCalls.push({ url, init });
-                if (url.endsWith('/messages?limit=10')) {
-                    return jsonResponse([
-                        {
-                            id: 'discord-status-untracked',
-                            author: { id: 'discord-user-1' },
-                            content: 'status',
-                            message_reference: { message_id: 'unknown-msg' },
-                        },
-                    ]);
-                }
-                if (url.endsWith('/messages')) {
-                    return jsonResponse({ id: 'status-failure-reply' });
-                }
-                throw new Error(`Unexpected fetch url: ${url}`);
-            },
-            lookupByMessageIdImpl: () => null,
-            injectReplyImpl: () => {
-                injectCalled = true;
-                return true;
-            },
-        });
-        assert.equal(injectCalled, false);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 0);
-        assert.equal(fetchCalls.length, 2);
-        const replyBody = JSON.parse(String(fetchCalls[1].init?.body));
-        assert.equal(replyBody.content, NO_TRACKED_SESSION_MESSAGE);
-    });
-    it('drops mapped Discord replies when the rate limiter rejects them', async () => {
-        resetReplyListenerTransientState();
-        const state = createBaseState();
-        let injectCalled = false;
-        await pollDiscordOnce(createBaseConfig(), state, { canProceed: () => false, reset: () => { } }, {
-            fetchImpl: async () => jsonResponse([
-                {
-                    id: 'discord-reply-3',
-                    author: { id: 'discord-user-1' },
-                    content: 'status?',
-                    message_reference: { message_id: 'orig-discord-msg' },
-                },
-            ]),
-            lookupByMessageIdImpl: () => createMapping('discord-bot'),
-            injectReplyImpl: () => {
-                injectCalled = true;
-                return true;
-            },
-        });
-        assert.equal(injectCalled, false);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 1);
-        assert.equal(state.discordLastMessageId, 'discord-reply-3');
-    });
-});
-describe('pollTelegramOnce', () => {
-    it('injects Telegram replies and sends a reply acknowledgement', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig();
-        const state = createBaseState();
-        const writes = [];
-        let sendMessageBody = '';
-        await pollTelegramOnce(config, state, new RateLimiter(10), {
-            httpsRequestImpl: createHttpsRequestMock({
-                [`GET /bot${config.telegramBotToken}/getUpdates?offset=0&timeout=0`]: () => ({
-                    statusCode: 200,
-                    body: {
-                        ok: true,
-                        result: [
-                            {
-                                update_id: 44,
-                                message: {
-                                    message_id: 333,
-                                    chat: { id: 777 },
-                                    text: 'continue',
-                                    reply_to_message: { message_id: 222 },
-                                },
-                            },
-                        ],
-                    },
-                }),
-                [`POST /bot${config.telegramBotToken}/sendMessage`]: (body) => {
-                    sendMessageBody = body;
-                    return { statusCode: 200, body: { ok: true, result: { message_id: 444 } } };
-                },
-            }),
-            lookupByMessageIdImpl: () => createMapping('telegram'),
-            injectReplyImpl: (paneId, text, platform) => {
-                assert.equal(paneId, '%9');
-                assert.equal(text, 'continue');
-                assert.equal(platform, 'telegram');
-                return true;
-            },
-            captureReplyAcknowledgementSummaryImpl: () => 'Recent telegram output',
-            writeDaemonStateImpl: (nextState) => {
-                writes.push(cloneState(nextState));
-            },
-        });
-        assert.equal(state.messagesInjected, 1);
-        assert.equal(state.errors, 0);
-        assert.equal(state.telegramLastUpdateId, 44);
-        assert.ok(writes.length >= 1);
-        const parsedBody = JSON.parse(sendMessageBody);
-        assert.equal(parsedBody.chat_id, config.telegramChatId);
-        assert.equal(parsedBody.reply_to_message_id, 333);
-        assert.equal(parsedBody.text, 'Injected into Codex CLI session.\n\nRecent output:\nRecent telegram output');
-    });
-    it('ignores Telegram replies from the wrong chat', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig();
-        let sendMessageAttempted = false;
-        await pollTelegramOnce(config, createBaseState(), new RateLimiter(10), {
-            httpsRequestImpl: createHttpsRequestMock({
-                [`GET /bot${config.telegramBotToken}/getUpdates?offset=0&timeout=0`]: () => ({
-                    statusCode: 200,
-                    body: {
-                        ok: true,
-                        result: [
-                            {
-                                update_id: 45,
-                                message: {
-                                    message_id: 334,
-                                    chat: { id: 999 },
-                                    text: 'wrong chat',
-                                    reply_to_message: { message_id: 222 },
-                                },
-                            },
-                        ],
-                    },
-                }),
-                [`POST /bot${config.telegramBotToken}/sendMessage`]: () => {
-                    sendMessageAttempted = true;
-                    return { statusCode: 200, body: { ok: true, result: { message_id: 445 } } };
-                },
-            }),
-            lookupByMessageIdImpl: () => createMapping('telegram'),
-            injectReplyImpl: () => {
-                throw new Error('injectReply should not run for wrong-chat messages');
-            },
-        });
-        assert.equal(sendMessageAttempted, false);
-    });
-    it('records an error when Telegram injection fails and does not send an acknowledgement', async () => {
-        resetReplyListenerTransientState();
-        const config = createBaseConfig();
-        const state = createBaseState();
-        let sendMessageAttempted = false;
-        await pollTelegramOnce(config, state, new RateLimiter(10), {
-            httpsRequestImpl: createHttpsRequestMock({
-                [`GET /bot${config.telegramBotToken}/getUpdates?offset=0&timeout=0`]: () => ({
-                    statusCode: 200,
-                    body: {
-                        ok: true,
-                        result: [
-                            {
-                                update_id: 46,
-                                message: {
-                                    message_id: 335,
-                                    chat: { id: 777 },
-                                    text: 'blocked',
-                                    reply_to_message: { message_id: 222 },
-                                },
-                            },
-                        ],
-                    },
-                }),
-                [`POST /bot${config.telegramBotToken}/sendMessage`]: () => {
-                    sendMessageAttempted = true;
-                    return { statusCode: 200, body: { ok: true, result: { message_id: 446 } } };
-                },
-            }),
-            lookupByMessageIdImpl: () => createMapping('telegram'),
-            injectReplyImpl: () => false,
-        });
-        assert.equal(sendMessageAttempted, false);
-        assert.equal(state.messagesInjected, 0);
-        assert.equal(state.errors, 1);
-        assert.equal(state.telegramLastUpdateId, 46);
-    });
-});
-//# sourceMappingURL=reply-listener.test.js.map