farming-code 2.2.30 → 2.2.32

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

@@ -1,190 +0,0 @@
-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

@@ -1,141 +0,0 @@
-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.post('/install', async (_req, res) => {
-    try {
-      res.json(await manager.installManagedChromium());
-    } 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

@@ -1,238 +0,0 @@
-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;
-  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');
-  }
-  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,
-};

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

@@ -1,83 +0,0 @@
-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

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