farming-code 2.2.27 → 2.2.29

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

@@ -0,0 +1,190 @@
+const fs = require('fs');
+const crypto = require('crypto');
+const { atomicWriteJson } = require('../../../backend/atomic-json-store');
+const storageLayout = require('../../../backend/storage-layout');
+
+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();
+  const workspace = String(value.workspace || '').trim();
+  if (!projectRootId || !workspace) return null;
+  return {
+    id: value.id,
+    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(),
+  };
+}
+
+class BrowserResourceStore {
+  constructor(configDir, options = {}) {
+    this.directory = storageLayout.browserResourcesDir(configDir);
+    this.file = storageLayout.browserResourcesFile(configDir);
+    this.writeJson = options.writeJson || ((file, value) => atomicWriteJson(file, value, { mode: 0o600 }));
+    this.resources = new Map();
+    this.revision = 0;
+  }
+
+  init() {
+    fs.mkdirSync(this.directory, { recursive: true });
+    let parsed = {};
+    try {
+      parsed = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+    } catch (error) {
+      if (error?.code !== 'ENOENT') {
+        console.warn('Failed to read Browser resources:', error?.message || error);
+      }
+    }
+    this.revision = Number.isSafeInteger(parsed?.revision) && parsed.revision >= 0
+      ? parsed.revision
+      : 0;
+    const resources = Array.isArray(parsed?.resources) ? parsed.resources : [];
+    for (const value of resources) {
+      const resource = normalizeResource(value);
+      if (!resource || this.resources.has(resource.id)) continue;
+      this.resources.set(resource.id, resource);
+    }
+    this.commit();
+  }
+
+  list() {
+    return [...this.resources.values()]
+      .map(resource => ({ ...resource }))
+      .sort((left, right) => left.createdAt - right.createdAt);
+  }
+
+  get(id) {
+    const resource = this.resources.get(id);
+    return resource ? { ...resource } : null;
+  }
+
+  create(input) {
+    const resource = normalizeResource({
+      id: createBrowserId(),
+      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(),
+    });
+    if (!resource) throw new Error('Invalid Browser resource');
+    this.resources.set(resource.id, resource);
+    this.commit();
+    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;
+    const next = normalizeResource({
+      ...current,
+      ...patch,
+      id: current.id,
+      projectRootId: current.projectRootId,
+      workspace: current.workspace,
+      revision: current.revision + 1,
+      updatedAt: Date.now(),
+    });
+    if (!next) throw new Error('Invalid Browser resource update');
+    this.resources.set(id, next);
+    this.commit();
+    return { ...next };
+  }
+
+  delete(id) {
+    if (!this.resources.delete(id)) return false;
+    this.commit();
+    return true;
+  }
+
+  commit() {
+    const previousRevision = this.revision;
+    this.revision += 1;
+    try {
+      this.writeJson(this.file, {
+        version: STORE_VERSION,
+        revision: this.revision,
+        resources: this.list(),
+        updatedAt: Date.now(),
+      });
+    } catch (error) {
+      this.revision = previousRevision;
+      throw error;
+    }
+  }
+}
+
+module.exports = {
+  BrowserResourceStore,
+  RESOURCE_ID_RE,
+};

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

@@ -0,0 +1,133 @@
+const express = require('express');
+
+function sendError(res, error) {
+  res.status(Number(error?.status) || 500).json({
+    error: error?.message || 'Browser request failed',
+    code: error?.code || 'BROWSER_INTERNAL_ERROR',
+  });
+}
+
+function createBrowserRouter(manager, workspaceRootRegistry) {
+  const router = express.Router();
+  router.use(express.json({ limit: '2mb' }));
+
+  router.get('/capability', async (_req, res) => {
+    try {
+      await manager.refreshCapability();
+      res.json(manager.capability());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.get('/', (_req, res) => {
+    try {
+      res.json(manager.snapshot());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.get('/events', (req, res) => {
+    try {
+      manager.requireEnabled();
+    } catch (error) {
+      sendError(res, error);
+      return;
+    }
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    });
+    const onResource = resource => {
+      res.write(`event: resource\ndata: ${JSON.stringify(resource)}\n\n`);
+    };
+    const onDeleted = deletion => {
+      res.write(`event: deleted\ndata: ${JSON.stringify(deletion)}\n\n`);
+    };
+    const keepalive = setInterval(() => res.write(': keepalive\n\n'), 25_000);
+    keepalive.unref?.();
+    manager.on('resource', onResource);
+    manager.on('deleted', onDeleted);
+    res.write(`event: resources\ndata: ${JSON.stringify(manager.snapshot())}\n\n`);
+    req.on('close', () => {
+      clearInterval(keepalive);
+      manager.off('resource', onResource);
+      manager.off('deleted', onDeleted);
+    });
+  });
+
+  router.post('/', (req, res) => {
+    try {
+      const root = workspaceRootRegistry.resolve(req.body?.rootId);
+      if (root.kind === 'global') {
+        return res.status(400).json({ error: 'Browsers require a Project workspace' });
+      }
+      const resource = manager.create({
+        projectRootId: root.rootId,
+        workspace: root.canonicalPath,
+        name: req.body?.name,
+        url: req.body?.url,
+      });
+      res.status(201).json(resource);
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.patch('/:id', (req, res) => {
+    try {
+      res.json(manager.rename(req.params.id, req.body?.name));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.post('/:id/start', async (req, res) => {
+    try {
+      res.json(await manager.start(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.post('/:id/stop', async (req, res) => {
+    try {
+      res.json(await manager.stop(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.delete('/:id', async (req, res) => {
+    try {
+      res.json(await manager.delete(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.post('/:id/navigate', async (req, res) => {
+    try {
+      res.json(await manager.navigate(req.params.id, req.body?.url));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  router.post('/:id/action', async (req, res) => {
+    try {
+      res.json(await manager.action(req.params.id, req.body));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+
+  return router;
+}
+
+module.exports = {
+  createBrowserRouter,
+};

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

@@ -0,0 +1,224 @@
+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;
+  try {
+    fs.accessSync(pathname, fs.constants.X_OK);
+    return { kind, path: pathname };
+  } catch {
+    return null;
+  }
+}
+
+function firstExecutable(candidates) {
+  for (const candidate of candidates) {
+    const found = executable(candidate.path, candidate.kind);
+    if (found) return found;
+  }
+  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 {
+    const program = process.platform === 'win32' ? 'where.exe' : 'which';
+    return execFileSync(program, [command], {
+      encoding: 'utf8',
+      timeout: 1_000,
+      maxBuffer: 16_384,
+    }).split(/\r?\n/).map(value => value.trim()).find(Boolean) || '';
+  } catch {
+    return '';
+  }
+}
+
+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 discoverMacBrowser() {
+  return firstExecutable(macBrowserCandidates());
+}
+
+function linuxBrowserCandidates() {
+  const commands = [
+    ['google-chrome', 'chrome'],
+    ['google-chrome-stable', 'chrome'],
+    ['brave-browser', 'brave'],
+    ['microsoft-edge', 'edge'],
+    ['chromium', 'chromium'],
+    ['chromium-browser', 'chromium'],
+  ];
+  return commands.map(([command, kind]) => ({ kind, path: which(command) }));
+}
+
+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) {
+    candidates.push(
+      { kind: 'edge', path: path.join(root, 'Microsoft', 'Edge', 'Application', 'msedge.exe') },
+      { kind: 'chrome', path: path.join(root, 'Google', 'Chrome', 'Application', 'chrome.exe') },
+      { kind: 'brave', path: path.join(root, 'BraveSoftware', 'Brave-Browser', 'Application', 'brave.exe') },
+      { kind: 'chromium', path: path.join(root, 'Chromium', 'Application', 'chrome.exe') },
+    );
+  }
+  return candidates;
+}
+
+function discoverWindowsBrowser(env) {
+  return firstExecutable(windowsBrowserCandidates(env));
+}
+
+function discoverBrowserExecutables(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  if (platform === 'darwin') return uniqueExecutables(macBrowserCandidates());
+  if (platform === 'linux') return uniqueExecutables(linuxBrowserCandidates());
+  if (platform === 'win32') return uniqueExecutables(windowsBrowserCandidates(env));
+  return [];
+}
+
+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 === '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',
+      };
+    }
+    if (platform === 'darwin') return discoverMacBrowser();
+    if (platform === 'linux') return discoverLinuxBrowser();
+    if (platform === 'win32') return discoverWindowsBrowser(env);
+    return null;
+  }
+  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;
+}
+
+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,
+};

package/extensions/browser/backend/farming-browser-client.js

@@ -0,0 +1,83 @@
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const storageLayout = require('../../../backend/storage-layout');
+
+const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function resolveConnection(env = process.env) {
+  const configDir = storageLayout.farmingConfigDir(env);
+  const state = readJson(storageLayout.serverStateFile(configDir));
+  const explicit = String(env.FARMING_CONTROL_URL || env.FARMING_BROWSER_URL || '').trim();
+  const basePath = String(state.basePath || '/').replace(/\/$/, '');
+  const origin = explicit || `http://127.0.0.1:${Number(state.port) || 3000}${basePath}`;
+  let token = String(env.FARMING_BROWSER_TOKEN || '').trim();
+  if (!token && env.FARMING_DISABLE_AUTH !== '1') {
+    const tokenFile = String(env.FARMING_TOKEN_FILE || storageLayout.sessionTokenFile(configDir));
+    try {
+      token = fs.readFileSync(tokenFile, 'utf8').trim();
+    } catch {
+      token = '';
+    }
+  }
+  return { origin: origin.replace(/\/$/, ''), token };
+}
+
+function requestTimeoutMs(env = process.env) {
+  const requested = Number(env.FARMING_BROWSER_REQUEST_TIMEOUT_MS);
+  if (!Number.isFinite(requested)) return DEFAULT_REQUEST_TIMEOUT_MS;
+  return Math.min(120_000, Math.max(1_000, Math.round(requested)));
+}
+
+function requestJson(method, pathname, body, env = process.env) {
+  const connection = resolveConnection(env);
+  const url = new URL(`${connection.origin}${pathname}`);
+  const transport = url.protocol === 'https:' ? https : http;
+  const payload = body === undefined ? null : Buffer.from(JSON.stringify(body));
+  return new Promise((resolve, reject) => {
+    const request = transport.request(url, {
+      method,
+      headers: {
+        Accept: 'application/json',
+        ...(payload ? { 'Content-Type': 'application/json', 'Content-Length': String(payload.length) } : {}),
+        ...(connection.token ? { Cookie: `farming_token=${encodeURIComponent(connection.token)}` } : {}),
+      },
+    }, response => {
+      const chunks = [];
+      response.on('data', chunk => chunks.push(chunk));
+      response.on('end', () => {
+        let value;
+        try {
+          value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        } catch {
+          reject(new Error(`Farming Browser returned HTTP ${response.statusCode}`));
+          return;
+        }
+        if ((response.statusCode || 500) >= 400) {
+          reject(new Error(value.error || `Farming Browser returned HTTP ${response.statusCode}`));
+          return;
+        }
+        resolve(value);
+      });
+    });
+    request.setTimeout(requestTimeoutMs(env), () => {
+      request.destroy(new Error(`Farming Browser request timed out after ${requestTimeoutMs(env)}ms`));
+    });
+    request.on('error', reject);
+    if (payload) request.write(payload);
+    request.end();
+  });
+}
+
+module.exports = {
+  requestJson,
+  resolveConnection,
+};

package/extensions/browser/backend/index.js

@@ -0,0 +1,7 @@
+const { BrowserResourceManager } = require('./browser-resource-manager');
+const { createBrowserRouter } = require('./browser-router');
+
+module.exports = {
+  BrowserResourceManager,
+  createBrowserRouter,
+};