zames_pro 2.7.0 → 2.8.0

package/README.md

@@ -41,6 +41,27 @@ While the agent is working you can keep typing: press Enter to queue a message
 abort the current generation. This mirrors typing during generation on the
 DeepSeek website.
 
+### Images and files
+
+You can paste an image or a file into the input line (Ctrl+Shift+V / Shift+Insert
+or the terminal's own paste). zames saves it under `<project>/tmp` and shows a
+marker in the line - `[image#1]` for images, `[file#1]` for other files - then
+uploads the real file to the chat together with your message. These are the
+same formats the DeepSeek web chat accepts (PNG, JPEG, GIF, WEBP, BMP, SVG and
+the usual document types).
+
+Pasting an image works when the terminal sends it as a `data:` URL or as a
+base64 blob with a recognizable image signature. You can also paste a path to a
+local file (drag a file into the terminal or copy its path); if the file exists
+it is attached, otherwise the text is inserted as usual.
+
+Press Ctrl+V (or use an empty paste) and zames reads the image straight from
+the clipboard: Linux via wl-paste (Wayland) or xclip/xsel (X11), macOS
+via pngpaste, Windows via PowerShell. The needed Linux tools are installed
+automatically on npm install (best-effort, through the detected package
+manager). If no image is found, zames says so and reports which tool it tried,
+instead of staying silent.
+
 ### Options
 
 ```

package/dist/agent-loop.js

@@ -2,7 +2,7 @@ import { buildSystemPrompt } from './system-prompt.js';
 import { getGitContext, formatGitContext } from './gitTools.js';
 import { parseXmlToolCalls } from './xml-toolcall.js';
 import { translate } from './i18n.js';
-export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
+export async function runAgentLoop({ browser, tools, task, workdir, maxIterations = 40, freshChat = false, sendSystemPrompt = false, transcript = null, attachments = [], onThinking = () => { }, onAssistantThought = () => { }, onToolCall = () => { }, onToolResult = () => { }, onAssistantMessage = () => { }, onChatReady = () => { }, onWarning = () => { }, debugLog = false, locale = 'ru', }) {
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -48,6 +48,25 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         await reportChat();
     }
     let message = task;
+    if (attachments.length) {
+        // Tell the model what the markers mean even when the system-prompt is not
+        // (re)sent (resumed chat). The files are uploaded to the chat by the
+        // browser; this note just explains the [image#N] / [file#N] markers.
+        const markers = attachments.map((a, i) => {
+            const ext = String(a.name || '');
+            const isImg = /\.(png|jpe?g|gif|webp|bmp|svg|ico)$/i.test(ext);
+            return (isImg ? '[image#' : '[file#') + (i + 1) + ']';
+        });
+        message =
+            task +
+                String.fromCharCode(10) +
+                String.fromCharCode(10) +
+                '(The user attached ' +
+                attachments.length +
+                ' file(s) to this message: ' +
+                markers.join(', ') +
+                '. Look at the uploaded images in the chat; file copies are in <project>/tmp.)';
+    }
     transcript?.log('task', { task });
     let malformedRetries = 0;
     const MAX_MALFORMED_RETRIES = 3;
@@ -67,7 +86,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
         // Subsequent ones (tool-result and resend requests) are agent sends:
         // throttled so we don't hit the rate limit.
         const isFirst = i === 0;
-        const rawResponse = await browser.ask(message, { agent: !isFirst });
+        const rawResponse = await browser.ask(message, {
+            agent: !isFirst,
+            attachments: isFirst ? attachments : [],
+        });
         await reportChat();
         transcript?.log('assistant_raw', { response: rawResponse });
         // The user aborted generation (Esc/Ctrl+C).

package/dist/attachments.js

@@ -0,0 +1,267 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { execFileSync } from 'child_process';
+export const IMAGE_EXTS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.svg', '.ico'];
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+function sanitize(name) {
+    return String(name || '')
+        .replace(/[\u0000-\u001f\u007f]/g, '')
+        .replace(/[\\/:*?"<>|]/g, '_')
+        .replace(/\s+/g, '_')
+        .slice(0, 80) || 'file';
+}
+export function guessMime(name) {
+    const ext = path.extname(String(name || '')).toLowerCase();
+    const map = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp',
+        '.bmp': 'image/bmp',
+        '.svg': 'image/svg+xml',
+        '.ico': 'image/x-icon',
+        '.txt': 'text/plain',
+        '.md': 'text/markdown',
+        '.json': 'application/json',
+        '.js': 'text/javascript',
+        '.ts': 'text/plain',
+        '.css': 'text/css',
+        '.html': 'text/html',
+        '.pdf': 'application/pdf',
+        '.zip': 'application/zip',
+        '.csv': 'text/csv',
+        '.log': 'text/plain',
+    };
+    return map[ext] || 'application/octet-stream';
+}
+export function extForMime(mime) {
+    const m = String(mime || '').toLowerCase();
+    if (m.includes('png'))
+        return '.png';
+    if (m.includes('jpeg') || m.includes('jpg'))
+        return '.jpg';
+    if (m.includes('gif'))
+        return '.gif';
+    if (m.includes('webp'))
+        return '.webp';
+    if (m.includes('svg'))
+        return '.svg';
+    if (m.includes('text/plain'))
+        return '.txt';
+    if (m.includes('json'))
+        return '.json';
+    if (m.includes('pdf'))
+        return '.pdf';
+    return '';
+}
+export function formatSize(bytes) {
+    const n = Number(bytes) || 0;
+    if (n < 1024)
+        return n + ' B';
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + ' KB';
+    return (n / (1024 * 1024)).toFixed(1) + ' MB';
+}
+export function isImageName(name) {
+    return IMAGE_EXTS.includes(path.extname(String(name || '')).toLowerCase());
+}
+export function parseDataUrl(text) {
+    const m = String(text || '').match(/^data:([^;,]*);base64,([\s\S]*)$/);
+    if (!m)
+        return null;
+    try {
+        return { mime: m[1] || 'application/octet-stream', data: Buffer.from(m[2].replace(/\s+/g, ''), 'base64') };
+    }
+    catch {
+        return null;
+    }
+}
+export function sniffMime(data) {
+    if (!data || data.length < 4)
+        return '';
+    const b = data;
+    if (b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47)
+        return 'image/png';
+    if (b[0] === 0xff && b[1] === 0xd8)
+        return 'image/jpeg';
+    if (b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46)
+        return 'image/gif';
+    if (b[0] === 0x52 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x46)
+        return 'image/webp';
+    if (b[0] === 0x42 && b[1] === 0x4d)
+        return 'image/bmp';
+    return '';
+}
+export function parseImagePaste(raw) {
+    const text = String(raw || '').trim();
+    if (!text)
+        return null;
+    const dataUrl = parseDataUrl(text);
+    if (dataUrl)
+        return dataUrl;
+    const onlyB64 = /^[A-Za-z0-9+/\s=]+$/;
+    if (onlyB64.test(text) && text.length >= 64) {
+        try {
+            const data = Buffer.from(text.replace(/\s+/g, ''), 'base64');
+            const mime = sniffMime(data);
+            if (mime && mime.startsWith('image/'))
+                return { mime, data };
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export class AttachmentStore {
+    items = [];
+    imageCount = 0;
+    fileCount = 0;
+    reset() {
+        this.items = [];
+        this.imageCount = 0;
+        this.fileCount = 0;
+    }
+    add(item) {
+        const image = isImageName(item.name) || String(item.mime).startsWith('image/');
+        const index = image ? ++this.imageCount : ++this.fileCount;
+        const marker = image ? '[image#' + index + ']' : '[file#' + index + ']';
+        const att = {
+            index,
+            path: item.path,
+            name: item.name,
+            mime: item.mime,
+            image,
+            marker,
+            size: Number(item.size) || 0,
+        };
+        this.items.push(att);
+        return att;
+    }
+}
+// True if the pasted text is a single file path (e.g. '/tmp/a.png', './img.jpg',
+// 'C:\\pics\\a.png' or a bare 'photo.png'). We do NOT require the file to
+// exist yet — the caller checks that.
+export function looksLikeFilePath(text) {
+    const s = String(text || '').trim();
+    if (!s || s.length > 500)
+        return false;
+    if (/[\r\n]/.test(s))
+        return false;
+    // A bare file name with an image/known extension.
+    if (looksLikeFileName(s))
+        return true;
+    // A path with separators and an extension.
+    if (/[\\/]/.test(s) && /\.[A-Za-z0-9]{1,8}$/.test(s))
+        return true;
+    return false;
+}
+export function looksLikeFileName(name) {
+    const n = String(name || '').trim();
+    if (!n)
+        return false;
+    if (/[\r\n]/.test(n))
+        return false;
+    return /^[\w.\- ]+\.[A-Za-z0-9]{1,8}$/.test(n);
+}
+export async function saveToTemp(tmpDir, name, data) {
+    await fs.mkdir(tmpDir, { recursive: true });
+    const base = sanitize(name);
+    let target = path.join(tmpDir, base);
+    if (await fs.stat(target).catch(() => null)) {
+        const ext = path.extname(base);
+        const stem = base.slice(0, base.length - ext.length);
+        let i = 1;
+        while (await fs.stat(target).catch(() => null)) {
+            target = path.join(tmpDir, stem + '-' + i + ext);
+            i++;
+        }
+    }
+    await fs.writeFile(target, data);
+    return target;
+}
+// Read an image from the OS clipboard. Tries, in order, every known tool for
+// the current platform. Returns the raw bytes plus a short note about which
+// tool was used (or the reason nothing was found) — the caller shows that note
+// to the user so a failed paste is never silent.
+export function readClipboardImageDetailed() {
+    if (process.platform === 'linux' || process.platform === 'freebsd' || process.platform === 'openbsd') {
+        const wayland = process.env.WAYLAND_DISPLAY;
+        const x11 = process.env.DISPLAY;
+        const attempts = [];
+        if (wayland || !x11)
+            attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
+        if (x11 || !wayland) {
+            attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
+            attempts.push({ bin: 'xsel', args: ['--clipboard', '--output'], via: 'xsel' });
+        }
+        // Even if the session env is missing, try the other family as a fallback.
+        attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
+        attempts.push({ bin: 'xclip', args: ['-selection', 'clipboard', '-t', 'image/png', '-o'], via: 'xclip' });
+        const tried = [];
+        for (const a of attempts) {
+            if (tried.includes(a.via))
+                continue;
+            tried.push(a.via);
+            const data = tryCommand(a.bin, a.args);
+            if (data && sniffMime(data).startsWith('image/'))
+                return { data, via: a.via };
+            if (data && data.length)
+                return { data, via: a.via };
+        }
+        return { data: null, via: 'no-tool:' + tried.join(',') };
+    }
+    if (process.platform === 'darwin') {
+        const data = tryCommand('pngpaste', ['-']);
+        return { data: data && data.length ? data : null, via: data ? 'pngpaste' : 'no-tool:pngpaste' };
+    }
+    if (process.platform === 'win32') {
+        // PowerShell reads the clipboard image and writes raw PNG bytes to stdout.
+        const ps = 'Add-Type -AssemblyName System.Windows.Forms,System.Drawing; ' +
+            '$img=[System.Windows.Forms.Clipboard]::GetImage(); ' +
+            'if($img){$ms=New-Object System.IO.MemoryStream; ' +
+            '$img.Save($ms,[System.Drawing.Imaging.ImageFormat]::Png); ' +
+            '[Console]::OpenStandardOutput().Write($ms.ToArray(),0,$ms.Length)}';
+        const data = tryCommand('powershell', ['-NoProfile', '-NonInteractive', '-Command', ps]);
+        return { data: data && data.length ? data : null, via: data ? 'powershell' : 'no-tool:powershell' };
+    }
+    return { data: null, via: 'unsupported-platform' };
+}
+// Backwards-compatible wrapper used elsewhere.
+export function readClipboardImage() {
+    return readClipboardImageDetailed().data;
+}
+function tryCommand(bin, args) {
+    try {
+        const out = execFileSync(bin, args, {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            maxBuffer: MAX_ATTACHMENT_BYTES,
+            timeout: 8000,
+            windowsHide: true,
+        });
+        if (!out || !out.length)
+            return null;
+        return out;
+    }
+    catch {
+        return null;
+    }
+}
+export async function findFileByName(workdir, name) {
+    const candidate = path.resolve(workdir, name);
+    if (await fs.stat(candidate).catch(() => null))
+        return candidate;
+    try {
+        const { glob } = await import('fs/promises');
+        for await (const f of glob('**/' + name, { cwd: workdir })) {
+            const abs = path.resolve(workdir, f);
+            const rel = path.relative(workdir, abs);
+            if (rel.startsWith('..') || path.isAbsolute(rel))
+                continue;
+            return abs;
+        }
+    }
+    catch { }
+    return null;
+}

package/dist/browser.js

@@ -43,6 +43,14 @@ const RATE_LIMIT_RE = /(messages? too frequent|too many requests|rate limit|сл
 export function isRateLimitText(text) {
     return RATE_LIMIT_RE.test(String(text || ''));
 }
+// Normalize text for comparison: collapse whitespace so that tiny DOM
+// differences (nbsp, trailing spaces) don't count as "a new answer".
+export function normText(s) {
+    return String(s || '')
+        .replace(/\u00a0/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
 // The "too frequent" error: distinct from others so ask() waits a long time
 // (DeepSeek limits reset over minutes) and retries the send itself.
 export class RateLimitError extends Error {
@@ -408,14 +416,14 @@ export class DeepSeekBrowser {
         catch { }
         return false;
     }
-    async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, } = {}) {
+    async ask(prompt, { timeout = this.answerTimeoutMs, agent = false, attachments = [], } = {}) {
         let lastErr = null;
         let attempt = 0;
         let rateLimitRetries = 0;
         while (attempt < this.askRetries) {
             attempt++;
             try {
-                return await this._askOnce(prompt, { timeout, agent });
+                return await this._askOnce(prompt, { timeout, agent, attachments });
             }
             catch (e) {
                 lastErr = e;
@@ -494,6 +502,69 @@ export class DeepSeekBrowser {
             await this.page.keyboard.insertText(text);
         }
     }
+    // Attach files/images to the chat via the hidden <input type=file> of the
+    // DeepSeek upload widget. The element is not visible, so we set the files
+    // programmatically (Playwright setInputFiles works on hidden inputs too).
+    async _attachFiles(files) {
+        const bufPayload = [];
+        for (const f of files) {
+            try {
+                const buffer = await fs.readFile(f.path);
+                bufPayload.push({ name: f.name, mimeType: f.mime, buffer });
+            }
+            catch (e) {
+                console.error(theme.warn('⚠ не удалось прочитать вложение ' +
+                    f.name +
+                    ': ' +
+                    e.message));
+            }
+        }
+        if (!bufPayload.length)
+            return;
+        // Preferred path: click the attach button and let the file chooser event
+        // carry the files. This is how a real user attaches a file and it reliably
+        // triggers DeepSeek's upload handler.
+        const ATTACH_SELECTORS = [
+            'div[role="button"][aria-label*="attach" i]',
+            'div[role="button"][aria-label*="влож" i]',
+            'button[aria-label*="attach" i]',
+            'button[aria-label*="влож" i]',
+            '[class*="upload"]',
+            '[class*="attach"]',
+        ];
+        for (const sel of ATTACH_SELECTORS) {
+            const btn = this.page.locator(sel).last();
+            try {
+                if ((await btn.count()) === 0)
+                    continue;
+                if (!(await btn.isVisible().catch(() => false)))
+                    continue;
+                const [chooser] = await Promise.all([
+                    this.page.waitForEvent('filechooser', { timeout: 3000 }),
+                    btn.click({ timeout: 1500 }),
+                ]);
+                await chooser.setFiles(bufPayload);
+                await this.page.waitForTimeout(2500);
+                return;
+            }
+            catch { }
+        }
+        // Fallback: set the files directly on the hidden <input type=file>.
+        const input = this.page.locator('input[type="file"]').first();
+        if ((await input.count()) === 0) {
+            console.error(theme.warn('⚠ не найдено поле загрузки файлов на странице — вложения не прикреплены'));
+            return;
+        }
+        try {
+            await input.setInputFiles(bufPayload, { timeout: 15_000 });
+        }
+        catch (e) {
+            console.error(theme.warn('⚠ не удалось прикрепить файлы: ' + e.message));
+            return;
+        }
+        // Wait for the upload to finish (the attach preview to appear).
+        await this.page.waitForTimeout(2000);
+    }
     // Pause between sends. Applied ONLY to agent messages
     // (tool-result, system-prompt) so we don't hit the rate limit.
     // User input is sent without delay.
@@ -508,7 +579,7 @@ export class DeepSeekBrowser {
         console.error(theme.warn(`⏳ пауза ${Math.ceil(gap / 1000)}с перед отправкой`));
         await this.page.waitForTimeout(gap);
     }
-    async _askOnce(prompt, { timeout, agent }) {
+    async _askOnce(prompt, { timeout, agent, attachments = [], }) {
         // We reset the abort flag ONLY at the very start of the send.
         this._abort = false;
         const input = await this._findVisible(INPUT_SELECTORS, 10_000);
@@ -519,6 +590,11 @@ export class DeepSeekBrowser {
         await this._waitForSendSlot(agent);
         this._netCapture = '';
         this._netCaptureAt = 0;
+        // Attach files/images FIRST (before the text): the DeepSeek upload widget
+        // shows them above the input, and only then the message can be sent.
+        if (attachments.length) {
+            await this._attachFiles(attachments);
+        }
         await this._setInputText(input, prompt);
         await this.page.waitForTimeout(200);
         let sent = false;
@@ -554,12 +630,19 @@ export class DeepSeekBrowser {
             if (isRateLimitText(pageText)) {
                 throw new RateLimitError(pageText.slice(0, 300));
             }
-            const gen = await this._isGenerating();
             const cur = await this._readLastAnswerTextClean().catch(() => '');
             const bodyLen = await this.page
                 .evaluate(() => document.body.innerText.length)
                 .catch(() => 0);
-            if (gen || (cur && cur !== beforeText) || bodyLen > startBodyLen) {
+            // A NEW answer is the only reliable sign that the message was actually
+            // sent: the text on the page must differ from what was there before the
+            // send, OR the page must have grown. The Stop-button heuristic
+            // (_isGenerating) is NOT used here: right after a tool result the stop
+            // button may briefly linger from the previous generation, which used to
+            // make us think the new answer had started when in fact nothing was sent
+            // — and then the agent silently "stopped".
+            const changed = cur && normText(cur) !== normText(beforeText);
+            if (changed || bodyLen > startBodyLen) {
                 started = true;
                 break;
             }
@@ -592,7 +675,12 @@ export class DeepSeekBrowser {
                 }
             }
             const cur = await this._readLastAnswerTextClean().catch(() => '');
-            if (cur && cur === last) {
+            // Ignore an "answer" that is identical to what was on the page BEFORE we
+            // sent the message: that is the previous answer, not a new one. Returning
+            // it would make the agent re-process the old tool call (or silently
+            // stop). We keep waiting instead.
+            const isNew = cur && normText(cur) !== normText(beforeText);
+            if (isNew && cur === last) {
                 stable++;
                 if (stable >= 2)
                     return cur;
@@ -600,12 +688,14 @@ export class DeepSeekBrowser {
             else {
                 stable = 0;
             }
-            last = cur;
+            if (isNew)
+                last = cur;
             await this.page.waitForTimeout(800);
         }
-        if (last)
+        if (last && normText(last) !== normText(beforeText))
             return last;
-        throw new Error('Таймаут ожидания ответа. Попробуйте /debug-dom.');
+        throw new Error('Новый ответ не получен (на странице остался прежний текст). ' +
+            'Возможно, сообщение не отправилось.');
     }
     async dumpDom(filePath) {
         if (!this.page)

package/dist/i18n.js

@@ -59,6 +59,10 @@ const CATALOG = {
     'help.key.slash': { ru: '/ + Tab                  подсказка и автодополнение slash-команд', en: '/ + Tab                   slash-command hints and completion' },
     'help.key.newline': { ru: 'Ctrl+J / Ctrl+Enter      новая строка (Shift+Enter в терминалах с поддержкой)', en: 'Ctrl+J / Ctrl+Enter       new line (Shift+Enter in capable terminals)' },
     'help.key.backslash': { ru: '\\ + Enter                тоже новая строка', en: '\\ + Enter                also a new line' },
+    'help.key.attach': {
+        ru: 'Ctrl+Shift+V картинки      вставить изображение/файл (сохранится в tmp)',
+        en: 'Ctrl+Shift+V image         paste an image/file (saved to tmp)',
+    },
     'help.key.esc': { ru: 'Esc, Ctrl+C              прервать текущую генерацию', en: 'Esc, Ctrl+C               abort current generation' },
     'help.commands': { ru: 'Обычные команды:', en: 'Commands:' },
     'help.cmd.new': { ru: '/new, /clear             новый чат (сброс контекста)', en: '/new, /clear             new chat (reset context)' },
@@ -133,6 +137,22 @@ const CATALOG = {
     'msg.abort_gen': { ru: '⏹ Esc — прерываю генерацию...', en: '⏹ Esc — aborting generation...' },
     'msg.abort_ctrlc': { ru: '⏹ Ctrl+C — прерываю генерацию...', en: '⏹ Ctrl+C — aborting generation...' },
     'msg.queued': { ru: '📨 В очередь ({n}): ', en: '📨 Queued ({n}): ' },
+    'msg.attached_image': {
+        ru: '🖼 Вложено изображение {marker} ({size}) — сохранено в tmp',
+        en: '🖼 Attached image {marker} ({size}) — saved to tmp',
+    },
+    'msg.attached_file': {
+        ru: '📎 Вложен файл {marker} {name} ({size}) — сохранён в tmp',
+        en: '📎 Attached file {marker} {name} ({size}) — saved to tmp',
+    },
+    'msg.clip_empty': {
+        ru: '⚠ В буфере обмена нет картинки (проверено: {via}).',
+        en: '⚠ No image found in the clipboard (tried: {via}).',
+    },
+    'msg.clip_hint': {
+        ru: '   Установите утилиту клипборда: Linux/X11 — xclip или xsel, Wayland — wl-clipboard; Windows/macOS — работает из коробки. Либо вставьте путь к файлу.',
+        en: '   Install a clipboard tool: Linux/X11 — xclip or xsel, Wayland — wl-clipboard; Windows/macOS — works out of the box. Or paste a file path.',
+    },
     'msg.from_queue': { ru: '▶ Из очереди: ', en: '▶ From queue: ' },
     'msg.agent_error': { ru: '✖ Ошибка агента:', en: '✖ Agent error:' },
     'msg.suspicious_stop': {