zames_pro 2.44.0 → 2.46.0

package/dist/browser.js

@@ -87,6 +87,65 @@ export function askPassword(question) {
 }
 const USER_DATA_DIR = path.join(os.homedir(), '.zames', 'profile');
 const CHAT_URL = 'https://chat.deepseek.com/';
+// 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;
+}
+function headlessEngineKey() {
+    try {
+        return chromium.executablePath();
+    }
+    catch {
+        return '';
+    }
+}
+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;
+    }
+}
+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
@@ -542,6 +601,14 @@ export class DeepSeekBrowser {
                 console.error('profile: удаляю Singleton-файлы');
             await cleanSingletonFiles();
         }
+        // Headless: if we already know the sanitized UA for THIS engine build, use
+        // it from the start — that skips the "launch, read UA, relaunch" dance
+        // (which otherwise doubled every headless start).
+        if (this.headless && !this.userAgent) {
+            const cached = await readCachedHeadlessUA(headlessEngineKey());
+            if (cached)
+                this.userAgent = cached;
+        }
         await this._launchOnce();
         await this._fixHeadlessUserAgent();
     }
@@ -563,6 +630,9 @@ export class DeepSeekBrowser {
             if (fixed === ua)
                 return;
             this.userAgent = fixed;
+            // Remember the good UA for this engine build so the NEXT headless start
+            // uses it immediately (no relaunch). Keyed by executable path.
+            void writeCachedHeadlessUA(headlessEngineKey(), fixed);
             if (this.debug)
                 console.error('profile: headless UA → перезапуск с обычным Chrome UA');
             await this.context.close().catch(() => { });
@@ -2124,28 +2194,70 @@ export class DeepSeekBrowser {
             finalPrompt = rewriteFailedAttachments(finalPrompt, failed);
         }
         await this._setInputText(input, finalPrompt);
-        // Send immediately: the input is already verified by _setInputText, and a
-        // clickable send button normally appears right away. The old code slept a
-        // fixed 50ms here, which only added latency (the button does not need it).
+        // Send: wait for the send button to become ENABLED first. After an
+        // attachment upload the button is DISABLED while the file is still
+        // uploading; a click on a disabled button silently does nothing, so the
+        // message stayed in the input and no generation started (the operator saw
+        // the text + the file in the box, but nothing was sent). We poll for an
+        // ENABLED button, then click; if none becomes enabled in time, fall back
+        // to Enter (which is also ignored while the send is disabled).
+        const sendDeadline = Date.now() + 8000;
         let sent = false;
-        for (const sel of SEND_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: 1500 });
-                sent = true;
-                break;
+        while (!sent && Date.now() < sendDeadline) {
+            for (const sel of SEND_SELECTORS) {
+                const btn = this.page.locator(sel).last();
+                try {
+                    if ((await btn.count()) === 0)
+                        continue;
+                    if (!(await btn.isVisible().catch(() => false)))
+                        continue;
+                    // DeepSeek's send control is a div[role=button]; Playwright's
+                    // isEnabled() does NOT honor aria-disabled on a div, so read the
+                    // attribute (and a disabled class) directly — during an upload the
+                    // button is aria-disabled=true and a click is silently ignored.
+                    const enabled = await btn
+                        .evaluate((el) => {
+                        if (el.getAttribute('aria-disabled') === 'true')
+                            return false;
+                        const cls = (el.className || '').toString();
+                        if (/disabled|is-disabled/.test(cls))
+                            return false;
+                        return true;
+                    })
+                        .catch(() => true);
+                    if (!enabled)
+                        continue;
+                    await btn.click({ timeout: 1500 });
+                    sent = true;
+                    break;
+                }
+                catch { }
             }
-            catch { }
+            if (!sent)
+                await this.page.waitForTimeout(150);
         }
         if (!sent) {
             await this.page.keyboard.press('Enter');
         }
         this._lastSentAt = Date.now();
-        this._askDebug('SENT at=' + this._lastSentAt);
+        this._askDebug('SENT at=' + this._lastSentAt + ' viaButton=' + sent);
+        // Verify the send REALLY went out: DeepSeek clears the input when the
+        // message is accepted. If the text is still there a moment later, the
+        // click/Enter was ignored (a disabled button during upload, a lost
+        // keystroke) — press Enter once more so the message is not silently stuck
+        // in the box (exactly the operator's "text + file in the box, no send").
+        try {
+            await this.page.waitForTimeout(300);
+            const stillThere = await input
+                .evaluate((el) => (el.value || el.innerText || el.textContent || '').trim())
+                .catch(() => '');
+            if (stillThere) {
+                this._askDebug('SEND not cleared, pressing Enter again');
+                await this.page.keyboard.press('Enter');
+                this._lastSentAt = Date.now();
+            }
+        }
+        catch { }
         // Wait for the start: either Stop appeared, or the answer text changed,
         // or the page grew (a new answer node / longer last answer). In parallel we
         // catch the rate-limit toast (only toasts, not the whole body).

package/dist/commands.js

@@ -199,6 +199,11 @@ export function renderDoctor(d) {
     if (typeof d.sshRemote === 'boolean') {
         row(true, 'session', d.sshRemote ? 'SSH remote' : 'local terminal');
     }
+    if (d.headless) {
+        row(!!d.headlessUaCached, 'headless', d.headlessUaCached
+            ? 'UA cached (no relaunch)'
+            : 'no cached UA yet (first start relaunches once)');
+    }
     return 'Doctor:' + NL + rows.join(NL);
 }
 export function renderPermissions(p) {

package/dist/index.js

@@ -4,7 +4,7 @@ import fs from 'fs/promises';
 import { existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { theme } from './theme.js';
-import { DeepSeekBrowser } from './browser.js';
+import { DeepSeekBrowser, headlessUACacheReady } from './browser.js';
 import { createTools } from './tools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
@@ -2830,6 +2830,8 @@ async function main() {
                     : undefined,
                 minSendIntervalMs: config.browser.minSendIntervalMs,
                 sshRemote: !!(process.env.SSH_CONNECTION || process.env.SSH_TTY),
+                headless: !!headless,
+                headlessUaCached: await headlessUACacheReady().catch(() => false),
             })));
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.44.0",
+  "version": "2.46.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {