@treegress.com/treegress-browser-mcp 0.0.56-treegress.3

package/mcp/browser/configIni.js

@@ -0,0 +1,194 @@
+"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 configIni_exports = {};
+__export(configIni_exports, {
+  configFromIniFile: () => configFromIniFile,
+  configsFromIniFile: () => configsFromIniFile
+});
+module.exports = __toCommonJS(configIni_exports);
+var import_fs = __toESM(require("fs"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+function configFromIniFile(filePath) {
+  const content = import_fs.default.readFileSync(filePath, "utf8");
+  const parsed = import_utilsBundle.ini.parse(content);
+  return iniEntriesToConfig(parsed);
+}
+function configsFromIniFile(filePath) {
+  const content = import_fs.default.readFileSync(filePath, "utf8");
+  const parsed = import_utilsBundle.ini.parse(content);
+  const result = /* @__PURE__ */ new Map();
+  for (const [sectionName, sectionData] of Object.entries(parsed)) {
+    if (typeof sectionData !== "object" || sectionData === null)
+      continue;
+    result.set(sectionName, iniEntriesToConfig(sectionData));
+  }
+  return result;
+}
+function iniEntriesToConfig(entries) {
+  const config = {};
+  for (const [targetPath, rawValue] of Object.entries(entries)) {
+    const type = longhandTypes[targetPath];
+    const value = type ? coerceToType(rawValue, type) : coerceIniValue(rawValue);
+    setNestedValue(config, targetPath, value);
+  }
+  return config;
+}
+function coerceToType(value, type) {
+  switch (type) {
+    case "string":
+      return String(value);
+    case "number":
+      return Number(value);
+    case "boolean":
+      if (typeof value === "boolean")
+        return value;
+      return value === "true" || value === "1";
+    case "string[]":
+      if (Array.isArray(value))
+        return value.map(String);
+      return [String(value)];
+    case "size": {
+      if (typeof value === "string" && value.includes("x")) {
+        const [w, h] = value.split("x").map(Number);
+        if (!isNaN(w) && !isNaN(h) && w > 0 && h > 0)
+          return { width: w, height: h };
+      }
+      return void 0;
+    }
+  }
+}
+function coerceIniValue(value) {
+  if (typeof value !== "string")
+    return value;
+  const trimmed = value.trim();
+  if (trimmed === "")
+    return trimmed;
+  const num = Number(trimmed);
+  if (!isNaN(num))
+    return num;
+  return value;
+}
+function setNestedValue(obj, dotPath, value) {
+  const parts = dotPath.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (!(part in current) || typeof current[part] !== "object" || current[part] === null)
+      current[part] = {};
+    current = current[part];
+  }
+  current[parts[parts.length - 1]] = value;
+}
+const longhandTypes = {
+  // browser direct
+  "browser.browserName": "string",
+  "browser.isolated": "boolean",
+  "browser.userDataDir": "string",
+  "browser.cdpEndpoint": "string",
+  "browser.cdpTimeout": "number",
+  "browser.remoteEndpoint": "string",
+  "browser.initPage": "string[]",
+  "browser.initScript": "string[]",
+  // browser.launchOptions
+  "browser.launchOptions.channel": "string",
+  "browser.launchOptions.headless": "boolean",
+  "browser.launchOptions.executablePath": "string",
+  "browser.launchOptions.chromiumSandbox": "boolean",
+  "browser.launchOptions.args": "string[]",
+  "browser.launchOptions.downloadsPath": "string",
+  "browser.launchOptions.handleSIGHUP": "boolean",
+  "browser.launchOptions.handleSIGINT": "boolean",
+  "browser.launchOptions.handleSIGTERM": "boolean",
+  "browser.launchOptions.slowMo": "number",
+  "browser.launchOptions.timeout": "number",
+  "browser.launchOptions.tracesDir": "string",
+  "browser.launchOptions.proxy.server": "string",
+  "browser.launchOptions.proxy.bypass": "string",
+  "browser.launchOptions.proxy.username": "string",
+  "browser.launchOptions.proxy.password": "string",
+  // browser.contextOptions
+  "browser.contextOptions.acceptDownloads": "boolean",
+  "browser.contextOptions.baseURL": "string",
+  "browser.contextOptions.bypassCSP": "boolean",
+  "browser.contextOptions.colorScheme": "string",
+  "browser.contextOptions.contrast": "string",
+  "browser.contextOptions.deviceScaleFactor": "number",
+  "browser.contextOptions.forcedColors": "string",
+  "browser.contextOptions.hasTouch": "boolean",
+  "browser.contextOptions.ignoreHTTPSErrors": "boolean",
+  "browser.contextOptions.isMobile": "boolean",
+  "browser.contextOptions.javaScriptEnabled": "boolean",
+  "browser.contextOptions.locale": "string",
+  "browser.contextOptions.offline": "boolean",
+  "browser.contextOptions.permissions": "string[]",
+  "browser.contextOptions.reducedMotion": "string",
+  "browser.contextOptions.screen": "size",
+  "browser.contextOptions.serviceWorkers": "string",
+  "browser.contextOptions.storageState": "string",
+  "browser.contextOptions.strictSelectors": "boolean",
+  "browser.contextOptions.timezoneId": "string",
+  "browser.contextOptions.userAgent": "string",
+  "browser.contextOptions.viewport": "size",
+  // top-level
+  "extension": "boolean",
+  "capabilities": "string[]",
+  "saveSession": "boolean",
+  "saveTrace": "boolean",
+  "saveVideo": "size",
+  "sharedBrowserContext": "boolean",
+  "outputDir": "string",
+  "outputMode": "string",
+  "imageResponses": "string",
+  "allowUnrestrictedFileAccess": "boolean",
+  "codegen": "string",
+  "testIdAttribute": "string",
+  // server
+  "server.port": "number",
+  "server.host": "string",
+  "server.allowedHosts": "string[]",
+  // console
+  "console.level": "string",
+  // network
+  "network.allowedOrigins": "string[]",
+  "network.blockedOrigins": "string[]",
+  // timeouts
+  "timeouts.action": "number",
+  "timeouts.navigation": "number",
+  // snapshot
+  "snapshot.mode": "string",
+  "snapshot.engine": "string",
+  "snapshot.domSerializerPath": "string",
+  "snapshot.domFallbackToAria": "boolean",
+  "snapshot.domNonstrict": "boolean"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configFromIniFile,
+  configsFromIniFile
+});

package/mcp/browser/context.js

@@ -0,0 +1,302 @@
+"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 context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_os = __toESM(require("os"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_playwright_core = require("playwright-core");
+var import_url = require("url");
+var import_log = require("../log");
+var import_tab = require("./tab");
+var import_config = require("./config");
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+class Context {
+  constructor(options) {
+    this._tabs = [];
+    this._routes = [];
+    this._abortController = new AbortController();
+    this.config = options.config;
+    this.sessionLog = options.sessionLog;
+    this.options = options;
+    this._browserContextFactory = options.browserContextFactory;
+    this._clientInfo = options.clientInfo;
+    testDebug("create context");
+    Context._allContexts.add(this);
+  }
+  static {
+    this._allContexts = /* @__PURE__ */ new Set();
+  }
+  static async disposeAll() {
+    await Promise.all([...Context._allContexts].map((context) => context.dispose()));
+  }
+  tabs() {
+    return this._tabs;
+  }
+  currentTab() {
+    return this._currentTab;
+  }
+  currentTabOrDie() {
+    if (!this._currentTab)
+      throw new Error("No open pages available.");
+    return this._currentTab;
+  }
+  async newTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    const page = await browserContext.newPage();
+    this._currentTab = this._tabs.find((t) => t.page === page);
+    return this._currentTab;
+  }
+  async selectTab(index) {
+    const tab = this._tabs[index];
+    if (!tab)
+      throw new Error(`Tab ${index} not found`);
+    await tab.page.bringToFront();
+    this._currentTab = tab;
+    return tab;
+  }
+  async ensureTab() {
+    const { browserContext } = await this._ensureBrowserContext();
+    if (!this._currentTab)
+      await browserContext.newPage();
+    return this._currentTab;
+  }
+  async closeTab(index) {
+    const tab = index === void 0 ? this._currentTab : this._tabs[index];
+    if (!tab)
+      throw new Error(`Tab ${index} not found`);
+    const url = tab.page.url();
+    await tab.page.close();
+    return url;
+  }
+  async workspaceFile(fileName, perCallWorkspaceDir) {
+    return await (0, import_config.workspaceFile)(this.config, this._clientInfo, fileName, perCallWorkspaceDir);
+  }
+  async outputFile(template, options) {
+    const baseName = template.suggestedFilename || `${template.prefix}-${(template.date ?? /* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}${template.ext ? "." + template.ext : ""}`;
+    return await (0, import_config.outputFile)(this.config, this._clientInfo, baseName, options);
+  }
+  async startVideoRecording(params) {
+    if (this._video)
+      throw new Error("Video recording has already been started.");
+    const listener = (page) => {
+      this._video?.allVideos.add(page.video());
+      page.video().start(params).catch(() => {
+      });
+    };
+    this._video = { allVideos: /* @__PURE__ */ new Set(), listener };
+    const browserContext = await this.ensureBrowserContext();
+    browserContext.pages().forEach(listener);
+    browserContext.on("page", listener);
+  }
+  async stopVideoRecording() {
+    if (!this._video)
+      throw new Error("Video recording has not been started.");
+    const video = this._video;
+    if (this._browserContextPromise) {
+      const { browserContext } = await this._browserContextPromise;
+      browserContext.off("page", video.listener);
+      for (const page of browserContext.pages())
+        await page.video().stop().catch(() => {
+        });
+    }
+    this._video = void 0;
+    return video.allVideos;
+  }
+  _onPageCreated(page) {
+    const tab = new import_tab.Tab(this, page, (tab2) => this._onPageClosed(tab2));
+    this._tabs.push(tab);
+    if (!this._currentTab)
+      this._currentTab = tab;
+  }
+  _onPageClosed(tab) {
+    const index = this._tabs.indexOf(tab);
+    if (index === -1)
+      return;
+    this._tabs.splice(index, 1);
+    if (this._currentTab === tab)
+      this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
+    if (!this._tabs.length)
+      void this.closeBrowserContext();
+  }
+  async closeBrowserContext() {
+    if (!this._closeBrowserContextPromise)
+      this._closeBrowserContextPromise = this._closeBrowserContextImpl().catch(import_log.logUnhandledError);
+    await this._closeBrowserContextPromise;
+    this._closeBrowserContextPromise = void 0;
+  }
+  routes() {
+    return this._routes;
+  }
+  async addRoute(entry) {
+    const { browserContext } = await this._ensureBrowserContext();
+    await browserContext.route(entry.pattern, entry.handler);
+    this._routes.push(entry);
+  }
+  async removeRoute(pattern) {
+    if (!this._browserContextPromise)
+      return 0;
+    const { browserContext } = await this._browserContextPromise;
+    let removed = 0;
+    if (pattern) {
+      const toRemove = this._routes.filter((r) => r.pattern === pattern);
+      for (const route of toRemove)
+        await browserContext.unroute(route.pattern, route.handler);
+      this._routes = this._routes.filter((r) => r.pattern !== pattern);
+      removed = toRemove.length;
+    } else {
+      for (const route of this._routes)
+        await browserContext.unroute(route.pattern, route.handler);
+      removed = this._routes.length;
+      this._routes = [];
+    }
+    return removed;
+  }
+  isRunningTool() {
+    return this._runningToolName !== void 0;
+  }
+  setRunningTool(name) {
+    this._runningToolName = name;
+  }
+  async _closeBrowserContextImpl() {
+    if (!this._browserContextPromise)
+      return;
+    testDebug("close context");
+    const promise = this._browserContextPromise;
+    this._browserContextPromise = void 0;
+    await promise.then(async ({ browserContext, close }) => {
+      if (this.config.saveTrace)
+        await browserContext.tracing.stop();
+      await close();
+    });
+  }
+  async dispose() {
+    this._abortController.abort("MCP context disposed");
+    await this.closeBrowserContext();
+    Context._allContexts.delete(this);
+  }
+  async _setupRequestInterception(context) {
+    if (this.config.network?.allowedOrigins?.length) {
+      await context.route("**", (route) => route.abort("blockedbyclient"));
+      for (const origin of this.config.network.allowedOrigins)
+        await context.route(originOrHostGlob(origin), (route) => route.continue());
+    }
+    if (this.config.network?.blockedOrigins?.length) {
+      for (const origin of this.config.network.blockedOrigins)
+        await context.route(originOrHostGlob(origin), (route) => route.abort("blockedbyclient"));
+    }
+  }
+  async ensureBrowserContext() {
+    const { browserContext } = await this._ensureBrowserContext();
+    return browserContext;
+  }
+  _ensureBrowserContext() {
+    if (this._browserContextPromise)
+      return this._browserContextPromise;
+    this._browserContextPromise = this._setupBrowserContext();
+    this._browserContextPromise.catch(() => {
+      this._browserContextPromise = void 0;
+    });
+    return this._browserContextPromise;
+  }
+  async _setupBrowserContext() {
+    if (this._closeBrowserContextPromise)
+      throw new Error("Another browser context is being closed.");
+    if (this.config.testIdAttribute)
+      import_playwright_core.selectors.setTestIdAttribute(this.config.testIdAttribute);
+    const result = await this._browserContextFactory.createContext(this._clientInfo, this._abortController.signal, { toolName: this._runningToolName });
+    const { browserContext } = result;
+    if (!this.config.allowUnrestrictedFileAccess) {
+      browserContext._setAllowedProtocols(["http:", "https:", "about:", "data:"]);
+      browserContext._setAllowedDirectories(allRootPaths(this._clientInfo));
+    }
+    await this._setupRequestInterception(browserContext);
+    for (const page of browserContext.pages())
+      this._onPageCreated(page);
+    browserContext.on("page", (page) => this._onPageCreated(page));
+    if (this.config.saveTrace) {
+      await browserContext.tracing.start({
+        name: "trace-" + Date.now(),
+        screenshots: true,
+        snapshots: true,
+        _live: true
+      });
+    }
+    return result;
+  }
+  lookupSecret(secretName) {
+    if (!this.config.secrets?.[secretName])
+      return { value: secretName, code: (0, import_utils.escapeWithQuotes)(secretName, "'") };
+    return {
+      value: this.config.secrets[secretName],
+      code: `process.env['${secretName}']`
+    };
+  }
+  firstRootPath() {
+    return allRootPaths(this._clientInfo)[0];
+  }
+}
+function allRootPaths(clientInfo) {
+  const paths = [];
+  for (const root of clientInfo.roots) {
+    const url = new URL(root.uri);
+    let rootPath;
+    try {
+      rootPath = (0, import_url.fileURLToPath)(url);
+    } catch (e) {
+      if (e.code === "ERR_INVALID_FILE_URL_PATH" && import_os.default.platform() === "win32")
+        rootPath = decodeURIComponent(url.pathname);
+    }
+    if (!rootPath)
+      continue;
+    paths.push(rootPath);
+  }
+  if (paths.length === 0)
+    paths.push(process.cwd());
+  return paths;
+}
+function originOrHostGlob(originOrHost) {
+  const wildcardPortMatch = originOrHost.match(/^(https?:\/\/[^/:]+):\*$/);
+  if (wildcardPortMatch)
+    return `${wildcardPortMatch[1]}:*/**`;
+  try {
+    const url = new URL(originOrHost);
+    if (url.origin !== "null")
+      return `${url.origin}/**`;
+  } catch {
+  }
+  return `*://${originOrHost}/**`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});