newmark-agent 0.3.10 → 0.3.11

package/dist/core/computerUseSession.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultComputerUseSessionRegistry = exports.ComputerUseSessionRegistry = exports.COMPUTER_USE_LOCK_TTL_MS = exports.COMPUTER_USE_OCCUPIED_MARKER = void 0;
+exports.COMPUTER_USE_OCCUPIED_MARKER = 'computerUse occupied';
+exports.COMPUTER_USE_LOCK_TTL_MS = 10 * 60 * 1000;
+class ComputerUseSessionRegistry {
+    ttlMs;
+    enabledByRuntime = new Map();
+    activeLease = null;
+    constructor(ttlMs = exports.COMPUTER_USE_LOCK_TTL_MS) {
+        this.ttlMs = ttlMs;
+    }
+    authorize(action, scope, dryRun = false) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        const runtimeKey = String(scope.runtimeKey || '').trim() || 'conversation:default';
+        const now = Date.now();
+        this.clearExpired(now);
+        if (this.activeLease && this.activeLease.runtimeKey !== runtimeKey) {
+            return this.occupiedError(normalizedAction, scope.ownerLabel, this.activeLease.ownerLabel);
+        }
+        if (normalizedAction === 'takeover_stop')
+            return null;
+        const enabled = this.enabledByRuntime.get(runtimeKey) !== false;
+        const readOnly = normalizedAction === 'observe' || normalizedAction === 'app_list' || normalizedAction === 'app_observe' || normalizedAction === 'wait';
+        if (!enabled && !readOnly && !dryRun && normalizedAction !== 'takeover_start') {
+            return JSON.stringify({
+                ok: false,
+                action: normalizedAction,
+                error: `ComputerUse is disabled for ${scope.ownerLabel}. Enable ComputerUse for this conversation before sending desktop operations.`,
+                computer_use_enabled: false,
+                requested_owner: scope.ownerLabel,
+            }, null, 2);
+        }
+        if (normalizedAction === 'takeover_start')
+            this.enabledByRuntime.set(runtimeKey, true);
+        if (!this.activeLease) {
+            this.activeLease = { ...scope, runtimeKey, updatedAt: now };
+        }
+        else {
+            this.activeLease.updatedAt = now;
+        }
+        return null;
+    }
+    complete(action, scope) {
+        const normalizedAction = String(action || '').trim().toLowerCase();
+        const runtimeKey = String(scope.runtimeKey || '').trim() || 'conversation:default';
+        if (normalizedAction === 'takeover_stop') {
+            if (!this.activeLease || this.activeLease.runtimeKey === runtimeKey)
+                this.activeLease = null;
+            this.enabledByRuntime.set(runtimeKey, false);
+            return;
+        }
+        if (this.activeLease?.runtimeKey === runtimeKey)
+            this.activeLease.updatedAt = Date.now();
+    }
+    setEnabled(scope, enabled) {
+        const runtimeKey = String(scope.runtimeKey || '').trim() || 'conversation:default';
+        this.clearExpired();
+        if (this.activeLease && this.activeLease.runtimeKey !== runtimeKey) {
+            return { ok: false, error: this.occupiedError('toggle', scope.ownerLabel, this.activeLease.ownerLabel), state: this.state(runtimeKey) };
+        }
+        this.enabledByRuntime.set(runtimeKey, enabled !== false);
+        if (enabled === false && this.activeLease?.runtimeKey === runtimeKey)
+            this.activeLease = null;
+        return { ok: true, state: this.state(runtimeKey) };
+    }
+    state(runtimeKey) {
+        const key = String(runtimeKey || '').trim() || 'conversation:default';
+        this.clearExpired();
+        const lease = this.activeLease;
+        return {
+            runtimeKey: key,
+            enabled: this.enabledByRuntime.get(key) !== false,
+            occupied: !!lease,
+            ...(lease ? { ownerLabel: lease.ownerLabel, updatedAt: lease.updatedAt } : {}),
+        };
+    }
+    cancelTarget(runtimeKey) {
+        const key = String(runtimeKey || '').trim();
+        if (!key)
+            return false;
+        const hadActiveLease = this.activeLease?.runtimeKey === key;
+        if (hadActiveLease)
+            this.activeLease = null;
+        this.enabledByRuntime.set(key, false);
+        return hadActiveLease;
+    }
+    clearExpired(now = Date.now()) {
+        if (this.activeLease && now - this.activeLease.updatedAt > this.ttlMs) {
+            this.activeLease = null;
+        }
+    }
+    occupiedError(action, requestedOwner, activeOwner) {
+        return JSON.stringify({
+            ok: false,
+            action,
+            error: `${exports.COMPUTER_USE_OCCUPIED_MARKER}: ComputerUse is already active in ${activeOwner}. Stop it with computer_use takeover_stop or wait before another conversation takes control.`,
+            lock_owner: activeOwner,
+            requested_owner: requestedOwner,
+        }, null, 2);
+    }
+}
+exports.ComputerUseSessionRegistry = ComputerUseSessionRegistry;
+exports.defaultComputerUseSessionRegistry = new ComputerUseSessionRegistry();
+//# sourceMappingURL=computerUseSession.js.map

package/dist/core/conversationKernel.d.ts

@@ -212,6 +212,7 @@ export declare class ConversationKernel {
     private processTimeoutMs;
     private runtime;
     private scheduleGoalContinuation;
+    private schedulePendingRuntimeContinuation;
     private startGoalDrivenBuild;
     private createRunner;
     private enqueueRootInboxWake;

package/dist/core/conversationKernel.js

@@ -217,6 +217,7 @@ class ConversationKernel {
             runtime.runner.recordGuideReceipt(deferred);
             this.emitQueueUpdate(runtime);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
         }
         if (runtime.guideAcceptanceClosedRunId === runtime.runId) {
@@ -248,6 +249,7 @@ class ConversationKernel {
                     createdAt: deferred.createdAt,
                 }]);
             this.activateAcceptedGoal(runtime, envelope.goalObjective);
+            this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
             return deferred;
         }
         const queued = runtime.runner.queueActiveKernelMessage(safeEnvelope.text, 'steer', clientMessageId, runtime.runId, safeEnvelope.images);
@@ -278,6 +280,7 @@ class ConversationKernel {
                 createdAt: deferred.createdAt,
             }]);
         this.activateAcceptedGoal(runtime, envelope.goalObjective);
+        this.schedulePendingRuntimeContinuation(runtime, runtime.runId);
         return deferred;
     }
     checkpoint(target) {
@@ -507,6 +510,12 @@ class ConversationKernel {
                         stopped = true;
                         this.settleCooperativeStop(runtime, runId);
                     }
+                    else if (runtime.pendingNextTurn.length > 0) {
+                        // A renderer/IPC Guide can arrive after the final-drain barrier's
+                        // last check but before this promise settles. Do not leave the
+                        // deferred continuation queued on an idle runtime.
+                        this.schedulePendingRuntimeContinuation(runtime, runId);
+                    }
                 }
             }
             if (!stopped && runtime.runId === runId)
@@ -656,6 +665,7 @@ class ConversationKernel {
             guideReceipts: new Map(),
             guideEnvelopes: new Map(),
             goalContinuationTimer: undefined,
+            pendingContinuationRunId: undefined,
         };
         runner.setGoalContinuationGate(() => {
             this.queueState(runtime);
@@ -748,6 +758,34 @@ class ConversationKernel {
             });
         }, 250);
     }
+    schedulePendingRuntimeContinuation(runtime, runId) {
+        if (runtime.pendingContinuationRunId === runId)
+            return;
+        runtime.pendingContinuationRunId = runId;
+        const active = runtime.activePromise;
+        if (active) {
+            const continueAfterSettlement = () => {
+                runtime.pendingContinuationRunId = undefined;
+                this.schedulePendingRuntimeContinuation(runtime, runId);
+            };
+            void active.then(continueAfterSettlement, continueAfterSettlement);
+            return;
+        }
+        setImmediate(() => {
+            runtime.pendingContinuationRunId = undefined;
+            if (runtime.runId !== runId || runtime.activePromise || runtime.stopRequestedRunId === runId)
+                return;
+            const next = runtime.pendingNextTurn.shift();
+            if (!next)
+                return;
+            const message = typeof next.message === 'string'
+                ? { text: next.message, runId }
+                : { ...next.message, runId: next.message.runId || runId };
+            void this.prompt(message, runtime.target, runtime.options, next.queueMode).catch(() => {
+                // Agent.process and the work-run finalizer already publish the error.
+            });
+        });
+    }
     startGoalDrivenBuild(runtime) {
         if (runtime.goalContinuationTimer) {
             clearTimeout(runtime.goalContinuationTimer);

package/dist/core/electronBrowserUseHost.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ElectronBrowserUseHost = void 0;
+const browserUsePageAdapter_1 = require("./browserUsePageAdapter");
 const SAFE_NAVIGATION = /^(?:https?:|about:blank|newmark-preview:)/i;
 const BROWSER_USE_WORLD_ID = 999;
 /**
@@ -109,6 +110,12 @@ class ElectronBrowserUseHost {
                 contents.sendInputEvent({ type: 'mouseUp', button: 'left', clickCount: 1, ...point });
                 await abortableDelay(10, signal);
             },
+            clickElement: contents.getType() === 'webview' ? async (token, signal) => {
+                throwIfAborted(signal);
+                const result = await raceWithAbort(contents.executeJavaScriptInIsolatedWorld(BROWSER_USE_WORLD_ID, [{ code: (0, browserUsePageAdapter_1.browserUseClickScript)(token) }], true), signal);
+                if (!result?.clicked)
+                    throw new Error(result?.error || 'Unable to click the observed Browser-Use element.');
+            } : undefined,
             replaceFocusedText: async (text, signal) => {
                 throwIfAborted(signal);
                 contents.focus();

package/dist/core/electronUtilityAgentClient.js

@@ -473,6 +473,70 @@ async function snapshotWindowsProcessTree(rootPid, timeoutMs = WINDOWS_TREE_SNAP
 function delay(ms) {
     return new Promise(resolve => setTimeout(resolve, Math.max(0, ms)));
 }
+function processRootIsAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * A graceful utility shutdown can make Electron's UtilityProcess.kill() return
+ * false before the child exit event is delivered.  On Windows the captured
+ * root creation identity lets us prove that the root and every owned
+ * descendant are gone without falling back to an unscoped PID kill.
+ */
+async function confirmWindowsUtilityProcessTreeStopped(pid, expectedRootCreationIdentity, options, ownerKey) {
+    if (process.platform !== 'win32' || !Number.isInteger(pid) || pid <= 0 || !/^\d+$/.test(expectedRootCreationIdentity))
+        return false;
+    const snapshotter = options.snapshot || snapshotWindowsProcessTree;
+    const deadline = Date.now() + Math.min(WINDOWS_TREE_FORCE_STOP_DEADLINE_MS, Math.max(1, Math.floor(options.forceStopDeadlineMs ?? WINDOWS_TREE_FORCE_STOP_DEADLINE_MS)));
+    const maxRescans = Math.max(2, Math.floor(options.maxRescans ?? WINDOWS_TREE_MAX_RESCANS));
+    const stableRequired = Math.max(2, Math.min(maxRescans, Math.floor(options.stableEmptyRescans ?? WINDOWS_TREE_STABLE_EMPTY_RESCANS)));
+    const syntheticRoot = {
+        pid,
+        parentPid: 0,
+        depth: 0,
+        creationIdentity: expectedRootCreationIdentity,
+    };
+    let stableEmpty = 0;
+    for (let scan = 0; scan < maxRescans; scan++) {
+        try {
+            if (scan > 0)
+                await withinWindowsTreeDeadline(delay(options.rescanDelayMs ?? WINDOWS_TREE_RESCAN_DELAY_MS), deadline, 'graceful-stop rescan delay');
+            const snapshot = await withinWindowsTreeDeadline(snapshotter(pid, remainingWindowsTreeBudget(deadline, options.rescanTimeoutMs ?? WINDOWS_TREE_RESCAN_TIMEOUT_MS, 'graceful-stop rescan', !options.snapshot), [pid], ownerKey), deadline, 'graceful-stop rescan');
+            const root = snapshot.entries.find(entry => entry.pid === pid);
+            if (root && root.creationIdentity !== expectedRootCreationIdentity)
+                return false;
+            if (!snapshot.entries.length) {
+                stableEmpty += 1;
+                if (stableEmpty >= stableRequired)
+                    return true;
+                continue;
+            }
+            // The root may have exited while a child was still observable through
+            // its parent PID. Add only the already-captured root identity so the
+            // normal identity/quiescence gate can safely terminate the survivor.
+            const captured = root
+                ? snapshot
+                : { rootPid: pid, entries: [syntheticRoot, ...snapshot.entries] };
+            await terminateCapturedWindowsProcessTree(captured, {
+                ...options,
+                helperOwnerKey: ownerKey,
+                forceStopDeadlineMs: Math.max(1, deadline - Date.now()),
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
 function remainingWindowsTreeBudget(deadline, capMs, label, reserveHelperClose = false) {
     const remaining = deadline - Date.now() - (reserveHelperClose ? WINDOWS_HELPER_CLOSE_GRACE_MS + 75 : 0);
     if (remaining < 100)
@@ -1014,6 +1078,20 @@ class ElectronUtilityAgentClient {
             if (exited && this.child === child)
                 this.detachChild(child, new Error('Electron utility runtime stopped'));
             else if (!exited) {
+                const rootIdentity = this.childRootIdentity;
+                if (!this.restartQuarantine
+                    && rootIdentity
+                    && rootIdentity.generation === this.childGeneration
+                    && rootIdentity.pid === Number(child.pid || 0)
+                    && rootIdentity.creationIdentity) {
+                    const helperOwnerKey = this.windowsHelperOwnerKey(rootIdentity.generation);
+                    const quiescent = await confirmWindowsUtilityProcessTreeStopped(rootIdentity.pid, rootIdentity.creationIdentity, { ...this.options.windowsProcessTree, helperOwnerKey }, helperOwnerKey);
+                    if (quiescent) {
+                        if (this.child === child)
+                            this.detachChild(child, new Error('Electron utility runtime stopped'));
+                        return;
+                    }
+                }
                 this.enterRestartQuarantine(failure);
                 // Retain the UtilityProcess object and surface the failure.  The pool
                 // must not evict the only identity-safe handle to a still-live child.
@@ -1071,8 +1149,12 @@ class ElectronUtilityAgentClient {
             // killing through it is identity-safe even when PID-tree discovery is
             // uncertain. Descendants remain unknown, hence quarantine is still
             // permanent and replacement remains forbidden.
-            const exited = await this.killChildHandleAndAwaitExit(child, 1_000);
-            if (exited && this.child === child)
+            const rootAlreadyGone = process.platform === 'win32' && !processRootIsAlive(pid);
+            const exited = await this.killChildHandleAndAwaitExit(child, 5_000);
+            // The root handle can outlive the OS process after a tree proof fails.
+            // Detach that dead root handle, but keep the sticky quarantine because
+            // the failed tree proof still leaves descendant ownership unknown.
+            if ((exited || rootAlreadyGone) && this.child === child)
                 this.detachChild(child, failure);
             throw failure;
         }

package/dist/core/utilityHostToolRouter.d.ts

@@ -2,6 +2,7 @@ import { BrowserControl } from './browserControl';
 import { BrowserUseReceipt, BrowserUseRequest } from './browserUse';
 import { UtilityHostToolRequest } from './utilityAgentProtocol';
 import { runComputerUse } from '../tools/computerUse';
+import { ComputerUseSessionState } from './computerUseSession';
 import { runTerminalTakeover } from '../tools/terminalTakeover';
 export interface UtilityHostToolRouterOptions {
     persistenceRoot: string;
@@ -15,6 +16,12 @@ export interface UtilityHostToolRouterOptions {
 }
 export type RoutedUtilityHostToolHandler = ((request: UtilityHostToolRequest, signal?: AbortSignal) => Promise<unknown>) & {
     cancelTarget(runtimeKey: string): void;
+    computerUseState(runtimeKey: string): ComputerUseSessionState;
+    setComputerUseEnabled(runtimeKey: string, enabled: boolean, ownerLabel?: string): {
+        ok: boolean;
+        state: ComputerUseSessionState;
+        error?: string;
+    };
 };
 /**
  * Routes every desktop-global capability in the Electron main process.

package/dist/core/utilityHostToolRouter.js

@@ -39,6 +39,7 @@ const fs = __importStar(require("fs"));
 const browserUse_1 = require("./browserUse");
 const toolPolicy_1 = require("./toolPolicy");
 const computerUse_1 = require("../tools/computerUse");
+const computerUseSession_1 = require("./computerUseSession");
 const terminalTakeover_1 = require("../tools/terminalTakeover");
 const ROOT_AGENT_ACTOR_ID = '00000000-0000-4000-8000-000000000001';
 const AUTOMATION_TOOLS = new Set([
@@ -54,10 +55,8 @@ const AUTOMATION_TOOLS = new Set([
  * one authoritative owner lock rather than one lock per child process.
  */
 function createUtilityHostToolHandler(options) {
-    let computerUseLease = null;
     const terminalOwners = new Map();
     const ephemeralScreenshots = new Map();
-    const lockTtlMs = 10 * 60 * 1000;
     const handler = async (request, signal) => {
         throwIfAborted(signal);
         validateTargetContext(request);
@@ -73,7 +72,14 @@ function createUtilityHostToolHandler(options) {
         if (request.tool === 'browser_control') {
             if (request.args.action === 'use')
                 throw new Error('Isolated Browser-Use must use the target-bound browser_use host RPC');
-            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))(request.args, signal);
+            const result = await (options.runBrowser || browserControl_1.BrowserControl.run.bind(browserControl_1.BrowserControl))({
+                ...request.args,
+                target: {
+                    workspaceId: request.target.workspaceId,
+                    conversationId: request.target.conversationId,
+                    runtimeKey: request.target.runtimeKey,
+                },
+            }, signal);
             throwIfAborted(signal);
             return result;
         }
@@ -124,20 +130,14 @@ function createUtilityHostToolHandler(options) {
         const action = String(args.action || '').trim().toLowerCase();
         const trustedComputerUseContext = request.context;
         const owner = `${request.target.runtimeKey}:${String(request.context.actorId || terminalTakeover_1.ROOT_TERMINAL_ACTOR_ID)}`;
-        const now = Date.now();
-        if (computerUseLease && now - computerUseLease.updatedAt > lockTtlMs)
-            computerUseLease = null;
-        if (action === 'takeover_stop') {
-            if (computerUseLease && computerUseLease.owner !== owner) {
-                return computerUseLockError(action, owner, computerUseLease.owner);
-            }
-        }
-        else if (computerUseLease && computerUseLease.owner !== owner) {
-            return computerUseLockError(action, owner, computerUseLease.owner);
-        }
-        else {
-            computerUseLease = { owner, runtimeKey: request.target.runtimeKey, workspacePath: request.target.workspacePath, updatedAt: now };
-        }
+        const sessionScope = {
+            runtimeKey: request.target.runtimeKey,
+            ownerLabel: owner,
+            workspacePath: request.target.workspacePath,
+        };
+        const lockGuard = computerUseSession_1.defaultComputerUseSessionRegistry.authorize(action, sessionScope, args.dry_run === true || args.dryRun === true);
+        if (lockGuard)
+            return lockGuard;
         let retainedScreenshotPath = '';
         try {
             const result = await (options.runComputer || computerUse_1.runComputerUse)({
@@ -214,10 +214,7 @@ function createUtilityHostToolHandler(options) {
                 }
                 catch { }
             }
-            if (action === 'takeover_stop' && (!computerUseLease || computerUseLease.owner === owner))
-                computerUseLease = null;
-            else if (computerUseLease?.owner === owner)
-                computerUseLease.updatedAt = Date.now();
+            computerUseSession_1.defaultComputerUseSessionRegistry.complete(action, sessionScope);
         }
     };
     handler.cancelTarget = (runtimeKey) => {
@@ -238,9 +235,9 @@ function createUtilityHostToolHandler(options) {
                     (0, terminalTakeover_1.stopTerminalTakeoverSession)(session.id, terminalOwner, 'runtime-force-restart');
             }
         }
-        if (computerUseLease?.runtimeKey === runtimeKey) {
-            const lease = computerUseLease;
-            computerUseLease = null;
+        const hadComputerUseLease = computerUseSession_1.defaultComputerUseSessionRegistry.cancelTarget(runtimeKey);
+        if (hadComputerUseLease) {
+            const lease = { workspacePath: options.persistenceRoot, owner: runtimeKey };
             void (options.runComputer || computerUse_1.runComputerUse)({
                 action: 'takeover_stop',
                 workspacePath: lease.workspacePath,
@@ -249,6 +246,10 @@ function createUtilityHostToolHandler(options) {
             }).catch(() => undefined);
         }
     };
+    handler.computerUseState = (runtimeKey) => computerUseSession_1.defaultComputerUseSessionRegistry.state(runtimeKey);
+    handler.setComputerUseEnabled = (runtimeKey, enabled, ownerLabel = `conversation:${runtimeKey}`) => {
+        return computerUseSession_1.defaultComputerUseSessionRegistry.setEnabled({ runtimeKey, ownerLabel, workspacePath: options.persistenceRoot }, enabled);
+    };
     return handler;
 }
 function throwIfAborted(signal) {
@@ -307,13 +308,4 @@ function evaluateUtilityHostToolPolicy(request) {
         args,
     });
 }
-function computerUseLockError(action, requestedOwner, activeOwner) {
-    return JSON.stringify({
-        ok: false,
-        action,
-        error: `Computer Use is already active in ${activeOwner}. Stop it with computer_use takeover_stop or wait before another conversation takes control.`,
-        lock_owner: activeOwner,
-        requested_owner: requestedOwner,
-    }, null, 2);
-}
 //# sourceMappingURL=utilityHostToolRouter.js.map

package/dist/launcher.js

@@ -43,7 +43,12 @@ const agent_1 = require("./core/agent");
 const flow_1 = require("./core/flow");
 const flow_runner_1 = require("./core/flow-runner");
 const cli_commands_1 = require("./cli-commands");
+const installUpdate_1 = require("./core/installUpdate");
+const cli_help_1 = require("./cli-help");
 const args = process.argv.slice(2);
+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 isTui = args.some(arg => arg.toLowerCase() === '--tui');
 const isGui = args.some(arg => arg.toLowerCase() === '--gui');
 const isCli = args.includes('--cli');
@@ -51,7 +56,6 @@ const isServer = args.includes('--server');
 const isEdit = args[0] === 'edit';
 const editFile = isEdit ? args[1] : '';
 const isFlow = args[0] === 'flow';
-const hasCliCommand = args.some(a => cli_commands_1.CLI_COMMANDS.includes(a));
 function pathArgValue(values, key) {
     const prefix = `${key}=`;
     const inlineIdx = values.findIndex(a => a.startsWith(prefix));
@@ -169,6 +173,14 @@ function writableRuntimeRoot(candidate) {
 }
 const explicitRoot = pathArgValue(args, '--root');
 const root = explicitRoot ? writableRuntimeRoot(explicitRoot) : userRuntimeRoot();
+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 firstRunInit(r) {
     fs.mkdirSync(r, { recursive: true });
     migrateLegacyRuntimeRoot(r);