zames_pro 2.16.0 → 2.18.0

package/dist/browser.js

@@ -5,8 +5,134 @@ import os from 'os';
 import fs from 'fs/promises';
 import { execSync } from 'child_process';
 import { theme } from './theme.js';
+import { translate, DEFAULT_LOCALE } from './i18n.js';
+// 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);
+    });
+}
 const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile');
 const CHAT_URL = 'https://chat.deepseek.com/';
+// 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).
+const AUTH_MARKER_FILE = path.join(os.homedir(), '.zames', 'auth.json');
+// DeepSeek sign-in form. The login page is served on the same origin and
+// swaps in a password field; the exact classes change, so we match loosely on
+// input types and the known placeholder/autocomplete attributes.
+const PASSWORD_SELECTORS = [
+    'input[type="password"]',
+    'input[autocomplete="current-password"]',
+    'input[autocomplete="new-password"]',
+];
+const LOGIN_SELECTORS = [
+    'input[type="email"]',
+    'input[type="tel"]',
+    'input[name="email"]',
+    'input[name="phone"]',
+    'input[name="username"]',
+    'input[placeholder*="email" i]',
+    'input[placeholder*="phone" i]',
+    'input[placeholder*="телефон" i]',
+    'input[placeholder*="почт" i]',
+    'input[autocomplete="username"]',
+    'input[autocomplete="email"]',
+];
+const LOGIN_SUBMIT_SELECTORS = [
+    // DeepSeek's real button: a div[role=button] with these classes and a
+    // <span class="ds-button__content">Log in</span> inside.
+    'div[role="button"].ds-button--primary.ds-button--filled',
+    'div[role="button"].ds-button--primary',
+    'button[type="submit"]',
+    'button:has-text("Log in")',
+    'button:has-text("Sign in")',
+    'button:has-text("Войти")',
+    'div[role="button"]:has-text("Log in")',
+    'div[role="button"]:has-text("Sign in")',
+    'div[role="button"]:has-text("Войти")',
+];
 const INPUT_SELECTORS = [
     'textarea',
     'div[contenteditable="true"]',
@@ -130,6 +256,16 @@ export class DeepSeekBrowser {
     // is never read/shown). webSearch: the "Smart search" toggle.
     deepThinking;
     webSearch;
+    // Credentials for automatic sign-in. The password is stored in the config
+    // file (~/.zames/config.json) and is used only when DeepSeek has logged the
+    // session out. `saveSession` keeps the profile (cookies) so a fresh launch
+    // reuses the session instead of asking the operator every time.
+    auth;
+    // Interface language for the login prompts printed by the browser itself.
+    locale;
+    // Called after a successful interactive login so index.ts can persist the
+    // credentials into the user config (the browser does not write config).
+    onAuthSave;
     _lastSentAt;
     _abort;
     // The user pressed Esc/Ctrl+C — a "stop" for the WHOLE current batch of
@@ -141,6 +277,13 @@ export class DeepSeekBrowser {
     _netCapture;
     _netCaptureAt;
     _netChatId;
+    // Authorization / PoW headers sniffed from DeepSeek's own API requests, so
+    // fetchChatMessages can replay them (a bare fetch does not get them).
+    _apiAuth;
+    _apiPow;
+    // Last error from fetchChatMessages ('' on success). Surfaced under --debug
+    // so a missing restored history can be diagnosed.
+    _lastHistoryError;
     _netSniff;
     _netSniffLimit;
     _netHookInstalled;
@@ -149,7 +292,15 @@ export class DeepSeekBrowser {
     // a generation really begins, not during the pre-send phase (chat open,
     // throttle wait), which used to show a spinner with no work in flight.
     onSendStart;
-    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, deepThinking = false, webSearch = true, } = {}) {
+    // Fired when the agent starts waiting out the send-interval pause, with the
+    // remaining seconds. Lets the UI animate the pause status instead of
+    // printing a static line (the dots used to be frozen during the pause).
+    onSendPause;
+    // User-Agent sent by the browser. In headless mode the "Headless" marker
+    // must be stripped (DeepSeek's CDN answers 403 to it); computed in the
+    // constructor, overridable by an explicit UA in the options/config.
+    userAgent;
+    constructor({ headless = false, debug = false, channel = 'chrome', answerTimeoutMs = 180000, askRetries = 3, stabilityChecks = 2, stabilityDelayMs = 400, minSendIntervalMs = 15000, rateLimitWaitMs = 300000, maxRateLimitRetries = 6, maxServerBusyRetries = 5, serverBusyWaitMs = 3000, deepThinking = false, webSearch = true, auth, locale, onAuthSave, userAgent, } = {}) {
         this.headless = headless;
         this.debug = debug;
         this.channel = channel;
@@ -164,16 +315,36 @@ export class DeepSeekBrowser {
         this.serverBusyWaitMs = serverBusyWaitMs;
         this.deepThinking = deepThinking;
         this.webSearch = webSearch;
+        this.auth = {
+            username: (auth?.username || '').trim(),
+            password: auth?.password || '',
+            saveSession: auth?.saveSession !== false,
+        };
+        this.locale = locale || DEFAULT_LOCALE;
+        this.onAuthSave = onAuthSave || null;
         this._lastSentAt = 0;
         this._abort = false;
         this._stopped = false;
         this._netCapture = '';
         this._netCaptureAt = 0;
         this._netChatId = null;
+        this._apiAuth = '';
+        this._apiPow = '';
+        this._lastHistoryError = '';
         this._netSniff = [];
         this._netSniffLimit = 5;
         this._netHookInstalled = false;
         this.onSendStart = null;
+        this.onSendPause = null;
+        // An explicit UA (config/options) is respected as-is. Otherwise it stays
+        // empty here and is derived from the real engine UA after launch — see
+        // _fixHeadlessUserAgent (a headless "HeadlessChrome/..." UA gets 403 from
+        // DeepSeek's CDN).
+        this.userAgent = userAgent ? sanitizeHeadlessUA(userAgent) : '';
+    }
+    /** Translation bound to this browser's locale. */
+    _t(key, params) {
+        return translate(this.locale)(key, params);
     }
     async launch() {
         await killStaleChrome();
@@ -183,6 +354,35 @@ export class DeepSeekBrowser {
             await cleanSingletonFiles();
         }
         await this._launchOnce();
+        await this._fixHeadlessUserAgent();
+    }
+    /**
+     * A headless Chromium advertises "HeadlessChrome/<v>" in its User-Agent, and
+     * DeepSeek's CDN (CloudFront/WAF) answers that UA with a plain "403 ERROR"
+     * page before the app is served — so sign-in worked with a visible window and
+     * silently failed headless. Read the UA the engine really reports and, when
+     * it carries the "Headless" marker, relaunch once with a sanitized
+     * `--user-agent` (the marker removed, the real version kept). A UA passed
+     * explicitly in the options/config is never touched.
+     */
+    async _fixHeadlessUserAgent() {
+        if (!this.headless)
+            return;
+        try {
+            const ua = await this.page.evaluate(() => navigator.userAgent);
+            const fixed = sanitizeHeadlessUA(ua);
+            if (fixed === ua)
+                return;
+            this.userAgent = fixed;
+            if (this.debug)
+                console.error('profile: headless UA → перезапуск с обычным Chrome UA');
+            await this.context.close().catch(() => { });
+            await this._launchOnce();
+        }
+        catch (e) {
+            if (this.debug)
+                console.error('profile: UA-фикс не удался:', e.message);
+        }
     }
     async _launchOnce() {
         const options = {
@@ -195,6 +395,8 @@ export class DeepSeekBrowser {
         };
         if (this.channel)
             options.channel = this.channel;
+        if (this.userAgent)
+            options.userAgent = this.userAgent;
         try {
             this.context = await chromium.launchPersistentContext(USER_DATA_DIR, options);
         }
@@ -232,6 +434,23 @@ export class DeepSeekBrowser {
         pg.on('response', (resp) => {
             void this._onResponse(resp).catch(() => { });
         });
+        // DeepSeek's own API calls carry an Authorization header (the app reads a
+        // token from its storage and sets it explicitly). A bare fetch from our
+        // code does NOT get it, so history_messages would answer 401/empty.
+        // Sniff the header off the real requests and replay it later.
+        pg.on('request', (req) => {
+            try {
+                const url = req.url();
+                if (!/deepseek\.com\/api\//i.test(url))
+                    return;
+                const h = req.headers();
+                if (h['authorization'])
+                    this._apiAuth = h['authorization'];
+                if (h['x-ds-pow-response'])
+                    this._apiPow = h['x-ds-pow-response'];
+            }
+            catch { }
+        });
     }
     async _onResponse(resp) {
         try {
@@ -273,11 +492,47 @@ export class DeepSeekBrowser {
         await this.launch();
     }
     async waitForLogin() {
-        const loggedIn = await this.isLoggedIn();
-        if (loggedIn)
+        // 1) Already signed in (session cookie in the persistent profile)?
+        if (await this.isLoggedIn()) {
+            if (this.debug)
+                console.error('auth: сессия уже активна');
             return;
-        console.log('\n🔐 Залогиньтесь в DeepSeek в открытом браузере.');
-        console.log('   После входа нажмите Enter в терминале...\n');
+        }
+        // 2) Try to sign in automatically with the saved credentials. The
+        //    password lives in the config (~/.zames/config.json) and is only used
+        //    when the session is logged out — i.e. exactly the "re-login without
+        //    asking" case. If the login form is absent (e.g. DeepSeek uses a
+        //    captcha / another provider), this fails and we fall through.
+        if (this.auth.username && this.auth.password) {
+            console.log(theme.system(this._t('auth.auto_login')));
+            const ok = await this._autoLogin().catch((e) => {
+                console.log(theme.warn(this._t('auth.auto_login_failed', { v: e.message })));
+                return false;
+            });
+            if (ok) {
+                console.log(theme.assistant(this._t('auth.auto_login_ok')));
+                return;
+            }
+        }
+        // 3) Ask the operator for credentials in the terminal, try them, and
+        //    only then fall back to the manual hint. Interactive only: in a
+        //    pipe/redirect (or headless without credentials) we print a hint.
+        const asked = await this._promptAndLogin().catch((e) => {
+            if (this.debug)
+                console.error('auth: prompt error:', e.message);
+            return false;
+        });
+        if (asked)
+            return;
+        // 4) Last resort: manual sign-in in the browser window.
+        console.log('\n' + theme.warn(this._t('auth.need_login')));
+        if (this.headless) {
+            console.log('   ' + this._t('auth.manual_hint_headless'));
+        }
+        else {
+            console.log('   ' + this._t('auth.manual_hint'));
+        }
+        console.log('\n');
         const readline = await import('readline');
         const rl = readline.createInterface({
             input: process.stdin,
@@ -289,20 +544,286 @@ export class DeepSeekBrowser {
                 resolve();
             });
         });
+        if (await this.isLoggedIn()) {
+            await this._persistSessionIfNeeded();
+            console.log(theme.assistant(this._t('auth.auto_login_ok')));
+        }
     }
-    async isLoggedIn() {
-        for (const sel of INPUT_SELECTORS) {
-            try {
-                await this.page.locator(sel).first().waitFor({
-                    state: 'visible',
-                    timeout: 3000,
-                });
+    /**
+     * Try to sign in with this.auth. Returns true when the login form was
+     * filled and the session became active. Never throws for a missing form —
+     * the caller decides whether to fall back.
+     */
+    async _autoLogin() {
+        const filled = await this._fillLoginForm(this.auth.username, this.auth.password);
+        if (!filled)
+            return false;
+        const ok = await this._waitLoggedIn(20_000);
+        if (ok)
+            await this._persistSessionIfNeeded();
+        return ok;
+    }
+    /**
+     * Ask the operator for login/password in the terminal (only in a TTY) and
+     * try them. An empty password falls back to the saved one. Returns true
+     * when the sign-in succeeded.
+     */
+    async _promptAndLogin() {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            return false;
+        const hasSaved = !!(this.auth.username && this.auth.password);
+        // Prompt only when we have a login field to fill.
+        if (!(await this._loginFormVisible())) {
+            if (this.debug)
+                console.error('auth: форма входа не найдена');
+            return false;
+        }
+        console.log('\n' + theme.warn(this._t('auth.need_login')));
+        // Username via a normal readline question (echoed).
+        let user = this.auth.username;
+        if (!user) {
+            const readline = await import('readline');
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+                terminal: true,
+            });
+            user = (await new Promise((resolve) => rl.question(this._t('auth.prompt_login'), (a) => resolve(a)))).trim();
+            rl.close();
+        }
+        // Password via raw keystroke reading, echoed as `*` (readline would echo
+        // it in clear or swallow the prompt — see askPassword).
+        const passPromptKey = hasSaved
+            ? 'auth.prompt_password_saved'
+            : 'auth.prompt_password';
+        const pass = await askPassword(this._t(passPromptKey));
+        const password = pass || this.auth.password;
+        if (!user || !password)
+            return false;
+        console.log(theme.system(this._t('auth.auto_login')));
+        const filled = await this._fillLoginForm(user, password);
+        if (!filled) {
+            console.log(theme.warn(this._t('auth.form_not_found')));
+            return false;
+        }
+        const ok = await this._waitLoggedIn(20_000);
+        if (ok) {
+            // Remember the credentials so the next launch can re-login silently.
+            this.auth.username = user;
+            this.auth.password = password;
+            await this._persistSessionIfNeeded();
+            this.onAuthSave?.(user, password);
+            console.log(theme.assistant(this._t('auth.auto_login_ok')));
+        }
+        else {
+            // Detect a credentials error shown by DeepSeek, otherwise report a
+            // generic failure with the page hint so the operator can react.
+            const reason = await this._readLoginError();
+            if (reason) {
+                console.log(theme.error(this._t('auth.login_rejected', { v: reason })));
+            }
+            else {
+                console.log(theme.warn(this._t('auth.auto_login_failed', { v: this._t('auth.no_reason') })));
+            }
+        }
+        return ok;
+    }
+    /**
+     * Read a visible login/credentials error message from the page, if any.
+     * Best-effort: returns '' when nothing recognizable is found.
+     */
+    async _readLoginError() {
+        try {
+            const txt = await this.page.evaluate(() => {
+                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();
+            });
+            return txt.slice(0, 200);
+        }
+        catch {
+            return '';
+        }
+    }
+    /** Is a login form (password field) present on the page? */
+    async _loginFormVisible() {
+        return await this.page
+            .locator(PASSWORD_SELECTORS.join(', '))
+            .first()
+            .isVisible({ timeout: 2000 })
+            .catch(() => false);
+    }
+    /**
+     * Fill the DeepSeek sign-in form with the given credentials and submit it.
+     * Returns false if the form (or the submit button) is not found.
+     */
+    async _fillLoginForm(username, password) {
+        const pwd = await this._findVisible(PASSWORD_SELECTORS, 4000);
+        if (!pwd)
+            return false;
+        // The email/phone field is the text input above the password field. Try
+        // the known selectors first, then fall back to the nearest text input.
+        let userInput = await this._findVisible(LOGIN_SELECTORS, 2000);
+        if (!userInput) {
+            // Find the index of the password input and use the closest preceding
+            // text/email/tel input as the login field.
+            const idx = await this.page.evaluate((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;
+            }, PASSWORD_SELECTORS[0]);
+            if (idx >= 0)
+                userInput = this.page.locator('input').nth(idx);
+        }
+        if (!userInput)
+            return false;
+        await this._setInputText(userInput, username);
+        await this._setInputText(pwd, password);
+        await this.page.waitForTimeout(150);
+        // Submit. DeepSeek's login form is a React form; the button text is
+        // localized and classes change, so we try, in order:
+        //   1. known submit selectors;
+        //   2. a submit/primary button inside the same <form> as the password;
+        //   3. pressing Enter in the password field;
+        //   4. clicking the password field's closest button sibling.
+        // After each attempt we give the login a short window and stop as soon as
+        // it succeeds, so a stray click does not fire on an already-logged-in page.
+        const tryLogin = async () => {
+            if (await this._waitLoggedIn(3000))
                 return true;
+            return false;
+        };
+        // Precise first attempt: DeepSeek's button is
+        // <div role="button" class="ds-button ds-button--primary ...">
+        //   <span class="ds-button__content">Log in</span></div>
+        // Click exactly the one whose visible label is a login word, so we never
+        // hit "Log in with Google" or another primary button by mistake.
+        const precise = this.page
+            .locator('div[role="button"].ds-button--primary, button')
+            .filter({ hasText: /^\s*(log ?in|sign ?in|войти)\s*$/i });
+        const pc = await precise.count().catch(() => 0);
+        if (pc > 0) {
+            try {
+                await precise.last().click({ timeout: 2000 });
+                if (await tryLogin())
+                    return true;
             }
             catch { }
         }
+        for (const sel of LOGIN_SUBMIT_SELECTORS) {
+            const btn = this.page.locator(sel).last();
+            try {
+                if ((await btn.count()) === 0)
+                    continue;
+                if (!(await btn.isVisible().catch(() => false)))
+                    continue;
+                await btn.click({ timeout: 2000 });
+                if (await tryLogin())
+                    return true;
+            }
+            catch { }
+        }
+        // Button inside the same form as the password field.
+        const formClicked = await this.page
+            .evaluate((pwdSel) => {
+            const p = document.querySelector(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 (/log ?in|sign ?in|войти|continue|продолж/.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;
+        }, PASSWORD_SELECTORS[0])
+            .catch(() => false);
+        if (formClicked && (await tryLogin()))
+            return true;
+        // Enter in the password field.
+        await pwd.press('Enter').catch(() => { });
+        return true;
+    }
+    /** Poll isLoggedIn until it succeeds or the deadline passes. */
+    async _waitLoggedIn(timeoutMs) {
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            if (await this.isLoggedIn().catch(() => false))
+                return true;
+            await this.page.waitForTimeout(500);
+        }
         return false;
     }
+    /**
+     * Persist the authenticated session. The persistent profile already keeps
+     * cookies on disk; `saveSession` (config) is kept as an explicit toggle for
+     * the operator. We additionally save a small marker so /doctor and the next
+     * launch can tell that a session exists.
+     */
+    async _persistSessionIfNeeded() {
+        if (!this.auth.saveSession)
+            return;
+        if (!(await this.isLoggedIn().catch(() => false)))
+            return;
+        try {
+            await fs.mkdir(path.join(os.homedir(), '.zames'), { recursive: true });
+            await fs.writeFile(AUTH_MARKER_FILE, JSON.stringify({ at: new Date().toISOString() }, null, 2), 'utf-8');
+        }
+        catch { }
+    }
+    async isLoggedIn() {
+        // Single combined query with a short timeout: the old loop waited up to
+        // 3s PER selector (9s total), and _waitLoggedIn calls this repeatedly,
+        // which made login feel like it "hangs".
+        try {
+            await this.page
+                .locator(INPUT_SELECTORS.join(', '))
+                .first()
+                .waitFor({ state: 'visible', timeout: 2000 });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     async newChat() {
         const newChatBtn = this.page
             .locator('button, a')
@@ -523,10 +1044,17 @@ export class DeepSeekBrowser {
                 if (e instanceof RateLimitError) {
                     rateLimitRetries++;
                     if (rateLimitRetries > this.maxRateLimitRetries) {
-                        console.error(theme.error(`✖ DeepSeek не принял сообщение после ${rateLimitRetries} пауз по ${Math.ceil(this.rateLimitWaitMs / 60000)} мин.`));
+                        console.error(theme.error(this._t('ds.rate_limit_give_up', {
+                            attempt: rateLimitRetries,
+                            min: Math.ceil(this.rateLimitWaitMs / 60000),
+                        })));
                         throw e;
                     }
-                    console.error(theme.warn(`⏳ DeepSeek: «слишком часто». Жду ${Math.ceil(this.rateLimitWaitMs / 60000)} мин (${rateLimitRetries}/${this.maxRateLimitRetries}) и повторю...`));
+                    console.error(theme.warn(this._t('ds.rate_limit_wait', {
+                        min: Math.ceil(this.rateLimitWaitMs / 60000),
+                        attempt: rateLimitRetries,
+                        max: this.maxRateLimitRetries,
+                    })));
                     // Interruptible: Esc/Ctrl+C must cancel this long wait too,
                     // otherwise "stop" stays frozen for up to 5 minutes.
                     const aborted = await this._sleepInterruptible(this.rateLimitWaitMs);
@@ -534,15 +1062,44 @@ export class DeepSeekBrowser {
                         return '(прервано пользователем)';
                     continue;
                 }
-                console.error(`\n⚠ ask() попытка ${attempt}/${this.askRetries} провалилась: ${e.message}`);
+                // Server busy / overloaded: clear in seconds, so we retry quickly
+                // (unlike the rate limit). Without this branch the error fell into the
+                // generic ask() retry and the operator saw a bare message with no
+                // explanation of what DeepSeek is doing.
+                if (e instanceof ServerBusyError) {
+                    serverBusyRetries++;
+                    if (serverBusyRetries > this.maxServerBusyRetries) {
+                        console.error(theme.error(this._t('ds.server_busy_give_up', {
+                            attempt: serverBusyRetries,
+                        })));
+                        throw e;
+                    }
+                    console.error(theme.warn(this._t('ds.server_busy_wait', {
+                        sec: Math.ceil(this.serverBusyWaitMs / 1000),
+                        attempt: serverBusyRetries,
+                        max: this.maxServerBusyRetries,
+                    })));
+                    const aborted = await this._sleepInterruptible(this.serverBusyWaitMs);
+                    if (aborted)
+                        return '(прервано пользователем)';
+                    continue;
+                }
+                console.error('\n' +
+                    theme.warn(this._t('ds.ask_retry', {
+                        attempt,
+                        max: this.askRetries,
+                        error: e.message,
+                    })));
                 if (/closed|crash|Target page|browser/i.test(e.message)) {
-                    console.error('⚠ перезапускаю браузер...');
+                    console.error(theme.warn(this._t('ds.ask_restart_browser')));
                     try {
                         await this.restart();
                         await this.waitForLogin();
                     }
                     catch (re) {
-                        console.error(`⚠ не удалось перезапустить: ${re.message}`);
+                        console.error(theme.warn(this._t('ds.ask_restart_failed', {
+                            error: re.message,
+                        })));
                     }
                 }
                 if (attempt < this.askRetries) {
@@ -550,7 +1107,10 @@ export class DeepSeekBrowser {
                 }
             }
         }
-        throw new Error(`ask() провалился после ${this.askRetries} попыток: ${lastErr?.message}`);
+        throw new Error(this._t('ds.ask_failed', {
+            max: this.askRetries,
+            error: lastErr?.message || '',
+        }));
     }
     async _setInputText(input, text) {
         const tag = await input.evaluate((el) => el.tagName.toLowerCase());
@@ -606,7 +1166,10 @@ export class DeepSeekBrowser {
                 return el.innerText || el.textContent || "";
             });
             if (norm(got2) !== norm(text)) {
-                throw new Error("Не удалось вставить текст в поле ввода DeepSeek целиком (вставлено " + norm(got2).length + " из " + norm(text).length + " символов). Сообщение не отправлено, чтобы не отправить обрезанный текст.");
+                throw new Error(this._t('ds.input_partial', {
+                    got: norm(got2).length,
+                    want: norm(text).length,
+                }));
             }
         }
     }
@@ -690,20 +1253,47 @@ export class DeepSeekBrowser {
         const gap = this.minSendIntervalMs - (Date.now() - this._lastSentAt);
         if (gap <= 0)
             return;
-        console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
-        await this._sleepInterruptible(gap);
+        // Report the pause to the UI as an ANIMATED status (with the remaining
+        // seconds) instead of the old static console line — the dots used to be
+        // frozen here, which looked like the spinner had hung. The seconds are
+        // refreshed once per second, so the status visibly counts down.
+        const report = (leftMs) => {
+            const secs = Math.max(0, Math.ceil(leftMs / 1000));
+            if (this.onSendPause) {
+                try {
+                    this.onSendPause(secs);
+                }
+                catch { }
+            }
+            else {
+                console.error(theme.warn(`⏳ send pause ${secs}s`));
+            }
+        };
+        report(gap);
+        await this._sleepInterruptible(gap, report);
     }
     // Sleep in small slices so Esc/Ctrl+C can cancel the wait promptly.
     // Returns true if the sleep was cut short by _abort.
-    async _sleepInterruptible(ms) {
+    //
+    // onTick (optional) is called about once per second with the remaining time,
+    // so the UI can show a live countdown during the pause.
+    async _sleepInterruptible(ms, onTick) {
         const step = 100;
         let left = ms;
+        let sinceTick = 0;
         while (left > 0) {
             if (this._abort)
                 return true;
             const chunk = Math.min(step, left);
             await this.page.waitForTimeout(chunk);
             left -= chunk;
+            if (onTick) {
+                sinceTick += chunk;
+                if (sinceTick >= 1000) {
+                    sinceTick = 0;
+                    onTick(left);
+                }
+            }
         }
         return this._abort;
     }
@@ -729,7 +1319,7 @@ export class DeepSeekBrowser {
             return '(прервано пользователем)';
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
         if (!input) {
-            throw new Error('Не найдено поле ввода. Запустите /debug-dom и поправьте INPUT_SELECTORS.');
+            throw new Error(this._t('ds.input_missing'));
         }
         const beforeText = await this._readLastAnswerTextClean().catch(() => '');
         this._askDebug('SEND agent=' + agent + ' len=' + prompt.length + ' beforeLen=' + beforeText.length + ' beforeHead=' + JSON.stringify(beforeText.slice(0, 60)));
@@ -890,8 +1480,7 @@ export class DeepSeekBrowser {
             }
         }
         if (!started) {
-            throw new Error('Ответ не начал генерироваться за 35с даже после повторной отправки. ' +
-                'Проверьте чат DeepSeek вручную.');
+            throw new Error(this._t('ds.send_no_start'));
         }
         // Wait until the answer stops changing. We check the "not generating"
         // condition via text growth, NOT via _isGenerating().
@@ -961,12 +1550,11 @@ export class DeepSeekBrowser {
             return this._netCapture;
         }
         this._askDebug('THROW no-new-answer lastLen=' + last.length + ' beforeLen=' + beforeText.length);
-        throw new Error('Новый ответ не получен (на странице остался прежний текст). ' +
-            'Возможно, сообщение не отправилось.');
+        throw new Error(this._t('ds.send_no_new_answer'));
     }
     async dumpDom(filePath) {
         if (!this.page)
-            throw new Error('браузер не запущен');
+            throw new Error(this._t('ds.not_launched'));
         const html = await this.page.content();
         await fs.writeFile(filePath, html, 'utf-8');
         const report = await this.page.evaluate((sels) => {
@@ -1060,9 +1648,220 @@ export class DeepSeekBrowser {
             return true;
         }
         catch (e) {
-            throw new Error(`Не удалось открыть чат ${id}: ${e.message}`);
+            throw new Error(this._t('ds.open_chat_failed', { id, error: e.message }));
+        }
+    }
+    // Fetch the WHOLE dialogue from DeepSeek's own history endpoint instead of
+    // scraping the DOM. The rendered page only shows a part of the history (the
+    // list is virtualized), while /api/v0/chat/history_messages returns every
+    // message of the chat as JSON. The request is made INSIDE the page, so the
+    // auth cookie and the CSRF/PoW handling are the browser's.
+    //
+    // Shape of data.biz_data.chat_messages[]: { role: 'USER'|'ASSISTANT',
+    // fragments: [{ type: 'REQUEST'|'RESPONSE'|'THINK'|'FILE', content }] }.
+    // We keep REQUEST (user) and RESPONSE (assistant); THINK (reasoning) is
+    // skipped and FILE fragments carry no text.
+    async fetchChatMessages(id) {
+        this._lastHistoryError = '';
+        if (!this.page || !id)
+            return [];
+        // The Authorization header is sniffed off DeepSeek's own API requests. On
+        // a freshly opened chat that request may not have fired yet — wait a bit
+        // (up to 3s) so the replay is authorized instead of answering 401/empty.
+        for (let i = 0; i < 15 && !this._apiAuth; i++) {
+            await this.page.waitForTimeout(200);
+        }
+        const auth = this._apiAuth;
+        const pow = this._apiPow;
+        const res = await this.page
+            .evaluate(async (opts) => {
+            try {
+                const url = 'https://chat.deepseek.com/api/v0/chat/history_messages?chat_session_id=' +
+                    encodeURIComponent(opts.chatId);
+                const headers = {
+                    accept: 'application/json',
+                };
+                if (opts.auth)
+                    headers['authorization'] = opts.auth;
+                if (opts.pow)
+                    headers['x-ds-pow-response'] = opts.pow;
+                const resp = await fetch(url, {
+                    credentials: 'include',
+                    headers,
+                });
+                if (!resp.ok)
+                    return { error: 'HTTP ' + resp.status, list: [] };
+                const json = await resp.json();
+                const messages = json && json.data && json.data.biz_data
+                    ? json.data.biz_data.chat_messages
+                    : null;
+                if (!Array.isArray(messages)) {
+                    return { error: 'no chat_messages in response', list: [] };
+                }
+                const NL = String.fromCharCode(10);
+                const out = [];
+                for (const m of messages) {
+                    const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
+                    const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+                    let text = '';
+                    for (const fr of (m && m.fragments) || []) {
+                        if (!fr || fr.type !== want)
+                            continue;
+                        if (typeof fr.content === 'string')
+                            text += fr.content;
+                    }
+                    text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+                    if (text)
+                        out.push({ role, text });
+                }
+                return { error: '', list: out };
+            }
+            catch (e) {
+                return { error: 'fetch failed: ' + e.message, list: [] };
+            }
+        }, { chatId: id, auth, pow })
+            .catch((e) => ({
+            error: 'evaluate failed: ' + e.message,
+            list: [],
+        }));
+        this._lastHistoryError = res?.error || '';
+        const list = (res?.list || []);
+        if (list.length || !res?.error)
+            return list;
+        // Fallback: Playwright's own request context (shares the browser cookies)
+        // when the in-page fetch was blocked (CSP, CORS, a page error).
+        this._lastHistoryError = res.error;
+        try {
+            const resp = await this.page.request.get('https://chat.deepseek.com/api/v0/chat/history_messages?chat_session_id=' +
+                encodeURIComponent(id), { headers: { accept: 'application/json' } });
+            if (!resp.ok())
+                return list;
+            const json = (await resp.json());
+            const messages = json?.data?.biz_data?.chat_messages;
+            if (!Array.isArray(messages))
+                return list;
+            const NL = String.fromCharCode(10);
+            const out = [];
+            for (const m of messages) {
+                const role = m && m.role === 'ASSISTANT' ? 'assistant' : 'user';
+                const want = role === 'assistant' ? 'RESPONSE' : 'REQUEST';
+                let text = '';
+                for (const fr of (m && m.fragments) || []) {
+                    if (!fr || fr.type !== want)
+                        continue;
+                    if (typeof fr.content === 'string')
+                        text += fr.content;
+                }
+                text = text.replace(new RegExp(NL + '{3,}', 'g'), NL + NL).trim();
+                if (text)
+                    out.push({ role, text });
+            }
+            this._lastHistoryError = '';
+            return out;
+        }
+        catch (e) {
+            this._lastHistoryError = 'request failed: ' + e.message;
+            return list;
         }
     }
+    // Read the WHOLE visible dialogue of the currently open chat, top to
+    // bottom. Used by /resume and /resume-id so the operator sees the restored
+    // context in the terminal instead of just "Chat opened.".
+    //
+    // Best-effort DOM scraping: DeepSeek renders every message as a markdown
+    // block (assistant) or a plain bubble (user). Role detection relies on the
+    // ds-assistant-message-* class; anything that is not an assistant block is
+    // treated as a user message. The model's reasoning (.ds-think-content) is
+    // skipped, exactly like in _readLastAnswerText.
+    async readChatMessages() {
+        if (!this.page)
+            return [];
+        const raw = await this.page
+            .evaluate(() => {
+            const inThink = (e) => {
+                let n = e;
+                while (n) {
+                    const cls = (n.className || '').toString();
+                    if (/ds-think-content|thinking-content/i.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();
+            };
+            // A message block is "assistant" when it contains an answer markdown
+            // wrapper (ds-markdown / ds-assistant-message), otherwise it is a
+            // user bubble. DeepSeek's class names drift between builds, so the
+            // detection is content-based, not class-prefix-based.
+            const looksAssistant = (e) => {
+                const cls = (e.className || '').toString();
+                if (/ds-assistant-message|assistant-message/i.test(cls))
+                    return true;
+                if (e.querySelector('[class*="ds-assistant-message"]'))
+                    return true;
+                // A user bubble has no rendered markdown; an answer does.
+                if (e.querySelector('[class*="ds-markdown"]'))
+                    return true;
+                return false;
+            };
+            // Message-level containers first (broad), then the answer wrappers.
+            const containerSels = [
+                '[data-message-id]',
+                '[class*="ds-message"]',
+                '[class*="chat-message"]',
+                '[class*="message-item"]',
+                '[class*="_message"]',
+            ];
+            let blocks = [];
+            for (const s of containerSels) {
+                const found = Array.from(document.querySelectorAll(s)).filter((e) => !inThink(e) && textOf(e).length > 0);
+                if (found.length) {
+                    blocks = found;
+                    break;
+                }
+            }
+            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;
+            }
+            // Last resort: assistant answers only (no user turns) — better than
+            // nothing when no message container matched.
+            const sels = [
+                'div.ds-assistant-message-main-content',
+                'div[class*="ds-assistant-message-main-content"]',
+                'div[class*="ds-markdown"]',
+            ];
+            for (const s of sels) {
+                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;
+        })
+            .catch(() => []);
+        return raw;
+    }
     async getCurrentChatId() {
         try {
             const url = this.page.url();