mirror of
https://github.com/TracksApp/tracks.git
synced 2025-12-19 16:50:12 +01:00
351 lines
13 KiB
JavaScript
351 lines
13 KiB
JavaScript
"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 cdpRelay_exports = {};
|
|
__export(cdpRelay_exports, {
|
|
CDPRelayServer: () => CDPRelayServer
|
|
});
|
|
module.exports = __toCommonJS(cdpRelay_exports);
|
|
var import_child_process = require("child_process");
|
|
var import_utilsBundle = require("playwright-core/lib/utilsBundle");
|
|
var import_registry = require("playwright-core/lib/server/registry/index");
|
|
var import_utils = require("playwright-core/lib/utils");
|
|
var import_http2 = require("../sdk/http");
|
|
var import_log = require("../log");
|
|
var protocol = __toESM(require("./protocol"));
|
|
const debugLogger = (0, import_utilsBundle.debug)("pw:mcp:relay");
|
|
class CDPRelayServer {
|
|
constructor(server, browserChannel, userDataDir, executablePath) {
|
|
this._playwrightConnection = null;
|
|
this._extensionConnection = null;
|
|
this._nextSessionId = 1;
|
|
this._wsHost = (0, import_http2.httpAddressToString)(server.address()).replace(/^http/, "ws");
|
|
this._browserChannel = browserChannel;
|
|
this._userDataDir = userDataDir;
|
|
this._executablePath = executablePath;
|
|
const uuid = crypto.randomUUID();
|
|
this._cdpPath = `/cdp/${uuid}`;
|
|
this._extensionPath = `/extension/${uuid}`;
|
|
this._resetExtensionConnection();
|
|
this._wss = new import_utilsBundle.wsServer({ server });
|
|
this._wss.on("connection", this._onConnection.bind(this));
|
|
}
|
|
cdpEndpoint() {
|
|
return `${this._wsHost}${this._cdpPath}`;
|
|
}
|
|
extensionEndpoint() {
|
|
return `${this._wsHost}${this._extensionPath}`;
|
|
}
|
|
async ensureExtensionConnectionForMCPContext(clientInfo, abortSignal, toolName) {
|
|
debugLogger("Ensuring extension connection for MCP context");
|
|
if (this._extensionConnection)
|
|
return;
|
|
this._connectBrowser(clientInfo, toolName);
|
|
debugLogger("Waiting for incoming extension connection");
|
|
await Promise.race([
|
|
this._extensionConnectionPromise,
|
|
new Promise((_, reject) => setTimeout(() => {
|
|
reject(new Error(`Extension connection timeout. Make sure the "Playwright MCP Bridge" extension is installed. See https://github.com/microsoft/playwright-mcp/blob/main/extension/README.md for installation instructions.`));
|
|
}, process.env.PWMCP_TEST_CONNECTION_TIMEOUT ? parseInt(process.env.PWMCP_TEST_CONNECTION_TIMEOUT, 10) : 5e3)),
|
|
new Promise((_, reject) => abortSignal.addEventListener("abort", reject))
|
|
]);
|
|
debugLogger("Extension connection established");
|
|
}
|
|
_connectBrowser(clientInfo, toolName) {
|
|
const mcpRelayEndpoint = `${this._wsHost}${this._extensionPath}`;
|
|
const url = new URL("chrome-extension://jakfalbnbhgkpmoaakfflhflbfpkailf/connect.html");
|
|
url.searchParams.set("mcpRelayUrl", mcpRelayEndpoint);
|
|
const client = {
|
|
name: clientInfo.name,
|
|
version: clientInfo.version
|
|
};
|
|
url.searchParams.set("client", JSON.stringify(client));
|
|
url.searchParams.set("protocolVersion", process.env.PWMCP_TEST_PROTOCOL_VERSION ?? protocol.VERSION.toString());
|
|
if (toolName)
|
|
url.searchParams.set("newTab", String(toolName === "browser_navigate"));
|
|
const token = process.env.PLAYWRIGHT_MCP_EXTENSION_TOKEN;
|
|
if (token)
|
|
url.searchParams.set("token", token);
|
|
const href = url.toString();
|
|
let executablePath = this._executablePath;
|
|
if (!executablePath) {
|
|
const executableInfo = import_registry.registry.findExecutable(this._browserChannel);
|
|
if (!executableInfo)
|
|
throw new Error(`Unsupported channel: "${this._browserChannel}"`);
|
|
executablePath = executableInfo.executablePath("javascript");
|
|
if (!executablePath)
|
|
throw new Error(`"${this._browserChannel}" executable not found. Make sure it is installed at a standard location.`);
|
|
}
|
|
const args = [];
|
|
if (this._userDataDir)
|
|
args.push(`--user-data-dir=${this._userDataDir}`);
|
|
args.push(href);
|
|
(0, import_child_process.spawn)(executablePath, args, {
|
|
windowsHide: true,
|
|
detached: true,
|
|
shell: false,
|
|
stdio: "ignore"
|
|
});
|
|
}
|
|
stop() {
|
|
this.closeConnections("Server stopped");
|
|
this._wss.close();
|
|
}
|
|
closeConnections(reason) {
|
|
this._closePlaywrightConnection(reason);
|
|
this._closeExtensionConnection(reason);
|
|
}
|
|
_onConnection(ws2, request) {
|
|
const url = new URL(`http://localhost${request.url}`);
|
|
debugLogger(`New connection to ${url.pathname}`);
|
|
if (url.pathname === this._cdpPath) {
|
|
this._handlePlaywrightConnection(ws2);
|
|
} else if (url.pathname === this._extensionPath) {
|
|
this._handleExtensionConnection(ws2);
|
|
} else {
|
|
debugLogger(`Invalid path: ${url.pathname}`);
|
|
ws2.close(4004, "Invalid path");
|
|
}
|
|
}
|
|
_handlePlaywrightConnection(ws2) {
|
|
if (this._playwrightConnection) {
|
|
debugLogger("Rejecting second Playwright connection");
|
|
ws2.close(1e3, "Another CDP client already connected");
|
|
return;
|
|
}
|
|
this._playwrightConnection = ws2;
|
|
ws2.on("message", async (data) => {
|
|
try {
|
|
const message = JSON.parse(data.toString());
|
|
await this._handlePlaywrightMessage(message);
|
|
} catch (error) {
|
|
debugLogger(`Error while handling Playwright message
|
|
${data.toString()}
|
|
`, error);
|
|
}
|
|
});
|
|
ws2.on("close", () => {
|
|
if (this._playwrightConnection !== ws2)
|
|
return;
|
|
this._playwrightConnection = null;
|
|
this._closeExtensionConnection("Playwright client disconnected");
|
|
debugLogger("Playwright WebSocket closed");
|
|
});
|
|
ws2.on("error", (error) => {
|
|
debugLogger("Playwright WebSocket error:", error);
|
|
});
|
|
debugLogger("Playwright MCP connected");
|
|
}
|
|
_closeExtensionConnection(reason) {
|
|
this._extensionConnection?.close(reason);
|
|
this._extensionConnectionPromise.reject(new Error(reason));
|
|
this._resetExtensionConnection();
|
|
}
|
|
_resetExtensionConnection() {
|
|
this._connectedTabInfo = void 0;
|
|
this._extensionConnection = null;
|
|
this._extensionConnectionPromise = new import_utils.ManualPromise();
|
|
void this._extensionConnectionPromise.catch(import_log.logUnhandledError);
|
|
}
|
|
_closePlaywrightConnection(reason) {
|
|
if (this._playwrightConnection?.readyState === import_utilsBundle.ws.OPEN)
|
|
this._playwrightConnection.close(1e3, reason);
|
|
this._playwrightConnection = null;
|
|
}
|
|
_handleExtensionConnection(ws2) {
|
|
if (this._extensionConnection) {
|
|
ws2.close(1e3, "Another extension connection already established");
|
|
return;
|
|
}
|
|
this._extensionConnection = new ExtensionConnection(ws2);
|
|
this._extensionConnection.onclose = (c, reason) => {
|
|
debugLogger("Extension WebSocket closed:", reason, c === this._extensionConnection);
|
|
if (this._extensionConnection !== c)
|
|
return;
|
|
this._resetExtensionConnection();
|
|
this._closePlaywrightConnection(`Extension disconnected: ${reason}`);
|
|
};
|
|
this._extensionConnection.onmessage = this._handleExtensionMessage.bind(this);
|
|
this._extensionConnectionPromise.resolve();
|
|
}
|
|
_handleExtensionMessage(method, params) {
|
|
switch (method) {
|
|
case "forwardCDPEvent":
|
|
const sessionId = params.sessionId || this._connectedTabInfo?.sessionId;
|
|
this._sendToPlaywright({
|
|
sessionId,
|
|
method: params.method,
|
|
params: params.params
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
async _handlePlaywrightMessage(message) {
|
|
debugLogger("\u2190 Playwright:", `${message.method} (id=${message.id})`);
|
|
const { id, sessionId, method, params } = message;
|
|
try {
|
|
const result = await this._handleCDPCommand(method, params, sessionId);
|
|
this._sendToPlaywright({ id, sessionId, result });
|
|
} catch (e) {
|
|
debugLogger("Error in the extension:", e);
|
|
this._sendToPlaywright({
|
|
id,
|
|
sessionId,
|
|
error: { message: e.message }
|
|
});
|
|
}
|
|
}
|
|
async _handleCDPCommand(method, params, sessionId) {
|
|
switch (method) {
|
|
case "Browser.getVersion": {
|
|
return {
|
|
protocolVersion: "1.3",
|
|
product: "Chrome/Extension-Bridge",
|
|
userAgent: "CDP-Bridge-Server/1.0.0"
|
|
};
|
|
}
|
|
case "Browser.setDownloadBehavior": {
|
|
return {};
|
|
}
|
|
case "Target.setAutoAttach": {
|
|
if (sessionId)
|
|
break;
|
|
const { targetInfo } = await this._extensionConnection.send("attachToTab", {});
|
|
this._connectedTabInfo = {
|
|
targetInfo,
|
|
sessionId: `pw-tab-${this._nextSessionId++}`
|
|
};
|
|
debugLogger("Simulating auto-attach");
|
|
this._sendToPlaywright({
|
|
method: "Target.attachedToTarget",
|
|
params: {
|
|
sessionId: this._connectedTabInfo.sessionId,
|
|
targetInfo: {
|
|
...this._connectedTabInfo.targetInfo,
|
|
attached: true
|
|
},
|
|
waitingForDebugger: false
|
|
}
|
|
});
|
|
return {};
|
|
}
|
|
case "Target.getTargetInfo": {
|
|
return this._connectedTabInfo?.targetInfo;
|
|
}
|
|
}
|
|
return await this._forwardToExtension(method, params, sessionId);
|
|
}
|
|
async _forwardToExtension(method, params, sessionId) {
|
|
if (!this._extensionConnection)
|
|
throw new Error("Extension not connected");
|
|
if (this._connectedTabInfo?.sessionId === sessionId)
|
|
sessionId = void 0;
|
|
return await this._extensionConnection.send("forwardCDPCommand", { sessionId, method, params });
|
|
}
|
|
_sendToPlaywright(message) {
|
|
debugLogger("\u2192 Playwright:", `${message.method ?? `response(id=${message.id})`}`);
|
|
this._playwrightConnection?.send(JSON.stringify(message));
|
|
}
|
|
}
|
|
class ExtensionConnection {
|
|
constructor(ws2) {
|
|
this._callbacks = /* @__PURE__ */ new Map();
|
|
this._lastId = 0;
|
|
this._ws = ws2;
|
|
this._ws.on("message", this._onMessage.bind(this));
|
|
this._ws.on("close", this._onClose.bind(this));
|
|
this._ws.on("error", this._onError.bind(this));
|
|
}
|
|
async send(method, params) {
|
|
if (this._ws.readyState !== import_utilsBundle.ws.OPEN)
|
|
throw new Error(`Unexpected WebSocket state: ${this._ws.readyState}`);
|
|
const id = ++this._lastId;
|
|
this._ws.send(JSON.stringify({ id, method, params }));
|
|
const error = new Error(`Protocol error: ${method}`);
|
|
return new Promise((resolve, reject) => {
|
|
this._callbacks.set(id, { resolve, reject, error });
|
|
});
|
|
}
|
|
close(message) {
|
|
debugLogger("closing extension connection:", message);
|
|
if (this._ws.readyState === import_utilsBundle.ws.OPEN)
|
|
this._ws.close(1e3, message);
|
|
}
|
|
_onMessage(event) {
|
|
const eventData = event.toString();
|
|
let parsedJson;
|
|
try {
|
|
parsedJson = JSON.parse(eventData);
|
|
} catch (e) {
|
|
debugLogger(`<closing ws> Closing websocket due to malformed JSON. eventData=${eventData} e=${e?.message}`);
|
|
this._ws.close();
|
|
return;
|
|
}
|
|
try {
|
|
this._handleParsedMessage(parsedJson);
|
|
} catch (e) {
|
|
debugLogger(`<closing ws> Closing websocket due to failed onmessage callback. eventData=${eventData} e=${e?.message}`);
|
|
this._ws.close();
|
|
}
|
|
}
|
|
_handleParsedMessage(object) {
|
|
if (object.id && this._callbacks.has(object.id)) {
|
|
const callback = this._callbacks.get(object.id);
|
|
this._callbacks.delete(object.id);
|
|
if (object.error) {
|
|
const error = callback.error;
|
|
error.message = object.error;
|
|
callback.reject(error);
|
|
} else {
|
|
callback.resolve(object.result);
|
|
}
|
|
} else if (object.id) {
|
|
debugLogger("\u2190 Extension: unexpected response", object);
|
|
} else {
|
|
this.onmessage?.(object.method, object.params);
|
|
}
|
|
}
|
|
_onClose(event) {
|
|
debugLogger(`<ws closed> code=${event.code} reason=${event.reason}`);
|
|
this._dispose();
|
|
this.onclose?.(this, event.reason);
|
|
}
|
|
_onError(event) {
|
|
debugLogger(`<ws error> message=${event.message} type=${event.type} target=${event.target}`);
|
|
this._dispose();
|
|
}
|
|
_dispose() {
|
|
for (const callback of this._callbacks.values())
|
|
callback.reject(new Error("WebSocket closed"));
|
|
this._callbacks.clear();
|
|
}
|
|
}
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
CDPRelayServer
|
|
});
|