script.js

/* Paste this file into the console at web.telegram.org/a/ or /k/.
 * The OpenAI key is requested at runtime and is not stored in this file.
 */
(async () => {
    'use strict';

    const NAME = 'Telegram Web OpenAI Integration';
    const VERSION = '2.3';
    const CONFIG = {
        model: 'gpt-4.1-mini',
        systemPrompt: 'Ты — дружелюбный помощник проекта. Отвечай на языке клиента. Если не знаешь ответа, скажи об этом. Не выдумывай цены, сроки и обещания.',
        pollMs: 2000,
        retryMs: 30000,
        historyLimit: 20,
        maxReplyCharacters: 3500,
        dryRun: false
    };

    if (!/^https:\/\/web\.telegram\.org\/(a|k)\//.test(location.href)) {
        console.error(NAME + ': open Telegram Web A or K first.');
        return;
    }
    if (window.TelegramWebOpenAIIntegration) window.TelegramWebOpenAIIntegration.stop();

    const variant = location.pathname.startsWith('/a/') ? 'A' : 'K';
    function requestKey() {
        return new Promise(resolve => {
            const panel = document.createElement('div');
            panel.id = 'telegram-openai-key-panel';
            panel.style.cssText = 'position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;background:rgba(0,0,0,.65);font:14px Arial,sans-serif';
            const box = document.createElement('div');
            box.style.cssText = 'width:min(420px,90vw);padding:24px;border-radius:12px;background:#fff;color:#111;box-shadow:0 8px 32px #0006';
            const title = document.createElement('div');
            title.textContent = 'OpenAI API key';
            title.style.cssText = 'font-size:18px;font-weight:bold;margin-bottom:10px';
            const note = document.createElement('div');
            note.textContent = 'Ключ останется только в памяти этой вкладки. Не вставляйте его в консоль.';
            note.style.cssText = 'margin-bottom:14px;line-height:1.4';
            const input = document.createElement('input');
            input.type = 'password';
            input.autocomplete = 'off';
            input.placeholder = 'sk-...';
            input.setAttribute('aria-label', 'OpenAI API key');
            input.style.cssText = 'box-sizing:border-box;width:100%;padding:10px;border:1px solid #999;border-radius:6px';
            const actions = document.createElement('div');
            actions.style.cssText = 'display:flex;gap:8px;justify-content:flex-end;margin-top:16px';
            const cancel = document.createElement('button');
            cancel.type = 'button';
            cancel.textContent = 'Отмена';
            const submit = document.createElement('button');
            submit.type = 'button';
            submit.textContent = 'Запустить';
            for (const button of [cancel, submit]) button.style.cssText = 'padding:8px 14px;cursor:pointer';
            function finish(value) {
                input.value = '';
                panel.remove();
                resolve(value);
            }
            cancel.addEventListener('click', () => finish(''));
            submit.addEventListener('click', () => finish(input.value.trim()));
            actions.append(cancel, submit);
            box.append(title, note, input, actions);
            panel.append(box);
            document.body.append(panel);
            input.focus();
        });
    }

    const key = CONFIG.dryRun ? '' : await requestKey();
    if (!CONFIG.dryRun && (!key || !key.trim())) {
        console.warn(NAME + ': no API key; nothing started.');
        return;
    }

    const seenRows = new Map();
    const seenMessages = new Map();
    const completed = new Map();
    const pending = new Set();
    const retryAfter = new Map();
    let timer = null;
    let stopped = false;
    let busy = false;
    let abortController = null;
    const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
    const log = (...args) => console.log('[' + NAME + ' ' + VERSION + ']', ...args);
    const warn = (...args) => console.warn('[' + NAME + ' ' + VERSION + ']', ...args);

    function chatRows() {
        const selector = variant === 'A' ? '.chat-list .chat-item-clickable' : '.chatlist .row-clickable';
        return [...document.querySelectorAll(selector)].map(element => {
            const link = element.matches('a[href]') ? element : element.querySelector('a[href]');
            const href = link?.getAttribute('href') || element.getAttribute('href') || '';
            const id = href.match(/#([^/?]+)/)?.[1] || element.getAttribute('data-peer-id');
            if (!id) return null;
            const isGroup = element.classList.contains('group') || element.classList.contains('channel') || id.startsWith('-');
            const muted = !!element.querySelector('.icon-muted, .dialog-subtitle-badge.muted');
            const badge = variant === 'A'
                ? element.querySelector('.chat-badge-transition')
                : element.querySelector('.dialog-subtitle-badge.unread');
            const unread = !!badge;
            const unreadCount = (badge?.textContent || '').trim();
            const preview = (element.querySelector('.last-message-summary, .dialog-subtitle-span-last')?.textContent || '').trim();
            const date = (element.querySelector('.date, .time, .dialog-title-details')?.textContent || '').trim();
            return { element, id, isGroup, muted, unread, preview, signature: [preview, date, unreadCount, unread].join('\u0000') };
        }).filter(Boolean);
    }

    function currentChatId() {
        return location.hash.match(/^#([^/?]+)/)?.[1] || '';
    }

    function messageElements() {
        return variant === 'A'
            ? [...document.querySelectorAll('.messages-layout .message-list-item')]
            : [...document.querySelectorAll('.bubbles-date-group .bubble[data-mid], .bubbles-date-group .bubble[data-message-id]')];
    }

    function readMessage(element, index) {
        const own = element.classList.contains('own') || element.classList.contains('is-out');
        const id = element.getAttribute('data-message-id') || element.getAttribute('data-mid') || element.id || '';
        const content = element.querySelector('.text-content, .translatable-message, .message');
        if (!content) return null;
        const copy = content.cloneNode(true);
        copy.querySelectorAll('.MessageMeta, .message-time, .time, .reactions, .reply, .forwarded, .MessageOutgoingStatus').forEach(node => node.remove());
        const text = (copy.textContent || '').replace(/[\uE000-\uF8FF]/g, '').replace(/\s+/g, ' ').trim();
        return text ? { id: id || index + ':' + text, own, text } : null;
    }

    function currentMessages() {
        return messageElements().map(readMessage).filter(Boolean);
    }

    function lastLoadedMessage() {
        const elements = messageElements();
        return elements.length ? readMessage(elements[elements.length - 1], elements.length - 1) : null;
    }

    function composer() {
        return variant === 'A'
            ? document.querySelector('#editable-message-text[contenteditable="true"]')
            : document.querySelector('.chat-input .input-message-input[contenteditable="true"]');
    }

    async function openChat(row) {
        const target = row.element.matches('a') ? row.element : row.element.querySelector('a[href]') || row.element;
        if (currentChatId() !== row.id) {
            target.dispatchEvent(new MouseEvent('mousedown', { view: window, bubbles: true, cancelable: true }));
            await sleep(150);
            if (currentChatId() !== row.id) target.click();
        }
        for (let i = 0; i < 20 && !stopped; i++) {
            const freshRow = chatRows().find(item => item.id === row.id);
            const selected = variant !== 'A' || !!freshRow?.element.classList.contains('selected');
            if (currentChatId() === row.id && selected && composer()) {
                await sleep(500);
                return true;
            }
            await sleep(150);
        }
        return false;
    }

    async function requestReply(messages) {
        abortController = new AbortController();
        const timeout = setTimeout(() => abortController.abort(), 30000);
        try {
            const response = await fetch('https://api.openai.com/v1/chat/completions', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + key.trim() },
                body: JSON.stringify({
                    model: CONFIG.model,
                    messages: [
                        { role: 'system', content: CONFIG.systemPrompt },
                        ...messages.slice(-CONFIG.historyLimit).map(m => ({ role: m.own ? 'assistant' : 'user', content: m.text }))
                    ]
                }),
                signal: abortController.signal
            });
            const data = await response.json().catch(() => ({}));
            if (!response.ok) throw new Error('OpenAI HTTP ' + response.status + ': ' + (data.error?.message || response.statusText));
            const reply = data.choices?.[0]?.message?.content;
            if (typeof reply !== 'string' || !reply.trim()) throw new Error('OpenAI returned an empty reply');
            return reply.trim().slice(0, CONFIG.maxReplyCharacters);
        } finally {
            clearTimeout(timeout);
            abortController = null;
        }
    }

    async function sendReply(chatId, expectedId, reply) {
        if (stopped || currentChatId() !== chatId) return false;
        const before = lastLoadedMessage();
        if (!before || before.id !== expectedId || before.own) return false;
        const input = composer();
        if (!input || input.textContent.trim()) {
            warn('Composer unavailable or contains a draft; reply was not sent.');
            return false;
        }
        input.focus();
        if (!document.execCommand('insertText', false, reply)) {
            warn('Telegram editor rejected text insertion; reply was not sent.');
            return false;
        }
        await sleep(200);
        if (currentChatId() !== chatId || input.textContent.trim() !== reply) {
            warn('Chat or draft changed before sending; reply was not sent.');
            return false;
        }
        const button = variant === 'A'
            ? document.querySelector('button[title="Send Message"], button[aria-label="Send Message"]')
            : document.querySelector('.chat-input .btn-send');
        if (!button || button.disabled) {
            warn('Send button was not found; reply remains in the draft.');
            return false;
        }
        button.click();
        for (let i = 0; i < 12 && !stopped; i++) {
            await sleep(250);
            const after = lastLoadedMessage();
            if (after?.own && after.text === reply) return true;
        }
        warn('Send was clicked, but no outgoing message was verified. Automatic retry is disabled for this message.');
        return undefined;
    }

    async function handle(row) {
        if (!await openChat(row)) throw new Error('Could not open chat ' + row.id);
        const messages = currentMessages();
        const last = lastLoadedMessage();
        if (!last || last.own || completed.get(row.id) === last.id) return true;
        if (CONFIG.dryRun) {
            log('Dry run: incoming text detected', { chatId: row.id, messageId: last.id });
            completed.set(row.id, last.id);
            return true;
        }
        const reply = await requestReply(messages);
        const sent = await sendReply(row.id, last.id, reply);
        if (sent === undefined) {
            completed.set(row.id, last.id);
            return true;
        }
        if (sent) {
            completed.set(row.id, last.id);
            log('Reply sent', { chatId: row.id, messageId: last.id });
        }
        return sent;
    }

    async function tick() {
        if (stopped || busy) return;
        busy = true;
        try {
            const rows = chatRows();
            if (!rows.length) {
                warn('No chat list found for Web ' + variant + '; waiting.');
                return;
            }
            const active = rows.find(row => row.id === currentChatId());
            if (active && !active.isGroup && !active.muted && active.id !== '777000') {
                const last = lastLoadedMessage();
                if (last) {
                    const previousId = seenMessages.get(active.id);
                    seenMessages.set(active.id, last.id);
                    if (previousId && previousId !== last.id && !last.own &&
                        (retryAfter.get(active.id) || 0) <= Date.now()) {
                        try {
                            const success = await handle(active);
                            if (success) {
                                retryAfter.delete(active.id);
                                pending.delete(active.id);
                            }
                            else retryAfter.set(active.id, Date.now() + CONFIG.retryMs);
                        } catch (error) {
                            warn('Chat ' + active.id + ':', error);
                            retryAfter.set(active.id, Date.now() + CONFIG.retryMs);
                        }
                        return;
                    }
                }
            }
            for (const row of rows) {
                if (row.isGroup || row.muted || row.id === '777000') continue;
                const previous = seenRows.get(row.id);
                seenRows.set(row.id, row.signature);
                // Rows present at startup were recorded below. An unknown row appeared later,
                // so it may be a newly arrived private chat even when Web A shows no badge.
                if (previous === undefined && !row.preview) continue;
                if (previous === row.signature && !retryAfter.has(row.id) && !pending.has(row.id)) continue;
                if ((retryAfter.get(row.id) || 0) > Date.now()) continue;
                try {
                    const success = await handle(row);
                    if (success) {
                        retryAfter.delete(row.id);
                        pending.delete(row.id);
                    } else retryAfter.set(row.id, Date.now() + CONFIG.retryMs);
                } catch (error) {
                    warn('Chat ' + row.id + ':', error);
                    retryAfter.set(row.id, Date.now() + CONFIG.retryMs);
                }
                break;
            }
        } finally {
            busy = false;
            if (!stopped) timer = setTimeout(tick, CONFIG.pollMs);
        }
    }

    window.TelegramWebOpenAIIntegration = {
        version: VERSION,
        variant,
        stop() {
            stopped = true;
            clearTimeout(timer);
            abortController?.abort();
            log('Stopped');
        },
        status() {
            return { version: VERSION, variant, running: !stopped, busy, watchedChats: seenRows.size, dryRun: CONFIG.dryRun };
        },
        async processCurrent() {
            const row = chatRows().find(item => item.id === currentChatId());
            if (!row || row.isGroup || row.id === '777000') throw new Error('Open a private user chat first');
            if (busy) throw new Error('Already processing another chat');
            busy = true;
            try { return await handle(row); }
            finally { busy = false; }
        }
    };

    for (const row of chatRows()) {
        seenRows.set(row.id, row.signature);
        if (row.unread && !row.isGroup && !row.muted && row.id !== '777000') pending.add(row.id);
    }
    const initialId = currentChatId();
    const initialLast = lastLoadedMessage();
    if (initialId && initialLast) seenMessages.set(initialId, initialLast.id);
    log('Started for Telegram Web ' + variant, window.TelegramWebOpenAIIntegration.status());
    timer = setTimeout(tick, CONFIG.pollMs);
})();