@moretea-labs/forge 1.5.1 → 1.7.0

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

@@ -15,14 +15,24 @@ export interface BrowserAutomationRegion {
   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 async function callBrowserAutomationBroker(

package/src/runtime/plugins/browser-handoff-host.ts

@@ -19,16 +19,10 @@ function delay(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-function hostnameAllowed(hostname: string, allowedDomains?: string[]): boolean {
-  if (!allowedDomains || allowedDomains.length === 0) return true;
-  const normalized = hostname.toLowerCase();
-  return allowedDomains.some((domain) => normalized === domain || normalized.endsWith(`.${domain}`));
-}
-
-function assertAllowed(url: string, allowedDomains?: string[]): void {
+function assertHttpUrl(url: string): void {
   const parsed = new URL(url);
-  if (!['http:', 'https:'].includes(parsed.protocol) || !hostnameAllowed(parsed.hostname, allowedDomains)) {
-    throw new Error(`URL is outside the browser handoff allowlist: ${url}`);
+  if (!['http:', 'https:'].includes(parsed.protocol)) {
+    throw new Error(`Browser handoff only supports HTTP(S) URLs: ${url}`);
   }
 }
 
@@ -105,7 +99,7 @@ async function runNativeHandoff(specPath: string, spec: BrowserHandoffLaunchSpec
       if (resume) {
         removeInteractionCommand(spec.repoRoot, 'browser', spec.interactionId, 'resume');
         metadata = await readMacOsBrowserOwnedTabMetadata(native.product, native.ref, spec.defaultTimeoutMs);
-        assertAllowed(metadata.url, spec.allowedDomains);
+        assertHttpUrl(metadata.url);
         const existing = existsSync(spec.sessionPath)
           ? readJsonFile<Record<string, unknown>>(spec.sessionPath, {})
           : {};
@@ -146,7 +140,7 @@ async function main(): Promise<void> {
   const specPath = process.argv[2];
   if (!specPath) throw new Error('browser handoff launch spec path is required');
   const spec = readJsonFile<BrowserHandoffLaunchSpec>(specPath);
-  assertAllowed(spec.url, spec.allowedDomains);
+  assertHttpUrl(spec.url);
   if (spec.nativeBrowser) {
     await runNativeHandoff(specPath, spec);
     return;
@@ -166,11 +160,6 @@ async function main(): Promise<void> {
           title(): Promise<string>;
           bringToFront?(): Promise<void>;
         }>;
-        route(pattern: string, handler: (route: {
-          request(): { url(): string };
-          continue(): Promise<void>;
-          abort(errorCode?: string): Promise<void>;
-        }) => Promise<void> | void): Promise<void>;
         close(): Promise<void>;
       }>;
     };
@@ -205,20 +194,6 @@ async function main(): Promise<void> {
 
   try {
     context = await playwright.chromium.launchPersistentContext(spec.profileDir, launchOptions);
-    await context.route('**/*', async (route) => {
-      const requestUrl = route.request().url();
-      try {
-        const parsed = new URL(requestUrl);
-        if (['http:', 'https:'].includes(parsed.protocol) && !hostnameAllowed(parsed.hostname, spec.allowedDomains)) {
-          await route.abort('blockedbyclient');
-          return;
-        }
-      } catch {
-        await route.abort('blockedbyclient');
-        return;
-      }
-      await route.continue();
-    });
     let page = context.pages()[0] ?? await context.newPage();
     await page.goto(spec.url, { waitUntil: 'domcontentloaded', timeout: spec.defaultTimeoutMs });
     if (page.bringToFront) await page.bringToFront();
@@ -263,7 +238,7 @@ async function main(): Promise<void> {
       const resume = readInteractionCommand(spec.repoRoot, 'browser', spec.interactionId, 'resume');
       if (resume) {
         removeInteractionCommand(spec.repoRoot, 'browser', spec.interactionId, 'resume');
-        assertAllowed(page.url(), spec.allowedDomains);
+        assertHttpUrl(page.url());
         const existing = existsSync(spec.sessionPath)
           ? readJsonFile<Record<string, unknown>>(spec.sessionPath, {})
           : {};

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

@@ -1,6 +1,6 @@
 import { randomUUID } from 'crypto';
 import { spawn } from 'child_process';
-import { closeSync, existsSync, openSync, readFileSync } from 'fs';
+import { closeSync, existsSync, openSync, readFileSync, readdirSync, rmSync } from 'fs';
 import { basename, dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { writeJsonAtomic } from '../shared/json-files';
@@ -25,6 +25,7 @@ const MAX_HANDOFF_TIMEOUT_MS = 60 * 60_000;
 const STARTUP_GRACE_MS = 15_000;
 const STARTUP_POLL_MS = 50;
 const MAX_STARTUP_LOG_CHARS = 4_000;
+const MAX_TERMINAL_BROWSER_HANDOFFS = 20;
 
 export interface BrowserHandoffLaunchSpec {
   schemaVersion: 1;
@@ -38,7 +39,6 @@ export interface BrowserHandoffLaunchSpec {
   profileDirectory?: string;
   browserChannel?: string;
   executablePath?: string;
-  allowedDomains?: string[];
   defaultTimeoutMs: number;
   nativeBrowser?: { product: MacOsBrowserProduct; ref: MacOsBrowserTabRef };
   expiresAt: string;
@@ -57,7 +57,6 @@ export interface BrowserHandoffStartInput {
   profileDirectory?: string;
   browserChannel?: string;
   executablePath?: string;
-  allowedDomains?: string[];
   defaultTimeoutMs: number;
   nativeBrowser?: { product: MacOsBrowserProduct; ref: MacOsBrowserTabRef };
   reason: string;
@@ -157,6 +156,15 @@ function reconcileRecord(_repoRoot: string, record: InteractionSessionRecord): I
   const expired = Number.isFinite(nowMs) && Number.isFinite(Date.parse(record.expiresAt)) && nowMs >= Date.parse(record.expiresAt);
   const startupGrace = record.status === 'starting' && Number.isFinite(createdMs) && nowMs - createdMs < STARTUP_GRACE_MS;
   const live = hooks.pidAlive(record.host?.pid);
+  const runtimeManaged = record.targetAliases?.includes('runtime-managed') === true;
+  if (runtimeManaged && expired) {
+    return {
+      ...record,
+      status: 'failed',
+      updatedAt: now,
+      error: { code: 'HANDOFF_EXPIRED', message: 'The runtime-managed browser handoff expired before it was resumed.' },
+    };
+  }
   if (record.status === 'closing') {
     if (live) return record;
     return {
@@ -186,12 +194,28 @@ function reconcileRecord(_repoRoot: string, record: InteractionSessionRecord): I
   };
 }
 
+function pruneBrowserHandoffLogs(repoRoot: string): number {
+  const retained = new Set(listInteractionSessions(repoRoot, PROVIDER).map((record) => record.interactionId));
+  const launchRoot = dirname(interactionLaunchSpecPath(repoRoot, PROVIDER, '__probe__'));
+  if (!existsSync(launchRoot)) return 0;
+  let removed = 0;
+  for (const name of readdirSync(launchRoot)) {
+    if (!name.endsWith('.log')) continue;
+    const interactionId = name.slice(0, -'.log'.length);
+    if (retained.has(interactionId)) continue;
+    rmSync(join(launchRoot, name), { force: true });
+    removed += 1;
+  }
+  return removed;
+}
+
 function persistDeadBrowserHandoffs(repoRoot: string): void {
   for (const stored of listInteractionSessions(repoRoot, PROVIDER)) {
     const reconciled = reconcileRecord(repoRoot, stored);
     if (stored.status !== reconciled.status && reconciled.status === 'failed') writeInteractionSession(repoRoot, reconciled);
   }
-  pruneInteractionSessions(repoRoot, PROVIDER);
+  pruneInteractionSessions(repoRoot, PROVIDER, MAX_TERMINAL_BROWSER_HANDOFFS);
+  pruneBrowserHandoffLogs(repoRoot);
 }
 
 export function listBrowserHandoffs(repoRoot: string): InteractionSessionRecord[] {
@@ -289,6 +313,70 @@ async function waitForBrowserHandoffStartup(
   throw new AssistantPluginError('PLUGIN_ACTION_FAILED', message, { retryable: true, details: { interactionId } });
 }
 
+export function isRuntimeManagedBrowserHandoff(record: InteractionSessionRecord): boolean {
+  return record.targetAliases?.includes('runtime-managed') === true;
+}
+
+export function startRuntimeManagedBrowserHandoff(
+  input: BrowserHandoffStartInput,
+  result: { url?: string; title?: string },
+): InteractionSessionRecord {
+  persistDeadBrowserHandoffs(input.repoRoot);
+  assertBrowserProfileAvailable(input.repoRoot, input.selectedProfilePath);
+  const timestamp = hooks.now();
+  const interactionId = `browser_handoff_${randomUUID()}`;
+  const expiresAt = new Date(Date.parse(timestamp) + boundedTimeout(input.timeoutMs)).toISOString();
+  const record: InteractionSessionRecord = {
+    schemaVersion: 1,
+    interactionId,
+    provider: PROVIDER,
+    sessionId: input.sessionId,
+    targetId: input.selectedProfilePath,
+    targetAliases: ['runtime-managed'],
+    status: 'waiting_for_user',
+    reason: input.reason,
+    instructions: input.instructions,
+    owner: {
+      repoId: input.repoId,
+      requestId: input.requestId,
+      jobId: input.jobId,
+    },
+    host: {
+      pid: process.pid,
+      startedAt: timestamp,
+      heartbeatAt: timestamp,
+      foregroundPresented: true,
+    },
+    result,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    expiresAt,
+  };
+  return writeInteractionSession(input.repoRoot, record);
+}
+
+export function resolveRuntimeManagedBrowserHandoff(
+  repoRoot: string,
+  interactionId: string,
+  resolution: 'resume' | 'cancel',
+  result?: { url?: string; title?: string },
+): InteractionSessionRecord {
+  const current = getBrowserHandoff(repoRoot, interactionId);
+  if (!isRuntimeManagedBrowserHandoff(current)) {
+    throw new AssistantPluginError('PLUGIN_ACTION_ARGUMENT_INVALID', 'The browser handoff is not runtime-managed.', { retryable: false });
+  }
+  if (!isInteractionSessionActive(current.status)) return current;
+  return patchInteractionSession(repoRoot, PROVIDER, interactionId, {
+    status: resolution === 'resume' ? 'completed' : 'closed',
+    result: result ?? current.result,
+    host: {
+      ...current.host,
+      heartbeatAt: hooks.now(),
+      foregroundPresented: false,
+    },
+  }) ?? current;
+}
+
 export async function startBrowserHandoff(input: BrowserHandoffStartInput): Promise<InteractionSessionRecord> {
   persistDeadBrowserHandoffs(input.repoRoot);
   assertBrowserProfileAvailable(input.repoRoot, input.selectedProfilePath);
@@ -326,7 +414,6 @@ export async function startBrowserHandoff(input: BrowserHandoffStartInput): Prom
     profileDirectory: input.profileDirectory,
     browserChannel: input.browserChannel,
     executablePath: input.executablePath,
-    allowedDomains: input.allowedDomains,
     defaultTimeoutMs: input.defaultTimeoutMs,
     nativeBrowser: input.nativeBrowser,
     expiresAt,