zames_pro 2.66.1 → 2.67.1

package/dist/web.js

@@ -3,8 +3,9 @@ import { lookup } from 'node:dns/promises';
 import { isIP } from 'node:net';
 const DEFAULT_TIMEOUT = 20_000;
 const MAX_TEXT = 12_000;
-// Removes scripts, styles, and turns HTML into readable text.
-function htmlToText(html) {
+// Removes scripts, styles, and turns HTML into readable text. Exported for
+// tests — the entity/whitespace/collapse branches are pure and worth pinning.
+export function htmlToText(html) {
     // Remove blocks we don't need
     let s = html
         .replace(/<script[\s\S]*?<\/script>/gi, '')
@@ -88,7 +89,7 @@ export function isPrivateHostname(host) {
         return true;
     return false;
 }
-async function assertPublicUrl(rawUrl) {
+export async function assertPublicUrl(rawUrl) {
     const u = new URL(rawUrl);
     if (u.protocol !== 'http:' && u.protocol !== 'https:') {
         throw new Error(`unsupported protocol: ${u.protocol}`);
@@ -164,23 +165,46 @@ async function httpFetchWithRetry(url, opts = {}, retries = 2) {
     }
     throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
 }
-// fetch with redirects and a timeout
-async function httpFetch(url, { timeout = DEFAULT_TIMEOUT, headers = {}, } = {}) {
+// fetch with redirects, RE-VALIDATING every hop against the SSRF guard.
+// redirect:'follow' would let a public URL bounce to 169.254.169.254 / 127.0.0.1
+// after assertPublicUrl already approved the original — a classic SSRF bypass.
+// So redirects are followed manually and each Location is checked first.
+const MAX_REDIRECTS = 5;
+export async function httpFetch(url, { timeout = DEFAULT_TIMEOUT, headers = {}, } = {}) {
     const ctrl = new AbortController();
     const t = setTimeout(() => ctrl.abort(), timeout);
     try {
-        const res = await fetch(url, {
-            signal: ctrl.signal,
-            redirect: 'follow',
-            headers: {
-                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) ds-agent/1.0',
-                'Accept-Language': 'en-US,en;q=0.9,ru;q=0.8',
-                ...headers,
-            },
-        });
-        const ct = res.headers.get('content-type') || '';
-        const body = await res.text();
-        return { status: res.status, url: res.url, contentType: ct, body };
+        let current = url;
+        for (let hop = 0; hop <= MAX_REDIRECTS; hop++) {
+            const res = await fetch(current, {
+                signal: ctrl.signal,
+                redirect: 'manual',
+                headers: {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) ds-agent/1.0',
+                    'Accept-Language': 'en-US,en;q=0.9,ru;q=0.8',
+                    ...headers,
+                },
+            });
+            if (res.status >= 300 && res.status < 400) {
+                const loc = res.headers.get('location');
+                if (loc) {
+                    const next = new URL(loc, current).toString();
+                    // Validate the TARGET before requesting it.
+                    await assertPublicUrl(next);
+                    current = next;
+                    continue;
+                }
+            }
+            const ct = res.headers.get('content-type') || '';
+            const body = await res.text();
+            return {
+                status: res.status,
+                url: res.url || current,
+                contentType: ct,
+                body,
+            };
+        }
+        throw new Error(`too many redirects (>${MAX_REDIRECTS})`);
     }
     finally {
         clearTimeout(t);
@@ -198,7 +222,38 @@ async function getHeadless() {
     });
     return _headless;
 }
+// ONE reused context for every render-fetch. Creating a fresh context per call
+// (as before) re-allocated the user-agent/network stack each time, which is
+// heavy for a series of render=true fetches. Pages are closed after each fetch,
+// the context itself is reused and closed in closeWeb().
+//
+// The cache is a tiny pure factory so the reuse/reset behaviour can be unit-
+// tested without launching a real browser.
+export function createReusable(factory, dispose) {
+    let cached = null;
+    return {
+        async get() {
+            if (cached === null)
+                cached = await factory();
+            return cached;
+        },
+        async reset() {
+            if (cached === null)
+                return;
+            const v = cached;
+            cached = null;
+            await dispose(v).catch(() => { });
+        },
+    };
+}
+const _headlessCtxCache = createReusable(async () => {
+    const browser = await getHeadless();
+    return browser.newContext({
+        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+    });
+}, (ctx) => ctx.close());
 export async function closeWeb() {
+    await _headlessCtxCache.reset();
     if (_headless) {
         try {
             await _headless.close();
@@ -208,12 +263,13 @@ export async function closeWeb() {
     }
 }
 async function renderWithHeadless(url, { timeout = DEFAULT_TIMEOUT } = {}) {
-    const browser = await getHeadless();
-    const ctx = await browser.newContext({
-        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-    });
+    const ctx = await _headlessCtxCache.get();
     const page = await ctx.newPage();
     try {
+        // Validate the pre-redirect URL (page.goto follows redirects internally,
+        // unlike fetch we cannot intercept each hop here — but at least the
+        // original is checked, matching the previous behavior).
+        await assertPublicUrl(url);
         const resp = await page.goto(url, {
             waitUntil: 'domcontentloaded',
             timeout,
@@ -223,10 +279,18 @@ async function renderWithHeadless(url, { timeout = DEFAULT_TIMEOUT } = {}) {
         const html = await page.content();
         const status = resp ? resp.status() : 0;
         const finalUrl = page.url();
+        // The page may have redirected somewhere private; check the FINAL url too.
+        try {
+            await assertPublicUrl(finalUrl);
+        }
+        catch {
+            throw new Error(`blocked private redirect target: ${finalUrl}`);
+        }
         return { status, url: finalUrl, html };
     }
     finally {
-        await ctx.close();
+        // Close the PAGE, not the shared context.
+        await page.close().catch(() => { });
     }
 }
 // ---------- tools ----------
@@ -307,22 +371,7 @@ export function createWebTools() {
                     if (r.status !== 200) {
                         return `DuckDuckGo returned HTTP ${r.status}`;
                     }
-                    // We parse with simple regexes. The html.duckduckgo.com format is stable.
-                    const results = [];
-                    const re = /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?(?:<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>)?/gi;
-                    let m;
-                    while ((m = re.exec(r.body)) && results.length < limit) {
-                        let href = m[1];
-                        // DuckDuckGo wraps links in a redirect like /l/?uddg=...
-                        const uddgMatch = href.match(/[?&]uddg=([^&]+)/);
-                        if (uddgMatch)
-                            href = decodeURIComponent(uddgMatch[1]);
-                        const title = htmlToText(m[2] || '').trim();
-                        const snippet = htmlToText(m[3] || '').trim();
-                        if (!title || !href)
-                            continue;
-                        results.push({ title, url: href, snippet });
-                    }
+                    const results = parseDuckDuckGoResults(r.body, limit);
                     if (!results.length) {
                         return `No results found. The DuckDuckGo output format may have changed.`;
                     }
@@ -337,6 +386,26 @@ export function createWebTools() {
         },
     ];
 }
+// Parse the DuckDuckGo HTML results page. Pure; exported for tests. The
+// html.duckduckgo.com format is stable, so simple regexes suffice. DuckDuckGo
+// wraps links in a /l/?uddg=... redirect which must be unwrapped.
+export function parseDuckDuckGoResults(body, limit) {
+    const results = [];
+    const re = /<a[^>]*class="[^"]*result__a[^"]*"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?(?:<a[^>]*class="[^"]*result__snippet[^"]*"[^>]*>([\s\S]*?)<\/a>)?/gi;
+    let m;
+    while ((m = re.exec(body)) && results.length < limit) {
+        let href = m[1];
+        const uddgMatch = href.match(/[?&]uddg=([^&]+)/);
+        if (uddgMatch)
+            href = decodeURIComponent(uddgMatch[1]);
+        const title = htmlToText(m[2] || '').trim();
+        const snippet = htmlToText(m[3] || '').trim();
+        if (!title || !href)
+            continue;
+        results.push({ title, url: href, snippet });
+    }
+    return results;
+}
 function formatResult(status, url, text, limit) {
     let out = text;
     let truncated = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.66.1",
+  "version": "2.67.1",
   "description": "Terminal coding agent that drives chat.deepseek.com through Playwright — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {
@@ -10,7 +10,6 @@
     "dist",
     "scripts",
     "README.md",
-    "README.ru.md",
     "CHANGELOG.md",
     "LICENSE",
     "logo-small.jpg"

package/scripts/build-readme.mts

@@ -2,10 +2,13 @@
 //
 // Why: npm renders exactly ONE readme per package (README.md in the root) and
 // has no language tabs, so a separate README.ru.md is invisible on the npm
-// page. But npm renders the readme with GitHub Flavored Markdown (via GitHub's
-// API), so a <details> block DOES work there -- and on GitHub too. We therefore
-// keep the English text on top and fold the other language into a collapsible
-// block at the bottom.
+// page. But npm renders the readme with GitHub Flavored Markdown (via
+// GitHub's API), so a <details> block DOES work there -- and on GitHub too.
+// We therefore keep the English text on top and fold the other language into
+// a collapsible block at the bottom. README.ru.md is generated too so the
+// GitHub switcher can point at it directly, but it is NOT published to npm
+// (see "files" in package.json):
+// it would just duplicate the folded block.
 //
 // The two sources (docs/readme.en.md, docs/readme.ru.md) are the single point
 // of edit for each language; this script wires the switcher and the collapsible
@@ -13,7 +16,7 @@
 // generated files are committed; test/readme-built.test.ts re-runs buildReadmes()
 // and fails if they drift from the sources.
 //
-// Usage:  node scripts/build-readme.mjs   (or: npm run build:readme)
+// Usage:  npm run build:readme
 
 import fs from 'node:fs'
 import path from 'node:path'
@@ -23,17 +26,13 @@ const NL = String.fromCharCode(10)
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
 export const SWITCHER = '<!-- SWITCHER -->'
 
-const REPO = 'https://github.com/Viqto0r/zames_pro/blob/master'
+// In-page anchor the switcher links to. GitHub strips `id` on some elements but
+// keeps `name` on an <a>, so both are set.
+export const RU_ANCHOR = '<a id="readme-ru" name="readme-ru"></a>'
+
 const EN_SWITCH = [
   '<p align="center">',
-  '  <strong>English</strong> | <a href="' +
-    REPO +
-    '/README.ru.md">Русский</a>',
-  '</p>',
-].join(NL)
-const RU_SWITCH = [
-  '<p align="center">',
-  '  <a href="' + REPO + '/README.md">English</a> | <strong>Русский</strong>',
+  '  <strong>English</strong> | <a href="#readme-ru">Русский</a>',
   '</p>',
 ].join(NL)
 
@@ -71,50 +70,30 @@ function details(summary: string, body: string): string {
   ].join(NL)
 }
 
-function assemble(opts: {
-  head: string
-  switchLine: string
-  body: string
-  foldSummary: string
-  foldBody: string
-}): string {
-  const { head, switchLine, body, foldSummary, foldBody } = opts
-  return [
-    head,
-    '',
-    switchLine,
-    '',
-    body,
-    '',
-    details(foldSummary, foldBody),
-    '',
-  ].join(NL)
-}
-
 // Returns the two generated readmes WITHOUT touching the disk, so a test can
-// compare them against the committed files.
+// compare them against the committed files. Both files carry the SAME content
+// (English on top, Russian folded): README.md is what npm publishes, and
+// README.ru.md exists only so the GitHub language switcher has a target. The
+// switcher is an IN-PAGE `#readme-ru` anchor, so it works from either file
+// without fetching the other one.
 export function buildReadmes(rootDir: string): {
   readmeEn: string
   readmeRu: string
 } {
   const en = readSource(rootDir, 'readme.en.md')
   const ru = readSource(rootDir, 'readme.ru.md')
-  return {
-    readmeEn: assemble({
-      head: en.head,
-      switchLine: EN_SWITCH,
-      body: en.body,
-      foldSummary: '🇷🇺 Читать по-русски (Russian)',
-      foldBody: ru.body,
-    }),
-    readmeRu: assemble({
-      head: ru.head,
-      switchLine: RU_SWITCH,
-      body: ru.body,
-      foldSummary: '🇬🇧 Read in English',
-      foldBody: en.body,
-    }),
-  }
+  const doc = [
+    en.head,
+    '',
+    EN_SWITCH,
+    '',
+    en.body,
+    '',
+    RU_ANCHOR,
+    details('🇷🇺 Читать по-русски (Russian)', ru.body),
+    '',
+  ].join(NL)
+  return { readmeEn: doc, readmeRu: doc }
 }
 
 // Run only when invoked directly (not when imported by a test).

package/scripts/coverage-gate.mjs

@@ -32,6 +32,10 @@ const FLOORS = {
   'permissions.ts': 85,
   'changelog.ts': 85,
   'attach-refs.ts': 85,
+  // N12: web.ts holds the SSRF guard and the DuckDuckGo/HTML parsers — a
+  // regression there is silent. Floors sit below the current values.
+  'web.ts': 40,
+  'spinner.ts': 55,
 }
 
 const run = spawnSync(