zames_pro 2.75.6 → 2.77.0

package/dist/tui/useMouseWheel.js

@@ -48,7 +48,16 @@ export function parseWheel(chunk) {
     let m;
     while ((m = re.exec(chunk)) !== null) {
         const cb = Number(m[1]);
+        // SGR reports a RELEASE as the same button number with a lowercase `m`.
+        // Only press events are wheels: a terminal that sends 1000/1002/1003
+        // release reports (xterm does for button events) would otherwise count
+        // every notch TWICE — once for the press and once for its release.
+        if (m[0].endsWith('m'))
+            continue;
         // Button code 64 = wheel up (scroll back), 65 = wheel down (scroll fwd).
+        // Modifier bits (4=shift, 8=alt, 16=ctrl) must be masked OFF first: the
+        // mask below used to keep bit 0, so Ctrl/Alt-wheel (Cb 80/72/... — odd or
+        // even) fell through and that notch was lost.
         const button = cb & 0b11000011;
         if (button === 64)
             delta += 1;

package/dist/web.js

@@ -5,7 +5,37 @@ const DEFAULT_TIMEOUT = 20_000;
 const MAX_TEXT = 12_000;
 // Removes scripts, styles, and turns HTML into readable text. Exported for
 // tests — the entity/whitespace/collapse branches are pure and worth pinning.
+// Decode ONE numeric HTML entity to its character. A hostile/broken page can
+// carry `�` (beyond Unicode), a surrogate (`�`) or a huge
+// hex value; String.fromCodePoint THROWS RangeError on those, and the throw
+// escaped htmlToText into the WebFetch handler — the whole page came back as
+// "Error fetching <url>: Invalid code point 999999999". An undecodable
+// reference is kept VERBATIM instead.
+//
+// A surrogate PAIR written as two references (`&#55357;&#56832;`) is ONE
+// astral character (an emoji): decoding each half alone left two lone
+// surrogates in the text. A lone high surrogate is remembered and JOINED with
+// the low surrogate that immediately follows it (the replacer runs in order).
+let pendingHighSurrogate = null;
+function decodeEntityCode(cp) {
+    if (!Number.isInteger(cp) || cp < 0 || cp > 0x10ffff)
+        return '';
+    if (cp >= 0xd800 && cp <= 0xdbff) {
+        pendingHighSurrogate = String.fromCharCode(cp);
+        return '';
+    }
+    if (cp >= 0xdc00 && cp <= 0xdfff) {
+        const high = pendingHighSurrogate;
+        pendingHighSurrogate = null;
+        return high ? high + String.fromCharCode(cp) : String.fromCharCode(cp);
+    }
+    pendingHighSurrogate = null;
+    return String.fromCodePoint(cp);
+}
 export function htmlToText(html) {
+    // Reset the cross-reference surrogate state: it must never leak from one
+    // document to the next.
+    pendingHighSurrogate = null;
     // Remove blocks we don't need
     let s = html
         .replace(/<script[\s\S]*?<\/script>/gi, '')
@@ -35,8 +65,8 @@ export function htmlToText(html) {
         .replace(/&mdash;/g, '—')
         .replace(/&ndash;/g, '–')
         .replace(/&hellip;/g, '…')
-        .replace(/&#(\d+);/g, (_, n) => String.fromCodePoint(Number(n)))
-        .replace(/&#x([0-9a-f]+);/gi, (_, n) => String.fromCodePoint(parseInt(n, 16)));
+        .replace(/&#(\d+);/g, (_, n) => decodeEntityCode(Number(n)))
+        .replace(/&#x([0-9a-f]+);/gi, (_, n) => decodeEntityCode(parseInt(n, 16)));
     // Collapse blank lines
     s = s
         .split('\n')
@@ -52,6 +82,49 @@ export function htmlToText(html) {
 // or localhost services. We resolve the hostname and refuse private / loopback
 // / link-local addresses. Best-effort: a DNS rebind between the check and the
 // fetch is out of scope for a CLI tool, but the common cases are covered.
+// Parse an inet_aton-style IPv4 literal (the form WHATWG URL and the OS also
+// accept) into a uint32, or null when it is not one. Rules: 1-4 parts; each
+// part may be hex (0x…), octal (leading 0) or decimal; the LAST part fills all
+// remaining bytes, so `127.1` == 127.0.0.1 and `2130706433` == 127.0.0.1.
+export function parseLegacyIpv4(host) {
+    const h = String(host || '').trim();
+    if (!h)
+        return null;
+    const parts = h.split('.');
+    if (parts.length < 1 || parts.length > 4)
+        return null;
+    const nums = [];
+    for (const p of parts) {
+        if (p === '')
+            return null;
+        let v;
+        if (/^0[xX][0-9a-fA-F]+$/.test(p))
+            v = parseInt(p.slice(2), 16);
+        else if (/^0[0-7]+$/.test(p))
+            v = parseInt(p.slice(1), 8);
+        else if (/^\d+$/.test(p))
+            v = parseInt(p, 10);
+        else
+            return null;
+        if (!Number.isFinite(v) || v < 0)
+            return null;
+        nums.push(v);
+    }
+    // Every part except the last must fit one byte; the last fills the rest.
+    for (let i = 0; i < nums.length - 1; i++) {
+        if (nums[i] > 0xff)
+            return null;
+    }
+    const lastMax = Math.pow(256, 5 - nums.length) - 1;
+    if (nums[nums.length - 1] > lastMax)
+        return null;
+    let n = 0;
+    for (let i = 0; i < nums.length - 1; i++) {
+        n += nums[i] * Math.pow(256, 3 - i);
+    }
+    n += nums[nums.length - 1];
+    return n >>> 0;
+}
 export function isPrivateIp(ip) {
     const v4 = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
     if (v4) {
@@ -68,6 +141,22 @@ export function isPrivateIp(ip) {
             return true; // CGNAT
         return false;
     }
+    // A NON-canonical IPv4 literal is still a number: WHATWG URL and inet_aton
+    // accept 1-4 parts with decimal/octal/hex digits (`2130706433`,
+    // `0x7f.1`, `0177.0.0.1`, `127.1` all mean 127.0.0.1). Recognising only the
+    // dotted-quad form let those through the SSRF guard (a classic bypass).
+    if (/^[0-9a-fx.]+$/i.test(ip) && !ip.includes(':')) {
+        const n = parseLegacyIpv4(ip);
+        if (n !== null) {
+            return isPrivateIp(((n >>> 24) & 0xff) +
+                '.' +
+                ((n >>> 16) & 0xff) +
+                '.' +
+                ((n >>> 8) & 0xff) +
+                '.' +
+                (n & 0xff));
+        }
+    }
     const low = ip.toLowerCase();
     if (low === '::1' || low === '::')
         return true;
@@ -123,7 +212,10 @@ export async function assertPublicUrl(rawUrl) {
     if (u.protocol !== 'http:' && u.protocol !== 'https:') {
         throw new Error(`unsupported protocol: ${u.protocol}`);
     }
-    const host = u.hostname;
+    // The URL API keeps the BRACKETS of an IPv6 literal (`[::ffff:7f00:1]`),
+    // and net.isIP() rejects a bracketed host — so the address fell through to
+    // the DNS lookup branch and the literal was never checked as an address.
+    const host = u.hostname.replace(/^\[(.*)\]$/, '$1');
     if (isPrivateHostname(host)) {
         throw new Error(`blocked private host: ${host}`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.75.6",
+  "version": "2.77.0",
   "description": "Terminal coding agent that drives a real browser to chat with DeepSeek, Qwen and other web LLMs — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {