farming-code 2.2.29 → 2.2.32

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

@@ -0,0 +1,228 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_resource_store_exports = {};
+__export(browser_resource_store_exports, {
+  BrowserResourceStore: () => BrowserResourceStore,
+  RESOURCE_ID_RE: () => RESOURCE_ID_RE
+});
+module.exports = __toCommonJS(browser_resource_store_exports);
+var crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var import_atomic_json_store = require("../../../backend/atomic-json-store.cjs");
+var import_storage_layout = require("../../../backend/storage-layout.cjs");
+const STORE_VERSION = 6;
+const RESOURCE_ID_RE = /^browser_[A-Za-z0-9_-]+$/;
+const TAB_ID_RE = /^t\d+$/;
+const STATUSES = /* @__PURE__ */ new Set([
+  "stopped",
+  "starting",
+  "running",
+  "stopping",
+  "failed"
+]);
+function recordValue(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function errorCode(error) {
+  if (!error || typeof error !== "object" || !("code" in error)) return "";
+  return typeof error.code === "string" ? error.code : "";
+}
+function isBrowserResourceStatus(value) {
+  return typeof value === "string" && STATUSES.has(value);
+}
+function createBrowserId() {
+  return `browser_${Date.now().toString(36)}_${crypto.randomBytes(6).toString("hex")}`;
+}
+function normalizeProcessIdentity(value) {
+  const identity = recordValue(value);
+  if (!value || Number(identity.pid) <= 0 || !Number.isSafeInteger(Number(identity.pid)) || Number(identity.processGroupId) <= 0 || !Number.isSafeInteger(Number(identity.processGroupId)) || !String(identity.startedAt || "").trim() || !String(identity.format || "").trim()) return null;
+  return {
+    pid: Number(identity.pid),
+    processGroupId: Number(identity.processGroupId),
+    startedAt: String(identity.startedAt).trim(),
+    format: String(identity.format).trim()
+  };
+}
+function normalizeResource(value) {
+  const resource = recordValue(value);
+  if (!value || typeof value !== "object" || !RESOURCE_ID_RE.test(String(resource.id || ""))) {
+    return null;
+  }
+  const projectRootId = String(resource.projectRootId || "").trim();
+  const workspace = String(resource.workspace || "").trim();
+  if (!projectRootId || !workspace) return null;
+  const ownerAgentId = String(resource.ownerAgentId || "").trim();
+  const ownerType = resource.ownerType === "agent" && ownerAgentId ? "agent" : "project";
+  return {
+    id: String(resource.id),
+    projectRootId,
+    workspace,
+    ownerType,
+    ownerAgentId: ownerType === "agent" ? ownerAgentId : "",
+    name: String(resource.name || "Browser").trim().slice(0, 120) || "Browser",
+    autoName: resource.autoName === true,
+    status: isBrowserResourceStatus(resource.status) ? resource.status : "failed",
+    generation: Number.isSafeInteger(resource.generation) && Number(resource.generation) >= 0 ? Number(resource.generation) : 0,
+    revision: Number.isSafeInteger(resource.revision) && Number(resource.revision) >= 0 ? Number(resource.revision) : 0,
+    url: String(resource.url || "about:blank").slice(0, 8192) || "about:blank",
+    title: String(resource.title || "").slice(0, 512),
+    browserKind: String(resource.browserKind || ""),
+    runtimeKind: String(resource.runtimeKind || ""),
+    sessionId: RESOURCE_ID_RE.test(String(resource.sessionId || "")) ? String(resource.sessionId) : "",
+    sessionGeneration: Number.isSafeInteger(resource.sessionGeneration) && Number(resource.sessionGeneration) >= 0 ? Number(resource.sessionGeneration) : 0,
+    tabId: TAB_ID_RE.test(String(resource.tabId || "")) ? String(resource.tabId) : "",
+    error: String(resource.error || "").slice(0, 2e3),
+    processIdentity: normalizeProcessIdentity(resource.processIdentity),
+    createdAt: Number.isFinite(resource.createdAt) ? Number(resource.createdAt) : Date.now(),
+    updatedAt: Number.isFinite(resource.updatedAt) ? Number(resource.updatedAt) : Date.now()
+  };
+}
+class BrowserResourceStore {
+  directory;
+  file;
+  writeJson;
+  resources = /* @__PURE__ */ new Map();
+  revision = 0;
+  constructor(configDir, options = {}) {
+    this.directory = (0, import_storage_layout.browserResourcesDir)(configDir);
+    this.file = (0, import_storage_layout.browserResourcesFile)(configDir);
+    this.writeJson = options.writeJson || ((file, value) => (0, import_atomic_json_store.atomicWriteJson)(file, value, { mode: 384 }));
+  }
+  init() {
+    fs.mkdirSync(this.directory, { recursive: true });
+    let parsed = {};
+    try {
+      parsed = recordValue(JSON.parse(fs.readFileSync(this.file, "utf8")));
+    } catch (error) {
+      if (errorCode(error) !== "ENOENT") {
+        const message = recordValue(error).message;
+        console.warn("Failed to read Browser resources:", message || error);
+      }
+    }
+    this.revision = Number.isSafeInteger(parsed.revision) && Number(parsed.revision) >= 0 ? Number(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,
+      ownerType: input.ownerType,
+      ownerAgentId: input.ownerAgentId,
+      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) throw new Error(`Browser resource does not exist: ${id}`);
+    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;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserResourceStore,
+  RESOURCE_ID_RE
+});

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

@@ -0,0 +1,203 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var browser_router_exports = {};
+__export(browser_router_exports, {
+  createBrowserRouter: () => createBrowserRouter
+});
+module.exports = __toCommonJS(browser_router_exports);
+const express = require("express");
+const INACTIVE_AGENT_STATUSES = /* @__PURE__ */ new Set(["dead", "error", "exited", "stopped"]);
+function recordValue(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function errorMessage(error) {
+  const message = recordValue(error).message;
+  return message || "Browser request failed";
+}
+function sendError(res, error) {
+  const value = recordValue(error);
+  res.status(Number(value.status) || 500).json({
+    error: errorMessage(error),
+    code: value.code || "BROWSER_INTERNAL_ERROR",
+    ...value.compatibilityRequired ? { compatibilityRequired: true } : {}
+  });
+}
+function requestAgentId(req) {
+  return String(req.get?.("X-Farming-Agent-Id") || "").trim();
+}
+function browserOwnerAgent(agentStateReader, agentId) {
+  const agents = agentStateReader?.getState()?.agents;
+  return Array.isArray(agents) ? agents.map(recordValue).find((agent) => agent.id === agentId) : void 0;
+}
+function requireActiveOwner(manager, agentStateReader, id) {
+  const resource = manager.get(id);
+  if (resource.ownerType !== "agent") return;
+  const owner = browserOwnerAgent(agentStateReader, String(resource.ownerAgentId || ""));
+  const lifecycleType = String(recordValue(owner?.lifecycleOperation).type || "");
+  const preservesBrowserRuntime = ["permission-restart", "runtime-switch"].includes(lifecycleType);
+  if (!owner || owner.archived === true || !preservesBrowserRuntime && INACTIVE_AGENT_STATUSES.has(String(owner.status || ""))) {
+    const error = new Error("Browser owner Agent is not running");
+    error.status = 409;
+    error.code = "BROWSER_OWNER_NOT_RUNNING";
+    throw error;
+  }
+}
+function requireRequestOwnership(manager, req, id) {
+  const agentId = requestAgentId(req);
+  if (!agentId) return;
+  const resource = manager.get(id);
+  if (resource.ownerType !== "agent" || resource.ownerAgentId !== agentId) {
+    const error = new Error("Browser Resource is not owned by this Agent");
+    error.status = 403;
+    error.code = "BROWSER_OWNER_MISMATCH";
+    throw error;
+  }
+}
+function createBrowserRouter(manager, workspaceRootRegistry, agentStateReader) {
+  const router = express.Router();
+  router.use(express.json({ limit: "2mb" }));
+  router.get("/capability", async (_req, res) => {
+    try {
+      await manager.refreshCapability(void 0, { reuseVerified: true });
+      res.json(manager.capability());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/isolated/prepare", async (_req, res) => {
+    try {
+      res.json(await manager.prepareIsolatedBrowser());
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.get("/", (req, res) => {
+    try {
+      const snapshot = recordValue(manager.snapshot());
+      const agentId = requestAgentId(req);
+      const resources = Array.isArray(snapshot.resources) ? snapshot.resources : [];
+      res.json(agentId ? {
+        ...snapshot,
+        resources: resources.filter((resource) => recordValue(resource).ownerType === "agent" && recordValue(resource).ownerAgentId === agentId)
+      } : snapshot);
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/", (req, res) => {
+    try {
+      const body = recordValue(req.body);
+      const root = workspaceRootRegistry.resolve(body.rootId);
+      if (root.kind === "global") {
+        return res.status(400).json({ error: "Browsers require a Project workspace" });
+      }
+      const callerAgentId = requestAgentId(req);
+      const requestedAgentId = String(body.agentId || "").trim();
+      if (callerAgentId && requestedAgentId && callerAgentId !== requestedAgentId) {
+        return res.status(403).json({ error: "Agent tools cannot create a Browser for another Agent" });
+      }
+      const ownerAgentId = callerAgentId || requestedAgentId;
+      if (ownerAgentId) {
+        const owner = browserOwnerAgent(agentStateReader, ownerAgentId);
+        if (!owner) {
+          return res.status(404).json({ error: "Browser owner Agent was not found" });
+        }
+        const ownerWorkspace = String(owner.projectWorkspace || owner.cwd || "").trim();
+        if (!ownerWorkspace || ownerWorkspace !== root.canonicalPath) {
+          return res.status(409).json({
+            error: "Browser owner Agent is not bound to the selected Project workspace"
+          });
+        }
+        const lifecycleType = String(recordValue(owner.lifecycleOperation).type || "");
+        const preservesBrowserRuntime = ["permission-restart", "runtime-switch"].includes(lifecycleType);
+        if (owner.archived === true || !preservesBrowserRuntime && INACTIVE_AGENT_STATUSES.has(String(owner.status || ""))) {
+          return res.status(409).json({ error: "Browser owner Agent is not running" });
+        }
+      }
+      const resource = manager.create({
+        projectRootId: root.rootId,
+        workspace: root.canonicalPath,
+        ownerType: ownerAgentId ? "agent" : "project",
+        ownerAgentId,
+        name: body.name,
+        url: body.url
+      });
+      res.status(201).json(resource);
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.patch("/:id", (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      res.json(manager.rename(req.params.id, recordValue(req.body).name));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/:id/start", async (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      requireActiveOwner(manager, agentStateReader, req.params.id);
+      res.json(await manager.start(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/:id/stop", async (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      res.json(await manager.stop(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.delete("/:id", async (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      res.json(await manager.delete(req.params.id));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/:id/navigate", async (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      requireActiveOwner(manager, agentStateReader, req.params.id);
+      res.json(await manager.navigate(req.params.id, recordValue(req.body).url));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  router.post("/:id/action", async (req, res) => {
+    try {
+      requireRequestOwnership(manager, req, req.params.id);
+      requireActiveOwner(manager, agentStateReader, req.params.id);
+      res.json(await manager.action(req.params.id, recordValue(req.body)));
+    } catch (error) {
+      sendError(res, error);
+    }
+  });
+  return router;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBrowserRouter
+});

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

@@ -0,0 +1,248 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var executable_discovery_exports = {};
+__export(executable_discovery_exports, {
+  discoverBrowserExecutable: () => discoverBrowserExecutable,
+  discoverBrowserExecutables: () => discoverBrowserExecutables,
+  discoverBrowserRuntime: () => discoverBrowserRuntime,
+  managedAgentBrowserPath: () => managedAgentBrowserPath,
+  normalizeExternalCdpUrl: () => normalizeExternalCdpUrl
+});
+module.exports = __toCommonJS(executable_discovery_exports);
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_child_process = require("child_process");
+var import_runtime_dependency_manager = require("../../../backend/runtime-dependency-manager.cjs");
+var import_agent_browser_runtime = require("./agent-browser-runtime.cjs");
+function executable(pathname, kind) {
+  if (!pathname) return null;
+  const executablePath = String(pathname);
+  try {
+    fs.accessSync(executablePath, fs.constants.X_OK);
+    return { kind, path: executablePath };
+  } 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 = /* @__PURE__ */ 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 (0, import_child_process.execFileSync)(program, [command], {
+      encoding: "utf8",
+      timeout: 1e3,
+      maxBuffer: 16384
+    }).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((root) => Boolean(root));
+  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);
+  return uniqueExecutables(candidates);
+}
+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 === "isolated") {
+    return { kind: "isolated-computer", path: "" };
+  }
+  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 systemBrowser2 = null;
+    if (platform === "darwin") systemBrowser2 = discoverMacBrowser();
+    if (platform === "linux") systemBrowser2 = discoverLinuxBrowser();
+    if (platform === "win32") systemBrowser2 = discoverWindowsBrowser(env);
+    return systemBrowser2;
+  }
+  if (source) 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");
+  }
+  let systemBrowser = null;
+  if (platform === "darwin") systemBrowser = discoverMacBrowser();
+  if (platform === "linux") systemBrowser = discoverLinuxBrowser();
+  if (platform === "win32") systemBrowser = discoverWindowsBrowser(env);
+  return systemBrowser;
+}
+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 ${import_agent_browser_runtime.AGENT_BROWSER_VERSION} is required; restart Farming through its launcher to prepare startup dependencies`,
+      runtimeErrorCode: "NOT_FOUND"
+    };
+  }
+  const verification = await (0, import_runtime_dependency_manager.verifyExecutable)(agentBrowserPath, import_agent_browser_runtime.AGENT_BROWSER_VERSION, {
+    execFile: options.execFile,
+    env: options.env || process.env,
+    platform: options.platform || process.platform,
+    useConfiguredLoader: (options.env || process.env).FARMING_AGENT_BROWSER_STATIC !== "1"
+  });
+  if (!verification.valid) {
+    return {
+      ...browser,
+      error: `The Farming-managed agent-browser must be version ${import_agent_browser_runtime.AGENT_BROWSER_VERSION}`,
+      runtimeErrorCode: "VERSION_MISMATCH"
+    };
+  }
+  return {
+    ...browser,
+    agentBrowserPath,
+    agentBrowserVersion: import_agent_browser_runtime.AGENT_BROWSER_VERSION,
+    agentBrowserSource: "managed"
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discoverBrowserExecutable,
+  discoverBrowserExecutables,
+  discoverBrowserRuntime,
+  managedAgentBrowserPath,
+  normalizeExternalCdpUrl
+});