zames_pro 2.71.0 → 2.72.1

package/dist/browser-chats.js

@@ -0,0 +1,161 @@
+// PURE parsing of the DeepSeek history/message payloads (BACKLOG C3). These
+// helpers are extracted from DeepSeekBrowser.fetchChatMessages: they used to be
+// copy-pasted INLINE twice (the in-page evaluate AND the Playwright-request
+// fallback), so the same role/fragment extraction lived in two places and could
+// drift. They operate on plain JSON, touch no browser state, and are
+// unit-tested without Playwright.
+// Collapse 3+ blank lines to one blank line and trim — DeepSeek pads the
+// fragments with newlines and the raw text looked double-spaced in the
+// restored dialogue.
+export function tidyFragmentText(text) {
+    const NL = String.fromCharCode(10);
+    return String(text || '')
+        .replace(new RegExp(NL + '{3,}', 'g'), NL + NL)
+        .trim();
+}
+/**
+ * Extract displayable messages from `data.biz_data.chat_messages[]`.
+ *
+ * Assistant turns keep only RESPONSE fragments, user turns only REQUEST
+ * fragments (THINK/FILE fragments are dropped, matching the live reader). The
+ * LATEST `accumulated_token_usage` seen in the payload is returned as
+ * `usage` (each message carries the running counter).
+ */
+export function parseHistoryMessages(messages) {
+    if (!Array.isArray(messages))
+        return { list: [], usage: null };
+    const list = [];
+    let usage = null;
+    for (const raw of messages) {
+        if (raw && typeof raw.accumulated_token_usage === 'number') {
+            usage = raw.accumulated_token_usage;
+        }
+        const role = raw && raw.role === 'ASSISTANT' ? 'assistant' : 'user';
+        const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+        let text = '';
+        for (const fr of (raw && raw.fragments) || []) {
+            if (!fr || fr.type !== want)
+                continue;
+            if (typeof fr.content === 'string')
+                text += fr.content;
+        }
+        text = tidyFragmentText(text);
+        if (text)
+            list.push({ role, text });
+    }
+    return { list, usage };
+}
+/**
+ * Pull `chat_messages` out of a history_messages JSON response, tolerating the
+ * two shapes the endpoint has shipped (`data.biz_data.chat_messages`); returns
+ * null when the shape does not match, so the caller can report a clear error.
+ */
+export function extractChatMessages(json) {
+    const j = json;
+    const messages = j?.data?.biz_data?.chat_messages;
+    return Array.isArray(messages) ? messages : null;
+}
+/**
+ * In-page scraper for the chat list (the sidebar anchors). Runs INSIDE the
+ * page via page.evaluate, so it must NOT close over module scope — it only
+ * uses its `limit` argument and DOM globals. Kept as a named export so the
+ * class body stays thin and this scraping policy has ONE home.
+ */
+export function scrapeChatList(limit) {
+    const out = [];
+    const seen = new Set();
+    const anchors = document.querySelectorAll('a[href*="/chat/"]');
+    for (const a of Array.from(anchors)) {
+        const href = a.getAttribute('href') || '';
+        const m = href.match(/\/chat\/s\/([a-zA-Z0-9_-]+)/) ||
+            href.match(/\/a\/chat\/s\/([a-zA-Z0-9_-]+)/);
+        if (!m)
+            continue;
+        const id = m[1];
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        const titleEl = a.querySelector('[class*="title"], [class*="text"]');
+        let title = (titleEl ? titleEl.textContent : a.textContent) || '';
+        title = title.trim().replace(/\s+/g, ' ');
+        if (!title)
+            title = '(без названия)';
+        out.push({ id, title, href });
+        if (out.length >= limit)
+            break;
+    }
+    return out;
+}
+/**
+ * In-page scraper for the WHOLE visible dialogue of the open chat. Runs INSIDE
+ * the page via page.evaluate (no module-scope closure). Message-level
+ * containers are tried first, then assistant-only answer wrappers as a
+ * fallback; nested duplicate blocks are collapsed to the OUTERMOST one (some
+ * builds match both an outer and an inner container, which printed each turn
+ * twice). The model's reasoning (think class) is skipped.
+ */
+export function scrapeChatMessages(opts) {
+    const think = new RegExp(opts.thinkRe, 'i');
+    const assistantRe = new RegExp(opts.assistantRe, 'i');
+    const inThink = (e) => {
+        let n = e;
+        while (n) {
+            const cls = (n.className || '').toString();
+            if (think.test(cls))
+                return true;
+            n = n.parentElement;
+        }
+        return false;
+    };
+    const textOf = (e) => {
+        const h = e;
+        const t = h.innerText || h.textContent || '';
+        const NL = String.fromCharCode(10);
+        return t.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+    };
+    const looksAssistant = (e) => {
+        const cls = (e.className || '').toString();
+        if (assistantRe.test(cls))
+            return true;
+        if (e.querySelector(opts.assistantSel))
+            return true;
+        if (e.querySelector(opts.markdownSel))
+            return true;
+        return false;
+    };
+    let blocks = [];
+    for (const s of opts.containerSels) {
+        const found = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e) && textOf(e).length > 0);
+        if (found.length) {
+            blocks = found;
+            break;
+        }
+    }
+    if (blocks.length > 1) {
+        const unique = Array.from(new Set(blocks));
+        blocks = unique.filter((b) => !unique.some((other) => other !== b && other.contains(b)));
+    }
+    const out = [];
+    if (blocks.length) {
+        for (const b of blocks) {
+            const t = textOf(b);
+            if (!t)
+                continue;
+            out.push({ role: looksAssistant(b) ? 'assistant' : 'user', text: t });
+        }
+        if (out.length)
+            return out;
+    }
+    for (const s of opts.answerSels) {
+        const list = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e));
+        if (!list.length)
+            continue;
+        for (const el of list) {
+            const t = textOf(el);
+            if (t)
+                out.push({ role: 'assistant', text: t });
+        }
+        break;
+    }
+    return out;
+}

package/dist/browser-dom.js

@@ -0,0 +1,416 @@
+// Pure in-page DOM helpers extracted from DeepSeekBrowser (BACKLOG C3).
+//
+// Every function here runs INSIDE page.evaluate, so it MUST be fully
+// self-contained: Playwright serializes the function SOURCE and evaluates it in
+// the page, where module scope does not exist. Only DOM globals and the passed
+// argument are available — a reference to another helper of this file would be
+// lost. This is the same constraint browser-chats.ts works under; keeping the
+// callbacks here instead of inline in the class keeps the class body thin
+// without changing behavior.
+/**
+ * Read ONLY visible toast/notification containers as one text blob.
+ *
+ * WHY this list is narrow: a broad `[class*="error" i]` matched leftover page
+ * text and produced a FALSE rate limit. Keeping to real toast containers means
+ * no false positives, so ask() does not go into a needless 5-minute wait.
+ */
+export function readPageToastsInDom() {
+    const sels = [
+        '[role="alert"]',
+        '[class*="toast" i]',
+        '[class*="notification" i]',
+    ];
+    let out = '';
+    for (const s of sels) {
+        for (const el of Array.from(document.querySelectorAll(s))) {
+            const e = el;
+            const st = getComputedStyle(e);
+            if (st.display === 'none' || st.visibility === 'hidden')
+                continue;
+            out += ' ' + (e.innerText || '');
+        }
+    }
+    return out;
+}
+/**
+ * Read a visible login/credentials error message from the page, if any.
+ * Best-effort: the caller slices/trims; this returns the joined text.
+ */
+export function readLoginErrorInDom() {
+    const sels = [
+        '[role="alert"]',
+        '[class*="error" i]',
+        '[class*="toast" i]',
+        '[class*="notification" i]',
+    ];
+    let out = '';
+    for (const s of sels) {
+        for (const el of Array.from(document.querySelectorAll(s))) {
+            const e = el;
+            const st = getComputedStyle(e);
+            if (st.display === 'none' || st.visibility === 'hidden')
+                continue;
+            const t = (e.innerText || '').trim();
+            if (t)
+                out += ' ' + t;
+        }
+    }
+    return out.replace(/\s+/g, ' ').trim();
+}
+/**
+ * The answer as RENDERED on the page, ALWAYS from the DOM (never the network
+ * capture). Reasoning blocks (think class) are skipped and must never be
+ * picked up as the answer.
+ */
+export function readLastAnswerInDom(opts) {
+    const sels = opts.sels;
+    const think = new RegExp(opts.thinkRe, 'i');
+    const inThink = (e) => {
+        let n = e;
+        while (n) {
+            const cls = (n.className || '').toString();
+            if (think.test(cls))
+                return true;
+            n = n.parentElement;
+        }
+        return false;
+    };
+    let el = null;
+    for (const s of sels) {
+        const list = document.querySelectorAll(s);
+        if (!list.length)
+            continue;
+        for (let i = list.length - 1; i >= 0; i--) {
+            const cand = list[i];
+            if (inThink(cand))
+                continue;
+            el = cand;
+            break;
+        }
+        if (el)
+            break;
+    }
+    if (!el)
+        return '';
+    const out = el.innerText || el.textContent || '';
+    const NL = String.fromCharCode(10);
+    return out.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+}
+/**
+ * A CHEAP growth signal for the "did the answer start?" loop: the number of
+ * message/answer nodes plus the length of the LAST answer element. The old code
+ * read document.body.innerText.length every tick, which serializes the WHOLE
+ * page (sidebar, history, menus) and forces a layout — expensive on a long chat.
+ */
+export function chatSignalInDom(opts) {
+    const nodes = document.querySelectorAll(opts.nodesSel).length;
+    let lastLen = 0;
+    const answers = document.querySelectorAll(opts.mdSel);
+    if (answers.length) {
+        const lastEl = answers[answers.length - 1];
+        lastLen = (lastEl.innerText || '').length;
+    }
+    return { nodes, lastLen };
+}
+/**
+ * Cheap first probe for the Continue button: ONE scan of buttons/role-buttons
+ * for a matching visible label. The common path (no button) is probed every
+ * tick, so a single evaluate replaces the getByRole count+isVisible scan.
+ */
+export function continueVisibleCheapInDom(nameRe) {
+    const re = new RegExp(nameRe, 'i');
+    const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+    for (const e of cands) {
+        const label = ((e.textContent || '') +
+            ' ' +
+            (e.getAttribute('aria-label') || ''))
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!re.test(label))
+            continue;
+        const st = getComputedStyle(e);
+        if (st.display === 'none' || st.visibility === 'hidden')
+            continue;
+        const r = e.getBoundingClientRect();
+        if (r.width > 0 && r.height > 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Find the Stop button in the DeepSeek UI. We can't rely on the class alone:
+ * during generation the send button (the same circle button) changes its icon
+ * to a "square" (stop) while keeping the classes, so a square icon (svg rect)
+ * also means Stop.
+ */
+export function stopButtonVisibleInDom(btnRe) {
+    const re = new RegExp(btnRe, 'i');
+    const btns = Array.from(document.querySelectorAll('div[role="button"], button'));
+    for (const b of btns) {
+        const cls = (b.className || '').toString();
+        if (!re.test(cls))
+            continue;
+        const label = ((b.getAttribute('aria-label') || '') +
+            ' ' +
+            (b.getAttribute('title') || '') +
+            ' ' +
+            (b.textContent || '')).toLowerCase();
+        if (/stop|останов/.test(label))
+            return true;
+        // A square icon = Stop button; an arrow (path without rect) = send.
+        const svg = b.querySelector('svg');
+        if (svg && svg.querySelector('rect'))
+            return true;
+    }
+    return false;
+}
+/**
+ * Raw-DOM Stop click with the full pointer/mouse sequence (older builds
+ * without a proper role, or a click intercepted by an overlay). Returns true
+ * when a square-icon button was found and clicked.
+ */
+export function clickStopInDom(btnRe) {
+    const re = new RegExp(btnRe, 'i');
+    const btns = Array.from(document.querySelectorAll('div[role="button"], button'));
+    for (const b of btns) {
+        const cls = (b.className || '').toString();
+        if (!re.test(cls))
+            continue;
+        const svg = b.querySelector('svg');
+        if (svg && svg.querySelector('rect')) {
+            for (const type of [
+                'pointerdown',
+                'mousedown',
+                'pointerup',
+                'mouseup',
+                'click',
+            ]) {
+                b.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true }));
+            }
+            b.click();
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Raw-DOM scan for a visible Continue button (fallback for builds without a
+ * proper role). The label match is an EXACT short form (optionally with a
+ * reasoning suffix) so a "Continue" inside rendered prose is never matched.
+ */
+export function continueVisibleInDom() {
+    const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+        .replace(/\s+/g, ' ')
+        .trim();
+    const isExact = (t) => /^(?:continue|продолжить|продолжение)(?:\s+(?:think(?:ing)?|reason(?:ing)?|размышлени[ея]|генераци[юя]|ответ))?\s*[.!…]?$/i.test(t);
+    const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+    for (const e of cands) {
+        if (!isExact(labelOf(e)))
+            continue;
+        const st = getComputedStyle(e);
+        if (st.display === 'none' || st.visibility === 'hidden')
+            continue;
+        const r = e.getBoundingClientRect();
+        if (r.width > 0 && r.height > 0)
+            return true;
+    }
+    return false;
+}
+/**
+ * Raw-DOM Continue click with the full pointer/mouse sequence (fallback for a
+ * build without a proper role, or a click intercepted by an overlay).
+ * Returns true when a matching visible button was clicked.
+ */
+export function clickContinueInDom() {
+    const labelOf = (b) => ((b.textContent || '') + ' ' + (b.getAttribute('aria-label') || ''))
+        .replace(/\s+/g, ' ')
+        .trim();
+    const isExact = (t) => /^(?:continue|продолжить|продолжение)(?:\s+(?:think(?:ing)?|reason(?:ing)?|размышлени[ея]|генераци[юя]|ответ))?\s*[.!…]?$/i.test(t);
+    const cands = Array.from(document.querySelectorAll('div[role="button"], button'));
+    for (const e of cands) {
+        const t = labelOf(e);
+        if (!isExact(t))
+            continue;
+        const st = getComputedStyle(e);
+        if (st.display === 'none' || st.visibility === 'hidden')
+            continue;
+        const rect = e.getBoundingClientRect();
+        if (rect.width === 0 || rect.height === 0)
+            continue;
+        const cx = rect.left + rect.width / 2;
+        const cy = rect.top + rect.height / 2;
+        const opts = {
+            bubbles: true,
+            cancelable: true,
+            composed: true,
+            clientX: cx,
+            clientY: cy,
+            button: 0,
+        };
+        try {
+            e.dispatchEvent(new PointerEvent('pointerdown', opts));
+            e.dispatchEvent(new MouseEvent('mousedown', opts));
+            e.dispatchEvent(new PointerEvent('pointerup', opts));
+            e.dispatchEvent(new MouseEvent('mouseup', opts));
+        }
+        catch { }
+        e.click();
+        return true;
+    }
+    return false;
+}
+/**
+ * Insert text into a contenteditable/input element by dispatching a synthetic
+ * paste event (the way a real paste lands, which React handlers honor). Runs
+ * bound to the element, so it receives `el` + the text value.
+ */
+export function pasteTextIntoElement(el, value) {
+    el.focus();
+    const dt = new DataTransfer();
+    dt.setData('text/plain', value);
+    const ev = new ClipboardEvent('paste', {
+        clipboardData: dt,
+        bubbles: true,
+        cancelable: true,
+    });
+    el.dispatchEvent(ev);
+    return true;
+}
+/**
+ * Read the current text of an input/textarea (its `value`) or a
+ * contenteditable element (its innerText/textContent). Runs bound to the
+ * element so it can distinguish the two by tagName.
+ */
+export function readElementText(el) {
+    const tag = el.tagName.toLowerCase();
+    if (tag === 'textarea' || tag === 'input') {
+        return el.value;
+    }
+    return el.innerText || el.textContent || '';
+}
+/**
+ * Lowercased tagName of an element. Runs bound to the element (Playwright's
+ * Locator.evaluate), used to tell a native input/textarea from a
+ * contenteditable box.
+ */
+export function elementTagNameInDom(el) {
+    return el.tagName.toLowerCase();
+}
+/**
+ * Is the send control actually enabled? DeepSeek's send control is a
+ * div[role=button]; Playwright's isEnabled() does NOT honor aria-disabled on a
+ * div, and a click on a disabled button is silently ignored (during an upload
+ * the message stays in the box). Read the attribute and a disabled class
+ * directly. Runs bound to the element.
+ */
+export function isElementEnabledInDom(el) {
+    if (el.getAttribute('aria-disabled') === 'true')
+        return false;
+    const cls = (el.className || '').toString();
+    if (/disabled|is-disabled/.test(cls))
+        return false;
+    return true;
+}
+/**
+ * The current text of the input box, trimmed — used to verify the message was
+ * actually SENT (DeepSeek clears the box on accept; if the text is still there
+ * the click/Enter was ignored). Runs bound to the element.
+ */
+export function readInputTrimmedTextInDom(el) {
+    return (el.value || el.innerText || el.textContent || '').trim();
+}
+/**
+ * The real User-Agent the engine reports. Read after launch so a headless run
+ * can strip the "Headless" marker (DeepSeek's CDN 403s that UA).
+ */
+export function readUserAgentInDom() {
+    return navigator.userAgent;
+}
+/**
+ * Find the index of the text/email/tel input that immediately precedes the
+ * password field, so the login form can be filled when no explicit
+ * LOGIN_SELECTORS matched. Returns -1 when not found.
+ */
+export function findLoginInputIndexInDom(pwdSel) {
+    const p = document.querySelector(pwdSel);
+    if (!p)
+        return -1;
+    const inputs = Array.from(document.querySelectorAll('input'));
+    const pi = inputs.indexOf(p);
+    for (let i = pi - 1; i >= 0; i--) {
+        const t = (inputs[i].type || 'text').toLowerCase();
+        if (t === 'text' || t === 'email' || t === 'tel')
+            return i;
+    }
+    return -1;
+}
+/**
+ * Submit the login form from inside the page: click the button whose label
+ * matches the login regex, else the primary-looking button in the password
+ * field's form. Returns true when a button was clicked. The in-page click is
+ * a fallback for a React form whose submit control the selectors missed.
+ */
+export function submitLoginFormInDom(opts) {
+    const loginRe = new RegExp(opts.submitRe, 'i');
+    const p = document.querySelector(opts.pwdSel);
+    if (!p)
+        return false;
+    const form = p.closest('form');
+    const scope = form || document;
+    const btns = Array.from(scope.querySelectorAll('button[type="submit"], button, div[role="button"]'));
+    for (const b of btns) {
+        const txt = (b.textContent || '').trim().toLowerCase();
+        const aria = (b.getAttribute('aria-label') || '').toLowerCase();
+        if (loginRe.test(txt + ' ' + aria)) {
+            b.click();
+            return true;
+        }
+    }
+    // Fallback: the primary-looking button in the scope.
+    const primary = btns.find((b) => {
+        const cls = (b.className || '').toString();
+        return /primary|submit|ds-button--primary/i.test(cls);
+    });
+    if (primary) {
+        primary.click();
+        return true;
+    }
+    return false;
+}
+/**
+ * Prefix/restore the tab title so the operator, looking at the browser
+ * window, can tell that the agent is generating. The ORIGINAL title is saved
+ * ONCE on `window` and restored when generation ends, so DeepSeek's own chat
+ * title is never lost.
+ */
+export function setBusyTitleInDom(on) {
+    const w = window;
+    if (on) {
+        if (typeof w.__zamesTitle !== 'string') {
+            w.__zamesTitle = document.title.replace(/^⏳\s*/, '');
+        }
+        document.title = '⏳ ' + w.__zamesTitle;
+    }
+    else if (typeof w.__zamesTitle === 'string') {
+        document.title = w.__zamesTitle;
+        w.__zamesTitle = undefined;
+    }
+}
+/**
+ * Count how many elements each candidate selector matches, for /debug-dom.
+ * Runs in-page (see the module header) so it takes the selector lists as an
+ * argument instead of referencing deepseek-ui.ts.
+ */
+export function dumpDomCountsInDom(sels) {
+    const result = { answers: {}, stops: {}, inputs: {} };
+    for (const s of sels.answers) {
+        result.answers[s] = document.querySelectorAll(s).length;
+    }
+    for (const s of sels.stops) {
+        result.stops[s] = document.querySelectorAll(s).length;
+    }
+    for (const s of sels.inputs) {
+        result.inputs[s] = document.querySelectorAll(s).length;
+    }
+    return result;
+}