@agenticmail/enterprise 0.5.80 → 0.5.82

package/src/engine/agent-routes.ts

@@ -927,6 +927,99 @@ export function createAgentRoutes(opts: {
     return c.json({ config: managed.config?.browserConfig || {} });
   });
 
+  router.post('/bridge/agents/:id/browser-config/test', async (c) => {
+    const agentId = c.req.param('id');
+    const managed = lifecycle.getAgent(agentId);
+    if (!managed) return c.json({ error: 'Agent not found' }, 404);
+
+    const cfg = managed.config?.browserConfig || {};
+    const provider = cfg.provider || 'local';
+
+    try {
+      if (provider === 'local') {
+        // Test local Chromium availability
+        try {
+          const { execSync } = await import('node:child_process');
+          const chromePath = cfg.executablePath || process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH || '/usr/bin/chromium';
+          const version = execSync(`${chromePath} --version 2>/dev/null || echo "not found"`, { timeout: 5000 }).toString().trim();
+          if (version.includes('not found')) {
+            return c.json({ error: 'Chromium not found at ' + chromePath });
+          }
+          return c.json({ ok: true, browserVersion: version, provider: 'local' });
+        } catch (e: any) {
+          return c.json({ error: 'Chromium not available: ' + e.message });
+        }
+      }
+
+      if (provider === 'remote-cdp') {
+        if (!cfg.cdpUrl) return c.json({ error: 'CDP URL not configured' });
+        try {
+          // Extract HTTP URL from WS URL to query /json/version
+          const wsUrl = new URL(cfg.cdpUrl);
+          const httpUrl = `http://${wsUrl.hostname}:${wsUrl.port}/json/version`;
+          const resp = await fetch(httpUrl, { signal: AbortSignal.timeout(cfg.cdpTimeout || 10000) });
+          if (!resp.ok) return c.json({ error: `CDP endpoint returned ${resp.status}` });
+          const data = await resp.json() as any;
+          return c.json({ ok: true, browserVersion: data.Browser || data['User-Agent'], webSocketUrl: data.webSocketDebuggerUrl, provider: 'remote-cdp' });
+        } catch (e: any) {
+          return c.json({ error: 'Cannot connect to CDP: ' + e.message });
+        }
+      }
+
+      if (provider === 'browserless') {
+        if (!cfg.browserlessToken) return c.json({ error: 'Browserless API token not configured' });
+        const endpoint = cfg.browserlessEndpoint || 'https://chrome.browserless.io';
+        try {
+          const resp = await fetch(`${endpoint}/config?token=${cfg.browserlessToken}`, { signal: AbortSignal.timeout(10000) });
+          if (!resp.ok) return c.json({ error: `Browserless returned ${resp.status}` });
+          const data = await resp.json() as any;
+          return c.json({ ok: true, browserVersion: data.chrome?.version || 'Connected', provider: 'browserless', concurrent: data.concurrent });
+        } catch (e: any) {
+          return c.json({ error: 'Cannot connect to Browserless: ' + e.message });
+        }
+      }
+
+      if (provider === 'browserbase') {
+        if (!cfg.browserbaseApiKey) return c.json({ error: 'Browserbase API key not configured' });
+        try {
+          const resp = await fetch('https://www.browserbase.com/v1/sessions', {
+            method: 'POST',
+            headers: { 'x-bb-api-key': cfg.browserbaseApiKey, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ projectId: cfg.browserbaseProjectId }),
+            signal: AbortSignal.timeout(15000),
+          });
+          if (!resp.ok) return c.json({ error: `Browserbase returned ${resp.status}` });
+          const data = await resp.json() as any;
+          return c.json({ ok: true, browserVersion: 'Session created: ' + (data.id || 'OK'), provider: 'browserbase' });
+        } catch (e: any) {
+          return c.json({ error: 'Cannot connect to Browserbase: ' + e.message });
+        }
+      }
+
+      if (provider === 'steel') {
+        if (!cfg.steelApiKey) return c.json({ error: 'Steel API key not configured' });
+        const endpoint = cfg.steelEndpoint || 'https://api.steel.dev';
+        try {
+          const resp = await fetch(`${endpoint}/v1/sessions`, {
+            method: 'POST',
+            headers: { 'Authorization': `Bearer ${cfg.steelApiKey}`, 'Content-Type': 'application/json' },
+            body: JSON.stringify({ timeout: 60 }),
+            signal: AbortSignal.timeout(15000),
+          });
+          if (!resp.ok) return c.json({ error: `Steel returned ${resp.status}` });
+          const data = await resp.json() as any;
+          return c.json({ ok: true, browserVersion: 'Session: ' + (data.id || 'OK'), provider: 'steel' });
+        } catch (e: any) {
+          return c.json({ error: 'Cannot connect to Steel: ' + e.message });
+        }
+      }
+
+      return c.json({ ok: true, provider, note: 'Connection test not implemented for this provider' });
+    } catch (e: any) {
+      return c.json({ error: e.message });
+    }
+  });
+
   router.put('/bridge/agents/:id/browser-config', async (c) => {
     const agentId = c.req.param('id');
     const managed = lifecycle.getAgent(agentId);

package/src/engine/db-adapter.ts

@@ -1022,10 +1022,11 @@ export class EngineDatabase {
   }
 
   private rowToManagedAgent(row: any): ManagedAgent {
-    return {
+    const config = sj(row.config);
+    const agent: ManagedAgent = {
       id: row.id,
       orgId: row.org_id,
-      config: sj(row.config),
+      config,
       state: row.state,
       stateHistory: [], // Loaded separately via getStateHistory
       health: sj(row.health || '{}'),
@@ -1036,6 +1037,11 @@ export class EngineDatabase {
       lastHealthCheckAt: row.last_health_check_at,
       version: row.version,
     };
+    // Restore budgetConfig from config JSON
+    if ((config as any)?.budgetConfig) {
+      agent.budgetConfig = (config as any).budgetConfig;
+    }
+    return agent;
   }
 
   private rowToOrg(row: any): Organization {

package/src/engine/lifecycle.ts

@@ -708,6 +708,9 @@ export class AgentLifecycleManager {
     const agent = this.agents.get(agentId);
     if (!agent) throw new Error(`Agent ${agentId} not found`);
     agent.budgetConfig = config;
+    // Also store in config JSON so it survives DB round-trips
+    if (!agent.config) agent.config = {} as any;
+    (agent.config as any).budgetConfig = config;
     agent.updatedAt = new Date().toISOString();
     await this.persistAgent(agent);
   }
@@ -716,7 +719,13 @@ export class AgentLifecycleManager {
    * Get per-agent budget configuration
    */
   getBudgetConfig(agentId: string): AgentBudgetConfig | undefined {
-    return this.agents.get(agentId)?.budgetConfig;
+    const agent = this.agents.get(agentId);
+    if (!agent) return undefined;
+    // Restore from config JSON if not on top-level
+    if (!agent.budgetConfig && (agent.config as any)?.budgetConfig) {
+      agent.budgetConfig = (agent.config as any).budgetConfig;
+    }
+    return agent.budgetConfig;
   }
 
   /**