zames_pro 2.23.0 → 2.25.0

package/dist/agent-loop.js

@@ -35,6 +35,16 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
     const safeToolResult = safe(onToolResult);
     const safeAssistantMessage = safe(onAssistantMessage);
     const safeWarning = safe(onWarning);
+    // One AbortController per task. A tool gets `toolAbort.signal`; the loop
+    // aborts it as soon as the operator presses Esc/Ctrl+C (browser._abort /
+    // _stopped). This is what actually kills a running `npm test` instead of
+    // just abandoning it.
+    const toolAbort = new AbortController();
+    const syncToolAbort = () => {
+        if ((browser._abort || browser._stopped) && !toolAbort.signal.aborted) {
+            toolAbort.abort();
+        }
+    };
     if (freshChat) {
         await browser.newChat();
         transcript?.log('new_chat');
@@ -546,21 +556,43 @@ export async function runAgentLoop({ browser, tools, task, workdir, maxIteration
                 results.push({ tool: call.tool, result: err });
                 continue;
             }
+            // The operator may have pressed Esc while we were parsing/among the
+            // previous calls — make sure the signal reflects it before we start.
+            syncToolAbort();
             safeToolCall(call.tool, call.args);
             transcript?.log('tool_call', { tool: call.tool, args: call.args });
             let result;
+            // While the tool runs, poll for an Esc/Ctrl+C: the abort flag is a plain
+            // boolean set by stopGeneration(), so the only way to turn it into a
+            // child-process kill is to check it periodically. 100ms is cheap and
+            // makes Esc feel immediate.
+            const poll = setInterval(syncToolAbort, 100);
+            if (typeof poll.unref === 'function')
+                poll.unref();
             try {
-                result = await tool.fn(call.args);
+                result = await tool.fn(call.args, { signal: toolAbort.signal });
             }
             catch (e) {
                 result = `Error: ${e.message}`;
             }
+            finally {
+                clearInterval(poll);
+            }
             safeToolResult(result);
             transcript?.log('tool_result', {
                 tool: call.tool,
                 result: String(result),
             });
             results.push({ tool: call.tool, result });
+            // The operator pressed Esc/Ctrl+C while the tool was running. The tool
+            // itself has finished (we cannot kill an arbitrary child process from
+            // here), but we must NOT feed its result back to the model and must NOT
+            // run the remaining calls in this batch — that would keep the agent
+            // going after an explicit stop.
+            if (browser._abort || browser._stopped) {
+                transcript?.log('user_aborted');
+                return '(прервано пользователем)';
+            }
         }
         // 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.

package/dist/browser.js

@@ -3,7 +3,6 @@ import { extractAnswer, extractTokenUsage, dumpNetBody } from './net-capture.js'
 import path from 'path';
 import os from 'os';
 import fs from 'fs/promises';
-import { execSync } from 'child_process';
 import { theme } from './theme.js';
 import { translate, DEFAULT_LOCALE } from './i18n.js';
 // Muted terminal input for passwords. We do NOT use readline here: readline
@@ -212,15 +211,6 @@ export class ServerBusyError extends Error {
     }
 }
 // ---------- profile cleanup ----------
-async function killStaleChrome() {
-    if (process.platform !== 'win32')
-        return;
-    try {
-        execSync(`powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"Name='chrome.exe'\\" | Where-Object { $_.CommandLine -like '*\\.zames\\profile*' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }"`, { stdio: 'ignore', timeout: 5000 });
-        await new Promise((r) => setTimeout(r, 800));
-    }
-    catch { }
-}
 async function cleanSingletonFiles() {
     const names = ['SingletonLock', 'SingletonCookie', 'SingletonSocket'];
     for (const name of names) {
@@ -361,7 +351,11 @@ export class DeepSeekBrowser {
         return translate(this.locale)(key, params);
     }
     async launch() {
-        await killStaleChrome();
+        // NOTE: we deliberately do NOT kill stray chrome processes here. Per the
+        // project rules, an agent must never kill a browser it did not start —
+        // another zames instance may be using the same profile. A locked profile
+        // is handled by removing the Singleton files (below) and, if it is still
+        // busy, by a clear error in _launchOnce().
         if (await profileLooksLocked()) {
             if (this.debug)
                 console.error('profile: удаляю Singleton-файлы');
@@ -418,7 +412,10 @@ export class DeepSeekBrowser {
             if (/Target page, context or browser has been closed|profile.*in use/i.test(e.message)) {
                 if (this.debug)
                     console.error('profile: занят, перезапускаю после очистки');
-                await killStaleChrome();
+                // Do NOT kill a foreign chrome (see AGENTS.md): only clear the
+                // Singleton files and retry. If the profile is genuinely in use by a
+                // live browser, nukeProfile() below fails safely and the error
+                // surfaces instead of silently killing someone else's session.
                 await cleanSingletonFiles();
                 try {
                     this.context = await chromium.launchPersistentContext(USER_DATA_DIR, options);
@@ -509,11 +506,11 @@ export class DeepSeekBrowser {
                 await this.context.close();
         }
         catch { }
-        // A restart must REUSE the existing profile. `launch()` would call
-        // killStaleChrome() and clean Singleton files, which can race with a
-        // sibling agent on the same profile; here we just relaunch the persistent
-        // context in place. A fresh window appears only because the old context was
-        // actually closed — no second window is created while one is alive.
+        // A restart must REUSE the existing profile. `launch()` would clean
+        // Singleton files, which can race with a sibling agent on the same
+        // profile; here we just relaunch the persistent context in place. A fresh
+        // window appears only because the old context was actually closed — no
+        // second window is created while one is alive.
         await this._launchOnce();
         await this._fixHeadlessUserAgent();
     }
@@ -2033,6 +2030,5 @@ export class DeepSeekBrowser {
                 await this.context.close();
         }
         catch { }
-        await killStaleChrome();
     }
 }

package/dist/index.js

@@ -871,6 +871,12 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     browser._stopped = false;
     browser._abort = false;
     const ui = editor || mod.createSpinner(currentLocale);
+    // Mark the editor busy for the WHOLE task, not only for /init and /self-fix.
+    // Esc / Ctrl+C abort the current generation only while busy; without this a
+    // long-running tool (Bash, npm, MCP) could not be interrupted — Esc did
+    // nothing. Cleared in the finally below.
+    if (editor)
+        editor.busy = true;
     const stopWatching = editor
         ? () => { }
         : watchInput({
@@ -971,6 +977,8 @@ async function runTask(browser, tools, taskText, workdir, opts, attachments = []
     finally {
         stopWatching();
         ui.stop();
+        if (editor)
+            editor.busy = false;
         // Detach the send hooks so a later browser.ask() outside this task cannot
         // start a stale spinner.
         browser.onSendStart = null;

package/dist/input.js

@@ -221,9 +221,9 @@ export function formatTokenStatus(tokens, limit = CONTEXT_LIMIT) {
     }
     const pct = Math.max(0, (n / limit) * 100);
     const pctStr = pct >= 10 ? String(Math.round(pct)) : pct.toFixed(1);
-    // "ctx" marks this as the USED context size, so the operator does not have
+    // "ctx:" marks this as the USED context size, so the operator does not have
     // to guess what "302k · 30%" means.
-    return 'ctx ' + compact + ' · ' + pctStr + '%';
+    return 'ctx: ' + compact + ' · ' + pctStr + '%';
 }
 export class LineEditor {
     promptStr;
@@ -242,6 +242,9 @@ export class LineEditor {
     // True while the dot-animation timer is running. Lets sendPause() update
     // only the base text (remaining seconds) without restarting the timer.
     _animating;
+    // Whether the animated status shows the trailing "Esc — стоп" hint. Off
+    // while a tool runs (its process cannot be cancelled).
+    _showHint;
     _dotPhase;
     _thinkBase;
     // The last rendered status row(s) (status + right-aligned context). Cached so
@@ -305,6 +308,7 @@ export class LineEditor {
         this._inPaste = false;
         this._dotTimer = null;
         this._animating = false;
+        this._showHint = true;
         this._dotPhase = 0;
         this._thinkBase = '';
         this._lastStatusBlock = '';
@@ -699,6 +703,8 @@ export class LineEditor {
     }
     // Status-line hint ("Esc — stop"), localized.
     _hint() {
+        if (!this._showHint)
+            return '';
         return theme.dim('  ·  ' + translate(this.locale)('spinner.hint'));
     }
     _startThinking() {
@@ -712,8 +718,13 @@ export class LineEditor {
     // Shared by the thinking spinner and the send-pause indicator, so the pause
     // is animated too (previously the pause was a static console line and the
     // dots stayed frozen).
-    _startAnimated(baseText) {
+    //
+    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
+    // TOOL runs we hide it: the tool's child process cannot be killed, so
+    // promising "Esc to stop" would be misleading.
+    _startAnimated(baseText, showHint = true) {
         this._thinkBase = theme.brown(stripEllipsis(baseText));
+        this._showHint = showHint;
         this._dotPhase = 0;
         this.setStatus(this._thinkBase + this._dots(0) + this._hint());
         this._stopDots();
@@ -764,7 +775,9 @@ export class LineEditor {
         // A tool may run for a long time (Bash, npm test, MCP). Without an active
         // animation the operator sees a frozen screen and cannot tell work is in
         // progress. Start the animated status AFTER printAbove (which stops the
-        // dots) and keep it running until toolResult()/assistant()/stop().
+        // dots) and keep it running until toolResult()/assistant()/stop(). Esc now
+        // really aborts the tool (the Bash child process is killed via the
+        // AbortSignal), so the "Esc — стоп" hint is shown.
         this._startAnimated(translate(this.locale)('spinner.running_tool', { name }));
     }
     toolResult(result) {

package/dist/spinner.js

@@ -52,12 +52,17 @@ export function createSpinner(locale = 'ru') {
     // "running" dot sequence. Shared by the thinking spinner and the send-pause
     // indicator, so the pause is animated too (before, it was a static line and
     // the dots did not move — the operator saw a frozen spinner).
-    const startAnimated = (baseText) => {
+    //
+    // `showHint` (default true) controls the trailing "· Esc — стоп". While a
+    // tool runs we hide it: its process cannot be cancelled, so promising a stop
+    // would be misleading.
+    const startAnimated = (baseText, showHint = true) => {
         animBase = theme.brown(stripEllipsis(baseText));
+        const hint = showHint ? HINT : '';
         // The dots are the same color as the base and of fixed width — otherwise
         // the hint on the right "jumps" when the animation phase changes.
         const dots = (n) => theme.brown(DOTS[n] + DOTS_PAD.slice(DOTS[n].length));
-        start(animBase + dots(0) + HINT);
+        start(animBase + dots(0) + hint);
         dotPhase = 0;
         if (dotTimer)
             clearInterval(dotTimer);
@@ -65,7 +70,7 @@ export function createSpinner(locale = 'ru') {
             if (!spinner)
                 return;
             dotPhase = (dotPhase + 1) % DOTS.length;
-            spinner.text = animBase + dots(dotPhase) + HINT;
+            spinner.text = animBase + dots(dotPhase) + hint;
         }, 400);
         animating = true;
         if (dotTimer.unref)

package/dist/tools.js

@@ -37,13 +37,16 @@ export function createTools(workdir, { undo } = {}) {
             }
         }
     };
-    const runShell = (command, timeout = 30_000) => new Promise((resolve) => {
+    const runShell = (command, timeout = 30_000, signal) => new Promise((resolve) => {
         const options = {
             cwd: workdir,
             timeout,
             maxBuffer: 1024 * 1024 * 8,
             windowsHide: true,
             env: { ...process.env },
+            // Abort the child process when the operator pressed Esc/Ctrl+C.
+            // Without it a long `npm test` kept running even after the stop.
+            signal,
         };
         if (process.platform === 'win32') {
             options.shell = process.env.ComSpec || 'C:\\Windows\\System32\\cmd.exe';
@@ -63,6 +66,9 @@ export function createTools(workdir, { undo } = {}) {
             if (err.killed) {
                 parts.push(`⏱ Timeout after ${timeout}ms — process killed.`);
             }
+            else if (err.code === 'ABORT_ERR') {
+                parts.push('(aborted by the operator)');
+            }
             else if (err.code !== undefined && err.code !== null) {
                 parts.push(`Exit code: ${err.code}`);
             }
@@ -195,9 +201,9 @@ export function createTools(workdir, { undo } = {}) {
                 'Do not use for commands that require interactive input. ' +
                 'For git use the Git* tools. For the web use WebFetch / WebSearch.',
             parameters: { command: 'string', timeout: 'number?' },
-            fn: async ({ command, timeout }) => {
+            fn: async ({ command, timeout }, ctx) => {
                 assertCommandInsideRoot(req(command, 'command'));
-                return runShell(req(command, 'command'), timeout);
+                return runShell(req(command, 'command'), timeout, ctx?.signal);
             },
         },
         {

package/package.json

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