@autobest-ui/agent 1.0.10 → 1.0.12

package/plugins/autobest-delivery/mcp-server/src/report.mjs

@@ -135,6 +135,27 @@ async function findLatestRunnerResult(featureDir) {
   return null;
 }
 
+async function findLatestFastCheckResult(featureDir) {
+  const runsDir = path.join(featureDir, 'fast-check', 'runs');
+  let entries;
+  try {
+    entries = await readdir(runsDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const candidates = entries
+    .filter(entry => entry.isDirectory() && /^iteration-\d+$/.test(entry.name))
+    .map(entry => ({
+      iteration: Number(entry.name.slice('iteration-'.length)),
+      filePath: path.join(runsDir, entry.name, 'fast-check-result.json')
+    }))
+    .sort((left, right) => right.iteration - left.iteration);
+  for (const candidate of candidates) {
+    if (await fileExists(candidate.filePath)) return candidate.filePath;
+  }
+  return null;
+}
+
 async function selectRunnerResult(checker, context) {
   if (checker.runnerResult) {
     const declared = resolveEvidencePath(checker.runnerResult, context);
@@ -249,7 +270,7 @@ function resolveApiMode(runner) {
   const resultMode = nonEmptyString(runner.apiMode);
   const metadataMode = nonEmptyString(runner.metadata?.apiMode);
   for (const mode of [resultMode, metadataMode].filter(Boolean)) {
-    if (!['real', 'mock'].includes(mode)) {
+    if (!['real', 'mock', 'none'].includes(mode)) {
       throw new Error(`Runner 包含无效 apiMode：${mode}`);
     }
   }
@@ -267,6 +288,9 @@ function reportMethodWithApiMode(group, apiMode) {
   if (apiMode === 'mock') {
     return `API 数据：模拟 API。\n${method}`;
   }
+  if (apiMode === 'none') {
+    return `API 数据：本次未指定业务 API。\n${method}`;
+  }
   return method;
 }
 
@@ -560,16 +584,35 @@ export async function exportDeliveryReport(options) {
   if (!(await fileExists(specPath))) {
     throw new Error(`缺少 spec.md：${specPath}`);
   }
-  if (!(await fileExists(checkerPath))) {
-    throw new Error(`缺少 Checker 结果：${checkerPath}`);
-  }
   const specText = await readFile(specPath, 'utf8');
-  const checker = await readJson(checkerPath, 'Checker 结果');
-  const runnerPath = await selectRunnerResult(checker, context);
-  if (!runnerPath) {
-    throw new Error(`缺少 Runner 结果：${path.join(featureDir, 'e2e', 'runs')}`);
+  let checker;
+  let runnerPath;
+  let evidenceSource;
+  if (await fileExists(checkerPath)) {
+    checker = await readJson(checkerPath, 'Checker 结果');
+    runnerPath = await selectRunnerResult(checker, context);
+    evidenceSource = 'independent-checker';
+    if (!runnerPath) {
+      throw new Error(`缺少 Runner 结果：${path.join(featureDir, 'e2e', 'runs')}`);
+    }
+  } else {
+    runnerPath = await findLatestFastCheckResult(featureDir);
+    if (!runnerPath) {
+      throw new Error(`缺少 Checker 或快速自测结果：${checkerPath}`);
+    }
+    const fastResult = await readJson(runnerPath, '快速自测结果');
+    if (fastResult.evidenceSource !== 'interactive-playwright') {
+      throw new Error(`快速自测结果包含无效 evidenceSource：${fastResult.evidenceSource}`);
+    }
+    checker = {
+      status: fastResult.status,
+      iteration: fastResult.iteration,
+      scenarioSha256: null,
+      checks: []
+    };
+    evidenceSource = 'interactive-playwright';
   }
-  const runner = await readJson(runnerPath, 'Runner 结果');
+  const runner = await readJson(runnerPath, evidenceSource === 'interactive-playwright' ? '快速自测结果' : 'Runner 结果');
   const apiMode = resolveApiMode(runner);
   const checks = mergeChecks(checker, runner);
   const stories = parseSpecItems(specText, checks);
@@ -649,14 +692,16 @@ export async function exportDeliveryReport(options) {
   return {
     outputPath,
     iteration: runner.iteration ?? checker.iteration ?? null,
-    checkerStatus: checker.status,
-    runnerStatus: runner.status,
+    checkerStatus: evidenceSource === 'independent-checker' ? checker.status : null,
+    runnerStatus: evidenceSource === 'independent-checker' ? runner.status : null,
+    fastCheckStatus: evidenceSource === 'interactive-playwright' ? runner.status : null,
     rows: groups.length,
     statuses: counts,
     embeddedScreenshots,
     screenshotPlacements,
     groupingSource: grouping.source,
     groupingPath: grouping.groupingPath,
-    apiMode
+    apiMode,
+    evidenceSource
   };
 }

package/plugins/autobest-delivery/mcp-server/src/server.mjs

@@ -9,6 +9,17 @@ import {
   resolveBlockedRun,
   runFeatureE2E
 } from './runner.mjs';
+import {
+  abortFastCheck,
+  captureFastCheck,
+  closeAllFastChecks,
+  fastBrowserAction,
+  fastBrowserCheck,
+  fastBrowserSnapshot,
+  finishFastCheck,
+  mockFastCheckRoute,
+  startFastCheck
+} from './fast-runner.mjs';
 
 const server = new McpServer(
   {
@@ -17,10 +28,164 @@ const server = new McpServer(
   },
   {
     instructions:
-      '调用 run_feature_e2e 前先调用 check_environment。headed 运行在 Blocked 时可保留浏览器，随后通过 resolve_blocked_run 记录人工决议并关闭会话。'
+      '调用 E2E 或快速浏览器工具前先调用 check_environment。run_feature_e2e 执行冻结场景；start_fast_check 提供不生成场景文件的交互式自测。'
   }
 );
 
+function jsonResult(result) {
+  return {
+    structuredContent: result,
+    content: [{ type: 'text', text: JSON.stringify(result) }]
+  };
+}
+
+server.registerTool(
+  'start_fast_check',
+  {
+    title: '启动快速 Playwright 自测',
+    description: '启动无需 E2E 场景文件的交互式浏览器会话，并在工作区内准备快速证据目录。',
+    inputSchema: {
+      workspaceRoot: z.string().min(1),
+      baseUrl: z.string().url(),
+      outputDir: z.string().min(1),
+      apiMode: z.enum(['real', 'mock', 'none']).default('none'),
+      iteration: z.number().int().positive().default(1),
+      headed: z.boolean().default(false),
+      viewport: z.object({
+        width: z.number().int().min(320).max(3840),
+        height: z.number().int().min(480).max(2160)
+      }).default({ width: 1400, height: 1000 }),
+      requirementIds: z.array(z.string().regex(/^REQ-[A-Z][A-Z0-9]{1,15}-\d{3}$/)).default([]),
+      sessionTtlMs: z.number().int().min(60000).max(3600000).default(3600000)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await startFastCheck(input))
+);
+
+server.registerTool(
+  'fast_browser_snapshot',
+  {
+    title: '读取快速自测页面',
+    description: '返回当前页面的 URL、标题和精简可访问性快照，供后续交互定位。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserSnapshot(input))
+);
+
+server.registerTool(
+  'fast_browser_action',
+  {
+    title: '执行快速自测页面操作',
+    description: '在快速自测会话中执行导航、点击、填写、选择、按键、等待或视口切换。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      action: z.enum(['navigate', 'click', 'fill', 'select', 'press', 'wait', 'viewport']),
+      locator: z.string().optional(),
+      value: z.string().optional(),
+      url: z.string().optional(),
+      width: z.number().int().min(320).max(3840).optional(),
+      height: z.number().int().min(480).max(2160).optional(),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserAction(input))
+);
+
+server.registerTool(
+  'mock_fast_check_route',
+  {
+    title: '设置快速自测 Mock',
+    description: '仅在 mock 模式为指定 HTTP method 和 pathname 设置 JSON 响应。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      method: z.string().regex(/^[A-Z]+$/).default('GET'),
+      pathname: z.string().startsWith('/'),
+      status: z.number().int().min(100).max(599).default(200),
+      body: z.unknown().default({})
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await mockFastCheckRoute(input))
+);
+
+const reportFields = {
+  requirementId: z.string().optional(),
+  reportModule: z.string().min(1),
+  reportGroup: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+  reportTitle: z.string().min(1),
+  reportMethod: z.string().min(1)
+};
+
+server.registerTool(
+  'fast_browser_check',
+  {
+    title: '记录快速自测检查',
+    description: '执行一个结构化页面检查并记录可供报告导出的检查证据。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      id: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+      ...reportFields,
+      specSnippet: z.string().min(1),
+      expect: z.string().min(1),
+      checkType: z.enum(['visible', 'hidden', 'text', 'value', 'count', 'url', 'attribute', 'css']),
+      locator: z.string().optional(),
+      expected: z.string().optional(),
+      expectedNumber: z.number().int().nonnegative().optional(),
+      property: z.string().optional(),
+      exact: z.boolean().default(false),
+      timeoutMs: z.number().int().min(1000).max(120000).default(10000)
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await fastBrowserCheck(input))
+);
+
+server.registerTool(
+  'capture_fast_check',
+  {
+    title: '保存快速自测报告截图',
+    description: '保存页面或组件 PNG，并记录功能分组和桌面端/移动端报告映射。',
+    inputSchema: {
+      sessionId: z.string().uuid(),
+      ...reportFields,
+      capture: z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]*\.png$/),
+      locator: z.string().optional(),
+      reportDevice: z.enum(['desktop', 'mobile']),
+      fullPage: z.boolean().default(true)
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true }
+  },
+  async input => jsonResult(await captureFastCheck(input))
+);
+
+server.registerTool(
+  'finish_fast_check',
+  {
+    title: '完成快速 Playwright 自测',
+    description: '关闭会话并写入 fast-check-result.json、Markdown、Trace 和截图索引。',
+    inputSchema: { sessionId: z.string().uuid() },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await finishFastCheck(input))
+);
+
+server.registerTool(
+  'abort_fast_check',
+  {
+    title: '放弃快速 Playwright 自测',
+    description: '关闭快速自测浏览器且不生成完成证据。',
+    inputSchema: { sessionId: z.string().uuid() },
+    annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+  },
+  async input => jsonResult(await abortFastCheck(input))
+);
+
 server.registerTool(
   'check_environment',
   {
@@ -198,7 +363,7 @@ await server.connect(transport);
 
 for (const signal of ['SIGINT', 'SIGTERM']) {
   process.once(signal, async () => {
-    await closeAllBlockedRuns();
+    await Promise.all([closeAllBlockedRuns(), closeAllFastChecks()]);
     process.exit(0);
   });
 }

package/plugins/autobest-delivery/mcp-server/tests/fast-runner.test.mjs

@@ -0,0 +1,232 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  abortFastCheck,
+  activeFastCheckCount,
+  captureFastCheck,
+  fastBrowserAction,
+  fastBrowserCheck,
+  fastBrowserSnapshot,
+  finishFastCheck,
+  mockFastCheckRoute,
+  startFastCheck
+} from '../src/fast-runner.mjs';
+import { startFixtureServer } from './fixture-server.mjs';
+
+const report = {
+  reportModule: '交付测试页',
+  reportGroup: 'reveal-result',
+  reportTitle: '结果展示',
+  reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。'
+};
+
+test('交互式快速自测生成检查、截图、Trace 和结果文件，不生成场景代码', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const started = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    iteration: 1
+  });
+  assert.equal(activeFastCheckCount(), 1);
+
+  const snapshot = await fastBrowserSnapshot({ sessionId: started.sessionId });
+  assert.match(snapshot.snapshot, /显示结果/);
+
+  const click = await fastBrowserAction({
+    sessionId: started.sessionId,
+    action: 'click',
+    locator: '#reveal'
+  });
+  assert.equal(click.success, true);
+
+  const checked = await fastBrowserCheck({
+    sessionId: started.sessionId,
+    id: 'story-01',
+    ...report,
+    specSnippet: '点击按钮后显示运行结果。',
+    expect: '结果区域显示“运行器运行正常”',
+    checkType: 'text',
+    locator: '#result',
+    expected: '运行器运行正常',
+    timeoutMs: 10000
+  });
+  assert.equal(checked.check.isPass, true);
+
+  const captured = await captureFastCheck({
+    sessionId: started.sessionId,
+    ...report,
+    capture: 'result-desktop.png',
+    locator: 'main',
+    reportDevice: 'desktop'
+  });
+  assert.match(captured.capture.path, /result-desktop\.png$/);
+
+  const result = await finishFastCheck({ sessionId: started.sessionId });
+  assert.equal(result.status, 'passed');
+  assert.equal(result.evidenceSource, 'interactive-playwright');
+  assert.equal(result.scenarioPath, null);
+  assert.equal(result.scenarioSha256, null);
+  assert.equal(result.checks.length, 1);
+  assert.equal(result.captureRecords.length, 1);
+  assert.equal(activeFastCheckCount(), 0);
+  await assert.rejects(
+    fastBrowserSnapshot({ sessionId: started.sessionId }),
+    /会话不存在或已结束/
+  );
+
+  const resultPath = path.join(workspaceRoot, result.resultPath);
+  const persisted = JSON.parse(await fs.readFile(resultPath, 'utf8'));
+  assert.equal(persisted.status, 'passed');
+  await fs.access(path.join(workspaceRoot, result.captureRecords[0].path));
+  await fs.access(path.join(workspaceRoot, result.tracePath));
+  await fs.access(path.join(workspaceRoot, result.markdownPath));
+  await assert.rejects(fs.access(path.join(workspaceRoot, 'feature', 'e2e', 'e2e.feature.mjs')));
+});
+
+test('快速自测失败会记录结果，会话也可以显式放弃', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-failed-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const failedSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01'
+  });
+  await fastBrowserCheck({
+    sessionId: failedSession.sessionId,
+    id: 'story-01',
+    ...report,
+    specSnippet: '结果应立即显示。',
+    expect: '结果文案可见',
+    checkType: 'text',
+    locator: '#result',
+    expected: '不存在的结果',
+    timeoutMs: 1000
+  });
+  await captureFastCheck({
+    sessionId: failedSession.sessionId,
+    ...report,
+    capture: 'failed-desktop.png',
+    reportDevice: 'desktop'
+  });
+  assert.equal((await finishFastCheck({ sessionId: failedSession.sessionId })).status, 'failed');
+
+  const abortedSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-02'
+  });
+  assert.deepEqual(await abortFastCheck({ sessionId: abortedSession.sessionId }), {
+    status: 'aborted',
+    sessionId: abortedSession.sessionId
+  });
+  assert.equal(activeFastCheckCount(), 0);
+});
+
+test('快速自测拒绝越界输出，且只有 mock 模式允许安装响应', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-policy-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  await assert.rejects(
+    startFastCheck({
+      workspaceRoot,
+      baseUrl: fixture.baseUrl,
+      outputDir: '../outside'
+    }),
+    /outputDir 必须位于 workspaceRoot 内/
+  );
+
+  const realSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    apiMode: 'real'
+  });
+  await assert.rejects(
+    mockFastCheckRoute({
+      sessionId: realSession.sessionId,
+      pathname: '/api/status'
+    }),
+    /只有 mock 模式可以安装请求响应/
+  );
+  await abortFastCheck({ sessionId: realSession.sessionId });
+
+  const mockSession = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-02',
+    apiMode: 'mock'
+  });
+  assert.deepEqual(
+    await mockFastCheckRoute({
+      sessionId: mockSession.sessionId,
+      pathname: '/api/status',
+      body: { source: 'mock' }
+    }),
+    {
+      sessionId: mockSession.sessionId,
+      method: 'GET',
+      pathname: '/api/status',
+      status: 200,
+      success: true
+    }
+  );
+  await abortFastCheck({ sessionId: mockSession.sessionId });
+  assert.equal(activeFastCheckCount(), 0);
+});
+
+test('追踪需求或报告功能组缺少证据时快速自测不能通过', async t => {
+  const fixture = await startFixtureServer();
+  t.after(fixture.close);
+  const workspaceRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'autobest-fast-check-coverage-'));
+  t.after(() => fs.rm(workspaceRoot, { recursive: true, force: true }));
+
+  const started = await startFastCheck({
+    workspaceRoot,
+    baseUrl: fixture.baseUrl,
+    outputDir: 'feature/fast-check/runs/iteration-01',
+    requirementIds: ['REQ-PAGE-001', 'REQ-PAGE-002']
+  });
+  await fastBrowserCheck({
+    sessionId: started.sessionId,
+    id: 'req-page-001-heading',
+    requirementId: 'REQ-PAGE-001',
+    ...report,
+    reportGroup: 'page-heading',
+    reportTitle: '页面标题',
+    specSnippet: '页面显示标题。',
+    expect: '标题可见',
+    checkType: 'visible',
+    locator: 'h1'
+  });
+  await captureFastCheck({
+    sessionId: started.sessionId,
+    requirementId: 'REQ-PAGE-001',
+    ...report,
+    reportGroup: 'other-group',
+    capture: 'other-group-desktop.png',
+    reportDevice: 'desktop'
+  });
+
+  const result = await finishFastCheck({ sessionId: started.sessionId });
+  assert.equal(result.status, 'blocked');
+  assert.ok(result.blockers.some(blocker =>
+    blocker.kind === 'traceability' && blocker.detail.includes('REQ-PAGE-002')
+  ));
+  assert.ok(result.blockers.some(blocker =>
+    blocker.kind === 'report-capture' && blocker.detail.includes('page-heading')
+  ));
+});

package/plugins/autobest-delivery/mcp-server/tests/mcp-smoke.test.mjs

@@ -35,6 +35,21 @@ test('stdio MCP 能暴露环境信息并执行功能场景', async t => {
   await client.connect(transport);
   t.after(() => client.close());
 
+  const { tools } = await client.listTools();
+  const toolNames = tools.map(tool => tool.name);
+  for (const toolName of [
+    'start_fast_check',
+    'fast_browser_snapshot',
+    'fast_browser_action',
+    'mock_fast_check_route',
+    'fast_browser_check',
+    'capture_fast_check',
+    'finish_fast_check',
+    'abort_fast_check'
+  ]) {
+    assert.ok(toolNames.includes(toolName), `缺少 MCP 工具 ${toolName}`);
+  }
+
   const environment = await client.callTool({
     name: 'check_environment',
     arguments: {}
@@ -57,6 +72,62 @@ test('stdio MCP 能暴露环境信息并执行功能场景', async t => {
   assert.equal(execution.structuredContent.status, 'passed');
   assert.equal(execution.structuredContent.checks.length, 2);
 
+  const fastStarted = await client.callTool({
+    name: 'start_fast_check',
+    arguments: {
+      workspaceRoot,
+      baseUrl: fixture.baseUrl,
+      outputDir: 'feature/fast-check/runs/iteration-01'
+    }
+  });
+  const fastSessionId = fastStarted.structuredContent.sessionId;
+  const fastSnapshot = await client.callTool({
+    name: 'fast_browser_snapshot',
+    arguments: { sessionId: fastSessionId }
+  });
+  assert.match(fastSnapshot.structuredContent.snapshot, /显示结果/);
+
+  await client.callTool({
+    name: 'fast_browser_action',
+    arguments: { sessionId: fastSessionId, action: 'click', locator: '#reveal' }
+  });
+  const fastCheck = await client.callTool({
+    name: 'fast_browser_check',
+    arguments: {
+      sessionId: fastSessionId,
+      id: 'story-01',
+      reportModule: '交付测试页',
+      reportGroup: 'reveal-result',
+      reportTitle: '结果展示',
+      reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。',
+      specSnippet: '点击按钮后显示结果。',
+      expect: '结果文案可见',
+      checkType: 'text',
+      locator: '#result',
+      expected: '运行器运行正常'
+    }
+  });
+  assert.equal(fastCheck.structuredContent.check.isPass, true);
+  await client.callTool({
+    name: 'capture_fast_check',
+    arguments: {
+      sessionId: fastSessionId,
+      reportModule: '交付测试页',
+      reportGroup: 'reveal-result',
+      reportTitle: '结果展示',
+      reportMethod: '通过交互式 Playwright 点击按钮并检查结果文案。',
+      capture: 'result-desktop.png',
+      locator: 'main',
+      reportDevice: 'desktop'
+    }
+  });
+  const fastFinished = await client.callTool({
+    name: 'finish_fast_check',
+    arguments: { sessionId: fastSessionId }
+  });
+  assert.equal(fastFinished.structuredContent.status, 'passed');
+  assert.equal(fastFinished.structuredContent.scenarioPath, null);
+
   const rejectedPath = await client.callTool({
     name: 'run_feature_e2e',
     arguments: {