|
1
|
"use strict"; |
|
2
|
var __create = Object.create; |
|
3
|
var __defProp = Object.defineProperty; |
|
4
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; |
|
5
|
var __getOwnPropNames = Object.getOwnPropertyNames; |
|
6
|
var __getProtoOf = Object.getPrototypeOf; |
|
7
|
var __hasOwnProp = Object.prototype.hasOwnProperty; |
|
8
|
var __copyProps = (to, from, except, desc) => { |
|
9
|
if (from && typeof from === "object" || typeof from === "function") { |
|
10
|
for (let key of __getOwnPropNames(from)) |
|
11
|
if (!__hasOwnProp.call(to, key) && key !== except) |
|
12
|
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); |
|
13
|
} |
|
14
|
return to; |
|
15
|
}; |
|
16
|
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( |
|
17
|
// If the importer is in node compatibility mode or this is not an ESM |
|
18
|
// file that has been converted to a CommonJS file using a Babel- |
|
19
|
// compatible transform (i.e. "__esModule" has not been set), then set |
|
20
|
// "default" to the CommonJS "module.exports" for node compatibility. |
|
21
|
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, |
|
22
|
mod |
|
23
|
)); |
|
24
|
var import_child_process = require("child_process"); |
|
25
|
var import_crypto = __toESM(require("crypto")); |
|
26
|
var import_fs = __toESM(require("fs")); |
|
27
|
var import_net = __toESM(require("net")); |
|
28
|
var import_os = __toESM(require("os")); |
|
29
|
var import_path = __toESM(require("path")); |
|
30
|
var import_utilsBundle = require("playwright-core/lib/utilsBundle"); |
|
31
|
var import_socketConnection = require("./socketConnection"); |
|
32
|
const debugCli = (0, import_utilsBundle.debug)("pw:cli"); |
|
33
|
const packageJSON = require("../../../package.json"); |
|
34
|
async function runCliCommand(sessionName, args) { |
|
35
|
const session = await connectToDaemon(sessionName); |
|
36
|
const result = await session.runCliCommand(args); |
|
37
|
console.log(result); |
|
38
|
session.dispose(); |
|
39
|
} |
|
40
|
async function socketExists(socketPath) { |
|
41
|
try { |
|
42
|
const stat = await import_fs.default.promises.stat(socketPath); |
|
43
|
if (stat?.isSocket()) |
|
44
|
return true; |
|
45
|
} catch (e) { |
|
46
|
} |
|
47
|
return false; |
|
48
|
} |
|
49
|
class SocketSession { |
|
50
|
constructor(connection) { |
|
51
|
this._nextMessageId = 1; |
|
52
|
this._callbacks = /* @__PURE__ */ new Map(); |
|
53
|
this._connection = connection; |
|
54
|
this._connection.onmessage = (message) => this._onMessage(message); |
|
55
|
this._connection.onclose = () => this.dispose(); |
|
56
|
} |
|
57
|
async callTool(name, args) { |
|
58
|
return this._send(name, args); |
|
59
|
} |
|
60
|
async runCliCommand(args) { |
|
61
|
return await this._send("runCliCommand", { args }); |
|
62
|
} |
|
63
|
async _send(method, params = {}) { |
|
64
|
const messageId = this._nextMessageId++; |
|
65
|
const message = { |
|
66
|
id: messageId, |
|
67
|
method, |
|
68
|
params |
|
69
|
}; |
|
70
|
await this._connection.send(message); |
|
71
|
return new Promise((resolve, reject) => { |
|
72
|
this._callbacks.set(messageId, { resolve, reject }); |
|
73
|
}); |
|
74
|
} |
|
75
|
dispose() { |
|
76
|
for (const callback of this._callbacks.values()) |
|
77
|
callback.reject(new Error("Disposed")); |
|
78
|
this._callbacks.clear(); |
|
79
|
this._connection.close(); |
|
80
|
} |
|
81
|
_onMessage(object) { |
|
82
|
if (object.id && this._callbacks.has(object.id)) { |
|
83
|
const callback = this._callbacks.get(object.id); |
|
84
|
this._callbacks.delete(object.id); |
|
85
|
if (object.error) |
|
86
|
callback.reject(new Error(object.error)); |
|
87
|
else |
|
88
|
callback.resolve(object.result); |
|
89
|
} else if (object.id) { |
|
90
|
throw new Error(`Unexpected message id: ${object.id}`); |
|
91
|
} else { |
|
92
|
throw new Error(`Unexpected message without id: ${JSON.stringify(object)}`); |
|
93
|
} |
|
94
|
} |
|
95
|
} |
|
96
|
function localCacheDir() { |
|
97
|
if (process.platform === "linux") |
|
98
|
return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache"); |
|
99
|
if (process.platform === "darwin") |
|
100
|
return import_path.default.join(import_os.default.homedir(), "Library", "Caches"); |
|
101
|
if (process.platform === "win32") |
|
102
|
return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local"); |
|
103
|
throw new Error("Unsupported platform: " + process.platform); |
|
104
|
} |
|
105
|
function playwrightCacheDir() { |
|
106
|
return import_path.default.join(localCacheDir(), "ms-playwright"); |
|
107
|
} |
|
108
|
function calculateSha1(buffer) { |
|
109
|
const hash = import_crypto.default.createHash("sha1"); |
|
110
|
hash.update(buffer); |
|
111
|
return hash.digest("hex"); |
|
112
|
} |
|
113
|
function socketDirHash() { |
|
114
|
return calculateSha1(__dirname); |
|
115
|
} |
|
116
|
function daemonSocketDir() { |
|
117
|
return import_path.default.resolve(playwrightCacheDir(), "daemon", socketDirHash()); |
|
118
|
} |
|
119
|
function daemonSocketPath(sessionName) { |
|
120
|
const socketName = `${sessionName}.sock`; |
|
121
|
if (import_os.default.platform() === "win32") |
|
122
|
return `\\\\.\\pipe\\${socketDirHash()}-${socketName}`; |
|
123
|
return import_path.default.resolve(daemonSocketDir(), socketName); |
|
124
|
} |
|
125
|
async function connectToDaemon(sessionName) { |
|
126
|
const socketPath = daemonSocketPath(sessionName); |
|
127
|
debugCli(`Connecting to daemon at ${socketPath}`); |
|
128
|
if (await socketExists(socketPath)) { |
|
129
|
debugCli(`Socket file exists, attempting to connect...`); |
|
130
|
try { |
|
131
|
return await connectToSocket(socketPath); |
|
132
|
} catch (e) { |
|
133
|
if (import_os.default.platform() !== "win32") |
|
134
|
await import_fs.default.promises.unlink(socketPath).catch(() => { |
|
135
|
}); |
|
136
|
} |
|
137
|
} |
|
138
|
const cliPath = import_path.default.join(__dirname, "../../../cli.js"); |
|
139
|
debugCli(`Will launch daemon process: ${cliPath}`); |
|
140
|
const userDataDir = import_path.default.resolve(daemonSocketDir(), `${sessionName}-user-data`); |
|
141
|
const child = (0, import_child_process.spawn)(process.execPath, [cliPath, "run-mcp-server", `--daemon=${socketPath}`, `--user-data-dir=${userDataDir}`], { |
|
142
|
detached: true, |
|
143
|
stdio: "ignore", |
|
144
|
cwd: process.cwd() |
|
145
|
// Will be used as root. |
|
146
|
}); |
|
147
|
child.unref(); |
|
148
|
const maxRetries = 50; |
|
149
|
const retryDelay = 100; |
|
150
|
for (let i = 0; i < maxRetries; i++) { |
|
151
|
await new Promise((resolve) => setTimeout(resolve, 100)); |
|
152
|
try { |
|
153
|
return await connectToSocket(socketPath); |
|
154
|
} catch (e) { |
|
155
|
if (e.code !== "ENOENT") |
|
156
|
throw e; |
|
157
|
debugCli(`Retrying to connect to daemon at ${socketPath} (${i + 1}/${maxRetries})`); |
|
158
|
} |
|
159
|
} |
|
160
|
throw new Error(`Failed to connect to daemon at ${socketPath} after ${maxRetries * retryDelay}ms`); |
|
161
|
} |
|
162
|
async function connectToSocket(socketPath) { |
|
163
|
const socket = await new Promise((resolve, reject) => { |
|
164
|
const socket2 = import_net.default.createConnection(socketPath, () => { |
|
165
|
debugCli(`Connected to daemon at ${socketPath}`); |
|
166
|
resolve(socket2); |
|
167
|
}); |
|
168
|
socket2.on("error", reject); |
|
169
|
}); |
|
170
|
return new SocketSession(new import_socketConnection.SocketConnection(socket)); |
|
171
|
} |
|
172
|
function currentSessionPath() { |
|
173
|
return import_path.default.resolve(daemonSocketDir(), "current-session"); |
|
174
|
} |
|
175
|
async function getCurrentSession() { |
|
176
|
try { |
|
177
|
const session = await import_fs.default.promises.readFile(currentSessionPath(), "utf-8"); |
|
178
|
return session.trim() || "default"; |
|
179
|
} catch { |
|
180
|
return "default"; |
|
181
|
} |
|
182
|
} |
|
183
|
async function setCurrentSession(sessionName) { |
|
184
|
await import_fs.default.promises.mkdir(daemonSocketDir(), { recursive: true }); |
|
185
|
await import_fs.default.promises.writeFile(currentSessionPath(), sessionName); |
|
186
|
} |
|
187
|
async function canConnectToSocket(socketPath) { |
|
188
|
return new Promise((resolve) => { |
|
189
|
const socket = import_net.default.createConnection(socketPath, () => { |
|
190
|
socket.destroy(); |
|
191
|
resolve(true); |
|
192
|
}); |
|
193
|
socket.on("error", () => { |
|
194
|
resolve(false); |
|
195
|
}); |
|
196
|
}); |
|
197
|
} |
|
198
|
async function listSessions() { |
|
199
|
const dir = daemonSocketDir(); |
|
200
|
try { |
|
201
|
const files = await import_fs.default.promises.readdir(dir); |
|
202
|
const sessions = []; |
|
203
|
for (const file of files) { |
|
204
|
if (file.endsWith("-user-data")) { |
|
205
|
const sessionName = file.slice(0, -"-user-data".length); |
|
206
|
const socketPath = daemonSocketPath(sessionName); |
|
207
|
const live = await canConnectToSocket(socketPath); |
|
208
|
sessions.push({ name: sessionName, live }); |
|
209
|
} |
|
210
|
} |
|
211
|
return sessions; |
|
212
|
} catch { |
|
213
|
return []; |
|
214
|
} |
|
215
|
} |
|
216
|
function resolveSessionName(args) { |
|
217
|
if (args.session) |
|
218
|
return args.session; |
|
219
|
if (process.env.PLAYWRIGHT_CLI_SESSION) |
|
220
|
return process.env.PLAYWRIGHT_CLI_SESSION; |
|
221
|
return "default"; |
|
222
|
} |
|
223
|
async function handleSessionCommand(args) { |
|
224
|
const subcommand = args._[1]; |
|
225
|
if (!subcommand) { |
|
226
|
const current = await getCurrentSession(); |
|
227
|
console.log(current); |
|
228
|
return; |
|
229
|
} |
|
230
|
if (subcommand === "list") { |
|
231
|
const sessions = await listSessions(); |
|
232
|
const current = await getCurrentSession(); |
|
233
|
console.log("Sessions:"); |
|
234
|
for (const session of sessions) { |
|
235
|
const marker = session.name === current ? "->" : " "; |
|
236
|
const liveMarker = session.live ? " (live)" : ""; |
|
237
|
console.log(`${marker} ${session.name}${liveMarker}`); |
|
238
|
} |
|
239
|
if (sessions.length === 0) |
|
240
|
console.log(" (no sessions)"); |
|
241
|
return; |
|
242
|
} |
|
243
|
if (subcommand === "set") { |
|
244
|
const sessionName = args._[2]; |
|
245
|
if (!sessionName) { |
|
246
|
console.error("Usage: playwright-cli session set <session-name>"); |
|
247
|
process.exit(1); |
|
248
|
} |
|
249
|
await setCurrentSession(sessionName); |
|
250
|
console.log(`Current session set to: ${sessionName}`); |
|
251
|
return; |
|
252
|
} |
|
253
|
console.error(`Unknown session subcommand: ${subcommand}`); |
|
254
|
process.exit(1); |
|
255
|
} |
|
256
|
async function main() { |
|
257
|
const argv = process.argv.slice(2); |
|
258
|
const args = require("minimist")(argv); |
|
259
|
const help = require("./help.json"); |
|
260
|
const commandName = args._[0]; |
|
261
|
if (args.version || args.v) { |
|
262
|
console.log(packageJSON.version); |
|
263
|
process.exit(0); |
|
264
|
} |
|
265
|
if (commandName === "session") { |
|
266
|
await handleSessionCommand(args); |
|
267
|
return; |
|
268
|
} |
|
269
|
const command = help.commands[commandName]; |
|
270
|
if (args.help || args.h) { |
|
271
|
if (command) { |
|
272
|
console.log(command); |
|
273
|
} else { |
|
274
|
console.log("playwright-cli - run playwright mcp commands from terminal\n"); |
|
275
|
console.log(help.global); |
|
276
|
} |
|
277
|
process.exit(0); |
|
278
|
} |
|
279
|
if (!command) { |
|
280
|
console.error(`Unknown command: ${commandName} |
|
281
|
`); |
|
282
|
console.log(help.global); |
|
283
|
process.exit(1); |
|
284
|
} |
|
285
|
let sessionName = resolveSessionName(args); |
|
286
|
if (sessionName === "default" && !args.session && !process.env.PLAYWRIGHT_CLI_SESSION) |
|
287
|
sessionName = await getCurrentSession(); |
|
288
|
runCliCommand(sessionName, args).catch((e) => { |
|
289
|
console.error(e.message); |
|
290
|
process.exit(1); |
|
291
|
}); |
|
292
|
} |
|
293
|
main().catch((e) => { |
|
294
|
console.error(e.message); |
|
295
|
process.exit(1); |
|
296
|
}); |
|
297
|
|