farming-code 2.2.28 → 2.2.30

package/extensions/browser/backend/browser-resource-store.js

@@ -3,14 +3,33 @@ const crypto = require('crypto');
 const { atomicWriteJson } = require('../../../backend/atomic-json-store');
 const storageLayout = require('../../../backend/storage-layout');
 
-const STORE_VERSION = 2;
+const STORE_VERSION = 5;
 const RESOURCE_ID_RE = /^browser_[A-Za-z0-9_-]+$/;
+const TAB_ID_RE = /^t\d+$/;
 const STATUSES = new Set(['stopped', 'starting', 'running', 'stopping', 'failed']);
 
 function createBrowserId() {
   return `browser_${Date.now().toString(36)}_${crypto.randomBytes(6).toString('hex')}`;
 }
 
+function normalizeProcessIdentity(value) {
+  if (
+    !value
+    || Number(value.pid) <= 0
+    || !Number.isSafeInteger(Number(value.pid))
+    || Number(value.processGroupId) <= 0
+    || !Number.isSafeInteger(Number(value.processGroupId))
+    || !String(value.startedAt || '').trim()
+    || !String(value.format || '').trim()
+  ) return null;
+  return {
+    pid: Number(value.pid),
+    processGroupId: Number(value.processGroupId),
+    startedAt: String(value.startedAt).trim(),
+    format: String(value.format).trim(),
+  };
+}
+
 function normalizeResource(value) {
   if (!value || typeof value !== 'object' || !RESOURCE_ID_RE.test(String(value.id || ''))) return null;
   const projectRootId = String(value.projectRootId || '').trim();
@@ -21,13 +40,21 @@ function normalizeResource(value) {
     projectRootId,
     workspace,
     name: String(value.name || 'Browser').trim().slice(0, 120) || 'Browser',
+    autoName: value.autoName === true,
     status: STATUSES.has(value.status) ? value.status : 'failed',
     generation: Number.isSafeInteger(value.generation) && value.generation >= 0 ? value.generation : 0,
     revision: Number.isSafeInteger(value.revision) && value.revision >= 0 ? value.revision : 0,
     url: String(value.url || 'about:blank').slice(0, 8_192) || 'about:blank',
     title: String(value.title || '').slice(0, 512),
     browserKind: String(value.browserKind || ''),
+    runtimeKind: String(value.runtimeKind || ''),
+    sessionId: RESOURCE_ID_RE.test(String(value.sessionId || '')) ? String(value.sessionId) : '',
+    sessionGeneration: Number.isSafeInteger(value.sessionGeneration) && value.sessionGeneration >= 0
+      ? value.sessionGeneration
+      : 0,
+    tabId: TAB_ID_RE.test(String(value.tabId || '')) ? String(value.tabId) : '',
     error: String(value.error || '').slice(0, 2_000),
+    processIdentity: normalizeProcessIdentity(value.processIdentity),
     createdAt: Number.isFinite(value.createdAt) ? value.createdAt : Date.now(),
     updatedAt: Number.isFinite(value.updatedAt) ? value.updatedAt : Date.now(),
   };
@@ -59,11 +86,6 @@ class BrowserResourceStore {
     for (const value of resources) {
       const resource = normalizeResource(value);
       if (!resource || this.resources.has(resource.id)) continue;
-      if (resource.status === 'running' || resource.status === 'starting' || resource.status === 'stopping') {
-        resource.status = 'failed';
-        resource.error = 'Farming restarted before the Browser runtime could be reconciled';
-        resource.updatedAt = Date.now();
-      }
       this.resources.set(resource.id, resource);
     }
     this.commit();
@@ -86,12 +108,16 @@ class BrowserResourceStore {
       projectRootId: input.projectRootId,
       workspace: input.workspace,
       name: input.name || 'Browser',
+      autoName: input.autoName === true,
       status: 'stopped',
       generation: 0,
       revision: 0,
       url: input.url || 'about:blank',
       title: '',
       browserKind: '',
+      sessionId: input.sessionId || '',
+      sessionGeneration: input.sessionGeneration || 0,
+      tabId: input.tabId || '',
       error: '',
       createdAt: Date.now(),
       updatedAt: Date.now(),
@@ -102,6 +128,21 @@ class BrowserResourceStore {
     return { ...resource };
   }
 
+  createRunningTab(input) {
+    const resource = this.create(input);
+    return this.update(resource.id, {
+      status: 'running',
+      autoName: true,
+      generation: 1,
+      browserKind: input.browserKind,
+      runtimeKind: 'agent-browser',
+      sessionId: input.sessionId,
+      sessionGeneration: input.sessionGeneration,
+      tabId: input.tabId,
+      title: input.title || '',
+    });
+  }
+
   update(id, patch) {
     const current = this.resources.get(id);
     if (!current) return null;

package/extensions/browser/backend/browser-router.js

@@ -11,8 +11,21 @@ function createBrowserRouter(manager, workspaceRootRegistry) {
   const router = express.Router();
   router.use(express.json({ limit: '2mb' }));
 
-  router.get('/capability', (_req, res) => {
-    res.json(manager.capability());
+  router.get('/capability', async (_req, res) => {
+    try {
+      await manager.refreshCapability();
+      res.json(manager.capability());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.post('/install', async (_req, res) => {
+    try {
+      res.json(await manager.installManagedChromium());
+    } catch (error) {
+      sendError(res, error);
+    }
   });
 
   router.get('/', (_req, res) => {

package/extensions/browser/backend/executable-discovery.js

@@ -1,6 +1,8 @@
 const fs = require('fs');
 const path = require('path');
 const { execFileSync } = require('child_process');
+const { verifyExecutable } = require('../../../backend/runtime-dependency-manager');
+const { AGENT_BROWSER_VERSION } = require('./agent-browser-runtime');
 
 function executable(pathname, kind) {
   if (!pathname) return null;
@@ -20,30 +22,57 @@ function firstExecutable(candidates) {
   return null;
 }
 
+function uniqueExecutables(candidates) {
+  const seen = new Set();
+  const result = [];
+  for (const candidate of candidates) {
+    const found = executable(candidate.path, candidate.kind);
+    if (!found || seen.has(found.path)) continue;
+    seen.add(found.path);
+    result.push(found);
+  }
+  return result;
+}
+
 function which(command) {
   try {
-    return execFileSync('which', [command], {
+    const program = process.platform === 'win32' ? 'where.exe' : 'which';
+    return execFileSync(program, [command], {
       encoding: 'utf8',
       timeout: 1_000,
       maxBuffer: 16_384,
-    }).trim();
+    }).split(/\r?\n/).map(value => value.trim()).find(Boolean) || '';
   } catch {
     return '';
   }
 }
 
-function discoverMacBrowser() {
-  return firstExecutable([
+function managedAgentBrowserPath(options = {}) {
+  const env = options.env || process.env;
+  return String(
+    options.agentBrowserPath
+    || env.FARMING_AGENT_BROWSER_BIN
+    || env.FARMING_AGENT_BROWSER_EXECUTABLE
+    || '',
+  ).trim();
+}
+
+function macBrowserCandidates() {
+  return [
     { kind: 'chrome', path: '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome' },
     { kind: 'brave', path: '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser' },
     { kind: 'edge', path: '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge' },
     { kind: 'chromium', path: '/Applications/Chromium.app/Contents/MacOS/Chromium' },
     { kind: 'chrome', path: path.join(process.env.HOME || '', 'Applications/Google Chrome.app/Contents/MacOS/Google Chrome') },
     { kind: 'brave', path: path.join(process.env.HOME || '', 'Applications/Brave Browser.app/Contents/MacOS/Brave Browser') },
-  ]);
+  ];
 }
 
-function discoverLinuxBrowser() {
+function discoverMacBrowser() {
+  return firstExecutable(macBrowserCandidates());
+}
+
+function linuxBrowserCandidates() {
   const commands = [
     ['google-chrome', 'chrome'],
     ['google-chrome-stable', 'chrome'],
@@ -52,14 +81,14 @@ function discoverLinuxBrowser() {
     ['chromium', 'chromium'],
     ['chromium-browser', 'chromium'],
   ];
-  for (const [command, kind] of commands) {
-    const found = executable(which(command), kind);
-    if (found) return found;
-  }
-  return null;
+  return commands.map(([command, kind]) => ({ kind, path: which(command) }));
 }
 
-function discoverWindowsBrowser(env) {
+function discoverLinuxBrowser() {
+  return firstExecutable(linuxBrowserCandidates());
+}
+
+function windowsBrowserCandidates(env) {
   const roots = [env.PROGRAMFILES, env['PROGRAMFILES(X86)'], env.LOCALAPPDATA].filter(Boolean);
   const candidates = [];
   for (const root of roots) {
@@ -70,22 +99,140 @@ function discoverWindowsBrowser(env) {
       { kind: 'chromium', path: path.join(root, 'Chromium', 'Application', 'chrome.exe') },
     );
   }
-  return firstExecutable(candidates);
+  return candidates;
+}
+
+function discoverWindowsBrowser(env) {
+  return firstExecutable(windowsBrowserCandidates(env));
+}
+
+function discoverBrowserExecutables(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  let candidates = [];
+  if (platform === 'darwin') candidates = macBrowserCandidates();
+  if (platform === 'linux') candidates = linuxBrowserCandidates();
+  if (platform === 'win32') candidates = windowsBrowserCandidates(env);
+  const managed = executable(options.managedBrowserPath, 'managed-chromium');
+  return [
+    ...uniqueExecutables(candidates),
+    ...(managed ? [managed] : []),
+  ];
+}
+
+function normalizeExternalCdpUrl(value) {
+  const input = String(value || '').trim();
+  if (!input) return '';
+  try {
+    const url = new URL(input);
+    if (!['http:', 'https:', 'ws:', 'wss:'].includes(url.protocol)) return '';
+    if (url.username || url.password || url.search) return '';
+    const hostname = url.hostname.toLowerCase();
+    if (!['localhost', '127.0.0.1', '[::1]'].includes(hostname)) return '';
+    url.hash = '';
+    return url.href;
+  } catch {
+    return '';
+  }
 }
 
 function discoverBrowserExecutable(options = {}) {
   const env = options.env || process.env;
   const platform = options.platform || process.platform;
+  const source = String(options.source || '').trim();
+  if (source === 'external-cdp') {
+    const cdpUrl = normalizeExternalCdpUrl(options.externalCdpUrl);
+    return cdpUrl
+      ? { kind: 'external-cdp', path: '', cdpUrl }
+      : {
+          kind: 'external-cdp',
+          path: '',
+          cdpUrl: '',
+          error: 'External CDP must be a loopback http(s) or ws(s) endpoint without credentials or query parameters',
+        };
+  }
+  if (source === 'managed') {
+    return executable(options.managedBrowserPath, 'managed-chromium') || {
+      kind: 'managed-chromium',
+      path: String(options.managedBrowserPath || ''),
+      error: 'Install or update the Farming-managed Chromium for this agent-browser version',
+    };
+  }
+  if (source === 'system') {
+    const configuredPath = String(options.executablePath || '').trim();
+    if (configuredPath) {
+      const configuredKind = String(options.executableKind || 'custom').trim() || 'custom';
+      return executable(path.resolve(configuredPath), configuredKind) || {
+        kind: configuredKind,
+        path: path.resolve(configuredPath),
+        error: 'The selected Chromium browser is no longer available',
+      };
+    }
+    let systemBrowser = null;
+    if (platform === 'darwin') systemBrowser = discoverMacBrowser();
+    if (platform === 'linux') systemBrowser = discoverLinuxBrowser();
+    if (platform === 'win32') systemBrowser = discoverWindowsBrowser(env);
+    return systemBrowser || executable(options.managedBrowserPath, 'managed-chromium');
+  }
+  const externalCdpInput = String(options.externalCdpUrl || env.FARMING_BROWSER_CDP_URL || '').trim();
+  if (externalCdpInput) {
+    const cdpUrl = normalizeExternalCdpUrl(externalCdpInput);
+    return cdpUrl
+      ? { kind: 'external-cdp', path: '', cdpUrl }
+      : {
+          kind: 'external-cdp',
+          path: '',
+          cdpUrl: '',
+          error: 'FARMING_BROWSER_CDP_URL must be a loopback http(s) or ws(s) CDP endpoint without credentials or query parameters',
+        };
+  }
   const configured = String(options.executablePath || env.FARMING_BROWSER_EXECUTABLE || '').trim();
   if (configured) {
     return executable(path.resolve(configured), 'custom');
   }
-  if (platform === 'darwin') return discoverMacBrowser();
-  if (platform === 'linux') return discoverLinuxBrowser();
-  if (platform === 'win32') return discoverWindowsBrowser(env);
-  return null;
+  let systemBrowser = null;
+  if (platform === 'darwin') systemBrowser = discoverMacBrowser();
+  if (platform === 'linux') systemBrowser = discoverLinuxBrowser();
+  if (platform === 'win32') systemBrowser = discoverWindowsBrowser(env);
+  return systemBrowser || executable(options.managedBrowserPath, 'managed-chromium');
+}
+
+async function discoverBrowserRuntime(options = {}) {
+  const browser = discoverBrowserExecutable(options);
+  if (!browser || browser.error) return browser;
+  const agentBrowserPath = managedAgentBrowserPath(options);
+  if (!agentBrowserPath) {
+    return {
+      ...browser,
+      error: `agent-browser ${AGENT_BROWSER_VERSION} is required; restart Farming through its launcher to prepare startup dependencies`,
+      runtimeErrorCode: 'NOT_FOUND',
+    };
+  }
+  const verification = await verifyExecutable(agentBrowserPath, AGENT_BROWSER_VERSION, {
+    execFile: options.execFile,
+    env: options.env || process.env,
+    platform: options.platform || process.platform,
+    useConfiguredLoader: true,
+  });
+  if (!verification.valid) {
+    return {
+      ...browser,
+      error: `The Farming-managed agent-browser must be version ${AGENT_BROWSER_VERSION}`,
+      runtimeErrorCode: 'VERSION_MISMATCH',
+    };
+  }
+  return {
+    ...browser,
+    agentBrowserPath,
+    agentBrowserVersion: AGENT_BROWSER_VERSION,
+    agentBrowserSource: 'managed',
+  };
 }
 
 module.exports = {
   discoverBrowserExecutable,
+  discoverBrowserExecutables,
+  discoverBrowserRuntime,
+  managedAgentBrowserPath,
+  normalizeExternalCdpUrl,
 };