zames_pro 2.70.0 → 2.72.0

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-pure.js

@@ -0,0 +1,238 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs/promises';
+import { chromium } from 'playwright';
+import { GENERATION_ERR_RE, INCOMPLETE_STATUS_RE, RATE_LIMIT_RE, SERVER_BUSY_RE, } from './deepseek-ui.js';
+// Pure, state-free helpers extracted from browser.ts (BACKLOG C3). Nothing
+// here touches the DeepSeekBrowser instance state, so this module is safe to
+// import anywhere (including hot-reloaded modules) without pulling in the
+// live Playwright context. browser.ts re-exports the public names, so the
+// existing API is unchanged.
+// Muted terminal input for passwords. We do NOT use readline here: readline
+// echoes the typed text through its own internal _writeToOutput, which cannot
+// be reliably overridden from outside (a real bug: the login prompt swallowed
+// the password step). Instead we read raw keystrokes from stdin and echo one
+// `*` per typed character. In a non-TTY (pipe/redirect) we fall back to a
+// plain line read.
+export function askPassword(question) {
+    return new Promise((resolve) => {
+        process.stdout.write(question);
+        // Non-interactive: read a single line from stdin as-is.
+        if (!process.stdin.isTTY) {
+            void import('readline').then(({ createInterface }) => {
+                const rl = createInterface({
+                    input: process.stdin,
+                    output: process.stdout,
+                });
+                rl.question('', (answer) => {
+                    rl.close();
+                    resolve(answer);
+                });
+            });
+            return;
+        }
+        const stdin = process.stdin;
+        const wasRaw = stdin.isRaw;
+        stdin.setRawMode(true);
+        stdin.resume();
+        let value = '';
+        const onData = (buf) => {
+            const s = buf.toString('utf8');
+            for (const ch of s) {
+                const code = ch.charCodeAt(0);
+                // Enter / Ctrl+J -> done.
+                if (ch === '\r' || ch === '\n') {
+                    done();
+                    return;
+                }
+                // Ctrl+C -> abort the whole process (same as elsewhere in the CLI).
+                if (code === 3) {
+                    cleanup();
+                    process.stdout.write('\n');
+                    process.exit(130);
+                }
+                // Ctrl+D -> finish with whatever we have.
+                if (code === 4) {
+                    done();
+                    return;
+                }
+                // Backspace (0x7f or 0x08): remove the last char and one star.
+                if (code === 127 || code === 8) {
+                    if (value.length > 0) {
+                        value = value.slice(0, -1);
+                        process.stdout.write('\b \b');
+                    }
+                    continue;
+                }
+                // Ignore other control characters (arrows, etc.).
+                if (code < 32)
+                    continue;
+                value += ch;
+                process.stdout.write('*');
+            }
+        };
+        const cleanup = () => {
+            stdin.removeListener('data', onData);
+            try {
+                stdin.setRawMode(wasRaw || false);
+            }
+            catch { }
+            stdin.pause();
+        };
+        const done = () => {
+            cleanup();
+            process.stdout.write('\n');
+            resolve(value);
+        };
+        stdin.on('data', onData);
+    });
+}
+export const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile');
+// Cache of the sanitized (non-Headless) User-Agent, keyed by the browser
+// engine path. On the FIRST headless run we detect the real UA, strip the
+// "Headless" marker and store it here; later runs pass it straight to
+// _launchOnce, so the browser starts with a good UA and the "launch → read UA →
+// relaunch" dance happens only once (it otherwise doubled every headless
+// start). Keying by the executable path means a Playwright update (new engine
+// path) invalidates the cache and we re-derive the UA once for the new build.
+const HEADLESS_UA_CACHE = path.join(os.homedir(), '.zames', 'headless-ua.json');
+// Pure: pick a reusable UA from the cache file's text for the given engine, or
+// null. Exported so the policy is unit-tested without touching ~/.zames.
+export function parseHeadlessUACache(raw, engine) {
+    try {
+        const j = JSON.parse(raw);
+        if (j &&
+            j.engine === engine &&
+            typeof j.ua === 'string' &&
+            j.ua &&
+            !/Headless/i.test(j.ua)) {
+            return j.ua;
+        }
+    }
+    catch { }
+    return null;
+}
+export function headlessEngineKey() {
+    try {
+        return chromium.executablePath();
+    }
+    catch {
+        return '';
+    }
+}
+export async function readCachedHeadlessUA(engine) {
+    if (!engine)
+        return null;
+    try {
+        const raw = await fs.readFile(HEADLESS_UA_CACHE, 'utf-8');
+        return parseHeadlessUACache(raw, engine);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCachedHeadlessUA(engine, ua) {
+    if (!engine || !ua)
+        return;
+    try {
+        await fs.mkdir(path.dirname(HEADLESS_UA_CACHE), { recursive: true });
+        await fs.writeFile(HEADLESS_UA_CACHE, JSON.stringify({ engine, ua }, null, 2), 'utf-8');
+    }
+    catch { }
+}
+// For /doctor: is a sanitized UA cached for the CURRENT engine build? A missing
+// cache only means the next headless start relaunches once (not an error), so
+// this is informational. Best-effort.
+export async function headlessUACacheReady() {
+    const ua = await readCachedHeadlessUA(headlessEngineKey());
+    return !!ua;
+}
+// A headless Chrome advertises "HeadlessChrome/..." in its User-Agent, and
+// DeepSeek's CDN (CloudFront/WAF) rejects that UA with a plain "403 ERROR"
+// page before the app is even served — so a headless login looked broken while
+// a headed one worked (headed Chrome sends "Chrome/..."). We keep the real
+// engine version and only drop the "Headless" marker. When the operator
+// explicitly set a UA in the config, that one wins (see _launchOnce).
+export function sanitizeHeadlessUA(ua) {
+    return String(ua || '').replace(/HeadlessChrome/g, 'Chrome');
+}
+// Written after a successful sign-in so the next launch knows a session was
+// stored in the persistent profile (used by /doctor and diagnostics).
+export const AUTH_MARKER_FILE = path.join(os.homedir(), '.zames', 'auth.json');
+export function isGenerationIncompleteText(text) {
+    const t = String(text || '');
+    return GENERATION_ERR_RE.test(t) || INCOMPLETE_STATUS_RE.test(t);
+}
+export function isRateLimitText(text) {
+    return RATE_LIMIT_RE.test(String(text || ''));
+}
+export function isServerBusyText(text) {
+    const t = String(text || '');
+    // Rate limit takes priority (it needs the long wait).
+    if (RATE_LIMIT_RE.test(t))
+        return false;
+    return SERVER_BUSY_RE.test(t);
+}
+// Normalize text for comparison: collapse whitespace so that tiny DOM
+// differences (nbsp, trailing spaces) don't count as "a new answer".
+export function normText(s) {
+    return String(s || '')
+        .replace(/\u00a0/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+// The "too frequent" error: distinct from others so ask() waits a long time
+// (DeepSeek limits reset over minutes) and retries the send itself.
+export class RateLimitError extends Error {
+    constructor(detail) {
+        super('Messages too frequent. Try again later. ' + detail);
+        this.name = 'RateLimitError';
+    }
+}
+// DeepSeek transient server error (Server busy).
+export class ServerBusyError extends Error {
+    constructor(detail) {
+        super('Server busy. Try again later. ' + detail);
+        this.name = 'ServerBusyError';
+    }
+}
+// The generation was truncated by the server (`generation_err` / INCOMPLETE).
+// Distinct from ServerBusyError: the DeepSeek backend answered, but the turn
+// did not finish, and the UI offers a "Continue" button. The agent retries the
+// same send (a new message into the chat) instead of waiting for an answer
+// that will never arrive. This is what the operator hit with the reasoning
+// (deep thinking) mode on: the long THINK phase makes the truncation far more
+// likely, so with thinking off everything worked and with it on the turn kept
+// stopping and showing "Continue".
+export class GenerationIncompleteError extends Error {
+    constructor(detail) {
+        super('Generation incomplete (server truncated the answer). ' + detail);
+        this.name = 'GenerationIncompleteError';
+    }
+}
+// ---------- profile cleanup ----------
+export async function cleanSingletonFiles() {
+    const names = ['SingletonLock', 'SingletonCookie', 'SingletonSocket'];
+    for (const name of names) {
+        const p = path.join(USER_DATA_DIR, name);
+        try {
+            await fs.unlink(p);
+        }
+        catch { }
+    }
+}
+export async function profileLooksLocked() {
+    try {
+        await fs.access(path.join(USER_DATA_DIR, 'SingletonLock'));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function nukeProfile() {
+    try {
+        await fs.rm(USER_DATA_DIR, { recursive: true, force: true });
+    }
+    catch { }
+}