@autobest-ui/agent 1.0.10 → 1.0.12

package/mcp/trace-mcp-recorder/index.js

@@ -0,0 +1,469 @@
+#!/usr/bin/env node
+
+import { createReadStream, existsSync, readFileSync, realpathSync } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import axios from 'axios';
+import FormData from 'form-data';
+import { chromium } from 'playwright';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+const DEFAULT_MAX_RECORD_DURATION = 1_800_000;
+const directory = path.dirname(fileURLToPath(import.meta.url));
+
+function readConfiguration(environment = process.env) {
+  const configuredBaseUrl = environment.BACKEND_BASE_URL?.trim();
+  if (!configuredBaseUrl) {
+    throw new Error('BACKEND_BASE_URL 未配置，无法创建录制会话');
+  }
+
+  let baseUrl;
+  try {
+    baseUrl = new URL(configuredBaseUrl);
+  } catch {
+    throw new Error('BACKEND_BASE_URL 必须是有效的 URL');
+  }
+  if (!['http:', 'https:'].includes(baseUrl.protocol)) {
+    throw new Error('BACKEND_BASE_URL 必须使用 http 或 https 协议');
+  }
+
+  const durationText = environment.MAX_RECORD_DURATION ?? String(DEFAULT_MAX_RECORD_DURATION);
+  const maxRecordDuration = Number(durationText);
+  if (!Number.isSafeInteger(maxRecordDuration) || maxRecordDuration <= 0) {
+    throw new Error('MAX_RECORD_DURATION 必须是正整数毫秒值');
+  }
+
+  return {
+    baseUrl: baseUrl.toString().replace(/\/$/, ''),
+    maxRecordDuration
+  };
+}
+
+function validateTargetUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error('url 必须是有效的网页地址');
+  }
+  if (!['http:', 'https:'].includes(url.protocol)) {
+    throw new Error('url 必须使用 http 或 https 协议');
+  }
+  return url.toString();
+}
+
+function optionalTrimmed(value) {
+  const trimmed = value?.trim();
+  return trimmed || undefined;
+}
+
+/** Prefer authenticated/request MCP identity data, then the explicit tool argument. */
+function resolveOperator(extra, suppliedOperator) {
+  const authExtra = extra?.authInfo?.extra;
+  const requestMeta = extra?._meta;
+  const candidates = [
+    authExtra?.operator,
+    authExtra?.name,
+    authExtra?.preferred_username,
+    requestMeta?.operator,
+    requestMeta?.user?.name,
+    suppliedOperator
+  ];
+  return candidates.find(value => typeof value === 'string' && value.trim())?.trim();
+}
+
+function errorMessage(error) {
+  if (axios.isAxiosError(error)) {
+    const responseData = error.response?.data;
+    const details =
+      typeof responseData === 'string' ? responseData : responseData ? JSON.stringify(responseData) : error.message;
+    return `后端请求失败${error.response?.status ? ` (HTTP ${error.response.status})` : ''}: ${details}`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
+function toolText(payload) {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }]
+  };
+}
+
+function toolError(error) {
+  return {
+    isError: true,
+    content: [{ type: 'text', text: errorMessage(error) }]
+  };
+}
+
+export class TraceRecorder {
+  constructor(options = {}) {
+    this.environment = options.environment ?? process.env;
+    this.launchChromium = options.launchChromium ?? (launchOptions => chromium.launch(launchOptions));
+    this.createHttpClient =
+      options.createHttpClient ??
+      (baseURL =>
+        axios.create({
+          baseURL,
+          timeout: 120_000,
+          maxBodyLength: Infinity,
+          maxContentLength: Infinity
+        }));
+    this.createFormData = options.createFormData ?? (() => new FormData());
+    this.createReadStream = options.createReadStream ?? createReadStream;
+    this.makeTemporaryDirectory =
+      options.makeTemporaryDirectory ?? (() => mkdtemp(path.join(os.tmpdir(), 'trace-mcp-recorder-')));
+    this.removeTemporaryDirectory =
+      options.removeTemporaryDirectory ?? (temporaryDirectory => rm(temporaryDirectory, { recursive: true, force: true }));
+    this.setTimer = options.setTimer ?? setTimeout;
+    this.clearTimer = options.clearTimer ?? clearTimeout;
+    this.platformInfo = options.platformInfo ?? (() => ({
+      platform: os.platform(),
+      type: os.type(),
+      release: os.release(),
+      architecture: os.arch()
+    }));
+    this.activeSession = undefined;
+    this.lastAutomaticResult = undefined;
+    this.lastAutomaticError = undefined;
+  }
+
+  async start(input, extra = {}) {
+    if (this.activeSession) {
+      throw new Error(`已有录制任务正在运行 (uuid: ${this.activeSession.uuid})，请先停止当前录制`);
+    }
+
+    const configuration = readConfiguration(this.environment);
+    const targetUrl = validateTargetUrl(input.url.trim());
+    const sessionInput = {
+      url: targetUrl,
+      version: optionalTrimmed(input.version),
+      title: optionalTrimmed(input.title),
+      operator: resolveOperator(extra, input.operator)
+    };
+    const reservation = { uuid: 'pending', state: 'starting' };
+    this.activeSession = reservation;
+    this.lastAutomaticResult = undefined;
+    this.lastAutomaticError = undefined;
+    let temporaryDirectory;
+    let browser;
+    let context;
+    let page;
+
+    try {
+      temporaryDirectory = await this.makeTemporaryDirectory();
+      browser = await this.launchChromium({ headless: false });
+      context = await browser.newContext();
+      await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
+      page = await context.newPage();
+      await page.goto(targetUrl);
+
+      const metadata = {
+        version: sessionInput.version,
+        title: sessionInput.title,
+        operator: sessionInput.operator,
+        targetUrl,
+        browserName: 'Chromium',
+        browserVersion: browser.version(),
+        userAgent: await page.evaluate(() => navigator.userAgent),
+        viewport: page.viewportSize(),
+        operatingSystem: this.platformInfo(),
+        startedAt: new Date().toISOString()
+      };
+      const session = {
+        browser,
+        context,
+        page,
+        metadata,
+        baseUrl: configuration.baseUrl,
+        tracePath: path.join(temporaryDirectory, 'trace.zip'),
+        temporaryDirectory,
+        state: 'recording',
+        stopPromise: undefined,
+        uploadPromise: undefined,
+        timer: undefined
+      };
+      this.activeSession = session;
+
+      const failOnBrowserExit = () => {
+        if (session.state === 'recording') {
+          session.stopPromise = this.failSession(session, new Error('Chromium 浏览器意外退出'));
+          void session.stopPromise.catch(failure => {
+            console.error('[trace-mcp-recorder] 浏览器异常退出:', errorMessage(failure));
+          });
+        }
+      };
+      browser.once('disconnected', failOnBrowserExit);
+      session.timer = this.setTimer(() => {
+        void this.stop({ trigger: 'timeout', confirm: 'upload' }).catch(error => {
+          this.lastAutomaticError = error;
+          console.error('[trace-mcp-recorder] 自动停止录制失败:', errorMessage(error));
+        });
+      }, configuration.maxRecordDuration);
+      session.timer?.unref?.();
+
+      return {
+        message: '浏览器已打开，请手动操作页面，完成后调用 stop_trace_recording',
+        maxRecordDuration: configuration.maxRecordDuration,
+        metadata
+      };
+    } catch (error) {
+      await this.closeResources({ browser, context, page, temporaryDirectory });
+      if (this.activeSession === reservation) {
+        this.activeSession = undefined;
+      }
+      throw error;
+    }
+  }
+
+  async stop({ trigger = 'manual', confirm } = {}) {
+    const session = this.activeSession;
+    if (!session) {
+      if (trigger === 'manual' && this.lastAutomaticError) {
+        const error = this.lastAutomaticError;
+        this.lastAutomaticError = undefined;
+        throw error;
+      }
+      if (trigger === 'manual' && this.lastAutomaticResult) {
+        const result = this.lastAutomaticResult;
+        this.lastAutomaticResult = undefined;
+        return result;
+      }
+      throw new Error('当前没有正在录制的 trace 会话');
+    }
+    if (session.state === 'starting') {
+      throw new Error('录制会话正在启动，请等待 start_trace_recording 返回后再停止');
+    }
+    if (session.state === 'recording') {
+      if (session.stopPromise) return session.stopPromise;
+      session.state = 'stopping';
+      this.clearTimer(session.timer);
+      session.stopPromise = this.prepareSession(session).finally(() => {
+        session.stopPromise = undefined;
+      });
+      const prepared = await session.stopPromise;
+      if (trigger === 'timeout' || confirm === 'upload') return this.uploadSession(session, trigger);
+      return prepared;
+    }
+    if (session.state === 'stopping' && session.stopPromise) return session.stopPromise;
+    if (session.state === 'awaiting_upload') {
+      if (confirm === 'upload') return this.uploadSession(session, trigger);
+      if (confirm === 'cancel') return this.cancelSession(session);
+      return {
+        uuid: undefined,
+        message: 'trace.zip 已生成，是否上传录制内容并创建回放记录？请确认“上传”或“不上传”。',
+        metadata: session.metadata
+      };
+    }
+    if (session.state === 'uploading' && session.uploadPromise) return session.uploadPromise;
+    throw new Error('当前录制会话不可停止');
+  }
+
+  async prepareSession(session) {
+    try {
+      await session.context.tracing.stop({ path: session.tracePath });
+      await this.closeResources({ page: session.page, context: session.context, browser: session.browser });
+      session.state = 'awaiting_upload';
+      return {
+        message: 'trace.zip 已生成，是否上传录制内容并创建回放记录？请确认“上传”或“不上传”。',
+        metadata: session.metadata
+      };
+    } catch (error) {
+      session.state = 'failed';
+      await this.removeTemporaryDirectory(session.temporaryDirectory).catch(() => {});
+      if (this.activeSession === session) this.activeSession = undefined;
+      throw error;
+    }
+  }
+
+  async uploadSession(session, trigger) {
+    if (session.uploadPromise) return session.uploadPromise;
+    session.state = 'uploading';
+    session.uploadPromise = (async () => {
+      const configuration = readConfiguration(this.environment);
+      const http = this.createHttpClient(configuration.baseUrl);
+      const form = this.createFormData();
+      form.append('target_url', session.metadata.targetUrl);
+      for (const [field, value] of [
+        ['version', session.metadata.version],
+        ['title', session.metadata.title],
+        ['operator', session.metadata.operator],
+        ['browser_name', session.metadata.browserName],
+        ['browser_version', session.metadata.browserVersion],
+        ['user_agent', session.metadata.userAgent],
+        ['os_name', session.metadata.operatingSystem.platform],
+        ['viewport', JSON.stringify(session.metadata.viewport)]
+      ]) {
+        if (value !== undefined && value !== null) form.append(field, String(value));
+      }
+      form.append('trace', this.createReadStream(session.tracePath), {
+        filename: 'trace.zip',
+        contentType: 'application/zip'
+      });
+      const uploadResponse = await http.post('/api/trace-sessions', form, {
+        headers: form.getHeaders()
+      });
+      const fileUrl = uploadResponse.data?.fileUrl;
+      if (typeof fileUrl !== 'string' || !fileUrl.trim()) throw new Error('上传响应缺少 fileUrl');
+      const replayLink = `${session.baseUrl}/trace-viewer/?trace=${fileUrl}`;
+      const result = {
+        uuid: uploadResponse.data?.uuid,
+        message: `✅录制完成，回放链接：${replayLink}`,
+        replayLink,
+        fileUrl,
+        stoppedBy: trigger,
+        metadata: {
+          version: session.metadata.version,
+          title: session.metadata.title,
+          operator: session.metadata.operator,
+          browserVersion: session.metadata.browserVersion
+        }
+      };
+      session.state = 'completed';
+      if (trigger === 'timeout') this.lastAutomaticResult = result;
+      return result;
+    })().catch(async error => {
+      session.state = 'failed';
+      if (trigger === 'timeout') this.lastAutomaticError = error;
+      await this.removeTemporaryDirectory(session.temporaryDirectory).catch(() => {});
+      if (this.activeSession === session) this.activeSession = undefined;
+      throw error;
+    }).finally(async () => {
+      await this.removeTemporaryDirectory(session.temporaryDirectory).catch(() => {});
+      if (this.activeSession === session && session.state === 'completed') this.activeSession = undefined;
+    });
+    return session.uploadPromise;
+  }
+
+  async cancelSession(session) {
+    session.state = 'cancelled';
+    await this.removeTemporaryDirectory(session.temporaryDirectory).catch(() => {});
+    if (this.activeSession === session) this.activeSession = undefined;
+    return { message: '已取消上传，本地 trace.zip 已删除。' };
+  }
+
+  async failSession(session, error) {
+    if (session.state !== 'recording') return;
+    session.state = 'failed';
+    this.clearTimer(session.timer);
+    await this.closeResources(session);
+    await this.removeTemporaryDirectory(session.temporaryDirectory).catch(() => {});
+    if (this.activeSession === session) this.activeSession = undefined;
+    throw error;
+  }
+
+  async closeResources({ browser, context, page, temporaryDirectory }) {
+    // Each cleanup step is independent so one closed/crashed Playwright object cannot block the rest.
+    await page?.close().catch(() => {});
+    await context?.close().catch(() => {});
+    await browser?.close().catch(() => {});
+    if (temporaryDirectory) await this.removeTemporaryDirectory(temporaryDirectory).catch(() => {});
+  }
+}
+
+function registerSkillResources(server) {
+  const skillPath = path.join(directory, '../../skills/common/trace-recorder/SKILL.md');
+  if (!existsSync(skillPath)) return;
+  const uri = 'skill://trace-recorder/SKILL.md';
+  server.registerResource(
+    'trace-recorder',
+    uri,
+    {
+      title: 'Skill: trace-recorder',
+      description: 'trace-mcp-recorder 的自然语言调用说明',
+      mimeType: 'text/markdown'
+    },
+    async () => ({
+      contents: [{ uri, mimeType: 'text/markdown', text: readFileSync(skillPath, 'utf8') }]
+    })
+  );
+}
+
+export function createServer(options = {}) {
+  const recorder = options.recorder ?? new TraceRecorder(options);
+  const server = new McpServer(
+    { name: 'trace-mcp-recorder', version: '1.0.0' },
+    {
+      instructions:
+        'Use start_trace_recording to open a visible Chromium window for manual testing. ' +
+        'When the user asks to stop recording, always call stop_trace_recording and return its replay link.'
+    }
+  );
+
+  server.registerTool(
+    'start_trace_recording',
+    {
+      title: '启动 Playwright Trace 人工录制',
+      description: '启动非无头 Chromium、开启 trace 并访问指定 URL，供测试人员在浏览器窗口中手动操作。',
+      inputSchema: {
+        url: z.string().min(1).describe('必填，被测页面的 HTTP(S) 地址'),
+        version: z.string().min(1).optional().describe('可选，被测版本号，例如 v2.1.0'),
+        title: z.string().min(1).optional().describe('可选，录制标题，例如登录页面'),
+        operator: z.string().min(1).optional().describe('可选，操作人；MCP 上下文中的身份优先')
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async (input, extra) => {
+      try {
+        return toolText(await recorder.start(input, extra));
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+
+  server.registerTool(
+    'stop_trace_recording',
+    {
+      title: '停止 Playwright Trace 录制',
+      description: '停止当前 trace 并询问上传；确认后上传 trace.zip 和浏览器元数据，返回回放链接。',
+      inputSchema: {
+        confirm: z.enum(['upload', 'cancel']).optional().describe('首次停止不传；用户确认上传传 upload，拒绝上传传 cancel')
+      },
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      }
+    },
+    async ({ confirm } = {}) => {
+      try {
+        return toolText(await recorder.stop({ confirm }));
+      } catch (error) {
+        return toolError(error);
+      }
+    }
+  );
+
+  registerSkillResources(server);
+  return server;
+}
+
+async function main() {
+  await createServer().connect(new StdioServerTransport());
+}
+
+let isCommandEntry = false;
+if (process.argv[1]) {
+  try {
+    isCommandEntry = realpathSync(process.argv[1]) === realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    isCommandEntry = false;
+  }
+}
+
+if (isCommandEntry) {
+  main().catch(error => {
+    console.error('[trace-mcp-recorder] 服务启动失败:', errorMessage(error));
+    process.exitCode = 1;
+  });
+}

package/mcp/trace-mcp-recorder/index.test.js

@@ -0,0 +1,179 @@
+import assert from 'node:assert/strict';
+import { EventEmitter } from 'node:events';
+import path from 'node:path';
+import test from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { TraceRecorder } from './index.js';
+
+const directory = path.dirname(fileURLToPath(import.meta.url));
+const sessionUuid = '123e4567-e89b-42d3-a456-426614174000';
+
+function createFixture(options = {}) {
+  const calls = [];
+  const browser = new EventEmitter();
+  const tracing = {
+    start: async options => calls.push(['trace-start', options]),
+    stop: async options => calls.push(['trace-stop', options])
+  };
+  const page = {
+    goto: async url => calls.push(['goto', url]),
+    evaluate: async () => 'Fixture User Agent',
+    viewportSize: () => ({ width: 1280, height: 720 }),
+    close: async () => calls.push(['page-close'])
+  };
+  const context = {
+    tracing,
+    newPage: async () => page,
+    close: async () => calls.push(['context-close'])
+  };
+  browser.newContext = async () => context;
+  browser.version = () => 'Fixture Chromium 1';
+  browser.close = async () => calls.push(['browser-close']);
+
+  const http = {
+    post: async (endpoint, body) => {
+      calls.push(['post', endpoint, body]);
+      if (endpoint === '/api/trace-sessions' && body !== form) return { data: { uuid: sessionUuid } };
+      if (options.uploadError) throw options.uploadError;
+      return { data: { fileUrl: '/private/traces/trace.zip' } };
+    },
+    patch: async (endpoint, body) => {
+      calls.push(['patch', endpoint, body]);
+      return { data: {} };
+    }
+  };
+  const form = {
+    append: (...args) => calls.push(['form-append', ...args]),
+    getHeaders: () => ({ 'content-type': 'multipart/form-data; boundary=fixture' })
+  };
+  const timer = { unref() {} };
+  const recorder = new TraceRecorder({
+    environment: {
+      BACKEND_BASE_URL: 'https://trace.example.test/root/',
+      MAX_RECORD_DURATION: '1000'
+    },
+    launchChromium: async options => {
+      calls.push(['launch', options]);
+      return browser;
+    },
+    createHttpClient: baseUrl => {
+      calls.push(['http-client', baseUrl]);
+      return http;
+    },
+    createFormData: () => form,
+    createReadStream: tracePath => ({ tracePath }),
+    makeTemporaryDirectory: async () => '/tmp/trace-fixture',
+    removeTemporaryDirectory: async temporaryDirectory => calls.push(['remove', temporaryDirectory]),
+    setTimer: (callback, duration) => {
+      calls.push(['timer', duration]);
+      timer.callback = callback;
+      return timer;
+    },
+    clearTimer: value => calls.push(['clear-timer', value]),
+    platformInfo: () => ({ platform: 'fixture-os' })
+  });
+  return { browser, calls, recorder, timer };
+}
+
+test('starts, records metadata, uploads, completes and cleans up one session', async () => {
+  const { calls, recorder } = createFixture();
+  const started = await recorder.start(
+    {
+      url: 'https://app.example.test/login',
+      version: 'v2.1.0',
+      title: 'bug3452',
+      operator: '传入操作人'
+    },
+    { authInfo: { extra: { operator: '上下文操作人' } } }
+  );
+
+  assert.equal(started.uuid, undefined);
+  assert.equal(started.metadata.operator, '上下文操作人');
+  assert.equal(started.metadata.browserVersion, 'Fixture Chromium 1');
+  await assert.rejects(
+    recorder.start({ url: 'https://app.example.test/another' }),
+    /已有录制任务/
+  );
+
+  const confirmation = await recorder.stop();
+  assert.match(confirmation.message, /是否上传/);
+  const stopped = await recorder.stop({ confirm: 'upload' });
+  assert.equal(
+    stopped.replayLink,
+    'https://trace.example.test/root/trace-viewer/?trace=/private/traces/trace.zip'
+  );
+  assert.equal(stopped.metadata.title, 'bug3452');
+  assert.ok(calls.some(call => call[0] === 'trace-start' && call[1].sources === true));
+  assert.ok(calls.some(call => call[0] === 'post' && call[1] === '/api/trace-sessions'));
+  assert.ok(calls.some(call => call[0] === 'form-append' && call[1] === 'target_url'));
+  assert.ok(calls.some(call => call[0] === 'remove' && call[1] === '/tmp/trace-fixture'));
+});
+
+test('rejects missing configuration before contacting the backend', async () => {
+  const recorder = new TraceRecorder({ environment: {} });
+  await assert.rejects(recorder.start({ url: 'https://app.example.test' }), /BACKEND_BASE_URL/);
+});
+
+test('cleans up when Chromium launch fails without a backend session', async () => {
+  const { calls, recorder } = createFixture();
+  recorder.launchChromium = async () => {
+    throw new Error('launch failed');
+  };
+
+  await assert.rejects(recorder.start({ url: 'https://app.example.test' }), /launch failed/);
+  assert.equal(calls.some(call => call[0] === 'post'), false);
+});
+
+test('marks the session failed and removes the local trace when upload fails', async () => {
+  const { calls, recorder } = createFixture({ uploadError: new Error('upload failed') });
+  await recorder.start({ url: 'https://app.example.test' });
+
+  await recorder.stop();
+  await assert.rejects(recorder.stop({ confirm: 'upload' }), /upload failed/);
+  assert.ok(calls.some(call => call[0] === 'remove' && call[1] === '/tmp/trace-fixture'));
+});
+
+test('automatically stops on timeout and returns that result on the next stop call', async () => {
+  const { recorder, timer } = createFixture();
+  await recorder.start({ url: 'https://app.example.test' });
+  timer.callback();
+
+  while (recorder.activeSession) await new Promise(resolve => setImmediate(resolve));
+  const result = await recorder.stop();
+  assert.equal(result.stoppedBy, 'timeout');
+  await assert.rejects(recorder.stop(), /当前没有正在录制/);
+});
+
+test('exposes both tools and the bundled skill over stdio', async () => {
+  const client = new Client({ name: 'trace-mcp-recorder-test', version: '1.0.0' });
+  const transport = new StdioClientTransport({
+    command: process.execPath,
+    args: [path.join(directory, 'index.js')],
+    cwd: directory,
+    env: { ...process.env },
+    stderr: 'pipe'
+  });
+
+  try {
+    await client.connect(transport);
+    assert.equal(client.getServerVersion()?.name, 'trace-mcp-recorder');
+    const { tools } = await client.listTools();
+    assert.deepEqual(
+      tools.map(tool => tool.name),
+      ['start_trace_recording', 'stop_trace_recording']
+    );
+    const { resources } = await client.listResources();
+    assert.ok(resources.some(resource => resource.uri === 'skill://trace-recorder/SKILL.md'));
+
+    const result = await client.callTool({
+      name: 'start_trace_recording',
+      arguments: { url: 'https://app.example.test' }
+    });
+    assert.equal(result.isError, true);
+    assert.match(result.content[0].text, /BACKEND_BASE_URL/);
+  } finally {
+    await client.close();
+  }
+});

package/mcp/trace-mcp-recorder/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@autobest/trace-mcp-recorder",
+  "version": "1.0.0",
+  "private": true,
+  "description": "MCP server for recording and uploading manual Playwright traces",
+  "type": "module",
+  "main": "index.js",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "start": "node index.js",
+    "lint": "node --check index.js && node --check index.test.js",
+    "test": "node --test index.test.js",
+    "verify": "npm run lint && npm test"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.30.0",
+    "axios": "1.20.0",
+    "form-data": "4.0.6",
+    "playwright": "1.63.0",
+    "uuid": "14.0.2",
+    "zod": "4.4.3"
+  }
+}