zames_pro 2.24.0 → 2.26.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,15 +556,28 @@ 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,

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) {
@@ -290,6 +280,10 @@ export class DeepSeekBrowser {
     // completion stream and from /api/v0/chat/history_messages. Null until the
     // first answer (or history fetch) delivers it. Shown by /cost and /status.
     _lastTokenUsage;
+    // Last known DeepSeek toggle states (deep thinking / web search), kept in
+    // sync by _applyToggles()/getToggleStates(). Exposed synchronously so the
+    // editor can draw the toggle icons on every render without awaiting.
+    _toggles;
     // Authorization / PoW headers sniffed from DeepSeek's own API requests, so
     // fetchChatMessages can replay them (a bare fetch does not get them).
     _apiAuth;
@@ -342,6 +336,7 @@ export class DeepSeekBrowser {
         this._netCaptureAt = 0;
         this._netChatId = null;
         this._lastTokenUsage = null;
+        this._toggles = { deepThinking, webSearch };
         this._apiAuth = '';
         this._apiPow = '';
         this._lastHistoryError = '';
@@ -361,7 +356,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 +417,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 +511,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();
     }
@@ -1042,6 +1044,37 @@ export class DeepSeekBrowser {
     async _applyToggles() {
         await this._setToggle(/глубок|deep\s*think/i, this.deepThinking);
         await this._setToggle(/поиск|search/i, this.webSearch);
+        this._toggles = await this.getToggleStates();
+    }
+    // Synchronous snapshot of the last known toggle states, for the editor's
+    // status icons (called on every render, must not await).
+    getToggleStatesSync() {
+        return this._toggles;
+    }
+    // The CURRENT state of the two DeepSeek toggles, read from the DOM
+    // (aria-pressed) so the status line reflects what is actually on, not what
+    // the config asked for. Falls back to the configured values when the buttons
+    // are not found.
+    async getToggleStates() {
+        const read = async (labelRe, fallback) => {
+            try {
+                const btns = this.page.locator('.ds-toggle-button');
+                const count = await btns.count().catch(() => 0);
+                for (let i = 0; i < count; i++) {
+                    const b = btns.nth(i);
+                    const txt = ((await b.textContent().catch(() => '')) || '').trim();
+                    if (!labelRe.test(txt))
+                        continue;
+                    return ((await b.getAttribute('aria-pressed').catch(() => null)) === 'true');
+                }
+            }
+            catch { }
+            return fallback;
+        };
+        return {
+            deepThinking: await read(/глубок|deep\s*think/i, this.deepThinking),
+            webSearch: await read(/поиск|search/i, this.webSearch),
+        };
     }
     async stopGeneration() {
         this._abort = true;
@@ -2033,6 +2066,5 @@ export class DeepSeekBrowser {
                 await this.context.close();
         }
         catch { }
-        await killStaleChrome();
     }
 }

package/dist/index.js

@@ -1219,6 +1219,9 @@ async function main() {
         // The editor pulls the number on every render, so it follows the live
         // DeepSeek counter (accumulated_token_usage) without a polling timer.
         ed.onContextQuery = () => browser.getLastTokenUsage();
+        // Toggle icons (🧠 deep thinking, 🌐 web search) before the context
+        // counter. The editor pulls the live state on every render.
+        ed.onToggleQuery = () => browser.getToggleStatesSync();
         ed.onAttach = async (raw) => {
             // Case 1: the paste is the image data itself (data URL / base64 blob).
             const image = parseImagePaste(raw);

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
@@ -286,6 +289,14 @@ export class LineEditor {
     contextStatus;
     // The raw token count behind contextStatus (for the color level).
     contextTokens;
+    // Whether the DeepSeek "Deep thinking" / "Smart search" toggles are ON.
+    // Shown as two colored icons before the context counter: a dim gray icon
+    // means off, a teal-green icon means on.
+    thinkingEnabled;
+    searchEnabled;
+    // A callback the editor calls to fetch the CURRENT toggle states before
+    // every render, so the icons follow the live chat state.
+    onToggleQuery;
     // A callback the editor calls to fetch the CURRENT token count before every
     // status render, so the status line stays fresh without the caller polling.
     onContextQuery;
@@ -305,6 +316,7 @@ export class LineEditor {
         this._inPaste = false;
         this._dotTimer = null;
         this._animating = false;
+        this._showHint = true;
         this._dotPhase = 0;
         this._thinkBase = '';
         this._lastStatusBlock = '';
@@ -324,8 +336,27 @@ export class LineEditor {
         this.locked = false;
         this.contextStatus = null;
         this.contextTokens = null;
+        this.thinkingEnabled = false;
+        this.searchEnabled = false;
+        this.onToggleQuery = null;
         this.onContextQuery = null;
     }
+    // Refresh the toggle icon states from onToggleQuery (if wired) before a
+    // render. A broken callback must never break the render.
+    _refreshToggles() {
+        if (!this.onToggleQuery)
+            return;
+        try {
+            const s = this.onToggleQuery();
+            if (s) {
+                this.thinkingEnabled = !!s.deepThinking;
+                this.searchEnabled = !!s.webSearch;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
     // The token status for the CURRENT render: refreshed from onContextQuery
     // when wired, otherwise the last value passed to setContextStatus().
     _contextForRender() {
@@ -355,6 +386,16 @@ export class LineEditor {
             return theme.warn(ctx);
         return theme.success(ctx);
     }
+    // Two colored icons for the DeepSeek toggles: 🧠 "Deep thinking" and 🌐 "Smart
+    // search". A dim gray icon = off, a teal-green icon = on. Placed just before
+    // the context counter, so the operator sees the live chat state at a glance.
+    _toggleIcons() {
+        const on = (s) => theme.toggleOn(s);
+        const off = (s) => theme.toggleOff(s);
+        const brain = this.thinkingEnabled ? on('🧠') : off('🧠');
+        const globe = this.searchEnabled ? on('🌐') : off('🌐');
+        return brain + ' ' + globe + ' ';
+    }
     // Read the OS clipboard for an image and insert its marker. Used when the
     // terminal sends no usable paste data (Ctrl+V / right-click / empty paste).
     async _tryClipboard() {
@@ -541,7 +582,12 @@ export class LineEditor {
         // though it PRINTS `status + ' '.repeat(space) + ctxText` with a DIFFERENT
         // total width, so at certain widths `top` disagreed with the printed rows.
         // Both branches below now derive `top` from the exact string they print.
-        const ctxText = this._contextText();
+        // Toggle icons (always shown) + the context counter (when known). The
+        // icons reflect the live DeepSeek toggles; a fresh chat has no token count
+        // but the icons are still meaningful.
+        const ctxRaw = this._contextText();
+        this._refreshToggles();
+        const ctxText = this._toggleIcons() + ctxRaw;
         let statusOut = '';
         let top = 0;
         // Never fill a row to the FULL terminal width: on terminals with
@@ -699,6 +745,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 +760,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 +817,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/theme.js

@@ -27,6 +27,8 @@ export const theme = {
     error: chalk.hex('#c98a80'), // muted terracotta
     success: chalk.hex('#a9c08c'), // soft sage
     brown: chalk.hex('#a1723f'), // brown (status/spinner)
+    toggleOn: chalk.hex('#6fd0b0'), // teal-green — a toggle is ON
+    toggleOff: chalk.hex('#4a4f5a'), // dim gray — a toggle is OFF
     bold: chalk.bold,
 };
 export default theme;

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.24.0",
+  "version": "2.26.0",
   "description": "Terminal coding agent over chat.deepseek.com via Playwright",
   "type": "module",
   "bin": {