zames_pro 2.72.1 → 2.72.3

package/CHANGELOG.md

@@ -7,6 +7,26 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.72.3] - 2026-10-09
+
+### Changed
+
+- **index:** extract the paste-aware terminal reader into src/prompt.ts
+
+### Changed
+
+- **index:** extract the paste-aware terminal reader into src/prompt.ts
+
+## [2.72.2] - 2026-10-09
+
+### Added
+
+- **self-smoke:** add --reuse-profile and a bounded, explicit login failure (exit 2)
+
+### Added
+
+- **self-smoke:** add --reuse-profile and a bounded, explicit login failure (exit 2)
+
 ## [2.72.1] - 2026-10-09
 
 ### Changed

package/dist/index.js

@@ -12,6 +12,7 @@ import { runAgentLoop } from './agent-loop.js';
 import { createSubagentRunner } from './subagent.js';
 import { createSpinner } from './spinner.js';
 import { LineEditor } from './input.js';
+import { promptOnce } from './prompt.js';
 import { parseImagePaste, extForMime, saveToTemp, guessMime, formatSize, readClipboardImageDetailed, sniffMime, readWindowsClipboardFiles, hasClipboardTool, writeClipboardText, contentHash, } 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';
@@ -567,208 +568,6 @@ async function cleanTmpDir() {
             console.error('tmp: cleanup failed:', e.message);
     }
 }
-// Terminal line input with correct paste handling (Shift+Insert,
-// Ctrl+Shift+V, right mouse button, etc.).
-//
-// Why a custom reader instead of readline:
-//   1) readline submits the line on the FIRST newline. When pasting
-//      multiline text this caused immediate submission and only the first
-//      line went to the chat. Here newlines inside a paste are replaced with
-//      spaces, and submission happens only on a single Enter press.
-//   2) We enable bracketed paste mode (\x1b[?2004h): the terminal wraps the
-//      pasted text in the markers \x1b[200~ … \x1b[201~, so we know for sure
-//      that this is a paste, not keyboard typing, and Enter inside it is not
-//      treated as submission.
-async function promptOnce(question) {
-    const stdin = process.stdin;
-    const stdout = process.stdout;
-    // Non-TTY (pipe, redirect): read everything up to EOF as a single string.
-    if (!stdin.isTTY || !stdin.setRawMode) {
-        const chunks = [];
-        return await new Promise((resolve) => {
-            const onData = (b) => chunks.push(b);
-            const onEnd = () => {
-                stdin.removeListener('data', onData);
-                stdin.removeListener('end', onEnd);
-                resolve(Buffer.concat(chunks).toString('utf-8'));
-            };
-            stdin.on('data', onData);
-            stdin.on('end', onEnd);
-            stdin.resume();
-        });
-    }
-    const wasRaw = stdin.isRaw;
-    stdin.setRawMode(true);
-    stdin.resume();
-    // We enable/disable bracketed paste in pairs.
-    stdout.write('\x1b[?2004h');
-    stdout.write(question);
-    let line = '';
-    let cursor = 0;
-    let inPaste = false;
-    const PASTE_START = '\x1b[200~';
-    const PASTE_END = '\x1b[201~';
-    const redraw = () => {
-        // Return to the start of the line, erase and print again.
-        stdout.write(String.fromCharCode(13));
-        stdout.write('\x1b[K');
-        stdout.write(question + line);
-        // Put the cursor in the right position.
-        const back = line.length - cursor;
-        if (back > 0)
-            stdout.write('\x1b[' + back + 'D');
-    };
-    return await new Promise((resolve) => {
-        const finish = (value, submit) => {
-            stdin.removeListener('data', onData);
-            stdout.write('\x1b[?2004l');
-            if (stdin.setRawMode)
-                stdin.setRawMode(wasRaw || false);
-            if (submit)
-                stdout.write(String.fromCharCode(10));
-            resolve(value);
-        };
-        const insertText = (text) => {
-            // Normalize newlines: they come from a multiline paste but mean
-            // "submit". Inside the message we replace them with a space so the
-            // whole paste goes as ONE message.
-            const clean = text
-                .replace(/\r\n/g, ' ')
-                .replace(/\r/g, ' ')
-                .replace(/\n/g, ' ');
-            line = line.slice(0, cursor) + clean + line.slice(cursor);
-            cursor += clean.length;
-        };
-        const onData = (buf) => {
-            let s = buf.toString('utf-8');
-            // Fallback for terminals without bracketed paste: if the whole chunk is
-            // a "bare" newline (one byte), then Enter was pressed → submit.
-            // If newlines came TOGETHER with other text in one chunk — that's a
-            // paste; such newlines don't submit the message but are replaced with
-            // spaces (see insertText).
-            if (!inPaste && (s === '\r' || s === '\n')) {
-                return finish(line, true);
-            }
-            while (s.length) {
-                if (inPaste) {
-                    const end = s.indexOf(PASTE_END);
-                    if (end === -1) {
-                        insertText(s);
-                        s = '';
-                    }
-                    else {
-                        insertText(s.slice(0, end));
-                        s = s.slice(end + PASTE_END.length);
-                        inPaste = false;
-                    }
-                    redraw();
-                    continue;
-                }
-                const start = s.indexOf(PASTE_START);
-                if (start !== -1) {
-                    // Everything before the marker is processed as regular input.
-                    const before = s.slice(0, start);
-                    s = s.slice(start + PASTE_START.length);
-                    inPaste = true;
-                    if (before) {
-                        for (const ch of before) {
-                            if (ch === '\r' || ch === '\n') {
-                                /* inside a paste — skip */
-                            }
-                            else
-                                insertText(ch);
-                        }
-                        redraw();
-                    }
-                    continue;
-                }
-                const ch = s[0];
-                const code = s.charCodeAt(0);
-                s = s.slice(1);
-                if (ch === '\r' || ch === '\n') {
-                    // A newline inside a chunk with other text (paste without
-                    // bracketed paste): don't submit, insert a space instead.
-                    insertText(' ');
-                    redraw();
-                    continue;
-                }
-                if (code === 3) {
-                    // Ctrl+C — abort input.
-                    return finish('', true);
-                }
-                if (code === 4) {
-                    // Ctrl+D — like submitting an empty line.
-                    return finish(line, true);
-                }
-                if (code === 21) {
-                    // Ctrl+U — erase the line.
-                    line = '';
-                    cursor = 0;
-                    redraw();
-                    continue;
-                }
-                if (code === 127 || code === 8) {
-                    // Backspace.
-                    if (cursor > 0) {
-                        line = line.slice(0, cursor - 1) + line.slice(cursor);
-                        cursor--;
-                        redraw();
-                    }
-                    continue;
-                }
-                if (ch === '\x1b') {
-                    // Escape sequences (arrows, Home/End, Delete…).
-                    const rest = s;
-                    if (rest.startsWith('[D')) {
-                        if (cursor > 0)
-                            cursor--;
-                        s = s.slice(2);
-                        redraw();
-                        continue;
-                    }
-                    if (rest.startsWith('[C')) {
-                        if (cursor < line.length)
-                            cursor++;
-                        s = s.slice(2);
-                        redraw();
-                        continue;
-                    }
-                    if (rest.startsWith('[H') || rest.startsWith('[1~')) {
-                        cursor = 0;
-                        s = s.slice(rest.startsWith('[1~') ? 3 : 2);
-                        redraw();
-                        continue;
-                    }
-                    if (rest.startsWith('[F') || rest.startsWith('[4~')) {
-                        cursor = line.length;
-                        s = s.slice(rest.startsWith('[4~') ? 3 : 2);
-                        redraw();
-                        continue;
-                    }
-                    if (rest.startsWith('[3~')) {
-                        // Delete.
-                        if (cursor < line.length) {
-                            line = line.slice(0, cursor) + line.slice(cursor + 1);
-                            redraw();
-                        }
-                        s = s.slice(3);
-                        continue;
-                    }
-                    // Other ESC sequences are skipped up to a letter/tilde.
-                    const m = s.match(/^\[[0-9;]*[A-Za-z~]/);
-                    if (m)
-                        s = s.slice(m[0].length);
-                    continue;
-                }
-                if (code < 32)
-                    continue; // other control characters are ignored
-                insertText(ch);
-                redraw();
-            }
-        };
-        stdin.on('data', onData);
-    });
-}
 // ---------- workdir resolution ----------
 // The agent works in the directory it was launched from (process.cwd()).
 // This is the sandbox root: tools cannot go above it.

package/dist/prompt.js

@@ -0,0 +1,202 @@
+// Terminal line input with correct paste handling (Shift+Insert,
+// Ctrl+Shift+V, right mouse button, etc.).
+//
+// Why a custom reader instead of readline:
+//   1) readline submits the line on the FIRST newline. When pasting
+//      multiline text this caused immediate submission and only the first
+//      line went to the chat. Here newlines inside a paste are replaced with
+//      spaces, and submission happens only on a single Enter press.
+//   2) We enable bracketed paste mode (\x1b[?2004h): the terminal wraps the
+//      pasted text in the markers \x1b[200~ … \x1b[201~, so we know for sure
+//      that this is a paste, not keyboard typing, and Enter inside it is not
+//      treated as submission.
+export async function promptOnce(question) {
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    // Non-TTY (pipe, redirect): read everything up to EOF as a single string.
+    if (!stdin.isTTY || !stdin.setRawMode) {
+        const chunks = [];
+        return await new Promise((resolve) => {
+            const onData = (b) => chunks.push(b);
+            const onEnd = () => {
+                stdin.removeListener('data', onData);
+                stdin.removeListener('end', onEnd);
+                resolve(Buffer.concat(chunks).toString('utf-8'));
+            };
+            stdin.on('data', onData);
+            stdin.on('end', onEnd);
+            stdin.resume();
+        });
+    }
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    // We enable/disable bracketed paste in pairs.
+    stdout.write('\x1b[?2004h');
+    stdout.write(question);
+    let line = '';
+    let cursor = 0;
+    let inPaste = false;
+    const PASTE_START = '\x1b[200~';
+    const PASTE_END = '\x1b[201~';
+    const redraw = () => {
+        // Return to the start of the line, erase and print again.
+        stdout.write(String.fromCharCode(13));
+        stdout.write('\x1b[K');
+        stdout.write(question + line);
+        // Put the cursor in the right position.
+        const back = line.length - cursor;
+        if (back > 0)
+            stdout.write('\x1b[' + back + 'D');
+    };
+    return await new Promise((resolve) => {
+        const finish = (value, submit) => {
+            stdin.removeListener('data', onData);
+            stdout.write('\x1b[?2004l');
+            if (stdin.setRawMode)
+                stdin.setRawMode(wasRaw || false);
+            if (submit)
+                stdout.write(String.fromCharCode(10));
+            resolve(value);
+        };
+        const insertText = (text) => {
+            // Normalize newlines: they come from a multiline paste but mean
+            // "submit". Inside the message we replace them with a space so the
+            // whole paste goes as ONE message.
+            const clean = text
+                .replace(/\r\n/g, ' ')
+                .replace(/\r/g, ' ')
+                .replace(/\n/g, ' ');
+            line = line.slice(0, cursor) + clean + line.slice(cursor);
+            cursor += clean.length;
+        };
+        const onData = (buf) => {
+            let s = buf.toString('utf-8');
+            // Fallback for terminals without bracketed paste: if the whole chunk is
+            // a "bare" newline (one byte), then Enter was pressed → submit.
+            // If newlines came TOGETHER with other text in one chunk — that's a
+            // paste; such newlines don't submit the message but are replaced with
+            // spaces (see insertText).
+            if (!inPaste && (s === '\r' || s === '\n')) {
+                return finish(line, true);
+            }
+            while (s.length) {
+                if (inPaste) {
+                    const end = s.indexOf(PASTE_END);
+                    if (end === -1) {
+                        insertText(s);
+                        s = '';
+                    }
+                    else {
+                        insertText(s.slice(0, end));
+                        s = s.slice(end + PASTE_END.length);
+                        inPaste = false;
+                    }
+                    redraw();
+                    continue;
+                }
+                const start = s.indexOf(PASTE_START);
+                if (start !== -1) {
+                    // Everything before the marker is processed as regular input.
+                    const before = s.slice(0, start);
+                    s = s.slice(start + PASTE_START.length);
+                    inPaste = true;
+                    if (before) {
+                        for (const ch of before) {
+                            if (ch === '\r' || ch === '\n') {
+                                /* inside a paste — skip */
+                            }
+                            else
+                                insertText(ch);
+                        }
+                        redraw();
+                    }
+                    continue;
+                }
+                const ch = s[0];
+                const code = s.charCodeAt(0);
+                s = s.slice(1);
+                if (ch === '\r' || ch === '\n') {
+                    // A newline inside a chunk with other text (paste without
+                    // bracketed paste): don't submit, insert a space instead.
+                    insertText(' ');
+                    redraw();
+                    continue;
+                }
+                if (code === 3) {
+                    // Ctrl+C — abort input.
+                    return finish('', true);
+                }
+                if (code === 4) {
+                    // Ctrl+D — like submitting an empty line.
+                    return finish(line, true);
+                }
+                if (code === 21) {
+                    // Ctrl+U — erase the line.
+                    line = '';
+                    cursor = 0;
+                    redraw();
+                    continue;
+                }
+                if (code === 127 || code === 8) {
+                    // Backspace.
+                    if (cursor > 0) {
+                        line = line.slice(0, cursor - 1) + line.slice(cursor);
+                        cursor--;
+                        redraw();
+                    }
+                    continue;
+                }
+                if (ch === '\x1b') {
+                    // Escape sequences (arrows, Home/End, Delete…).
+                    const rest = s;
+                    if (rest.startsWith('[D')) {
+                        if (cursor > 0)
+                            cursor--;
+                        s = s.slice(2);
+                        redraw();
+                        continue;
+                    }
+                    if (rest.startsWith('[C')) {
+                        if (cursor < line.length)
+                            cursor++;
+                        s = s.slice(2);
+                        redraw();
+                        continue;
+                    }
+                    if (rest.startsWith('[H') || rest.startsWith('[1~')) {
+                        cursor = 0;
+                        s = s.slice(rest.startsWith('[1~') ? 3 : 2);
+                        redraw();
+                        continue;
+                    }
+                    if (rest.startsWith('[F') || rest.startsWith('[4~')) {
+                        cursor = line.length;
+                        s = s.slice(rest.startsWith('[4~') ? 3 : 2);
+                        redraw();
+                        continue;
+                    }
+                    if (rest.startsWith('[3~')) {
+                        // Delete.
+                        if (cursor < line.length) {
+                            line = line.slice(0, cursor) + line.slice(cursor + 1);
+                            redraw();
+                        }
+                        s = s.slice(3);
+                        continue;
+                    }
+                    // Other ESC sequences are skipped up to a letter/tilde.
+                    const m = s.match(/^\[[0-9;]*[A-Za-z~]/);
+                    if (m)
+                        s = s.slice(m[0].length);
+                    continue;
+                }
+                if (code < 32)
+                    continue; // other control characters are ignored
+                insertText(ch);
+                redraw();
+            }
+        };
+        stdin.on('data', onData);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zames_pro",
-  "version": "2.72.1",
+  "version": "2.72.3",
   "description": "Terminal coding agent that drives chat.deepseek.com through Playwright — no API key required. Reads and edits files, runs commands, commits to git, like Claude Code / Codex CLI.",
   "type": "module",
   "bin": {

package/scripts/self-smoke.mts

@@ -7,18 +7,35 @@
 // config.json (so auto-login works) and symlinks the Playwright browser cache.
 // Nothing in the operator's profile is written.
 //
-// Usage:  npm run self-smoke            (headless)
+// Usage:  npm run self-smoke                     (headless, empty profile)
 //         npm run self-smoke -- --headed
-// Exit code 0 = all scenarios passed.
+//         npm run self-smoke -- --reuse-profile   (logged-in profile, see below)
+// Exit code 0 = all scenarios passed; 2 = login failed (could not start).
+//
+// --reuse-profile: copy the REAL profile (~/.zames/profile) read-only into the
+// throwaway HOME so the browser starts ALREADY SIGNED IN. Reason: DeepSeek's
+// anti-bot increasingly blocks a COLD login on a fresh profile (captcha / rate
+// limit), so a smoke that logs in from scratch fails for reasons unrelated to
+// the agent. Copying (never opening the live profile) keeps isolation intact.
 
 import fs from 'fs'
 import path from 'path'
 import os from 'os'
 
+// --- flags -----------------------------------------------------------------
 const HEADED = process.argv.includes('--headed')
+const REUSE_PROFILE =
+  process.argv.includes('--reuse-profile') ||
+  process.env.ZAMES_SMOKE_REUSE_PROFILE === '1'
+// Optional explicit source profile (default: the real ~/.zames/profile).
+const profileArgIdx = process.argv.indexOf('--profile')
+const REAL_HOME = os.homedir()
+const PROFILE_SRC =
+  profileArgIdx >= 0 && process.argv[profileArgIdx + 1]
+    ? path.resolve(process.argv[profileArgIdx + 1])
+    : path.join(REAL_HOME, '.zames', 'profile')
 
 // --- isolate HOME before importing project modules -------------------------
-const REAL_HOME = os.homedir()
 if (!process.env.ZAMES_SMOKE_HOME) {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'zames-smoke-'))
   process.env.HOME = tmp
@@ -35,6 +52,16 @@ if (!process.env.ZAMES_SMOKE_HOME) {
   if (fs.existsSync(realPw)) {
     fs.symlinkSync(realPw, path.join(tmp, '.cache', 'ms-playwright'))
   }
+  // Reuse a logged-in profile: COPY it (the live one is never opened) and drop
+  // the Singleton* files — Chrome refuses to start on a profile whose lock is
+  // present, and the live browser may hold it. The cookies survive the copy
+  // because Playwright launches with --password-store=basic.
+  if (REUSE_PROFILE && fs.existsSync(PROFILE_SRC)) {
+    fs.cpSync(PROFILE_SRC, path.join(tmp, '.zames', 'profile'), {
+      recursive: true,
+      filter: (src) => !/^Singleton/.test(path.basename(src)),
+    })
+  }
 }
 const SMOKE_HOME = process.env.ZAMES_SMOKE_HOME
 const WORK = path.join(SMOKE_HOME, 'work')
@@ -54,6 +81,9 @@ interface SmokeResult {
   note?: string
 }
 const results: SmokeResult[] = []
+// Set when we could not even start (login failed): exit code 2, distinct from a
+// scenario failure (1).
+let loginFailed = false
 const record = (name: string, ok: boolean, note?: string): void => {
   results.push({ name, ok, note })
   console.log((ok ? 'PASS ' : 'FAIL ') + name + (note ? '  — ' + note : ''))
@@ -76,9 +106,33 @@ const browser = new DeepSeekBrowser({
 })
 
 async function main() {
-  console.log('self-smoke: HOME=' + SMOKE_HOME + ' headed=' + HEADED)
+  console.log(
+    'self-smoke: HOME=' +
+      SMOKE_HOME +
+      ' headed=' +
+      HEADED +
+      ' reuse-profile=' +
+      REUSE_PROFILE,
+  )
   await browser.launch()
-  await browser.waitForLogin()
+  // waitForLogin() can block on a manual Enter in a pipe. Bound it so a cold
+  // login (anti-bot / captcha) fails fast with a clear hint instead of hanging
+  // until the caller's tool timeout. On failure exit code 2 signals "could not
+  // even start" — distinct from a scenario failure.
+  const loggedIn = await Promise.race([
+    browser.waitForLogin().then(() => true),
+    new Promise<boolean>((r) => setTimeout(() => r(false), 120_000)),
+  ])
+  if (!loggedIn) {
+    console.error(
+      '\nself-smoke: LOGIN FAILED — a cold login on a fresh profile is often\n' +
+        'blocked by DeepSeek anti-bot/captcha. Re-run against a signed-in profile:\n' +
+        '  npm run self-smoke -- --reuse-profile\n' +
+        '(or sign in once with: npm run self-smoke -- --headed).',
+    )
+    loginFailed = true
+    return
+  }
   record('login', true, 'DeepSeek session is active')
 
   const tools = createTools(WORK, {})
@@ -252,4 +306,4 @@ if (!process.env.ZAMES_SMOKE_KEEP) {
     fs.rmSync(SMOKE_HOME, { recursive: true, force: true })
   } catch {}
 }
-process.exit(anyFail ? 1 : 0)
+process.exit(loginFailed ? 2 : anyFail ? 1 : 0)