zames_pro 2.66.0 → 2.67.0

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);
@@ -214,6 +238,10 @@ async function renderWithHeadless(url, { timeout = DEFAULT_TIMEOUT } = {}) {
     });
     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,6 +251,13 @@ 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 {
@@ -307,22 +342,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 +357,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.0",
+  "version": "2.67.0",
   "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": {
@@ -33,6 +33,7 @@
     "test:watch": "tsx --test --watch test/*.test.ts",
     "self-smoke": "tsx scripts/self-smoke.mjs",
     "render-demo": "node scripts/render-demo.mjs",
+    "build:readme": "tsx scripts/build-readme.mts",
     "postinstall": "node scripts/postinstall.mjs",
     "prepare": "husky"
   },

package/scripts/build-readme.mts

@@ -0,0 +1,129 @@
+// Assemble README.md and README.ru.md from two language sources.
+//
+// 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.
+//
+// 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
+// cross-language block so neither README has to be maintained by hand. The
+// 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)
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+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'
+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>',
+  '</p>',
+].join(NL)
+
+export function readSource(
+  rootDir: string,
+  name: string,
+): { head: string; body: string } {
+  const file = path.join(rootDir, 'docs', name)
+  const text = fs.readFileSync(file, 'utf-8')
+  const i = text.indexOf(SWITCHER)
+  if (i < 0) {
+    throw new Error(
+      file + ' has no ' + SWITCHER + ' marker (was it edited by hand?)',
+    )
+  }
+  return {
+    // Everything above the marker: logo, title, badges.
+    head: text.slice(0, i).replace(/\n+$/, ''),
+    // Everything below: the actual documentation.
+    body: text
+      .slice(i + SWITCHER.length)
+      .replace(/^\n+/, '')
+      .replace(/\n+$/, ''),
+  }
+}
+
+function details(summary: string, body: string): string {
+  return [
+    '<details>',
+    '<summary>' + summary + '</summary>',
+    '',
+    body,
+    '',
+    '</details>',
+  ].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.
+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,
+    }),
+  }
+}
+
+// Run only when invoked directly (not when imported by a test).
+const invoked =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (invoked) {
+  const { readmeEn, readmeRu } = buildReadmes(root)
+  fs.writeFileSync(path.join(root, 'README.md'), readmeEn)
+  fs.writeFileSync(path.join(root, 'README.ru.md'), readmeRu)
+  console.log('build-readme: wrote README.md and README.ru.md')
+}

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(

package/scripts/release.mts

@@ -108,7 +108,18 @@ const subjects = git(['log', '--no-merges', '--pretty=format:%s', ref + '..HEAD'
 const parsed = subjects
   .map(parseConventionalCommit)
   .filter((c): c is NonNullable<typeof c> => c !== null)
-const body = renderChangelogDraft(groupCommits(parsed))
+let body = renderChangelogDraft(groupCommits(parsed))
+
+// The conventional draft skips chore/docs/test/etc, so a release whose only
+// change is a docs fix (a README tweak users WILL see on the npm page) would
+// otherwise collapse to a useless "Internal improvements." placeholder. Fall
+// back to the raw commit subjects under Changed instead of that stub.
+if (!body) {
+  const fallback = subjects.filter((s) => !/^chore(:|\(release\))/i.test(s))
+  if (fallback.length) {
+    body = ['## Changed', ''].concat(fallback.map((s) => '- ' + s)).join(NL)
+  }
+}
 
 // CHANGELOG groups are `### Added` (Keep a Changelog), the draft renders
 // `## Added` — normalize here.