zames_pro 2.53.0 → 2.54.0

package/dist/attachments.js

@@ -1,6 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { existsSync } from 'fs';
 import { createHash } from 'crypto';
 import { execFileSync } from 'child_process';
 import { extractPathToken } from './path-token.js';
@@ -233,7 +234,7 @@ export function windowsReachable() {
     if (process.platform !== 'linux')
         return false;
     try {
-        return require('fs').existsSync('/mnt/c/Windows');
+        return existsSync('/mnt/c/Windows');
     }
     catch {
         return false;

package/dist/config.js

@@ -10,6 +10,13 @@ const HOME_CONFIG = path.join(ZAMES_HOME, 'config.json');
 export function projectConfigPath() {
     return path.join(process.cwd(), '.zamesrc.json');
 }
+// Write via a temp file + rename so a crash or Ctrl+C mid-write can never
+// leave a truncated/broken config (it is read at every startup).
+function atomicWriteJson(file, value) {
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+    fs.renameSync(tmp, file);
+}
 export const DEFAULTS = {
     maxIterations: 0,
     // Headless by default: the browser runs without a visible window. Set
@@ -426,7 +433,7 @@ export function readConfigFile(file) {
     catch (e) {
         const err = e;
         if (err.code !== 'ENOENT') {
-            throw new Error(`не удалось прочитать ${file}: ${err.message}`);
+            throw new Error(`failed to read ${file}: ${err.message}`);
         }
     }
     return {};
@@ -444,7 +451,7 @@ export function writeConfigValue(scope, key, raw) {
     const data = readConfigFile(file);
     setByPath(data, key, value);
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    atomicWriteJson(file, data);
     return { value, file };
 }
 /** Reset a setting to the default (remove the key from the file). */
@@ -467,7 +474,7 @@ export function resetConfigValue(scope, key) {
     if (cur)
         delete cur[parts[parts.length - 1]];
     fs.mkdirSync(path.dirname(file), { recursive: true });
-    fs.writeFileSync(file, JSON.stringify(data, null, 2) + '\n', 'utf-8');
+    atomicWriteJson(file, data);
     return file;
 }
 // 'PROJECT_CONFIG' stays a getter so existing callers that only DISPLAY the

package/dist/i18n.js

@@ -26,7 +26,7 @@ export function normalizeLocale(v) {
     return DEFAULT_LOCALE;
 }
 // String catalog. Key -> { ru, en }. If a key is missing — we return the key itself.
-const CATALOG = {
+export const CATALOG = {
     'app.tagline': {
         ru: 'агент поверх chat.deepseek.com через Playwright',
         en: 'coding agent over chat.deepseek.com via Playwright',

package/dist/self-review.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import fs from 'fs/promises';
+import { readdirSync } from 'fs';
 import { theme, divider } from './theme.js';
 import { translate, DEFAULT_LOCALE } from './i18n.js';
 import { fileURLToPath } from 'url';
@@ -13,7 +14,7 @@ function resolveSrcDir() {
     const candidates = [__dirname, path.join(__dirname, '..', 'src')];
     for (const dir of candidates) {
         try {
-            const entries = require('fs').readdirSync(dir);
+            const entries = readdirSync(dir);
             if (entries.some((e) => e.endsWith('.ts')))
                 return dir;
         }

package/dist/undo.js

@@ -22,7 +22,10 @@ export class UndoStore {
         }
     }
     async _writeIndex(history) {
-        await fs.writeFile(INDEX, JSON.stringify(history, null, 2));
+        // Atomic write: a crash mid-write must not corrupt the undo history.
+        const tmp = `${INDEX}.tmp-${process.pid}`;
+        await fs.writeFile(tmp, JSON.stringify(history, null, 2));
+        await fs.rename(tmp, INDEX);
     }
     async backup(filePath) {
         if (!this.enabled)

package/dist/web.js

@@ -1,4 +1,6 @@
 import { chromium } from 'playwright';
+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.
@@ -42,6 +44,102 @@ function htmlToText(html) {
         .join('\n');
     return s;
 }
+// ---------- SSRF guard ----------
+//
+// WebFetch takes an arbitrary URL from the model. Without a guard it could be
+// talked into reading cloud metadata (169.254.169.254), internal admin panels
+// 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.
+export function isPrivateIp(ip) {
+    const v4 = ip.match(/^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/);
+    if (v4) {
+        const [a, b] = v4.slice(1).map(Number);
+        if (a === 10 || a === 127 || a === 0)
+            return true;
+        if (a === 169 && b === 254)
+            return true; // link-local + cloud metadata
+        if (a === 172 && b >= 16 && b <= 31)
+            return true;
+        if (a === 192 && b === 168)
+            return true;
+        if (a === 100 && b >= 64 && b <= 127)
+            return true; // CGNAT
+        return false;
+    }
+    const low = ip.toLowerCase();
+    if (low === '::1' || low === '::')
+        return true;
+    if (low.startsWith('fe80') || low.startsWith('fc') || low.startsWith('fd')) {
+        return true;
+    }
+    const mapped = low.match(/^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
+    if (mapped)
+        return isPrivateIp(mapped[1]);
+    return false;
+}
+export function isPrivateHostname(host) {
+    const h = host.toLowerCase().replace(/\.$/, '');
+    if (!h)
+        return true;
+    if (h === 'localhost' || h.endsWith('.localhost'))
+        return true;
+    if (h === 'metadata.google.internal')
+        return true;
+    return false;
+}
+async function assertPublicUrl(rawUrl) {
+    const u = new URL(rawUrl);
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+        throw new Error(`unsupported protocol: ${u.protocol}`);
+    }
+    const host = u.hostname;
+    if (isPrivateHostname(host)) {
+        throw new Error(`blocked private host: ${host}`);
+    }
+    if (isIP(host)) {
+        if (isPrivateIp(host))
+            throw new Error(`blocked private address: ${host}`);
+        return;
+    }
+    try {
+        const addrs = await lookup(host, { all: true });
+        for (const a of addrs) {
+            if (isPrivateIp(a.address)) {
+                throw new Error(`blocked private address for ${host}: ${a.address}`);
+            }
+        }
+    }
+    catch (e) {
+        // Re-throw our own block, but let a DNS failure fall through so fetch()
+        // surfaces the real network error instead of a misleading one.
+        if (e.message.startsWith('blocked'))
+            throw e;
+    }
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+// fetch with retries for transient network errors and 5xx responses.
+async function httpFetchWithRetry(url, opts = {}, retries = 2) {
+    let lastErr;
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            const r = await httpFetch(url, opts);
+            if (r.status >= 500 && attempt < retries) {
+                await sleep(300 * 2 ** attempt);
+                continue;
+            }
+            return r;
+        }
+        catch (e) {
+            lastErr = e;
+            if (attempt < retries) {
+                await sleep(300 * 2 ** attempt);
+                continue;
+            }
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(String(lastErr));
+}
 // fetch with redirects and a timeout
 async function httpFetch(url, { timeout = DEFAULT_TIMEOUT, headers = {}, } = {}) {
     const ctrl = new AbortController();
@@ -126,12 +224,13 @@ export function createWebTools() {
                 }
                 const limit = Math.min(Number(maxChars) || MAX_TEXT, 60_000);
                 try {
+                    await assertPublicUrl(String(url));
                     if (render) {
                         const r = await renderWithHeadless(String(url));
                         const text = htmlToText(r.html);
                         return formatResult(r.status, r.url, text, limit);
                     }
-                    const r = await httpFetch(String(url));
+                    const r = await httpFetchWithRetry(String(url));
                     // If it's JSON/plain text — return as is
                     if (/application\/json|text\/plain|text\/markdown/i.test(r.contentType)) {
                         const trimmed = r.body.slice(0, limit);
@@ -168,7 +267,7 @@ export function createWebTools() {
                     return 'Error: query is empty.';
                 const limit = Math.min(Math.max(Number(maxResults) || 8, 1), 20);
                 try {
-                    const r = await httpFetch(`https://html.duckduckgo.com/html/?q=${q}`, {
+                    const r = await httpFetchWithRetry(`https://html.duckduckgo.com/html/?q=${q}`, {
                         timeout: 25_000,
                         headers: {
                             Accept: 'text/html,application/xhtml+xml',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.53.0",
+  "version": "2.54.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {
@@ -45,7 +45,6 @@
     "chalk": "^5.3.0",
     "cli-highlight": "^2.1.11",
     "markdansi": "^0.3.4",
-    "marked": "^15.0.12",
     "ora": "^8.0.1",
     "playwright": "^1.48.0"
   },