@playwright/mcp 0.0.33 → 0.0.35-alpha-2025-08-27

package/lib/program.js

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 import { program, Option } from 'commander';
-// @ts-ignore
-import { startTraceViewerServer } from 'playwright-core/lib/server';
-import * as mcpTransport from './mcp/transport.js';
+import * as mcpServer from './mcp/server.js';
 import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList } from './config.js';
-import { packageJSON } from './package.js';
-import { createExtensionContextFactory, runWithExtension } from './extension/main.js';
-import { BrowserServerBackend } from './browserServerBackend.js';
+import { packageJSON } from './utils/package.js';
 import { Context } from './context.js';
 import { contextFactory } from './browserContextFactory.js';
 import { runLoopTools } from './loopTools/main.js';
+import { ProxyBackend } from './mcp/proxyBackend.js';
+import { BrowserServerBackend } from './browserServerBackend.js';
+import { ExtensionContextFactory } from './extension/extensionContextFactory.js';
+import { runVSCodeTools } from './vscode/host.js';
 program
     .version('Version ' + packageJSON.version)
     .name(packageJSON.name)
@@ -36,6 +36,7 @@ program
     .option('--config <path>', 'path to the configuration file.')
     .option('--device <device>', 'device to emulate, for example: "iPhone 15"')
     .option('--executable-path <path>', 'path to the browser executable.')
+    .option('--extension', 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.')
     .option('--headless', 'run browser in headless mode, headed by default')
     .option('--host <host>', 'host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
     .option('--ignore-https-errors', 'ignore https errors')
@@ -52,8 +53,8 @@ program
     .option('--user-agent <ua string>', 'specify user agent string')
     .option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
     .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"')
-    .addOption(new Option('--extension', 'Connect to a running browser instance (Edge/Chrome only). Requires the "Playwright MCP Bridge" browser extension to be installed.').hideHelp())
     .addOption(new Option('--connect-tool', 'Allow to switch between different browser connection methods.').hideHelp())
+    .addOption(new Option('--vscode', 'VS Code tools.').hideHelp())
     .addOption(new Option('--loop-tools', 'Run loop tools').hideHelp())
     .addOption(new Option('--vision', 'Legacy option, use --caps=vision instead').hideHelp())
     .action(async (options) => {
@@ -64,27 +65,55 @@ program
         options.caps = 'vision';
     }
     const config = await resolveCLIConfig(options);
+    const browserContextFactory = contextFactory(config);
+    const extensionContextFactory = new ExtensionContextFactory(config.browser.launchOptions.channel || 'chrome', config.browser.userDataDir, config.browser.launchOptions.executablePath);
     if (options.extension) {
-        await runWithExtension(config);
+        const serverBackendFactory = {
+            name: 'Playwright w/ extension',
+            nameInConfig: 'playwright-extension',
+            version: packageJSON.version,
+            create: () => new BrowserServerBackend(config, extensionContextFactory)
+        };
+        await mcpServer.start(serverBackendFactory, config.server);
+        return;
+    }
+    if (options.vscode) {
+        await runVSCodeTools(config);
         return;
     }
     if (options.loopTools) {
         await runLoopTools(config);
         return;
     }
-    const browserContextFactory = contextFactory(config);
-    const factories = [browserContextFactory];
-    if (options.connectTool)
-        factories.push(createExtensionContextFactory(config));
-    const serverBackendFactory = () => new BrowserServerBackend(config, factories);
-    await mcpTransport.start(serverBackendFactory, config.server);
-    if (config.saveTrace) {
-        const server = await startTraceViewerServer();
-        const urlPrefix = server.urlPrefix('human-readable');
-        const url = urlPrefix + '/trace/index.html?trace=' + config.browser.launchOptions.tracesDir + '/trace.json';
-        // eslint-disable-next-line no-console
-        console.error('\nTrace viewer listening on ' + url);
+    if (options.connectTool) {
+        const providers = [
+            {
+                name: 'default',
+                description: 'Starts standalone browser',
+                connect: () => mcpServer.wrapInProcess(new BrowserServerBackend(config, browserContextFactory)),
+            },
+            {
+                name: 'extension',
+                description: 'Connect to a browser using the Playwright MCP extension',
+                connect: () => mcpServer.wrapInProcess(new BrowserServerBackend(config, extensionContextFactory)),
+            },
+        ];
+        const factory = {
+            name: 'Playwright w/ switch',
+            nameInConfig: 'playwright-switch',
+            version: packageJSON.version,
+            create: () => new ProxyBackend(providers),
+        };
+        await mcpServer.start(factory, config.server);
+        return;
     }
+    const factory = {
+        name: 'Playwright',
+        nameInConfig: 'playwright',
+        version: packageJSON.version,
+        create: () => new BrowserServerBackend(config, browserContextFactory)
+    };
+    await mcpServer.start(factory, config.server);
 });
 function setupExitWatchdog() {
     let isExiting = false;

package/lib/sessionLog.js

@@ -15,7 +15,7 @@
  */
 import fs from 'fs';
 import path from 'path';
-import { logUnhandledError } from './log.js';
+import { logUnhandledError } from './utils/log.js';
 import { outputFile } from './config.js';
 export class SessionLog {
     _folder;

package/lib/tab.js

@@ -15,8 +15,8 @@
  */
 import { EventEmitter } from 'events';
 import { callOnPageNoTrace, waitForCompletion } from './tools/utils.js';
-import { logUnhandledError } from './log.js';
-import { ManualPromise } from './manualPromise.js';
+import { logUnhandledError } from './utils/log.js';
+import { ManualPromise } from './mcp/manualPromise.js';
 export const TabEvents = {
     modalState: 'modalState'
 };

package/lib/tools/evaluate.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const evaluateSchema = z.object({
     function: z.string().describe('() => { /* code */ } or (element) => { /* code */ } when element is provided'),

package/lib/tools/form.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTabTool } from './tool.js';
+import { generateLocator } from './utils.js';
+import * as javascript from '../utils/codegen.js';
+const fillForm = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_fill_form',
+        title: 'Fill form',
+        description: 'Fill multiple form fields',
+        inputSchema: z.object({
+            fields: z.array(z.object({
+                name: z.string().describe('Human-readable field name'),
+                type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the field'),
+                ref: z.string().describe('Exact target field reference from the page snapshot'),
+                value: z.string().describe('Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.'),
+            })).describe('Fields to fill in'),
+        }),
+        type: 'destructive',
+    },
+    handle: async (tab, params, response) => {
+        for (const field of params.fields) {
+            const locator = await tab.refLocator({ element: field.name, ref: field.ref });
+            const locatorSource = `await page.${await generateLocator(locator)}`;
+            if (field.type === 'textbox' || field.type === 'slider') {
+                await locator.fill(field.value);
+                response.addCode(`${locatorSource}.fill(${javascript.quote(field.value)});`);
+            }
+            else if (field.type === 'checkbox' || field.type === 'radio') {
+                await locator.setChecked(field.value === 'true');
+                response.addCode(`${locatorSource}.setChecked(${javascript.quote(field.value)});`);
+            }
+            else if (field.type === 'combobox') {
+                await locator.selectOption({ label: field.value });
+                response.addCode(`${locatorSource}.selectOption(${javascript.quote(field.value)});`);
+            }
+        }
+    },
+});
+export default [
+    fillForm,
+];

package/lib/tools/keyboard.js

@@ -17,7 +17,7 @@ import { z } from 'zod';
 import { defineTabTool } from './tool.js';
 import { elementSchema } from './snapshot.js';
 import { generateLocator } from './utils.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 const pressKey = defineTabTool({
     capability: 'core',
     schema: {

package/lib/tools/navigate.js

@@ -48,23 +48,7 @@ const goBack = defineTabTool({
         response.addCode(`await page.goBack();`);
     },
 });
-const goForward = defineTabTool({
-    capability: 'core',
-    schema: {
-        name: 'browser_navigate_forward',
-        title: 'Go forward',
-        description: 'Go forward to the next page',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (tab, params, response) => {
-        await tab.page.goForward();
-        response.setIncludeSnapshot();
-        response.addCode(`await page.goForward();`);
-    },
-});
 export default [
     navigate,
     goBack,
-    goForward,
 ];

package/lib/tools/pdf.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 const pdfSchema = z.object({
     filename: z.string().optional().describe('File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.'),
 });

package/lib/tools/screenshot.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const screenshotSchema = z.object({
     type: z.enum(['png', 'jpeg']).default('png').describe('Image format for the screenshot. Default is png.'),

package/lib/tools/snapshot.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool, defineTool } from './tool.js';
-import * as javascript from '../javascript.js';
+import * as javascript from '../utils/codegen.js';
 import { generateLocator } from './utils.js';
 const snapshot = defineTool({
     capability: 'core',

package/lib/tools/tabs.js

@@ -15,73 +15,45 @@
  */
 import { z } from 'zod';
 import { defineTool } from './tool.js';
-const listTabs = defineTool({
+const browserTabs = defineTool({
     capability: 'core-tabs',
     schema: {
-        name: 'browser_tab_list',
-        title: 'List tabs',
-        description: 'List browser tabs',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.ensureTab();
-        response.setIncludeTabs();
-    },
-});
-const selectTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_select',
-        title: 'Select a tab',
-        description: 'Select a tab by index',
-        inputSchema: z.object({
-            index: z.number().describe('The index of the tab to select'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.selectTab(params.index);
-        response.setIncludeSnapshot();
-    },
-});
-const newTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_new',
-        title: 'Open a new tab',
-        description: 'Open a new tab',
-        inputSchema: z.object({
-            url: z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        const tab = await context.newTab();
-        if (params.url)
-            await tab.navigate(params.url);
-        response.setIncludeSnapshot();
-    },
-});
-const closeTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_close',
-        title: 'Close a tab',
-        description: 'Close a tab',
+        name: 'browser_tabs',
+        title: 'Manage tabs',
+        description: 'List, create, close, or select a browser tab.',
         inputSchema: z.object({
-            index: z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+            action: z.enum(['list', 'new', 'close', 'select']).describe('Operation to perform'),
+            index: z.number().optional().describe('Tab index, used for close/select. If omitted for close, current tab is closed.'),
         }),
         type: 'destructive',
     },
     handle: async (context, params, response) => {
-        await context.closeTab(params.index);
-        response.setIncludeSnapshot();
+        switch (params.action) {
+            case 'list': {
+                await context.ensureTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'new': {
+                await context.newTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'close': {
+                await context.closeTab(params.index);
+                response.setIncludeSnapshot();
+                return;
+            }
+            case 'select': {
+                if (!params.index)
+                    throw new Error('Tab index is required');
+                await context.selectTab(params.index);
+                response.setIncludeSnapshot();
+                return;
+            }
+        }
     },
 });
 export default [
-    listTabs,
-    newTab,
-    selectTab,
-    closeTab,
+    browserTabs,
 ];

package/lib/tools/verify.js

@@ -0,0 +1,137 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { z } from 'zod';
+import { defineTabTool } from './tool.js';
+import * as javascript from '../utils/codegen.js';
+import { generateLocator } from './utils.js';
+const verifyElement = defineTabTool({
+    capability: 'verify',
+    schema: {
+        name: 'browser_verify_element_visible',
+        title: 'Verify element visible',
+        description: 'Verify element is visible on the page',
+        inputSchema: z.object({
+            role: z.string().describe('ROLE of the element. Can be found in the snapshot like this: \`- {ROLE} "Accessible Name":\`'),
+            accessibleName: z.string().describe('ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: \`- role "{ACCESSIBLE_NAME}"\`'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        const locator = tab.page.getByRole(params.role, { name: params.accessibleName });
+        if (await locator.count() === 0) {
+            response.addError(`Element with role "${params.role}" and accessible name "${params.accessibleName}" not found`);
+            return;
+        }
+        response.addCode(`await expect(page.getByRole(${javascript.escapeWithQuotes(params.role)}, { name: ${javascript.escapeWithQuotes(params.accessibleName)} })).toBeVisible();`);
+        response.addResult('Done');
+    },
+});
+const verifyText = defineTabTool({
+    capability: 'verify',
+    schema: {
+        name: 'browser_verify_text_visible',
+        title: 'Verify text visible',
+        description: `Verify text is visible on the page. Prefer ${verifyElement.schema.name} if possible.`,
+        inputSchema: z.object({
+            text: z.string().describe('TEXT to verify. Can be found in the snapshot like this: \`- role "Accessible Name": {TEXT}\` or like this: \`- text: {TEXT}\`'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        const locator = tab.page.getByText(params.text).filter({ visible: true });
+        if (await locator.count() === 0) {
+            response.addError('Text not found');
+            return;
+        }
+        response.addCode(`await expect(page.getByText(${javascript.escapeWithQuotes(params.text)})).toBeVisible();`);
+        response.addResult('Done');
+    },
+});
+const verifyList = defineTabTool({
+    capability: 'verify',
+    schema: {
+        name: 'browser_verify_list_visible',
+        title: 'Verify list visible',
+        description: 'Verify list is visible on the page',
+        inputSchema: z.object({
+            element: z.string().describe('Human-readable list description'),
+            ref: z.string().describe('Exact target element reference that points to the list'),
+            items: z.array(z.string()).describe('Items to verify'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        const locator = await tab.refLocator({ ref: params.ref, element: params.element });
+        const itemTexts = [];
+        for (const item of params.items) {
+            const itemLocator = locator.getByText(item);
+            if (await itemLocator.count() === 0) {
+                response.addError(`Item "${item}" not found`);
+                return;
+            }
+            itemTexts.push((await itemLocator.textContent()));
+        }
+        const ariaSnapshot = `\`
+- list:
+${itemTexts.map(t => `  - text: ${javascript.escapeWithQuotes(t, '"')}`).join('\n')}
+\``;
+        response.addCode(`await expect(page.locator('body')).toMatchAriaSnapshot(${ariaSnapshot});`);
+        response.addResult('Done');
+    },
+});
+const verifyValue = defineTabTool({
+    capability: 'verify',
+    schema: {
+        name: 'browser_verify_value',
+        title: 'Verify value',
+        description: 'Verify element value',
+        inputSchema: z.object({
+            type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the element'),
+            element: z.string().describe('Human-readable element description'),
+            ref: z.string().describe('Exact target element reference that points to the element'),
+            value: z.string().describe('Value to verify. For checkbox, use "true" or "false".'),
+        }),
+        type: 'readOnly',
+    },
+    handle: async (tab, params, response) => {
+        const locator = await tab.refLocator({ ref: params.ref, element: params.element });
+        const locatorSource = `page.${await generateLocator(locator)}`;
+        if (params.type === 'textbox' || params.type === 'slider' || params.type === 'combobox') {
+            const value = await locator.inputValue();
+            if (value !== params.value) {
+                response.addError(`Expected value "${params.value}", but got "${value}"`);
+                return;
+            }
+            response.addCode(`await expect(${locatorSource}).toHaveValue(${javascript.quote(params.value)});`);
+        }
+        else if (params.type === 'checkbox' || params.type === 'radio') {
+            const value = await locator.isChecked();
+            if (value !== (params.value === 'true')) {
+                response.addError(`Expected value "${params.value}", but got "${value}"`);
+                return;
+            }
+            const matcher = value ? 'toBeChecked' : 'not.toBeChecked';
+            response.addCode(`await expect(${locatorSource}).${matcher}();`);
+        }
+        response.addResult('Done');
+    },
+});
+export default [
+    verifyElement,
+    verifyText,
+    verifyList,
+    verifyValue,
+];

package/lib/tools/wait.js

@@ -31,20 +31,19 @@ const wait = defineTool({
     handle: async (context, params, response) => {
         if (!params.text && !params.textGone && !params.time)
             throw new Error('Either time, text or textGone must be provided');
-        const code = [];
         if (params.time) {
-            code.push(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
+            response.addCode(`await new Promise(f => setTimeout(f, ${params.time} * 1000));`);
             await new Promise(f => setTimeout(f, Math.min(30000, params.time * 1000)));
         }
         const tab = context.currentTabOrDie();
         const locator = params.text ? tab.page.getByText(params.text).first() : undefined;
         const goneLocator = params.textGone ? tab.page.getByText(params.textGone).first() : undefined;
         if (goneLocator) {
-            code.push(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
+            response.addCode(`await page.getByText(${JSON.stringify(params.textGone)}).first().waitFor({ state: 'hidden' });`);
             await goneLocator.waitFor({ state: 'hidden' });
         }
         if (locator) {
-            code.push(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
+            response.addCode(`await page.getByText(${JSON.stringify(params.text)}).first().waitFor({ state: 'visible' });`);
             await locator.waitFor({ state: 'visible' });
         }
         response.addResult(`Waited for ${params.text || params.textGone || params.time}`);

package/lib/tools.js

@@ -18,8 +18,10 @@ import console from './tools/console.js';
 import dialogs from './tools/dialogs.js';
 import evaluate from './tools/evaluate.js';
 import files from './tools/files.js';
+import form from './tools/form.js';
 import install from './tools/install.js';
 import keyboard from './tools/keyboard.js';
+import mouse from './tools/mouse.js';
 import navigate from './tools/navigate.js';
 import network from './tools/network.js';
 import pdf from './tools/pdf.js';
@@ -27,13 +29,14 @@ import snapshot from './tools/snapshot.js';
 import tabs from './tools/tabs.js';
 import screenshot from './tools/screenshot.js';
 import wait from './tools/wait.js';
-import mouse from './tools/mouse.js';
+import verify from './tools/verify.js';
 export const allTools = [
     ...common,
     ...console,
     ...dialogs,
     ...evaluate,
     ...files,
+    ...form,
     ...install,
     ...keyboard,
     ...navigate,
@@ -44,6 +47,7 @@ export const allTools = [
     ...snapshot,
     ...tabs,
     ...wait,
+    ...verify,
 ];
 export function filteredTools(config) {
     return allTools.filter(tool => tool.capability.startsWith('core') || config.capabilities?.includes(tool.capability));

package/lib/{javascript.js → utils/codegen.js}

@@ -25,7 +25,7 @@ export function escapeWithQuotes(text, char = '\'') {
     if (char === '"')
         return char + escapedText.replace(/["]/g, '\\"') + char;
     if (char === '`')
-        return char + escapedText.replace(/[`]/g, '`') + char;
+        return char + escapedText.replace(/[`]/g, '\\`') + char;
     throw new Error('Invalid escape char');
 }
 export function quote(text) {

package/lib/{fileUtils.js → utils/fileUtils.js}

@@ -27,6 +27,10 @@ export function cacheDir() {
         throw new Error('Unsupported platform: ' + process.platform);
     return path.join(cacheDirectory, 'ms-playwright');
 }
-export async function userDataDir(browserConfig) {
-    return path.join(cacheDir(), 'ms-playwright', `mcp-${browserConfig.launchOptions?.channel ?? browserConfig?.browserName}-profile`);
+export function sanitizeForFilePath(s) {
+    const sanitize = (s) => s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-');
+    const separator = s.lastIndexOf('.');
+    if (separator === -1)
+        return sanitize(s);
+    return sanitize(s.substring(0, separator)) + '.' + sanitize(s.substring(separator + 1));
 }

package/lib/{utils.js → utils/guid.js}

@@ -14,13 +14,9 @@
  * limitations under the License.
  */
 import crypto from 'crypto';
+export function createGuid() {
+    return crypto.randomBytes(16).toString('hex');
+}
 export function createHash(data) {
     return crypto.createHash('sha256').update(data).digest('hex').slice(0, 7);
 }
-export function sanitizeForFilePath(s) {
-    const sanitize = (s) => s.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, '-');
-    const separator = s.lastIndexOf('.');
-    if (separator === -1)
-        return sanitize(s);
-    return sanitize(s.substring(0, separator)) + '.' + sanitize(s.substring(separator + 1));
-}

package/lib/{package.js → utils/package.js}

@@ -17,4 +17,4 @@ import fs from 'fs';
 import path from 'path';
 import url from 'url';
 const __filename = url.fileURLToPath(import.meta.url);
-export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), '..', 'package.json'), 'utf8'));
+export const packageJSON = JSON.parse(fs.readFileSync(path.join(path.dirname(__filename), '..', '..', 'package.json'), 'utf8'));