@moretea-labs/forge 1.7.1 → 1.8.0

package/src/runtime/plugins/browser-adapter.ts

@@ -5,34 +5,41 @@ import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'pat
 import type {
   AssistantPluginActionExecutionInput,
   AssistantPluginAuthorizationContext,
+  AssistantPluginBuildContext,
   AssistantPluginHealth,
   AssistantPluginManifest,
 } from './types';
 import { AssistantPluginError, toAssistantPluginError } from './errors';
+import { readRepositoryPluginConfig, writeRepositoryPluginConfig, type RepositoryPluginConfigContext } from './config-store';
 import {
   browserActions,
   browserCapabilities,
   browserPermissions,
 } from './browser-manifest-surface';
 import { executeBrowserActionThroughNode, shouldUseBrowserNodeBridge } from './browser-node-bridge';
-import { BrowserProviderUnavailableBeforeActionError } from './browser-provider-registry';
-import { MAX_BROWSER_CDP_ENDPOINT_CANDIDATES } from './browser-runtime-contract';
+import { BrowserProviderUnavailableBeforeActionError } from '../../../packages/plugin-runtime/browser/provider-registry';
+import { MAX_BROWSER_CDP_ENDPOINT_CANDIDATES } from '../../../packages/plugin-runtime/browser/runtime-contract';
 import {
   ALL_BROWSER_PROVIDER_CAPABILITIES,
   browserActionCanReplayAfterDispatch as canReplayBrowserActionAfterDispatch,
+  browserExplicitPostActionWaitMs,
+  browserNativeForegroundVerificationWaitMs,
   executeBrowserRuntimeAction,
   invalidateBrowserRuntime,
 } from './browser-runtime';
-import { getExternalPluginAdapter } from './external-adapter';
+import { activateRuntimeComputerBrowserApplication } from '../root/computer-composition';
 import {
-  currentBrowserSessionAuthorityContext,
   DEFAULT_BROWSER_SESSION_LIST_LIMIT,
   MAX_BROWSER_SESSION_LIST_LIMIT,
-  withBrowserSessionAuthorityContext,
-} from './browser-session-authority';
+} from '../../../packages/plugin-runtime/browser/session-authority';
+import {
+  currentRuntimeBrowserSessionAuthorityContext as currentBrowserSessionAuthorityContext,
+  withRuntimeBrowserSessionAuthorityContext as withBrowserSessionAuthorityContext,
+} from '../root/browser-session-composition';
 import {
   closeMacOsBrowserOwnedTab,
   createMacOsBrowserOwnedPage,
+  createMacOsBrowserOwnedPageForProduct,
   reattachMacOsBrowserOwnedPage,
   discoverMacOsBrowserAttachment,
   invalidateMacOsBrowserPageHandle,
@@ -87,13 +94,11 @@ import type {
   BrowserTabMatchReason,
   BrowserTabResumeState,
   CdpAttachAttempt,
-} from './browser-session-types';
+} from '../../../packages/protocols/browser/index';
 
 const BROWSER_PLUGIN_ID = 'browser';
-const CONFIG_ROOT = '.forge/plugins';
 const DEFAULT_TIMEOUT_MS = 30_000;
 const DEFAULT_MAX_TEXT_CHARS = 20_000;
-const DEFAULT_POST_ACTION_WAIT_MS = 750;
 const DEFAULT_CDP_DISCOVERY_TIMEOUT_MS = 1_500;
 const MAX_CDP_DISCOVERY_TIMEOUT_MS = 5_000;
 
@@ -149,6 +154,15 @@ interface BrowserActionTarget {
   existingSession?: BrowserSessionState;
 }
 
+export function browserExplicitSessionRequiresExistingResource(
+  actionId: string,
+  explicitSessionId: string | undefined,
+  existingSessionPresent: boolean,
+): boolean {
+  if (!explicitSessionId) return false;
+  return actionId === 'navigate' || existingSessionPresent;
+}
+
 interface BrowserActionScreenshot {
   path: string;
   relativePath: string;
@@ -245,39 +259,6 @@ interface BrowserPluginRuntimeHooks {
   activateNativeBrowserApplication(input: AssistantPluginActionExecutionInput, product: MacOsBrowserProduct): Promise<void>;
 }
 
-const NATIVE_BROWSER_BUNDLE_IDS: Record<MacOsBrowserProduct, string> = {
-  chrome: 'com.google.Chrome',
-  vivaldi: 'com.vivaldi.Vivaldi',
-};
-
-async function activateNativeBrowserApplicationViaDesktopOperator(
-  input: AssistantPluginActionExecutionInput,
-  product: MacOsBrowserProduct,
-): Promise<void> {
-  const desktopOperator = getExternalPluginAdapter(input.controllerHome, 'desktop_operator');
-  if (!desktopOperator) {
-    throw new AssistantPluginError(
-      'PLUGIN_BROWSER_NATIVE_FOREGROUND_ACTIVATOR_UNAVAILABLE',
-      'Native browser foreground activation requires the registered Forge Desktop Operator.',
-      { retryable: true, details: { browserProduct: product } },
-    );
-  }
-  await desktopOperator.executeAction({
-    controllerHome: input.controllerHome,
-    repoId: input.repoId,
-    repoRoot: input.repoRoot,
-    pluginId: 'desktop_operator',
-    actionId: 'desktop_session_open',
-    requestId: `${input.requestId}:native-browser-foreground:${product}`,
-    args: { bundle_id: NATIVE_BROWSER_BUNDLE_IDS[product], launch: false, activate: true },
-    origin: input.origin,
-    jobId: input.jobId,
-    timeoutMs: input.timeoutMs,
-    signal: input.signal,
-    deadlineAtMs: input.deadlineAtMs,
-  });
-}
-
 const defaultRuntimeHooks: BrowserPluginRuntimeHooks = {
   now: () => new Date().toISOString(),
   moduleAvailable: (name: string, repoRoot?: string) => {
@@ -318,7 +299,7 @@ const defaultRuntimeHooks: BrowserPluginRuntimeHooks = {
       clearTimeout(timer);
     }
   },
-  activateNativeBrowserApplication: activateNativeBrowserApplicationViaDesktopOperator,
+  activateNativeBrowserApplication: activateRuntimeComputerBrowserApplication,
 };
 
 let runtimeHooks: BrowserPluginRuntimeHooks = { ...defaultRuntimeHooks };
@@ -406,10 +387,6 @@ function stringList(value: unknown): string[] | undefined {
   return normalized.length > 0 ? Array.from(new Set(normalized)) : undefined;
 }
 
-function configPath(repoRoot: string): string {
-  return join(repoRoot, CONFIG_ROOT, 'browser.json');
-}
-
 function defaultProfileDir(repoRoot: string): string {
   return join(browserStateDir(repoRoot, 'profiles'), 'default');
 }
@@ -501,8 +478,10 @@ function writeJson(path: string, value: unknown): void {
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, 'utf-8');
 }
 
-function loadConfig(repoRoot: string): BrowserPluginConfig {
-  const persisted = readJson<PersistedBrowserPluginConfig>(configPath(repoRoot));
+function loadConfig(repoRoot: string, context?: Pick<RepositoryPluginConfigContext, 'controllerHome' | 'repoId'>): BrowserPluginConfig {
+  const persisted = context
+    ? readRepositoryPluginConfig<PersistedBrowserPluginConfig>({ ...context, repoRoot }, BROWSER_PLUGIN_ID)
+    : undefined;
   if (!persisted) return normalizeConfig({});
   return normalizeConfig(migrateLegacyRepositoryConfig(persisted));
 }
@@ -513,7 +492,7 @@ async function resolveBrowserPluginAuthorizationContextInternal(
   const action = browserActions().find((entry) => entry.actionId === input.actionId);
   if (!action || action.confirmation !== 'authorization' || !action.scopes.includes('browser.interact')) return undefined;
 
-  const persistedConfig = loadConfig(input.repoRoot);
+  const persistedConfig = loadConfig(input.repoRoot, input);
   const sessionId = stringValue(input.args.session_id);
   const authorizationBrowserMode = parseBrowserModeInput(input.args.browser_mode) ?? persistedConfig.browserMode;
   if (!sessionId || authorizationBrowserMode === 'isolated') return undefined;
@@ -568,15 +547,9 @@ export async function resolveBrowserPluginAuthorizationContext(
   );
 }
 
-export function readBrowserPluginConfiguration(repoRoot: string): { enabled: boolean } {
-  const config = loadConfig(repoRoot);
-  return { enabled: config.enabled };
-}
-
-function saveConfig(repoRoot: string, patch: Partial<BrowserPluginConfig>): BrowserPluginConfig {
-  const next = normalizeConfig({ ...loadConfig(repoRoot), ...patch });
-  writeJson(configPath(repoRoot), next);
-  return next;
+function saveConfig(input: Pick<AssistantPluginActionExecutionInput, 'controllerHome' | 'repoId' | 'repoRoot'>, patch: Partial<BrowserPluginConfig>): BrowserPluginConfig {
+  const next = normalizeConfig({ ...loadConfig(input.repoRoot, input), ...patch });
+  return writeRepositoryPluginConfig(input, BROWSER_PLUGIN_ID, next);
 }
 
 function parsedAbsoluteUrl(value: unknown): { raw: string; parsed: URL } {
@@ -1054,7 +1027,7 @@ async function establishAuthoritativeNativeForeground(
     const cause = error instanceof Error ? error.message : String(error);
     throw new AssistantPluginError(
       'PLUGIN_BROWSER_ACTIVATION_FAILED',
-      'Native browser exact-tab activation could not establish macOS system foreground authority through Forge Desktop Operator.',
+      'Native browser exact-tab activation could not establish system foreground authority through the configured Computer provider.',
       { retryable: true, details: { sessionId: target.sessionId, browserProduct: product, ...state, ...(causeCode ? { causeCode } : {}), cause: cause.slice(0, 500) } },
     );
   }
@@ -2127,14 +2100,36 @@ async function openNativeAttachedContext(
       : { sessionId: target.sessionId, status: 'no_saved_tab', reason: 'Created one plugin-owned tab while preserving the user active tab.' };
   }
 
+  let createdThisCallRef: MacOsBrowserTabRef | undefined;
   if (!discovered?.attachment) {
     const candidates = savedProduct ? [savedProduct] : (config.nativeBrowserCandidates ?? [...DEFAULT_USER_NATIVE_BROWSER_CANDIDATES]);
     discovered = await discoverMacOsBrowserAttachment(candidates, Math.min(timeout, MAX_CDP_DISCOVERY_TIMEOUT_MS));
+    const zeroWindowAttempt = args.__forge_require_existing_resource !== true
+      ? discovered.attempts.find((attempt) => attempt.status === 'unavailable' && attempt.error?.includes('FORGE_NO_BROWSER_WINDOW'))
+      : undefined;
+    if (!discovered.attachment && zeroWindowAttempt) {
+      const created = await createMacOsBrowserOwnedPageForProduct(
+        zeroWindowAttempt.product,
+        target.url,
+        discovered.attempts,
+        timeout,
+      );
+      page = created.page as unknown as PageLike;
+      discovered = { attachment: created.attachment, attempts: created.attachment.attempts };
+      createdThisCallRef = created.page.tabRef();
+      matchedBy = 'owned_token';
+      effectiveOwnership = 'plugin_owned';
+      sessionResume = {
+        sessionId: target.sessionId,
+        status: 'stale_tab',
+        reason: 'Browser process had no window; created the first Forge-owned tab through the existing create_tab Computer capability.',
+        savedTab,
+      };
+    }
   }
   if (!discovered.attachment) return { attempts: discovered.attempts };
   let activeAttachment = discovered.attachment;
 
-  let createdThisCallRef: MacOsBrowserTabRef | undefined;
   let navigationUsedReplacement = false;
   const navigateNativePageWithReplacement = async (candidate: PageLike): Promise<PageLike> => {
     const obsoleteRef = (candidate as unknown as { tabRef?: () => MacOsBrowserTabRef | undefined }).tabRef?.();
@@ -2486,11 +2481,13 @@ async function withPage<T>(
   let lastError: unknown;
   for (let attempt = 1; attempt <= retries; attempt += 1) {
     let handle: BrowserOpenHandle | undefined;
-    // Opening a browser resource may itself create or navigate a tab before a
-    // handle is returned. Replay is safe only for an observation action that is
-    // fenced to an already-existing resource. Anything else is potentially
-    // externally mutating from the outset.
-    let actionDispatched = !postDispatchReplaySafe;
+    // A provider/readiness failure before openBrowser returns a handle has not
+    // crossed the action dispatch boundary. Native open-page creation is itself
+    // transactional: its bridge either returns an exact created-tab receipt or
+    // cleans up the created tab before propagating failure. Mark dispatch only
+    // after a usable handle exists; subsequent goto/click/fill failures retain
+    // outcome-unknown fencing for non-replay-safe actions.
+    let actionDispatched = false;
     try {
       if (target.existingSession) assertBrowserSessionAvailable(repoRoot, target.sessionId);
       const browserArgs = requireExistingResource
@@ -2537,7 +2534,7 @@ async function withPage<T>(
         throw new AssistantPluginError(
           'PLUGIN_BROWSER_MUTATION_OUTCOME_UNKNOWN',
           `Browser action ${actionId} reported a transient failure after dispatch. Forge refused automatic replay because the external mutation outcome is unknown; verify current browser state before retrying.`,
-          { retryable: false, details: { actionId, requestedRetries: retries } },
+          { retryable: false, effectOutcome: 'outcome_unknown', details: { actionId, requestedRetries: retries } },
         );
       }
       if (attempt >= retries) throw error;
@@ -2733,9 +2730,10 @@ const STABLE_SELECTOR_HELPERS = `
 `;
 
 const EXTRACTION_SCRIPTS = {
-  query: (selector: string, limit: number) => `(() => {
+  query: (selector: string, limit: number, fromEnd = false) => `(() => {
     ${STABLE_SELECTOR_HELPERS}
-    const nodes = ${openShadowSelectorExpression(selector, true)}.slice(0, ${limit});
+    const allNodes = ${openShadowSelectorExpression(selector, true)};
+    const nodes = ${fromEnd ? `allNodes.slice(-${limit})` : `allNodes.slice(0, ${limit})`};
     return nodes.map((el) => {
       const role = el.getAttribute('role');
       const text = (el.innerText || el.textContent || '').trim().slice(0, 120);
@@ -3223,9 +3221,9 @@ function health(config: BrowserPluginConfig, repoRoot?: string): AssistantPlugin
   };
 }
 
-export function buildBrowserPluginManifest(previousRevision = 0, previousUpdatedAt?: string, repoRoot?: string): AssistantPluginManifest {
+export function buildBrowserPluginManifest(previousRevision = 0, previousUpdatedAt?: string, repoRoot?: string, context?: AssistantPluginBuildContext): AssistantPluginManifest {
   const root = repoRoot ?? process.cwd();
-  const config = loadConfig(root);
+  const config = loadConfig(root, context);
   const state = health(config, root);
   return {
     schemaVersion: 1,
@@ -3238,7 +3236,7 @@ export function buildBrowserPluginManifest(previousRevision = 0, previousUpdated
     authority: {
       strategy: 'derived',
       duplicateStateAllowed: false,
-      sourceOfTruth: ['repo-local:.forge/plugins/browser.json', 'controller-home:sqlite/browser_session', 'repo-local:.forge/browser/{screenshots,downloads,diagnostics}'],
+      sourceOfTruth: ['controller-home:repositories/<repoId>/plugins/config/browser.json', 'controller-home:sqlite/computer_interaction_target', 'controller-home:repository browser artifacts'],
     },
     enabled: config.enabled,
     lifecycle: {
@@ -3278,7 +3276,7 @@ async function executeBrowserPluginActionInternal(
   input: AssistantPluginActionExecutionInput,
   runtimeAlreadyRouted = false,
 ): Promise<Record<string, unknown>> {
-  const persisted = loadConfig(input.repoRoot);
+  const persisted = loadConfig(input.repoRoot, input);
   const actionSessionId = input.actionId === 'configure' ? undefined : stringValue(input.args.session_id);
   const actionSession = actionSessionId ? findBrowserSession(input.repoRoot, actionSessionId) : undefined;
   const current = input.actionId === 'configure' ? persisted : effectiveBrowserActionConfig(persisted, input.args, actionSession);
@@ -3360,7 +3358,7 @@ async function executeBrowserPluginActionInternal(
         const nextCdpAttachFallback = parseCdpAttachFallbackInput(args.cdp_attach_fallback) ?? current.cdpAttachFallback;
         const nextNativeAttachMode = parseNativeAttachModeInput(args.native_attach_mode) ?? current.nativeAttachMode;
         const nextNativeBrowserCandidates = parseNativeBrowserCandidatesInput(args.native_browser_candidates) ?? current.nativeBrowserCandidates;
-        const config = saveConfig(input.repoRoot, {
+        const config = saveConfig(input, {
           enabled: typeof args.enabled === 'boolean' ? args.enabled : current.enabled,
           browserMode: nextBrowserMode,
           profileMode: nextProfileMode,
@@ -3807,7 +3805,13 @@ async function executeBrowserPluginActionInternal(
               ? { text: await extractText(page, undefined, positiveNumber(input.args.max_chars, DEFAULT_MAX_TEXT_CHARS)) }
               : {}),
           };
-        }, { requireExistingResource: Boolean(existingSessionId) });
+        }, {
+          requireExistingResource: browserExplicitSessionRequiresExistingResource(
+            input.actionId,
+            existingSessionId,
+            Boolean(target.existingSession),
+          ),
+        });
       }
       case 'reload':
       case 'go_back':
@@ -3877,7 +3881,11 @@ async function executeBrowserPluginActionInternal(
         const limit = Math.min(positiveNumber(input.args.limit, 25), 100);
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
           const selection = resolveBrowserEvaluationScope(page, input.args, connection);
-          const matches = await selection.scope.evaluate<Array<Record<string, unknown>>>(EXTRACTION_SCRIPTS.query(selector, input.actionId === 'query_selector' ? 1 : limit));
+          const matches = await selection.scope.evaluate<Array<Record<string, unknown>>>(EXTRACTION_SCRIPTS.query(
+            selector,
+            input.actionId === 'query_selector' ? 1 : limit,
+            input.actionId === 'query_all' && input.args.from_end === true,
+          ));
           return {
             provider: browserResultProvider(connection.provider),
             sessionId: target.sessionId,
@@ -3932,17 +3940,50 @@ async function executeBrowserPluginActionInternal(
           };
         }, { persistSession: true });
       }
+      case 'reconcile_effect': {
+        const effectRequestId = requiredString(input.args.effect_request_id, 'effect_request_id');
+        requiredString(input.args.session_id, 'session_id');
+        const observationArgs = (prefix: 'applied' | 'not_applied'): Record<string, unknown> => ({
+          session_id: input.args.session_id,
+          ...(input.args.url !== undefined ? { url: input.args.url } : {}),
+          ...(input.args.max_chars !== undefined ? { max_chars: input.args.max_chars } : {}),
+          ...(input.args.frame_url !== undefined ? { frame_url: input.args.frame_url } : {}),
+          ...(input.args.frame_name !== undefined ? { frame_name: input.args.frame_name } : {}),
+          ...(input.args.frame_index !== undefined ? { frame_index: input.args.frame_index } : {}),
+          ...(input.args[`${prefix}_url_contains_any`] !== undefined ? { url_contains_any: input.args[`${prefix}_url_contains_any`] } : {}),
+          ...(input.args[`${prefix}_url_contains_none`] !== undefined ? { url_contains_none: input.args[`${prefix}_url_contains_none`] } : {}),
+          ...(input.args[`${prefix}_text_contains_any`] !== undefined ? { text_contains_any: input.args[`${prefix}_text_contains_any`] } : {}),
+          ...(input.args[`${prefix}_text_contains_none`] !== undefined ? { text_contains_none: input.args[`${prefix}_text_contains_none`] } : {}),
+          ...(input.args[`${prefix}_selector`] !== undefined ? { selector: input.args[`${prefix}_selector`] } : {}),
+        });
+        const hasCriteria = (args: Record<string, unknown>) => Object.keys(args).some((key) => !['session_id', 'url', 'max_chars', 'frame_url', 'frame_name', 'frame_index'].includes(key));
+        const appliedArgs = observationArgs('applied');
+        if (!hasCriteria(appliedArgs)) throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'reconcile_effect requires at least one applied_* observation criterion.', { retryable: false });
+        const applied = await executeBrowserPluginAction({ ...input, actionId: 'verify_state', args: appliedArgs });
+        if (applied.matched === true) return { effectRequestId, outcome: 'applied', output: applied, observation: applied };
+        const notAppliedArgs = observationArgs('not_applied');
+        if (hasCriteria(notAppliedArgs)) {
+          const notApplied = await executeBrowserPluginAction({ ...input, actionId: 'verify_state', args: notAppliedArgs });
+          if (notApplied.matched === true) return { effectRequestId, outcome: 'not_applied', observation: notApplied };
+          return { effectRequestId, outcome: 'unknown', observation: { applied, notApplied } };
+        }
+        return { effectRequestId, outcome: 'unknown', observation: { applied } };
+      }
       case 'verify_state': {
         requiredString(input.args.session_id, 'session_id');
         const target = resolveActionTarget(input.repoRoot, input.args);
         const expectedUrlRaw = stringValue(input.args.expected_url);
         const expectedUrl = expectedUrlRaw ? normalizedUrl(expectedUrlRaw) : undefined;
         const urlContains = stringValue(input.args.url_contains);
+        const urlContainsAny = stringList(input.args.url_contains_any);
+        const urlContainsNone = stringList(input.args.url_contains_none);
         const selector = stringValue(input.args.selector);
         const requireVisible = input.args.require_visible === true;
         const textContains = stringValue(input.args.text_contains);
-        if (!expectedUrl && !urlContains && !selector && !textContains) {
-          throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'verify_state requires at least one of expected_url, url_contains, selector, or text_contains.', { retryable: false });
+        const textContainsAny = stringList(input.args.text_contains_any);
+        const textContainsNone = stringList(input.args.text_contains_none);
+        if (!expectedUrl && !urlContains && !urlContainsAny && !urlContainsNone && !selector && !textContains && !textContainsAny && !textContainsNone) {
+          throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'verify_state requires at least one URL, selector, or text criterion.', { retryable: false });
         }
         if (requireVisible && !selector) {
           throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'require_visible requires selector.', { retryable: false });
@@ -3953,9 +3994,11 @@ async function executeBrowserPluginActionInternal(
           const checks: Array<Record<string, unknown>> = [];
           if (expectedUrl) checks.push({ criterion: 'url_exact', expected: expectedUrl, observed: observedUrl, matched: observedUrl === expectedUrl });
           if (urlContains) checks.push({ criterion: 'url_contains', expected: urlContains, observed: observedUrl, matched: observedUrl.includes(urlContains) });
+          if (urlContainsAny) checks.push({ criterion: 'url_contains_any', expected: urlContainsAny, observed: observedUrl, matched: urlContainsAny.some((value) => observedUrl.includes(value)) });
+          if (urlContainsNone) checks.push({ criterion: 'url_contains_none', expected: urlContainsNone, observed: observedUrl, matched: urlContainsNone.every((value) => !observedUrl.includes(value)) });
           let observation: { verificationVersion?: unknown; selectorExists?: unknown; visible?: unknown; textContains?: unknown; textSample?: unknown; textLength?: unknown; truncated?: unknown } | undefined;
-          if (selector || textContains) {
-            observation = await selection.scope.evaluate(verifyStateObservationScript(selector, textContains, Math.min(positiveNumber(input.args.max_chars, 2_000), 100_000)));
+          if (selector || textContains || textContainsAny || textContainsNone) {
+            observation = await selection.scope.evaluate(verifyStateObservationScript(selector, textContains, Math.min(positiveNumber(input.args.max_chars, 12_000), 100_000)));
             if (observation?.verificationVersion !== 1) {
               throw new AssistantPluginError('PLUGIN_BROWSER_VERIFY_STATE_UNAVAILABLE', 'Browser state observation returned an unsupported result.', { retryable: true });
             }
@@ -3973,6 +4016,9 @@ async function executeBrowserPluginActionInternal(
               ...(selector ? { selector } : {}),
             });
           }
+          const textSample = typeof observation?.textSample === 'string' ? observation.textSample : '';
+          if (textContainsAny) checks.push({ criterion: 'text_contains_any', expected: textContainsAny, observed: textSample, matched: textContainsAny.some((value) => textSample.includes(value)), textLength: observation?.textLength, truncated: observation?.truncated });
+          if (textContainsNone) checks.push({ criterion: 'text_contains_none', expected: textContainsNone, observed: textSample, matched: textContainsNone.every((value) => !textSample.includes(value)), textLength: observation?.textLength, truncated: observation?.truncated });
           return {
             provider: browserResultProvider(connection.provider),
             sessionId: target.sessionId,
@@ -4086,15 +4132,16 @@ async function executeBrowserPluginActionInternal(
       case 'activate_page': {
         const target = resolveActionTarget(input.repoRoot, input.args);
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
-          const waitMs = positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS);
           if (connection.provider === 'macos-apple-events') {
-            await establishAuthoritativeNativeForeground(input, page, connection, target, waitMs);
+            await establishAuthoritativeNativeForeground(
+              input, page, connection, target, browserNativeForegroundVerificationWaitMs(input.args.post_action_wait_ms),
+            );
           } else {
             if (!page.bringToFront) {
               throw new AssistantPluginError('PLUGIN_BROWSER_ACTIVATION_UNSUPPORTED', 'The selected browser provider cannot bring the saved page to the foreground.', { retryable: false });
             }
             await page.bringToFront();
-            await delay(waitMs);
+            await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           }
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'activate_page', 'Activated the exact saved browser page in authoritative foreground state.', {});
         });
@@ -4137,7 +4184,7 @@ async function executeBrowserPluginActionInternal(
             element.click();
             return { tag: element.tagName.toLowerCase(), className: element.className || '', text: normalize(element.innerText || element.textContent || '') };
           }, { text });
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'click_text', `Clicked exact visible text ${text}.`, { text, clicked });
         });
       }
@@ -4182,7 +4229,7 @@ async function executeBrowserPluginActionInternal(
               if (page.uncheck) await page.uncheck(selector, { timeout: timeoutMs });
               else await page.click(selector, { timeout: timeoutMs });
             }
-            await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+            await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
             const summary = input.actionId === 'click'
               ? `Clicked ${selector}.`
               : input.actionId === 'double_click'
@@ -4213,7 +4260,7 @@ async function executeBrowserPluginActionInternal(
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
           if (input.actionId === 'fill' || !page.type) await page.fill(selector, text, { timeout: timeoutMs });
           else await page.type(selector, text, { timeout: timeoutMs });
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, input.actionId, `${input.actionId} ${selector} with ${text.length} characters.`, {
             selector,
             textLength: text.length,
@@ -4233,7 +4280,7 @@ async function executeBrowserPluginActionInternal(
           if (!Array.isArray(selectedValues) || selectedValues.length === 0) {
             throw new AssistantPluginError('PLUGIN_BROWSER_SELECT_OPTION_FAILED', 'The browser provider did not retain any requested option selection.', { retryable: true, details: { selector, requestedCount: values.length } });
           }
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'select_option', `Selected ${values.length} option(s) on ${selector}.`, { selector, values, selectedValues });
         });
       }
@@ -4243,7 +4290,7 @@ async function executeBrowserPluginActionInternal(
         const key = requiredString(input.args.key, 'key');
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
           await page.press(selector, key, { timeout: positiveNumber(input.args.timeout_ms, current.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS) });
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'press', `Pressed ${key} on ${selector}.`, {
             selector,
             key,
@@ -4256,7 +4303,7 @@ async function executeBrowserPluginActionInternal(
         return await withPage(input.actionId, input.repoRoot, current, target, input.args, async (page, _diagnostics, connection) => {
           if (page.keyboard?.press) await page.keyboard.press(key);
           else await page.press('body', key, { timeout: positiveNumber(input.args.timeout_ms, current.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS) });
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'keyboard_shortcut', `Pressed shortcut ${key}.`, { key });
         });
       }
@@ -4398,7 +4445,7 @@ async function executeBrowserPluginActionInternal(
             }
           }
           if (nativeTrustedInput) await page.trustedInput!(trustedRequest);
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'trusted_input', `Sent trusted browser input (${kind}).`, { kind, ...(guard ? { guard } : {}) });
         });
       }
@@ -4418,7 +4465,7 @@ async function executeBrowserPluginActionInternal(
             const accepted = element.dispatchEvent(domEvent);
             return { accepted, defaultPrevented: domEvent.defaultPrevented };
           }, { selector, event });
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'dispatch_event', `Dispatched ${event} on ${selector}.`, {
             selector,
             event,
@@ -4488,7 +4535,7 @@ async function executeBrowserPluginActionInternal(
             throw new AssistantPluginError('PLUGIN_BROWSER_FILE_ATTACH_UNSUPPORTED', 'The selected browser provider does not support local file attachment.', { retryable: false });
           }
           await page.setInputFiles(selector, resolved.length === 1 ? resolved[0] : resolved);
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           const fileNames = resolved.map((path) => basename(path));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'attach_local_file', `Attached ${resolved.length} local file(s) to ${selector}.`, {
             selector,
@@ -4549,7 +4596,7 @@ async function executeBrowserPluginActionInternal(
           if (!existsSync(dest)) {
             throw new AssistantPluginError('PLUGIN_BROWSER_DOWNLOAD_FAILED', 'Browser download save completed without producing an artifact; refusing false success.', { retryable: true, details: { selector } });
           }
-          await delay(positiveNumber(input.args.post_action_wait_ms, DEFAULT_POST_ACTION_WAIT_MS));
+          await delay(browserExplicitPostActionWaitMs(input.args.post_action_wait_ms));
           return finalizeInteractiveAction(input.repoRoot, current, page, target, connection, 'await_file_transfer', `Captured download artifact for ${selector}.`, {
             selector,
             download: {
@@ -4588,10 +4635,3 @@ export async function executeBrowserPluginAction(input: AssistantPluginActionExe
     () => executeBrowserPluginActionInternal(input),
   );
 }
-
-export const browserPluginAdapter = {
-  pluginId: BROWSER_PLUGIN_ID,
-  buildManifest: buildBrowserPluginManifest,
-  executeAction: executeBrowserPluginAction,
-  resolveAuthorizationContext: resolveBrowserPluginAuthorizationContext,
-};

package/src/runtime/plugins/browser-automation-service.ts

@@ -1,45 +1,24 @@
-import { callMacOsCapabilityBroker } from './macos-capability-broker';
+import type {
+  ComputerBrowserAutomationRequest,
+  ComputerBrowserProduct,
+  ComputerBrowserTabRef,
+  ComputerCaptureRegion,
+  ComputerTrustedInput,
+} from '../../../packages/protocols/computer/index';
+import { executeRuntimeComputerBrowserAutomation } from '../root/computer-composition';
 import { AssistantPluginError } from './errors';
 
-const BROWSER_AUTOMATION_PROTOCOL_VERSION = 1;
-
-export type BrowserAutomationProduct = 'chrome' | 'vivaldi';
-export interface BrowserAutomationTabRef {
-  windowId: string;
-  tabId: string;
-}
-export interface BrowserAutomationRegion {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-export type BrowserAutomationTrustedInput =
-  | { kind: 'click'; x: number; y: number; button: 'left' | 'middle' | 'right'; clickCount: number }
-  | { kind: 'move'; x: number; y: number; steps: number }
-  | { kind: 'wheel'; deltaX: number; deltaY: number }
-  | { kind: 'drag'; fromX: number; fromY: number; toX: number; toY: number; button: 'left' | 'middle' | 'right'; steps: number }
-  | { kind: 'key'; key: string }
-  | { kind: 'text'; text: string };
-
-export type BrowserAutomationBrokerAction =
-  | { action: 'metadata'; product: BrowserAutomationProduct; ref?: BrowserAutomationTabRef }
-  | { action: 'list_tabs'; product: BrowserAutomationProduct }
-  | { action: 'create_tab'; product: BrowserAutomationProduct; url: string }
-  | { action: 'close_tab'; product: BrowserAutomationProduct; ref: BrowserAutomationTabRef }
-  | { action: 'navigate'; product: BrowserAutomationProduct; ref?: BrowserAutomationTabRef; url: string }
-  | { action: 'reload'; product: BrowserAutomationProduct; ref?: BrowserAutomationTabRef }
-  | { action: 'execute_javascript'; product: BrowserAutomationProduct; ref?: BrowserAutomationTabRef; source: string }
-  | { action: 'activate'; product: BrowserAutomationProduct; ref?: BrowserAutomationTabRef }
-  | { action: 'trusted_input'; product: BrowserAutomationProduct; ref: BrowserAutomationTabRef; input: BrowserAutomationTrustedInput }
-  | { action: 'capture_region'; region: BrowserAutomationRegion };
+export type BrowserAutomationProduct = ComputerBrowserProduct;
+export type BrowserAutomationTabRef = ComputerBrowserTabRef;
+export type BrowserAutomationRegion = ComputerCaptureRegion;
+export type BrowserAutomationTrustedInput = ComputerTrustedInput;
+export type BrowserAutomationBrokerAction = ComputerBrowserAutomationRequest;
 
 export async function callBrowserAutomationBroker(
   request: BrowserAutomationBrokerAction,
   timeoutMs: number,
 ): Promise<Record<string, unknown>> {
-  return await callMacOsCapabilityBroker({ ...request, timeoutMs, protocolVersion: BROWSER_AUTOMATION_PROTOCOL_VERSION }, timeoutMs);
+  return await executeRuntimeComputerBrowserAutomation(request, timeoutMs);
 }
 
 export async function captureBrowserAutomationRegion(region: BrowserAutomationRegion, timeoutMs: number): Promise<Buffer> {
@@ -48,7 +27,7 @@ export async function captureBrowserAutomationRegion(region: BrowserAutomationRe
   if (!base64) {
     throw new AssistantPluginError(
       'PLUGIN_MACOS_CAPABILITY_BROKER_PROTOCOL_ERROR',
-      'Stable Forge macOS capability broker returned an invalid screenshot payload.',
+      'Computer capture provider returned an invalid screenshot payload.',
       { retryable: true },
     );
   }