zames_pro 2.45.0 → 2.47.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(() => { });

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.45.0",
+  "version": "2.47.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {