zames_pro 2.77.0 → 2.77.1

package/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.77.1] - 2026-10-17
+
+### Fixed
+
+- **backlog:** only collapse real archive blocks, not notes that mention details
+- **qwen:** do not read a retry phrase in the answer as a rate limit
+- **web:** block IPv4-compatible IPv6 addresses in the SSRF guard
+- **sessions:** cap the input history when loading it
+- **sessions:** keep chat ids with unsafe characters in separate files
+
 ## [2.77.0] - 2026-10-17
 
 ### Added

package/dist/backlog.js

@@ -62,6 +62,20 @@ function isRealBoundary(line) {
 function isDetailsOpen(line) {
     return line.trim().startsWith('<details');
 }
+// An ARCHIVE block is a <details> that actually wraps the struck-through copy
+// of an item heading (`### X. ~~original~~`). A note that merely MENTIONS
+// `Use <details> in README:` must not be treated as an archive: collapsing it
+// deleted the note's own body (everything up to the next heading).
+function isArchiveBlock(lines, from) {
+    for (let j = from; j < lines.length; j++) {
+        const t = lines[j].trim();
+        if (isArchivedHeading(t))
+            return true;
+        if (t.startsWith('</details>') || isRealBoundary(t))
+            return false;
+    }
+    return false;
+}
 function isArchivedHeading(line) {
     return /^###\s+[A-Z]\d+[.]\s+~~/.test(line.trim());
 }
@@ -85,7 +99,8 @@ export function collapseBacklog(text) {
     let collapsed = 0;
     let i = 0;
     while (i < lines.length) {
-        if (isDetailsOpen(lines[i]) || isArchivedHeading(lines[i])) {
+        const archiveOpen = isDetailsOpen(lines[i]) && isArchiveBlock(lines, i + 1);
+        if (archiveOpen || isArchivedHeading(lines[i])) {
             // Skip to the end of the archive: the first `</details>` OR the first
             // real heading, whichever comes first (see the note above).
             let j = i + 1;

package/dist/qwen-net-capture.js

@@ -195,6 +195,12 @@ export function isFinishedWithoutAnswer(body) {
 }
 // True when the body carries Qwen's rate-limit / busy notice, so ask() can
 // back off instead of waiting out the deadline. Matched against the RAW body.
+// The classifier runs against the RAW body, so a phrase like `please try again
+// later` would also match a NORMAL answer (the model writing about retry
+// logic) and make ask() back off on a good turn. A real notice arrives in an
+// ERROR payload (`event: error` / `"type":"error"`) or as a code; answer text
+// lives in `choices[].delta.content`. We therefore only inspect the body when
+// it is NOT a plain answer stream, or when it carries no answer content.
 export function isRateLimitText(body) {
     const b = String(body || '');
     if (!b)
@@ -203,7 +209,42 @@ export function isRateLimitText(body) {
     // ("The service is currently experiencing high demand. Please try again
     // later.") — a TRANSIENT capacity limit, so it belongs with the rate-limit
     // family (back off and retry), not with the guest DAILY limit.
-    return /too many requests|rate limit|too frequent|please try again later|quota_limit|high demand|слишком часто/i.test(b);
+    if (/quota_limit/i.test(b))
+        return true;
+    if (/event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b)) {
+        return /too many requests|rate limit|too frequent|please try again later|high demand|слишком часто/i.test(b);
+    }
+    // No structured error marker: only treat the body as a notice when it has
+    // NO answer content (a bare notice page/JSON).
+    if (hasAnswerContent(b))
+        return false;
+    return /too many requests|rate limit|too frequent|please try again later|high demand|слишком часто/i.test(b);
+}
+// True when the body carries actual answer text in an SSE/JSON chunk.
+function hasAnswerContent(body) {
+    for (const obj of parseDataLines(body)) {
+        const choices = obj.choices;
+        if (!Array.isArray(choices))
+            continue;
+        for (const ch of choices) {
+            if (!ch || typeof ch !== 'object')
+                continue;
+            const c = ch;
+            const delta = c.delta && typeof c.delta === 'object'
+                ? c.delta
+                : c.message && typeof c.message === 'object'
+                    ? c.message
+                    : null;
+            if (!delta)
+                continue;
+            if (isThinkingPhase(delta))
+                continue;
+            if (typeof delta.content === 'string' && delta.content.trim()) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 // The GUEST daily limit is a DIFFERENT failure from a transient rate limit:
 // Qwen answers `RateLimited` with "You've reached the guest chat limit for
@@ -221,5 +262,11 @@ export function isServerBusyText(body) {
     const b = String(body || '');
     if (!b)
         return false;
+    // Same rule as isRateLimitText: a normal ANSWER may mention "try again
+    // later"; only a structured error payload or a body with NO answer content
+    // can be a server-busy notice.
+    const errNotice = /event:\s*error|"type"\s*:\s*"error"|"error"\s*:/i.test(b);
+    if (!errNotice && hasAnswerContent(b))
+        return false;
     return /server is busy|service unavailable|try again later/i.test(b);
 }

package/dist/sessions.js

@@ -46,8 +46,21 @@ export function isInternalChat(id) {
 function ensureDir() {
     fs.mkdirSync(SESSIONS_DIR, { recursive: true });
 }
+// A chat id is used as a FILE NAME. Replacing every unsafe character with `_`
+// made two DIFFERENT ids collide on one file ('a/b' and 'a_b'), so the second
+// session overwrote the first and the other chat could not be resumed. Encode
+// the unsafe characters instead: `_` becomes `_5f` and every other unsafe byte
+// `_XX` (hex), which is injective and still path-safe.
 function safeName(id) {
-    return String(id).replace(/[^a-zA-Z0-9_.-]/g, '_');
+    const s = String(id);
+    let out = '';
+    for (const ch of s) {
+        if (/[a-zA-Z0-9.-]/.test(ch))
+            out += ch;
+        else
+            out += '_' + ch.codePointAt(0).toString(16).padStart(2, '0');
+    }
+    return out;
 }
 // Save/update a session. workdir is needed so that when launched from the same
 // project we restore exactly its last chat.
@@ -194,7 +207,11 @@ export function loadHistory() {
         const raw = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf-8'));
         if (!Array.isArray(raw))
             return [];
-        return raw.filter((x) => typeof x === 'string');
+        const list = raw.filter((x) => typeof x === 'string');
+        // Cap on LOAD as well: an old/hand-edited/merged file could exceed the
+        // limit, and the next save would write the whole array back out. Keep the
+        // most recent (tail) entries, matching saveHistory().
+        return list.length > HISTORY_LIMIT ? list.slice(-HISTORY_LIMIT) : list;
     }
     catch {
         return [];

package/dist/web.js

@@ -188,6 +188,26 @@ export function isPrivateIp(ip) {
     }
     if (low.startsWith('64:ff9b:'))
         return true;
+    // IPv4-COMPATIBLE form `::a.b.c.d` (deprecated, but the OS/HTTP stack still
+    // resolves it, so `http://[::127.0.0.1]/` reached localhost). `::` itself and
+    // `::1` are already handled above; `::ffff:…` was handled as MAPPED. Any
+    // other `::`-prefixed address whose tail is an embedded IPv4 belongs to the
+    // same family and must be judged by the embedded address.
+    const compat = low.match(/^::(?:ffff:)?(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+    if (compat)
+        return isPrivateIp(compat[1]);
+    const compatHex = low.match(/^::([0-9a-f]{1,4}):([0-9a-f]{1,4})$/);
+    if (compatHex) {
+        const hi = parseInt(compatHex[1], 16);
+        const lo = parseInt(compatHex[2], 16);
+        return isPrivateIp(((hi >> 8) & 0xff) +
+            '.' +
+            (hi & 0xff) +
+            '.' +
+            ((lo >> 8) & 0xff) +
+            '.' +
+            (lo & 0xff));
+    }
     return false;
 }
 export function isPrivateHostname(host) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.77.0",
+  "version": "2.77.1",
   "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": {