farming-code 2.2.23 → 2.2.28

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

@@ -0,0 +1,167 @@
+const WebSocket = require('ws');
+
+class CdpClient {
+  constructor(options = {}) {
+    this.WebSocket = options.WebSocket || WebSocket;
+    this.timeoutMs = options.timeoutMs || 15_000;
+    this.socket = null;
+    this.nextId = 0;
+    this.pending = new Map();
+    this.listeners = new Map();
+    this.closeListeners = new Set();
+    this.closeNotified = false;
+    this.closed = false;
+  }
+
+  connect(url) {
+    if (this.socket) throw new Error('CDP client is already connected');
+    return new Promise((resolve, reject) => {
+      const socket = new this.WebSocket(url);
+      this.socket = socket;
+      const onOpen = () => {
+        cleanupConnectListeners();
+        socket.on('message', data => this.handleMessage(data));
+        socket.on('close', () => this.handleClose(new Error('CDP connection closed')));
+        socket.on('error', error => this.handleClose(error));
+        resolve();
+      };
+      const onError = error => {
+        cleanupConnectListeners();
+        this.socket = null;
+        reject(error);
+      };
+      const onClose = () => {
+        cleanupConnectListeners();
+        this.socket = null;
+        reject(new Error('CDP connection closed during startup'));
+      };
+      const cleanupConnectListeners = () => {
+        socket.off('open', onOpen);
+        socket.off('error', onError);
+        socket.off('close', onClose);
+      };
+      socket.once('open', onOpen);
+      socket.once('error', onError);
+      socket.once('close', onClose);
+    });
+  }
+
+  send(method, params = {}, sessionId) {
+    if (!this.socket || this.closed || this.socket.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error('CDP connection is not open'));
+    }
+    const id = ++this.nextId;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (!this.pending.delete(id)) return;
+        reject(new Error(`CDP command timed out: ${method}`));
+      }, this.timeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { resolve, reject, timer });
+      const message = { id, method, params };
+      if (sessionId) message.sessionId = sessionId;
+      this.socket.send(JSON.stringify(message), error => {
+        if (!error) return;
+        const pending = this.pending.get(id);
+        if (!pending) return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        pending.reject(error);
+      });
+    });
+  }
+
+  on(method, handler, sessionId) {
+    const listener = { handler, sessionId: sessionId || null };
+    if (!this.listeners.has(method)) this.listeners.set(method, new Set());
+    this.listeners.get(method).add(listener);
+    return () => {
+      const listeners = this.listeners.get(method);
+      if (!listeners) return;
+      listeners.delete(listener);
+      if (listeners.size === 0) this.listeners.delete(method);
+    };
+  }
+
+  onClose(handler) {
+    this.closeListeners.add(handler);
+    return () => this.closeListeners.delete(handler);
+  }
+
+  waitFor(method, options = {}) {
+    const timeoutMs = options.timeoutMs || this.timeoutMs;
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const off = this.on(method, params => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        off();
+        resolve(params);
+      }, options.sessionId);
+      const timer = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        off();
+        reject(new Error(`CDP event timed out: ${method}`));
+      }, timeoutMs);
+      timer.unref?.();
+    });
+  }
+
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    const socket = this.socket;
+    this.socket = null;
+    if (socket && (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)) {
+      socket.close();
+    }
+    this.handleClose(new Error('CDP client closed'));
+  }
+
+  handleMessage(data) {
+    let message;
+    try {
+      message = JSON.parse(data.toString());
+    } catch {
+      return;
+    }
+    if (message.id && this.pending.has(message.id)) {
+      const pending = this.pending.get(message.id);
+      this.pending.delete(message.id);
+      clearTimeout(pending.timer);
+      if (message.error) {
+        const error = new Error(message.error.message || 'CDP command failed');
+        error.code = message.error.code;
+        error.data = message.error.data;
+        pending.reject(error);
+      } else {
+        pending.resolve(message.result || {});
+      }
+      return;
+    }
+    if (!message.method) return;
+    const listeners = this.listeners.get(message.method);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      if (listener.sessionId && listener.sessionId !== message.sessionId) continue;
+      listener.handler(message.params || {}, message);
+    }
+  }
+
+  handleClose(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+    if (this.closeNotified) return;
+    this.closeNotified = true;
+    for (const listener of [...this.closeListeners]) listener(error);
+  }
+}
+
+module.exports = {
+  CdpClient,
+};

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

@@ -0,0 +1,91 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+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 which(command) {
+  try {
+    return execFileSync('which', [command], {
+      encoding: 'utf8',
+      timeout: 1_000,
+      maxBuffer: 16_384,
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function discoverMacBrowser() {
+  return firstExecutable([
+    { 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() {
+  const commands = [
+    ['google-chrome', 'chrome'],
+    ['google-chrome-stable', 'chrome'],
+    ['brave-browser', 'brave'],
+    ['microsoft-edge', 'edge'],
+    ['chromium', 'chromium'],
+    ['chromium-browser', 'chromium'],
+  ];
+  for (const [command, kind] of commands) {
+    const found = executable(which(command), kind);
+    if (found) return found;
+  }
+  return null;
+}
+
+function discoverWindowsBrowser(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 firstExecutable(candidates);
+}
+
+function discoverBrowserExecutable(options = {}) {
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  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;
+}
+
+module.exports = {
+  discoverBrowserExecutable,
+};

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,
+};

package/extensions/browser/bin/farming-browser

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { requestJson } = require('../backend/farming-browser-client');
+const { rootIdForPath } = require('../../../backend/workspace-root-registry');
+
+function usage() {
+  return `Usage:
+  farming-browser capability
+  farming-browser create [--workspace <path>] [--name <name>] [--url <url>]
+  farming-browser list [--workspace <path>]
+  farming-browser start <browser-id>
+  farming-browser stop <browser-id>
+  farming-browser snapshot <browser-id>
+  farming-browser navigate <browser-id> <url>
+  farming-browser click <browser-id> <ref-or-selector>
+  farming-browser fill <browser-id> <ref-or-selector> <text>
+  farming-browser type <browser-id> <ref-or-selector> <text>
+  farming-browser press <browser-id> <key>
+  farming-browser scroll <browser-id> <delta-y> [delta-x]
+  farming-browser screenshot <browser-id> <output.png>
+
+Element refs come from snapshot. Prefix a CSS selector with "css=".
+`;
+}
+
+function locator(value) {
+  return value.startsWith('css=') ? { selector: value.slice(4) } : { ref: value };
+}
+
+async function run(argv = process.argv.slice(2)) {
+  const [command, ...args] = argv;
+  if (!command || command === '--help' || command === 'help') {
+    process.stdout.write(usage());
+    return 0;
+  }
+  if (command === 'mcp') {
+    const { runBrowserMcpServer } = require('../backend/browser-mcp-server');
+    await runBrowserMcpServer();
+    return 0;
+  }
+  if (command === 'capability') {
+    const result = await requestJson('GET', '/api/browsers/capability');
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  }
+  if (command === 'create') {
+    const option = name => {
+      const index = args.indexOf(name);
+      return index >= 0 ? String(args[index + 1] || '') : '';
+    };
+    const requestedWorkspace = option('--workspace') || process.env.FARMING_PROJECT_WORKSPACE || '';
+    if (!requestedWorkspace) {
+      throw new Error('Browser create requires --workspace or FARMING_PROJECT_WORKSPACE');
+    }
+    const workspace = path.resolve(requestedWorkspace);
+    const result = await requestJson('POST', '/api/browsers', {
+      rootId: rootIdForPath(workspace),
+      name: option('--name') || undefined,
+      url: option('--url') || undefined,
+    });
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  }
+  if (command === 'list') {
+    const workspaceIndex = args.indexOf('--workspace');
+    const requestedWorkspace = workspaceIndex >= 0
+      ? args[workspaceIndex + 1] || ''
+      : process.env.FARMING_PROJECT_WORKSPACE || '';
+    const workspace = requestedWorkspace ? path.resolve(requestedWorkspace) : '';
+    const result = await requestJson('GET', '/api/browsers');
+    const resources = workspace
+      ? result.resources.filter(resource => path.resolve(resource.workspace) === workspace)
+      : result.resources;
+    process.stdout.write(`${JSON.stringify({ resources }, null, 2)}\n`);
+    return 0;
+  }
+  const id = args[0];
+  if (!id) throw new Error(`Browser id is required\n\n${usage()}`);
+  if (command === 'start' || command === 'stop') {
+    const result = await requestJson('POST', `/api/browsers/${encodeURIComponent(id)}/${command}`);
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return 0;
+  }
+  let action;
+  if (command === 'snapshot') action = { kind: 'snapshot' };
+  else if (command === 'navigate') action = { kind: 'navigate', url: args[1] };
+  else if (command === 'click') action = { kind: 'click', ...locator(args[1] || '') };
+  else if (command === 'fill' || command === 'type') {
+    action = { kind: command, ...locator(args[1] || ''), text: args.slice(2).join(' ') };
+  } else if (command === 'press') action = { kind: 'press', key: args[1] };
+  else if (command === 'scroll') {
+    action = { kind: 'scroll', deltaY: Number(args[1]) || 0, deltaX: Number(args[2]) || 0 };
+  } else if (command === 'screenshot') {
+    const output = path.resolve(args[1] || 'farming-browser.png');
+    const result = await requestJson('POST', `/api/browsers/${encodeURIComponent(id)}/action`, { kind: 'screenshot' });
+    fs.writeFileSync(output, Buffer.from(result.data, 'base64'));
+    process.stdout.write(`${output}\n`);
+    return 0;
+  } else {
+    throw new Error(`Unknown command: ${command}\n\n${usage()}`);
+  }
+  const result = await requestJson('POST', `/api/browsers/${encodeURIComponent(id)}/action`, action);
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  return 0;
+}
+
+if (require.main === module) {
+  run().catch(error => {
+    process.stderr.write(`${error.message}\n`);
+    process.exitCode = 1;
+  });
+}
+
+module.exports = {
+  run,
+};