@moretea-labs/forge 1.6.0 → 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.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;
@@ -155,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 {
@@ -184,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[] {
@@ -287,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);