zames_pro 2.8.0 → 2.9.1

package/dist/agent-loop.js

@@ -80,6 +80,14 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     // chatty model.
     let looksDoneRetries = 0;
     const MAX_LOOKSDONE_RETRIES = 3;
+    // Watchdog against the agent emitting a tool call and then going silent.
+    // After a tool result the expected next answer is a fresh tool call; if we
+    // instead get an EMPTY answer or the EXACT same answer as the previous turn
+    // (a sign the new message was not sent), we nudge instead of stopping.
+    let lastRaw = '';
+    let justRanTool = false;
+    let watchdogRetries = 0;
+    const MAX_WATCHDOG_RETRIES = 3;
     for (let i = 0; i < maxIterations; i++) {
         onThinking();
         // The first message (task) is user input: no throttle.
@@ -97,6 +105,23 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             transcript?.log('user_aborted');
             return rawResponse;
         }
+        // Watchdog: after a tool result we expect a FRESH tool call. If the answer
+        // is empty or identical to the previous turn (the new message was not
+        // sent), nudge instead of stopping.
+        const wdEmpty = !String(rawResponse || '').trim();
+        const wdStale = justRanTool && lastRaw.trim() !== '' && rawResponse.trim() === lastRaw.trim();
+        if (!isFirst && (wdEmpty || wdStale) && watchdogRetries < MAX_WATCHDOG_RETRIES) {
+            watchdogRetries++;
+            transcript?.log('watchdog_nudge', {
+                attempt: watchdogRetries,
+                empty: wdEmpty,
+                stale: wdStale,
+                response: String(rawResponse || '').slice(0, 200),
+            });
+            await new Promise((r) => setTimeout(r, 1500));
+            continue;
+        }
+        lastRaw = rawResponse;
         const parsed = parseToolCall(rawResponse);
         if (parsed) {
             const thought = extractPreToolText(rawResponse);
@@ -259,6 +284,10 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
             });
             results.push({ tool: call.tool, result });
         }
+        // A tool just ran — the next answer is expected to be a fresh tool call.
+        // Reset the watchdog so the next empty/repeated answer is nudged.
+        justRanTool = true;
+        watchdogRetries = 0;
         if (results.length === 1) {
             const r = results[0];
             const resultStr = typeof r.result === 'string' ? r.result : JSON.stringify(r.result);

package/dist/attachments.js

@@ -1,5 +1,6 @@
 import fs from 'fs/promises';
 import path from 'path';
+import os from 'os';
 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;
@@ -185,11 +186,42 @@ export async function saveToTemp(tmpDir, name, data) {
 // 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() {
+// True when running inside WSL. There the X11 clipboard is a SEPARATE
+// clipboard from the Windows one: the user copies an image in Windows, so we
+// must read it through powershell.exe, not xclip.
+export function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    if (process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP)
+        return true;
+    try {
+        const rel = os.release().toLowerCase();
+        if (rel.includes('microsoft') || rel.includes('wsl'))
+            return true;
+    }
+    catch { }
+    return false;
+}
+// PowerShell image grabber, embedded as a UTF-16LE base64 script and run
+// via powershell.exe -EncodedCommand: it saves the clipboard image to a
+// Windows temp .png and prints the Windows path; we read it from WSL.
+const PS_IMAGE_ENCODED = 'QQBkAGQALQBUAHkAcABlACAALQBBAHMAcwBlAG0AYgBsAHkATgBhAG0AZQAgAFMAeQBzAHQAZQBtAC4AVwBpAG4AZABvAHcAcwAuAEYAbwByAG0AcwAsAFMAeQBzAHQAZQBtAC4ARAByAGEAdwBpAG4AZwAKACQAaQBtAGcAPQBbAFMAeQBzAHQAZQBtAC4AVwBpAG4AZABvAHcAcwAuAEYAbwByAG0AcwAuAEMAbABpAHAAYgBvAGEAcgBkAF0AOgA6AEcAZQB0AEkAbQBhAGcAZQAoACkACgBpAGYAKAAkAGkAbQBnACkAewAkAHAAPQBKAG8AaQBuAC0AUABhAHQAaAAgACQAZQBuAHYAOgBUAEUATQBQACAAKAAiAHoAYQBtAGUAcwAtAGMAbABpAHAALQAiACsAWwBHAHUAaQBkAF0AOgA6AE4AZQB3AEcAdQBpAGQAKAApAC4AVABvAFMAdAByAGkAbgBnACgAKQArACIALgBwAG4AZwAiACkAOwAkAGkAbQBnAC4AUwBhAHYAZQAoACQAcAAsAFsAUwB5AHMAdABlAG0ALgBEAHIAYQB3AGkAbgBnAC4ASQBtAGEAZwBpAG4AZwAuAEkAbQBhAGcAZQBGAG8AcgBtAGEAdABdADoAOgBQAG4AZwApADsAVwByAGkAdABlAC0ATwB1AHQAcAB1AHQAIAAkAHAAfQAKAA==';
+// PowerShell one-liner: write the clipboard file paths (CF_HDROP) to stdout.
+const PS_GET_FILE_DROP = 'Add-Type -AssemblyName System.Windows.Forms; ' +
+    '$d=[System.Windows.Forms.Clipboard]::GetDataObject(); ' +
+    'if($d -and $d.GetDataPresent([System.Windows.Forms.DataFormats]::FileDrop)){' +
+    '$f=$d.GetData([System.Windows.Forms.DataFormats]::FileDrop); $f -join [Environment]::NewLine}';
+export async 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 = [];
+        // On WSL the Windows clipboard is what the user copies into — read it first.
+        if (isWsl()) {
+            const win = await readWindowsClipboardImage();
+            if (win)
+                return { data: win, via: 'powershell.exe' };
+        }
         if (wayland || !x11)
             attempts.push({ bin: 'wl-paste', args: ['--type', 'image/png', '--no-newline'], via: 'wl-paste' });
         if (x11 || !wayland) {
@@ -229,8 +261,8 @@ export function readClipboardImageDetailed() {
     return { data: null, via: 'unsupported-platform' };
 }
 // Backwards-compatible wrapper used elsewhere.
-export function readClipboardImage() {
-    return readClipboardImageDetailed().data;
+export async function readClipboardImage() {
+    return (await readClipboardImageDetailed()).data;
 }
 function tryCommand(bin, args) {
     try {
@@ -265,3 +297,56 @@ export async function findFileByName(workdir, name) {
     catch { }
     return null;
 }
+// Read file paths from the Windows clipboard (copied files, CF_HDROP) and
+// translate them to WSL paths. On WSL the user often copies a FILE, not an
+// image. Returns [] on non-WSL / when nothing is there.
+export function readWindowsClipboardFiles() {
+    if (!isWsl())
+        return [];
+    const out = tryCommand('powershell.exe', ['-STA', '-NoProfile', '-NonInteractive', '-Command', PS_GET_FILE_DROP]);
+    if (!out)
+        return [];
+    const text = out.toString('utf-8');
+    return text
+        .split(/\r?\n/)
+        .map((s) => s.trim())
+        .filter(Boolean)
+        .map(winPathToWsl)
+        .filter((p) => !!p);
+}
+// Convert a Windows path (C:\\Users\\me\\a.png) into a WSL path
+// (/mnt/c/Users/me/a.png). Leaves already-POSIX paths untouched.
+export function winPathToWsl(winPath) {
+    let p = String(winPath || '').trim();
+    if (p.startsWith('"') && p.endsWith('"'))
+        p = p.slice(1, -1);
+    if (!p)
+        return null;
+    if (p.startsWith('/'))
+        return p;
+    if (p.charAt(1) !== ':' || (p.charAt(2) !== '/' && p.charAt(2) !== '\\'))
+        return null;
+    const drive = p.charAt(0).toLowerCase();
+    const rest = p.slice(3).split('\\').join('/');
+    return '/mnt/' + drive + '/' + rest;
+}
+// Run the embedded PowerShell script and return the clipboard image bytes.
+export async function readWindowsClipboardImage() {
+    if (!isWsl())
+        return null;
+    const out = tryCommand('powershell.exe', ['-STA', '-NoProfile', '-NonInteractive', '-EncodedCommand', PS_IMAGE_ENCODED]);
+    if (!out)
+        return null;
+    const first = out.toString('utf-8').trim().split(String.fromCharCode(10))[0].trim();
+    if (!first)
+        return null;
+    const wslPath = winPathToWsl(first);
+    if (!wslPath)
+        return null;
+    try {
+        return await fs.readFile(wslPath);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/index.js

@@ -8,7 +8,7 @@ import { createTools } from './tools.js';
 import { runAgentLoop } from './agent-loop.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor, expandPastes, pasteReplacement } from './input.js';
-import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, } from './attachments.js';
+import { parseImagePaste, extForMime, saveToTemp, guessMime, isImageName, formatSize, looksLikeFilePath, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, } from './attachments.js';
 import { loadConfig, DEFAULTS, CONFIG_PATHS, ZAMES_HOME, CONFIG_SCHEMA, getByPath, validateConfigValue, writeConfigValue, resetConfigValue, } from './config.js';
 import { runConfigMenu } from './config-menu.js';
 import { translate, normalizeLocale, localeDisplayName, isLocale, } from './i18n.js';
@@ -995,8 +995,28 @@ async function main() {
             return att;
         };
         ed.onClipboard = async () => {
-            const res = readClipboardImageDetailed();
+            const res = await readClipboardImageDetailed();
             if (!res.data || !res.data.length) {
+                // On WSL the user may have copied a FILE in Windows (not an image):
+                // the Windows clipboard holds its path - attach it directly.
+                for (const fp of readWindowsClipboardFiles()) {
+                    const data = await fs.readFile(fp).catch(() => null);
+                    if (!data)
+                        continue;
+                    const nm = path.basename(fp);
+                    const att = ed.attachments.add({
+                        path: fp,
+                        name: nm,
+                        mime: guessMime(nm),
+                        size: data.length,
+                    });
+                    ed.printAbove(theme.system(t('msg.attached_file', {
+                        marker: att.marker,
+                        name: nm,
+                        size: formatSize(data.length),
+                    }) + theme.dim(' (windows-clipboard)')));
+                    return att;
+                }
                 if (!clipboardWarned) {
                     clipboardWarned = true;
                     ed.printAbove(theme.warn(t('msg.clip_empty', { via: res.via }) +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.8.0",
+  "version": "2.9.1",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {