@agenticmail/enterprise 0.5.327 → 0.5.328

package/src/agent-tools/tools/bash.ts

@@ -1,179 +0,0 @@
-/**
- * AgenticMail Agent Tools — Bash
- *
- * Execute shell commands with timeout, output limiting, safety checks,
- * command sanitization, and environment variable protection.
- */
-
-import { exec } from 'node:child_process';
-import path from 'node:path';
-import type { AnyAgentTool, ToolCreationOptions } from '../types.js';
-import { readStringParam, readNumberParam, textResult, errorResult } from '../common.js';
-import type { CommandSanitizer } from '../security.js';
-
-const DEFAULT_TIMEOUT_MS = 120_000;
-const MAX_TIMEOUT_MS = 600_000;
-const DEFAULT_MAX_OUTPUT_BYTES = 200_000;
-
-/** Env vars stripped from child process when sandboxed */
-var SENSITIVE_ENV_VARS = [
-  'AWS_SECRET_ACCESS_KEY', 'AWS_SESSION_TOKEN',
-  'DATABASE_URL', 'DATABASE_PASSWORD', 'DB_PASSWORD',
-  'OPENAI_API_KEY', 'ANTHROPIC_API_KEY',
-  'STRIPE_SECRET_KEY', 'STRIPE_API_KEY',
-  'GITHUB_TOKEN', 'GH_TOKEN',
-  'NPM_TOKEN', 'NODE_AUTH_TOKEN',
-  'FIRECRAWL_API_KEY', 'BRAVE_API_KEY',
-  'PERPLEXITY_API_KEY', 'OPENROUTER_API_KEY', 'XAI_API_KEY',
-  'SENDGRID_API_KEY', 'TWILIO_AUTH_TOKEN',
-  'SLACK_BOT_TOKEN', 'SLACK_SIGNING_SECRET',
-  'MASTER_KEY', 'ENCRYPTION_KEY', 'SECRET_KEY',
-];
-
-function truncateOutput(output: string, maxBytes: number): { text: string; truncated: boolean } {
-  var bytes = Buffer.byteLength(output, 'utf-8');
-  if (bytes <= maxBytes) return { text: output, truncated: false };
-  var buf = Buffer.from(output, 'utf-8');
-  var sliced = buf.subarray(0, maxBytes).toString('utf-8');
-  return { text: sliced, truncated: true };
-}
-
-function buildSanitizedEnv(sandboxed: boolean): Record<string, string | undefined> {
-  var env: Record<string, string | undefined> = { ...process.env, TERM: 'dumb' };
-  if (sandboxed) {
-    for (var key of SENSITIVE_ENV_VARS) {
-      delete env[key];
-    }
-  }
-  return env;
-}
-
-export function createBashTool(options?: ToolCreationOptions & { commandSanitizer?: CommandSanitizer }): AnyAgentTool {
-  var bashConfig = options?.config?.bash;
-  var sanitizer = options?.commandSanitizer;
-  var sandboxed = options?.sandboxed ?? false;
-
-  return {
-    name: 'bash',
-    label: 'Execute Command',
-    description: 'Execute a bash command. Returns stdout, stderr, and exit code. Commands have a configurable timeout (default 2 minutes, max 10 minutes).',
-    category: 'command',
-    risk: 'high',
-    parameters: {
-      type: 'object',
-      properties: {
-        command: { type: 'string', description: 'The bash command to execute.' },
-        timeout: { type: 'number', description: 'Timeout in milliseconds (max 600000).' },
-        working_dir: { type: 'string', description: 'Working directory for the command.' },
-      },
-      required: ['command'],
-    },
-    execute: async function(_toolCallId, args) {
-      var params = args as Record<string, unknown>;
-      var command = readStringParam(params, 'command', { required: true });
-      var timeoutRaw = readNumberParam(params, 'timeout', { integer: true });
-      var workingDir = readStringParam(params, 'working_dir');
-
-      if (bashConfig?.enabled === false) {
-        return errorResult('Bash tool is disabled.');
-      }
-
-      // Command sanitizer enforcement
-      if (sanitizer) {
-        try {
-          sanitizer.validate(command);
-        } catch (err: any) {
-          return errorResult('Command blocked: ' + (err.message || 'blocked by security policy'));
-        }
-      }
-
-      // Check blocked commands from config
-      if (bashConfig?.blockedCommands) {
-        var cmdLower = command.toLowerCase().trim();
-        for (var blocked of bashConfig.blockedCommands) {
-          if (cmdLower.startsWith(blocked.toLowerCase())) {
-            return errorResult('Command "' + blocked + '" is blocked by configuration.');
-          }
-        }
-      }
-
-      // Intercept package install commands → redirect to install_dependency
-      var _cmdCheck = command.trim().toLowerCase();
-      var _installPatterns = [
-        /^(sudo\s+)?brew\s+install\s/,
-        /^(sudo\s+)?apt(-get)?\s+install\s/,
-        /^(sudo\s+)?dnf\s+install\s/,
-        /^(sudo\s+)?pacman\s+-S\s/,
-        /^(sudo\s+)?snap\s+install\s/,
-        /^choco\s+install\s/,
-        /^winget\s+install\s/,
-        /^scoop\s+install\s/,
-        /^(sudo\s+)?pip3?\s+install\s(?!-r\s|--requirement)/,  // allow pip install -r requirements.txt
-        /^npm\s+install\s+-g\s/,
-      ];
-      if (_installPatterns.some(p => p.test(_cmdCheck))) {
-        return {
-          content: [{
-            type: 'text',
-            text: 'POLICY: Package installation via bash is not allowed. Use the install_dependency tool instead.\n\n' +
-              'Example: install_dependency({ command: "wget" })\n\n' +
-              'install_dependency handles cross-platform detection, permission policies, sudo passwords, and cleanup tracking automatically.',
-          }],
-        };
-      }
-
-      var timeoutMs = Math.min(
-        timeoutRaw && timeoutRaw > 0 ? timeoutRaw : bashConfig?.timeoutMs ?? DEFAULT_TIMEOUT_MS,
-        MAX_TIMEOUT_MS,
-      );
-
-      var maxOutput = bashConfig?.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
-      var cwd = workingDir || options?.workspaceDir || process.cwd();
-      var env = buildSanitizedEnv(sandboxed);
-
-      return new Promise(function(resolve) {
-        var child = exec(command, {
-          cwd,
-          timeout: timeoutMs,
-          maxBuffer: maxOutput * 2,
-          env,
-          shell: '/bin/bash',
-          killSignal: 'SIGTERM',
-        }, function(error, stdout, stderr) {
-          var exitCode = error?.code ?? (error ? 1 : 0);
-          if (typeof exitCode === 'string') exitCode = 1;
-
-          var outputParts: string[] = [];
-          if (stdout) {
-            var truncatedOut = truncateOutput(stdout, maxOutput);
-            outputParts.push(truncatedOut.text);
-            if (truncatedOut.truncated) outputParts.push('\n... (stdout truncated)');
-          }
-          if (stderr) {
-            var truncatedErr = truncateOutput(stderr, Math.floor(maxOutput / 4));
-            if (truncatedErr.text) {
-              outputParts.push('\nSTDERR:\n' + truncatedErr.text);
-              if (truncatedErr.truncated) outputParts.push('\n... (stderr truncated)');
-            }
-          }
-
-          if (error && error.killed) {
-            // Attempt to kill entire process group on timeout
-            if (child.pid) {
-              try { process.kill(-child.pid, 'SIGKILL'); } catch { /* ignore */ }
-            }
-            resolve(errorResult('Command timed out after ' + timeoutMs + 'ms'));
-            return;
-          }
-
-          var output = outputParts.join('');
-          if (exitCode !== 0) {
-            resolve(textResult(output + '\n\nExit code: ' + exitCode));
-          } else {
-            resolve(textResult(output || '(no output)'));
-          }
-        });
-      });
-    },
-  };
-}

package/src/agent-tools/tools/browser-tool.schema.ts

@@ -1,112 +0,0 @@
-import { Type } from "@sinclair/typebox";
-import { optionalStringEnum, stringEnum } from "../schema/typebox.js";
-
-const BROWSER_ACT_KINDS = [
-  "click",
-  "type",
-  "press",
-  "hover",
-  "drag",
-  "select",
-  "fill",
-  "resize",
-  "wait",
-  "evaluate",
-  "close",
-] as const;
-
-const BROWSER_TOOL_ACTIONS = [
-  "status",
-  "start",
-  "stop",
-  "profiles",
-  "tabs",
-  "open",
-  "focus",
-  "close",
-  "snapshot",
-  "screenshot",
-  "navigate",
-  "console",
-  "pdf",
-  "upload",
-  "dialog",
-  "act",
-] as const;
-
-const BROWSER_TARGETS = ["sandbox", "host", "node"] as const;
-
-const BROWSER_SNAPSHOT_FORMATS = ["aria", "ai"] as const;
-const BROWSER_SNAPSHOT_MODES = ["efficient"] as const;
-const BROWSER_SNAPSHOT_REFS = ["role", "aria"] as const;
-
-const BROWSER_IMAGE_TYPES = ["png", "jpeg"] as const;
-
-// NOTE: Using a flattened object schema instead of Type.Union([Type.Object(...), ...])
-// because Claude API on Vertex AI rejects nested anyOf schemas as invalid JSON Schema.
-// The discriminator (kind) determines which properties are relevant; runtime validates.
-const BrowserActSchema = Type.Object({
-  kind: stringEnum(BROWSER_ACT_KINDS),
-  // Common fields
-  targetId: Type.Optional(Type.String()),
-  ref: Type.Optional(Type.String()),
-  // click
-  doubleClick: Type.Optional(Type.Boolean()),
-  button: Type.Optional(Type.String()),
-  modifiers: Type.Optional(Type.Array(Type.String())),
-  // type
-  text: Type.Optional(Type.String()),
-  submit: Type.Optional(Type.Boolean()),
-  slowly: Type.Optional(Type.Boolean()),
-  // press
-  key: Type.Optional(Type.String()),
-  // drag
-  startRef: Type.Optional(Type.String()),
-  endRef: Type.Optional(Type.String()),
-  // select
-  values: Type.Optional(Type.Array(Type.String())),
-  // fill - use permissive array of objects
-  fields: Type.Optional(Type.Array(Type.Object({}, { additionalProperties: true }))),
-  // resize
-  width: Type.Optional(Type.Number()),
-  height: Type.Optional(Type.Number()),
-  // wait
-  timeMs: Type.Optional(Type.Number()),
-  textGone: Type.Optional(Type.String()),
-  // evaluate
-  fn: Type.Optional(Type.String()),
-});
-
-// IMPORTANT: OpenAI function tool schemas must have a top-level `type: "object"`.
-// A root-level `Type.Union([...])` compiles to `{ anyOf: [...] }` (no `type`),
-// which OpenAI rejects ("Invalid schema ... type: None"). Keep this schema an object.
-export const BrowserToolSchema = Type.Object({
-  action: stringEnum(BROWSER_TOOL_ACTIONS),
-  target: optionalStringEnum(BROWSER_TARGETS),
-  node: Type.Optional(Type.String()),
-  profile: Type.Optional(Type.String()),
-  targetUrl: Type.Optional(Type.String()),
-  targetId: Type.Optional(Type.String()),
-  limit: Type.Optional(Type.Number()),
-  maxChars: Type.Optional(Type.Number()),
-  mode: optionalStringEnum(BROWSER_SNAPSHOT_MODES),
-  snapshotFormat: optionalStringEnum(BROWSER_SNAPSHOT_FORMATS),
-  refs: optionalStringEnum(BROWSER_SNAPSHOT_REFS),
-  interactive: Type.Optional(Type.Boolean()),
-  compact: Type.Optional(Type.Boolean()),
-  depth: Type.Optional(Type.Number()),
-  selector: Type.Optional(Type.String()),
-  frame: Type.Optional(Type.String()),
-  labels: Type.Optional(Type.Boolean()),
-  fullPage: Type.Optional(Type.Boolean()),
-  ref: Type.Optional(Type.String()),
-  element: Type.Optional(Type.String()),
-  type: optionalStringEnum(BROWSER_IMAGE_TYPES),
-  level: Type.Optional(Type.String()),
-  paths: Type.Optional(Type.Array(Type.String())),
-  inputRef: Type.Optional(Type.String()),
-  timeoutMs: Type.Optional(Type.Number()),
-  accept: Type.Optional(Type.Boolean()),
-  promptText: Type.Optional(Type.String()),
-  request: Type.Optional(BrowserActSchema),
-});

package/src/agent-tools/tools/browser-tool.ts

@@ -1,388 +0,0 @@
-/**
- * Enterprise Browser Tool
- *
- * Full browser automation for enterprise agents using Playwright.
- * Adapted from AgenticMail's browser system — supports all actions:
- * status, start, stop, profiles, tabs, open, focus, close,
- * snapshot, screenshot, navigate, console, pdf, upload, dialog, act.
- *
- * No restrictions by default — restrictions are configurable per-agent
- * via the dashboard Tools tab and agent config.
- */
-
-import crypto from "node:crypto";
-import {
-  browserAct,
-  browserArmDialog,
-  browserArmFileChooser,
-  browserConsoleMessages,
-  browserNavigate,
-  browserPdfSave,
-  browserScreenshotAction,
-} from "../../browser/client-actions.js";
-import {
-  browserCloseTab,
-  browserFocusTab,
-  browserOpenTab,
-  browserProfiles,
-  browserSnapshot,
-  browserStart,
-  browserStatus,
-  browserStop,
-  browserTabs,
-} from "../../browser/client.js";
-import { DEFAULT_AI_SNAPSHOT_MAX_CHARS } from "../../browser/constants.js";
-import { DEFAULT_UPLOAD_DIR, resolvePathsWithinRoot, wrapExternalContent } from "../../browser/enterprise-compat.js";
-import { BrowserToolSchema } from "./browser-tool.schema.js";
-import { type AnyAgentTool, imageResultFromFile, jsonResult, readStringParam } from "../common.js";
-
-function wrapBrowserExternalJson(params: {
-  kind: "snapshot" | "console" | "tabs";
-  payload: unknown;
-  includeWarning?: boolean;
-}): { wrappedText: string; safeDetails: Record<string, unknown> } {
-  const extractedText = JSON.stringify(params.payload, null, 2);
-  const wrappedText = wrapExternalContent(extractedText, {
-    source: "browser",
-    includeWarning: params.includeWarning ?? true,
-  });
-  return {
-    wrappedText,
-    safeDetails: {
-      ok: true,
-      externalContent: {
-        untrusted: true,
-        source: "browser",
-        kind: params.kind,
-        wrapped: true,
-      },
-    },
-  };
-}
-
-/** Enterprise browser tool configuration */
-export interface EnterpriseBrowserToolConfig {
-  /** Base URL for browser control server (default: auto-detect) */
-  baseUrl?: string;
-  /** Default profile to use */
-  defaultProfile?: string;
-  /** Allow JavaScript evaluation */
-  allowEvaluate?: boolean;
-  /** Allow file:// URLs */
-  allowFileUrls?: boolean;
-  /** Allow navigation to any URL (no SSRF protection) */
-  allowAllUrls?: boolean;
-  /** Blocked URL patterns */
-  blockedUrlPatterns?: string[];
-  /** Max screenshot size */
-  maxScreenshotBytes?: number;
-  /** Upload directory root */
-  uploadDir?: string;
-}
-
-export function createEnterpriseBrowserTool(config?: EnterpriseBrowserToolConfig): AnyAgentTool {
-  const baseUrl = config?.baseUrl;
-  const defaultProfile = config?.defaultProfile;
-
-  return {
-    label: "Browser",
-    name: "browser",
-    description: [
-      "Control the browser for web automation — navigate, screenshot, snapshot (accessibility tree), click, type, hover, drag, fill forms, manage tabs, capture console logs, save PDFs, upload files, and handle dialogs.",
-      "Actions: status, start, stop, profiles, tabs, open, focus, close, snapshot, screenshot, navigate, console, pdf, upload, dialog, act.",
-      "Use snapshot+act for UI automation. snapshot returns the page accessibility tree; use refs from it with act to interact.",
-      'snapshot format="ai" returns a text description; format="aria" returns structured nodes.',
-      'act supports: click, type, press, hover, drag, select, fill, resize, wait, evaluate, close.',
-      'For multi-tab workflows, use tabs to list, open to create, focus to switch, close to remove.',
-    ].join(" "),
-    parameters: BrowserToolSchema as any,
-    execute: async (_toolCallId: any, args: any) => {
-      const params = args as Record<string, unknown>;
-      const action = readStringParam(params, "action", { required: true });
-      const profile = readStringParam(params, "profile") || defaultProfile;
-
-      switch (action) {
-        case "status":
-          return jsonResult(await browserStatus(baseUrl, { profile }));
-
-        case "start":
-          await browserStart(baseUrl, { profile });
-          return jsonResult(await browserStatus(baseUrl, { profile }));
-
-        case "stop":
-          await browserStop(baseUrl, { profile });
-          return jsonResult(await browserStatus(baseUrl, { profile }));
-
-        case "profiles":
-          return jsonResult({ profiles: await browserProfiles(baseUrl) });
-
-        case "tabs": {
-          const tabs = await browserTabs(baseUrl, { profile });
-          const wrapped = wrapBrowserExternalJson({
-            kind: "tabs",
-            payload: { tabs },
-            includeWarning: false,
-          });
-          return {
-            content: [{ type: "text", text: wrapped.wrappedText }],
-            details: { ...wrapped.safeDetails, tabCount: tabs.length },
-          };
-        }
-
-        case "open": {
-          const targetUrl = readStringParam(params, "targetUrl", { required: true });
-          return jsonResult(await browserOpenTab(baseUrl, targetUrl, { profile }));
-        }
-
-        case "focus": {
-          const targetId = readStringParam(params, "targetId", { required: true });
-          await browserFocusTab(baseUrl, targetId, { profile });
-          return jsonResult({ ok: true });
-        }
-
-        case "close": {
-          const targetId = readStringParam(params, "targetId");
-          if (targetId) {
-            await browserCloseTab(baseUrl, targetId, { profile });
-          } else {
-            await browserAct(baseUrl, { kind: "close" }, { profile });
-          }
-          return jsonResult({ ok: true });
-        }
-
-        case "snapshot": {
-          const format =
-            params.snapshotFormat === "ai" || params.snapshotFormat === "aria"
-              ? params.snapshotFormat
-              : "ai";
-          const mode = params.mode === "efficient" ? "efficient" : undefined;
-          const labels = typeof params.labels === "boolean" ? params.labels : undefined;
-          const refs = params.refs === "aria" || params.refs === "role" ? params.refs : undefined;
-          const hasMaxChars = Object.hasOwn(params, "maxChars");
-          const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
-          const limit =
-            typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : undefined;
-          const maxChars =
-            typeof params.maxChars === "number" && Number.isFinite(params.maxChars) && params.maxChars > 0
-              ? Math.floor(params.maxChars)
-              : undefined;
-          const resolvedMaxChars =
-            format === "ai"
-              ? hasMaxChars
-                ? maxChars
-                : mode === "efficient"
-                  ? undefined
-                  : DEFAULT_AI_SNAPSHOT_MAX_CHARS
-              : undefined;
-          const interactive = typeof params.interactive === "boolean" ? params.interactive : undefined;
-          const compact = typeof params.compact === "boolean" ? params.compact : undefined;
-          const depth =
-            typeof params.depth === "number" && Number.isFinite(params.depth) ? params.depth : undefined;
-          const selector = typeof params.selector === "string" ? params.selector.trim() : undefined;
-          const frame = typeof params.frame === "string" ? params.frame.trim() : undefined;
-
-          const snapshot = await browserSnapshot(baseUrl, {
-            format,
-            targetId,
-            limit,
-            ...(typeof resolvedMaxChars === "number" ? { maxChars: resolvedMaxChars } : {}),
-            refs,
-            interactive,
-            compact,
-            depth,
-            selector,
-            frame,
-            labels,
-            mode,
-            profile,
-          });
-
-          if (snapshot.format === "ai") {
-            const extractedText = snapshot.snapshot ?? "";
-            const wrappedSnapshot = wrapExternalContent(extractedText, {
-              source: "browser",
-              includeWarning: true,
-            });
-            const safeDetails = {
-              ok: true,
-              format: snapshot.format,
-              targetId: snapshot.targetId,
-              url: snapshot.url,
-              truncated: snapshot.truncated,
-              stats: snapshot.stats,
-              refs: snapshot.refs ? Object.keys(snapshot.refs).length : undefined,
-              labels: snapshot.labels,
-              labelsCount: snapshot.labelsCount,
-              labelsSkipped: snapshot.labelsSkipped,
-              imagePath: snapshot.imagePath,
-              imageType: snapshot.imageType,
-              externalContent: {
-                untrusted: true,
-                source: "browser",
-                kind: "snapshot",
-                format: "ai",
-                wrapped: true,
-              },
-            };
-            if (labels && snapshot.imagePath) {
-              return await imageResultFromFile({
-                label: "browser:snapshot",
-                path: snapshot.imagePath,
-                extraText: wrappedSnapshot,
-                details: safeDetails,
-              });
-            }
-            return {
-              content: [{ type: "text", text: wrappedSnapshot }],
-              details: safeDetails,
-            };
-          }
-
-          // aria format
-          const wrapped = wrapBrowserExternalJson({
-            kind: "snapshot",
-            payload: snapshot,
-          });
-          return {
-            content: [{ type: "text", text: wrapped.wrappedText }],
-            details: {
-              ...wrapped.safeDetails,
-              format: "aria",
-              targetId: snapshot.targetId,
-              url: snapshot.url,
-              nodeCount: snapshot.nodes.length,
-            },
-          };
-        }
-
-        case "screenshot": {
-          const targetId = readStringParam(params, "targetId");
-          const fullPage = Boolean(params.fullPage);
-          const ref = readStringParam(params, "ref");
-          const element = readStringParam(params, "element");
-          const type = params.type === "jpeg" ? "jpeg" : "png";
-          const result = await browserScreenshotAction(baseUrl, {
-            targetId,
-            fullPage,
-            ref,
-            element,
-            type,
-            profile,
-          });
-          return await imageResultFromFile({
-            label: "browser:screenshot",
-            path: result.path,
-            details: result,
-          });
-        }
-
-        case "navigate": {
-          const targetUrl = readStringParam(params, "targetUrl", { required: true });
-          const targetId = readStringParam(params, "targetId");
-          return jsonResult(
-            await browserNavigate(baseUrl, {
-              url: targetUrl,
-              targetId,
-              profile,
-            }),
-          );
-        }
-
-        case "console": {
-          const level = typeof params.level === "string" ? params.level.trim() : undefined;
-          const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
-          const result = await browserConsoleMessages(baseUrl, { level, targetId, profile });
-          const wrapped = wrapBrowserExternalJson({
-            kind: "console",
-            payload: result,
-            includeWarning: false,
-          });
-          return {
-            content: [{ type: "text", text: wrapped.wrappedText }],
-            details: {
-              ...wrapped.safeDetails,
-              targetId: result.targetId,
-              messageCount: result.messages.length,
-            },
-          };
-        }
-
-        case "pdf": {
-          const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
-          const result = await browserPdfSave(baseUrl, { targetId, profile });
-          return {
-            content: [{ type: "text", text: `FILE:${result.path}` }],
-            details: result,
-          };
-        }
-
-        case "upload": {
-          const paths = Array.isArray(params.paths) ? params.paths.map((p) => String(p)) : [];
-          if (paths.length === 0) throw new Error("paths required");
-
-          const uploadDir = config?.uploadDir || DEFAULT_UPLOAD_DIR;
-          const normalizedPaths = resolvePathsWithinRoot(uploadDir, ...paths);
-
-          const ref = readStringParam(params, "ref");
-          const inputRef = readStringParam(params, "inputRef");
-          const element = readStringParam(params, "element");
-          const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
-          const timeoutMs =
-            typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)
-              ? params.timeoutMs
-              : undefined;
-
-          return jsonResult(
-            await browserArmFileChooser(baseUrl, {
-              paths: normalizedPaths,
-              ref,
-              inputRef,
-              element,
-              targetId,
-              timeoutMs,
-              profile,
-            }),
-          );
-        }
-
-        case "dialog": {
-          const accept = Boolean(params.accept);
-          const promptText = typeof params.promptText === "string" ? params.promptText : undefined;
-          const targetId = typeof params.targetId === "string" ? params.targetId.trim() : undefined;
-          const timeoutMs =
-            typeof params.timeoutMs === "number" && Number.isFinite(params.timeoutMs)
-              ? params.timeoutMs
-              : undefined;
-
-          return jsonResult(
-            await browserArmDialog(baseUrl, {
-              accept,
-              promptText,
-              targetId,
-              timeoutMs,
-              profile,
-            }),
-          );
-        }
-
-        case "act": {
-          const request = params.request as Record<string, unknown> | undefined;
-          if (!request || typeof request !== "object") throw new Error("request required");
-
-          // Check evaluate restrictions
-          if (request.kind === "evaluate" && config?.allowEvaluate === false) {
-            throw new Error("JavaScript evaluation is disabled for this agent. Enable it in agent config.");
-          }
-
-          const result = await browserAct(baseUrl, request as Parameters<typeof browserAct>[1], {
-            profile,
-          });
-          return jsonResult(result);
-        }
-
-        default:
-          throw new Error(`Unknown browser action: ${action}`);
-      }
-    },
-  };
-}