newmark-agent 0.3.10 → 0.3.11

package/dist/main.js

@@ -73,6 +73,7 @@ const runtimeShutdown_1 = require("./core/runtimeShutdown");
 const runtimeLifecycle_1 = require("./core/runtimeLifecycle");
 const compat_1 = require("./core/compat");
 const mcpManager_1 = require("./core/mcpManager");
+const cli_help_1 = require("./cli-help");
 const APP_NAME = 'Newmark Agent';
 const APP_ID = 'ai.newmark.agent';
 const CONFIG_RELOAD_RUNTIME_TIMEOUT_MS = 6_000;
@@ -116,7 +117,27 @@ let _forceQuit = false;
 let forcedExitTimer = null;
 let electronBrowserUseHost = null;
 let browserUseEngine = null;
+// A single renderer can host several hidden conversation-bound guests. The
+// legacy host map is retained for focused-window discovery, while this map is
+// the authoritative Browser-Use/right-sidebar binding.
 const browserGuestContentsByHost = new Map();
+const browserGuestBindingsByRuntime = new Map();
+function browserGuestRuntimeKey(target) {
+    return (0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey;
+}
+function browserGuestBindingFor(runtimeKey) {
+    const binding = browserGuestBindingsByRuntime.get(String(runtimeKey || ''));
+    if (!binding)
+        return null;
+    const guest = electron_1.webContents.fromId(binding.guestId);
+    if (!guest || guest.isDestroyed() || guest.getType() !== 'webview' || guest.hostWebContents?.id !== binding.hostId) {
+        browserGuestBindingsByRuntime.delete(String(runtimeKey || ''));
+        if (browserGuestContentsByHost.get(binding.hostId) === binding.guestId)
+            browserGuestContentsByHost.delete(binding.hostId);
+        return null;
+    }
+    return binding;
+}
 let workspaceSwitchGeneration = 0;
 let workspaceSelectionCoordinator = null;
 function defaultTerminalShell() {
@@ -737,7 +758,15 @@ async function waitForWebContentsLoad(contents, timeoutMs = 15000) {
         contents.once('did-fail-load', finish);
     });
 }
-function registeredBrowserGuest(hostContentsId) {
+function registeredBrowserGuest(hostContentsId, runtimeKey) {
+    if (runtimeKey) {
+        const binding = browserGuestBindingFor(runtimeKey);
+        if (binding && (!hostContentsId || binding.hostId === hostContentsId)) {
+            const guest = electron_1.webContents.fromId(binding.guestId);
+            if (guest && !guest.isDestroyed())
+                return guest;
+        }
+    }
     const hostIds = hostContentsId
         ? [hostContentsId]
         : [
@@ -752,8 +781,14 @@ function registeredBrowserGuest(hostContentsId) {
         if (!guestId)
             continue;
         const guest = electron_1.webContents.fromId(guestId);
-        if (guest && !guest.isDestroyed() && guest.getType() === 'webview' && guest.hostWebContents?.id === hostId)
+        if (guest && !guest.isDestroyed() && guest.getType() === 'webview' && guest.hostWebContents?.id === hostId) {
+            if (runtimeKey) {
+                const bound = browserGuestBindingsByRuntime.get(runtimeKey);
+                if (!bound || bound.hostId !== hostId || bound.guestId !== guest.id)
+                    continue;
+            }
             return guest;
+        }
         browserGuestContentsByHost.delete(hostId);
     }
     return null;
@@ -774,37 +809,64 @@ async function boundedOperation(operation, timeoutMs, label) {
             clearTimeout(timer);
     }
 }
-function registerBrowserGuest(host, guest) {
+function registerBrowserGuest(host, guest, requestedTarget) {
     if (host.isDestroyed() || guest.isDestroyed() || guest.getType() !== 'webview' || guest.hostWebContents?.id !== host.id)
         return false;
+    let target;
+    try {
+        target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
+    }
+    catch {
+        return false;
+    }
+    const prior = browserGuestBindingsByRuntime.get(target.runtimeKey);
+    if (prior && prior.guestId !== guest.id) {
+        const priorGuest = electron_1.webContents.fromId(prior.guestId);
+        if (priorGuest && !priorGuest.isDestroyed())
+            priorGuest.hostWebContents?.send('browser:guestVisibility', { runtimeKey: target.runtimeKey, visible: false });
+    }
+    browserGuestBindingsByRuntime.set(target.runtimeKey, {
+        hostId: host.id,
+        guestId: guest.id,
+        workspaceId: target.workspaceId,
+        conversationId: target.conversationId,
+    });
     browserGuestContentsByHost.set(host.id, guest.id);
     guest.once('destroyed', () => {
         if (browserGuestContentsByHost.get(host.id) === guest.id)
             browserGuestContentsByHost.delete(host.id);
+        const binding = browserGuestBindingsByRuntime.get(target.runtimeKey);
+        if (binding?.guestId === guest.id)
+            browserGuestBindingsByRuntime.delete(target.runtimeKey);
     });
     ensureElectronBrowserUseHost().attach(guest);
     return true;
 }
-async function waitForRegisteredBrowserGuest(host, timeoutMs = 12_000) {
+async function waitForRegisteredBrowserGuest(host, runtimeKey, timeoutMs = 12_000) {
     const deadline = Date.now() + Math.max(250, timeoutMs);
     while (!host.isDestroyed() && Date.now() < deadline) {
-        const guest = registeredBrowserGuest(host.id);
+        const guest = registeredBrowserGuest(host.id, runtimeKey);
         if (guest)
             return guest;
         await new Promise(resolve => setTimeout(resolve, 25));
     }
     throw new Error('Built-in Browser guest did not become ready before the Browser-Use timeout');
 }
-async function ensureBrowserWebContents(boundContentsId) {
+async function ensureBrowserWebContents(boundContentsId, runtimeKey) {
     if (boundContentsId) {
         const bound = electron_1.webContents.fromId(boundContentsId);
         if (bound && !bound.isDestroyed() && bound.getType() === 'webview'
             && browserGuestContentsByHost.get(bound.hostWebContents?.id || 0) === bound.id) {
+            if (runtimeKey) {
+                const binding = browserGuestBindingsByRuntime.get(runtimeKey);
+                if (!binding || binding.guestId !== bound.id)
+                    return await ensureBrowserWebContents(undefined, runtimeKey);
+            }
             bound.hostWebContents?.send('browser:ensureGuest');
             return bound;
         }
     }
-    const registered = registeredBrowserGuest();
+    const registered = registeredBrowserGuest(undefined, runtimeKey);
     if (registered) {
         registered.hostWebContents?.send('browser:ensureGuest');
         return registered;
@@ -814,13 +876,13 @@ async function ensureBrowserWebContents(boundContentsId) {
     const host = hostWindow?.webContents;
     if (!host || host.isDestroyed())
         throw new Error('Built-in Browser UI is unavailable');
-    host.send('browser:ensureGuest');
-    return await waitForRegisteredBrowserGuest(host);
+    host.send('browser:ensureGuest', runtimeKey ? { runtimeKey } : undefined);
+    return await waitForRegisteredBrowserGuest(host, runtimeKey, 12_000);
 }
 function ensureElectronBrowserUseHost() {
     if (!electronBrowserUseHost) {
         electronBrowserUseHost = new electronBrowserUseHost_1.ElectronBrowserUseHost({
-            resolveContents: async (_scope, boundContentsId) => await ensureBrowserWebContents(boundContentsId),
+            resolveContents: async (scope, boundContentsId) => await ensureBrowserWebContents(boundContentsId, scope.runtimeKey),
             openExternal: async (url) => { await electron_1.shell.openExternal(url); },
         });
     }
@@ -833,10 +895,18 @@ function ensureBrowserUseEngine() {
     }
     return browserUseEngine;
 }
-function currentBrowserUseContext() {
-    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget());
+function currentBrowserUseContext(requestedTarget) {
+    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
     return { runtimeKey: target.runtimeKey, actorId: agent?.runtimeActorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID };
 }
+function browserControlTargetInput(input) {
+    if (!input)
+        return undefined;
+    return {
+        workspaceId: String(input.workspaceId || ''),
+        conversationId: String(input.conversationId || 'default'),
+    };
+}
 async function runBoundBrowserUse(input, context, signal) {
     return await ensureBrowserUseEngine().run((0, browserUse_1.bindBrowserUseRequest)(input, context), signal);
 }
@@ -856,8 +926,10 @@ function browserSnapshotScript(maxChars) {
 }
 async function runBrowserControl(request) {
     const action = request.action;
+    const requestedTarget = browserControlTargetInput(request.target);
+    const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(requestedTarget));
     if (action === 'use') {
-        const receipt = await runBoundBrowserUse(request.browserUse, currentBrowserUseContext());
+        const receipt = await runBoundBrowserUse(request.browserUse, currentBrowserUseContext(requestedTarget));
         return {
             ok: receipt.ok,
             action,
@@ -868,7 +940,7 @@ async function runBrowserControl(request) {
             error: receipt.error,
         };
     }
-    const contents = await ensureBrowserWebContents();
+    const contents = await ensureBrowserWebContents(undefined, target.runtimeKey);
     try {
         if (action === 'open') {
             await contents.loadURL(request.url || 'about:blank');
@@ -953,12 +1025,25 @@ function installBrowserControlBackend() {
 const args = userArgs();
 const command = args.find(a => a === 'flow' || a === 'edit');
 const isTuiArg = args.some(arg => arg.toLowerCase() === '--tui');
+const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+const isHelpArg = !hasCliCommand && (args.some(arg => ['--help', '-h'].includes(arg.toLowerCase())) || args[0]?.toLowerCase() === 'help');
+const isVersionArg = !hasCliCommand && args.some(arg => ['--version', '-v'].includes(arg.toLowerCase()));
 const isViewerArg = args.some(arg => arg.toLowerCase() === '--newmark-viewer');
 const isCliArg = args.includes('--cli');
 const isServerArg = args.includes('--server');
 const isFlowArg = command === 'flow';
 const isEditArg = command === 'edit';
-const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
+// Help/version are terminating discovery commands. They must be handled
+// before Electron's GUI/TUI/server branches can initialize runtime state or
+// spawn a window, so a product-new tester can use them safely in any surface.
+if (isHelpArg) {
+    console.log((0, cli_help_1.newmarkHelpText)((0, installUpdate_1.currentAppVersion)()));
+    process.exit(0);
+}
+if (isVersionArg) {
+    console.log((0, installUpdate_1.currentAppVersion)());
+    process.exit(0);
+}
 function viewerEscape(value) {
     return String(value || '').replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[character] || character);
 }
@@ -1513,7 +1598,12 @@ else {
                     rejectUiReadinessById(Number(fileRouterOwnerId), new Error('Startup window closed before UI readiness'));
                     fileRouter.revokeOwner(fileRouterOwnerId);
                     pdfPreviewServer.revokeOwner(fileRouterOwnerId);
-                    browserGuestContentsByHost.delete(Number(fileRouterOwnerId));
+                    const closedHostId = Number(fileRouterOwnerId);
+                    browserGuestContentsByHost.delete(closedHostId);
+                    for (const [runtimeKey, binding] of browserGuestBindingsByRuntime) {
+                        if (binding.hostId === closedHostId)
+                            browserGuestBindingsByRuntime.delete(runtimeKey);
+                    }
                     const remaining = electron_1.BrowserWindow.getAllWindows().filter(candidate => !candidate.isDestroyed() && candidate !== win);
                     if (mainWindow === win)
                         mainWindow = remaining[0] || null;
@@ -2179,6 +2269,7 @@ else {
                 electronBrowserUseHost = null;
                 browserControl_1.BrowserControl.setBackend(null);
                 browserGuestContentsByHost.clear();
+                browserGuestBindingsByRuntime.clear();
                 if (sidecarProcess) {
                     sidecarProcess.kill();
                     sidecarProcess = null;
@@ -2569,9 +2660,9 @@ else {
                     }
                 }
             });
-            electron_1.ipcMain.handle('browser:registerGuest', (event, guestContentsId) => {
+            electron_1.ipcMain.handle('browser:registerGuest', (event, guestContentsId, target) => {
                 const guest = electron_1.webContents.fromId(Number(guestContentsId || 0));
-                return { accepted: !!guest && registerBrowserGuest(event.sender, guest) };
+                return { accepted: !!guest && registerBrowserGuest(event.sender, guest, target) };
             });
             electron_1.ipcMain.handle('browser:control', async (_event, request) => {
                 return await browserControl_1.BrowserControl.run(request);
@@ -2955,6 +3046,28 @@ else {
                     runtimeDeferred: false,
                 };
             });
+            electron_1.ipcMain.handle('agent:computerUseState', async (_event, targetInput) => {
+                if (!agent)
+                    return { enabled: false, occupied: false, runtimeKey: '' };
+                const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default'));
+                return utilityHostToolHandler.computerUseState(target.runtimeKey);
+            });
+            electron_1.ipcMain.handle('agent:setComputerUseEnabled', async (_event, targetInput, enabled) => {
+                if (!agent)
+                    return { ok: false, error: 'Agent not initialized' };
+                const target = (0, conversationTarget_1.normalizeConversationTarget)(conversationRuntimeTarget(targetInput || agent.activeConversationId || 'default'));
+                const result = utilityHostToolHandler.setComputerUseEnabled(target.runtimeKey, enabled !== false, `conversation:${target.conversationId}`);
+                if (!result.ok)
+                    return result;
+                if (enabled === false) {
+                    try {
+                        const { runComputerUse } = require('./tools/computerUse');
+                        await runComputerUse({ action: 'takeover_stop', workspacePath: target.workspace?.path || root, ownerId: target.runtimeKey, invocation: 'agent' });
+                    }
+                    catch { }
+                }
+                return result;
+            });
             electron_1.ipcMain.handle('agent:updateGoal', async (_event, goal, targetInput) => {
                 if (!agent)
                     return null;
@@ -3057,6 +3170,7 @@ else {
                     pendingOptions: conversationSnapshot.pendingOptions || agent.pendingOptions,
                     flowSuspension: flowSuspensionForTarget(target),
                     flowRunning: flowRunningForTarget(target),
+                    computerUse: utilityHostToolHandler.computerUseState((0, conversationTarget_1.normalizeConversationTarget)(target).runtimeKey),
                     draft: agent.getStoredConversationDraft(target.conversationId) || '',
                     proxyEnabled: agent.config.getBool('proxy', 'enabled'),
                     proxyUrl: agent.config.getStr('proxy', 'url'),

package/dist/preload.js

@@ -34,11 +34,13 @@ contextBridge.exposeInMainWorld('api', {
     setConversationPinned: (id, pinned) => ipcRenderer.invoke('agent:setConversationPinned', id, pinned),
     renameConversation: (id, title) => ipcRenderer.invoke('agent:renameConversation', id, title),
     reorderConversations: (ids) => ipcRenderer.invoke('agent:reorderConversations', ids),
-    browserRegisterGuest: (guestContentsId) => ipcRenderer.invoke('browser:registerGuest', guestContentsId),
+    browserRegisterGuest: (guestContentsId, target) => ipcRenderer.invoke('browser:registerGuest', guestContentsId, target),
     onBrowserEnsureGuest: (callback) => {
-        ipcRenderer.on('browser:ensureGuest', () => callback());
+        ipcRenderer.on('browser:ensureGuest', (_event, target) => callback(target));
     },
     browserControl: (request) => ipcRenderer.invoke('browser:control', request),
+    computerUseState: (target) => ipcRenderer.invoke('agent:computerUseState', target),
+    setComputerUseEnabled: (target, enabled) => ipcRenderer.invoke('agent:setComputerUseEnabled', target, enabled),
     runFlow: (name, input, start) => ipcRenderer.invoke('flow:run', name, input, start),
     resumeFlow: (response, target) => ipcRenderer.invoke('flow:resume', response, target),
     guideFlow: (message, target) => ipcRenderer.invoke('flow:guide', message, target),

package/dist/tools/index.js

@@ -57,8 +57,7 @@ const nativeBash_1 = require("../core/nativeBash");
 const toolArgumentValidator_1 = require("../core/toolArgumentValidator");
 const localOcr_1 = require("../core/localOcr");
 const visualTextFallback_1 = require("../core/visualTextFallback");
-let computerUseLock = null;
-const COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1000;
+const computerUseSession_1 = require("../core/computerUseSession");
 function normalizeComputerUseAction(action) {
     return String(action || '').trim().toLowerCase();
 }
@@ -154,50 +153,28 @@ async function abortableToolDelay(durationMs, signal) {
             abort();
     });
 }
-function clearStaleComputerUseLock(now = Date.now()) {
-    if (computerUseLock && now - computerUseLock.updatedAt > COMPUTER_USE_LOCK_TTL_MS) {
-        computerUseLock = null;
-    }
-}
-function computerUseLockError(action, owner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `ComputerUse is already active in ${computerUseLock?.owner || 'another conversation'}. Stop it with computer_use takeover_stop or wait before using ComputerUse from another conversation.`,
-        lock_owner: computerUseLock?.owner || '',
-        requested_owner: owner,
-    }, null, 2);
-}
-function acquireComputerUseLock(action, owner, wsPath) {
-    const now = Date.now();
-    clearStaleComputerUseLock(now);
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    computerUseLock = {
-        owner,
+function computerUseSessionScope(context, wsPath, owner) {
+    return {
+        runtimeKey: browserUseScope(context, wsPath).runtimeKey,
+        ownerLabel: owner,
         workspacePath: path.resolve(wsPath || process.cwd()),
-        acquiredAt: computerUseLock?.owner === owner ? computerUseLock.acquiredAt : now,
-        updatedAt: now,
     };
-    return null;
 }
-function releaseComputerUseLock(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
-    if (computerUseLock?.owner === owner)
-        computerUseLock = null;
-    return null;
+function acquireComputerUseLock(action, owner, wsPath, context = {}, dryRun = false) {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner), dryRun);
 }
-function assertComputerUseLockOwner(action, owner) {
-    clearStaleComputerUseLock();
-    if (computerUseLock && computerUseLock.owner !== owner) {
-        return computerUseLockError(action, owner);
-    }
+function releaseComputerUseLock(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    const scope = computerUseSessionScope(context, wsPath, owner);
+    computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, scope);
     return null;
 }
+function assertComputerUseLockOwner(action, owner, context = {}, wsPath = context.workspacePath || '') {
+    return computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, computerUseSessionScope(context, wsPath, owner));
+}
+// A competing conversation receives the stable user-facing marker
+// "ComputerUse is already active" / "computerUse occupied".
+// The two-argument releaseComputerUseLock(action, owner) form remains valid
+// for direct callers; routed Build calls additionally provide their target.
 class ToolExecutor {
     config;
     ssh;
@@ -754,8 +731,8 @@ class ToolExecutor {
                     const action = normalizeComputerUseAction(g('action'));
                     const owner = `${computerUseOwner(context, wsPath)}:${String(context.actorId || 'root')}`;
                     const lockGuard = action === 'takeover_stop'
-                        ? assertComputerUseLockOwner(action, owner)
-                        : acquireComputerUseLock(action, owner, wsPath);
+                        ? assertComputerUseLockOwner(action, owner, context, wsPath)
+                        : acquireComputerUseLock(action, owner, wsPath, context, args.dry_run === true);
                     if (lockGuard)
                         return lockGuard;
                     if (process.env.NEWMARK_WSL_DISTRO) {
@@ -772,7 +749,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
@@ -794,7 +771,7 @@ class ToolExecutor {
                         }
                         finally {
                             if (action === 'takeover_stop')
-                                releaseComputerUseLock(action, owner);
+                                releaseComputerUseLock(action, owner, context, wsPath);
                         }
                     }
                     const output = await (0, computerUse_1.runComputerUse)({
@@ -838,7 +815,7 @@ class ToolExecutor {
                             : undefined,
                     });
                     if (action === 'takeover_stop')
-                        releaseComputerUseLock(action, owner);
+                        releaseComputerUseLock(action, owner, context, wsPath);
                     return output;
                 }
                 case 'terminal_takeover': {
@@ -1352,9 +1329,17 @@ class ToolExecutor {
         }
     }
     async browserRun(request, signal, context = {}, workspacePath = this.root) {
+        const scope = browserUseScope(context, workspacePath);
+        const scopedRequest = {
+            ...request,
+            target: {
+                workspaceId: context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
+                conversationId: context.conversationId || 'default',
+                runtimeKey: scope.runtimeKey,
+            },
+        };
         if (process.env.NEWMARK_WSL_DISTRO) {
-            const scope = browserUseScope(context, workspacePath);
-            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', request, {
+            const result = await (0, wslHostToolBridge_1.requestWindowsHostTool)('browser_control', scopedRequest, {
                 conversationId: context.conversationId || process.env.NEWMARK_CONVERSATION_ID || 'default',
                 workspaceId: process.env.NEWMARK_WORKSPACE_ID || context.workspaceId || (0, terminalTakeover_1.terminalTakeoverWorkspaceId)(workspacePath),
                 actorId: context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID,
@@ -1364,10 +1349,12 @@ class ToolExecutor {
             return this.formatBrowserResult(result);
         }
         if (process.env.NEWMARK_ISOLATED_RUNTIME === '1') {
-            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', request, undefined, 30_000, signal);
+            const result = await (0, utilityHostToolBridge_1.requestUtilityHostTool)('browser_control', scopedRequest, undefined, 30_000, signal);
             return this.formatBrowserResult(result);
         }
-        const result = await browserControl_1.BrowserControl.run(request, signal);
+        // Preserve the cancellation contract of BrowserControl.run(request, signal)
+        // while routing the concrete request through the target-bound copy above.
+        const result = await browserControl_1.BrowserControl.run(scopedRequest, signal);
         return this.formatBrowserResult(result);
     }
     formatBrowserResult(result) {