android-midscene-automation 0.2.2 → 0.2.4

package/server/remote-agents/registry.test.ts

@@ -0,0 +1,65 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { registerRemoteAgent, makeRemoteDeviceId, sendRemoteCommand, pollRemoteCommand, completeRemoteCommand, stopRemoteReplay } from './registry';
+
+test('replay heartbeat renews beyond ten minutes, cancellation survives dispatch, late results save once', async () => {
+  const originalSetTimeout = globalThis.setTimeout;
+  const originalClearTimeout = globalThis.clearTimeout;
+  const originalNow = Date.now;
+  const token = process.env.REMOTE_AGENT_TOKEN;
+  let now = originalNow();
+  const timers = new Set<{ at: number; callback: () => void; refresh: () => void }>();
+  const advance = (ms: number) => {
+    now += ms;
+    for (const timer of [...timers]) if (timer.at <= now) { timers.delete(timer); timer.callback(); }
+  };
+  try {
+    Date.now = () => now;
+    globalThis.setTimeout = ((callback: () => void, ms: number) => {
+      const timer = { at: now + ms, callback, refresh: () => { timer.at = now + ms; } };
+      timers.add(timer); return timer;
+    }) as unknown as typeof setTimeout;
+    globalThis.clearTimeout = ((timer: any) => { timers.delete(timer); }) as typeof clearTimeout;
+    const agentId = 'test-lease-agent';
+    const heartbeat = () => registerRemoteAgent({ agentId, token, devices: [{ id: 'device', status: 'device' }] });
+    const device = makeRemoteDeviceId(agentId, 'device');
+    heartbeat();
+    const result = sendRemoteCommand(device, 'replay', { script: { id: 'script' } });
+    let completed = false;
+    void result.then(() => { completed = true; });
+    const command = pollRemoteCommand({ agentId, token })!;
+    assert.throws(() => sendRemoteCommand(device, 'replay'), /已有回放任务/);
+    for (let i = 0; i < 70; i++) { advance(10000); heartbeat(); }
+    assert.equal(completed, false, 'healthy replay remains pending after 11 minutes');
+    assert.equal(stopRemoteReplay(device), true);
+    assert.deepEqual(heartbeat().cancelledCommandIds, [command.id]);
+    assert.throws(() => completeRemoteCommand({ agentId: 'other', token, commandId: command.id, ok: true }), /不属于/);
+    let saves = 0;
+    const stopped = { stopped: true, history: { status: 'stopped' } };
+    completeRemoteCommand({ agentId, token, commandId: command.id, ok: true, data: stopped }, () => { saves++; });
+    assert.deepEqual(await result, stopped);
+    completeRemoteCommand({ agentId, token, commandId: command.id, ok: true, data: stopped }, () => { saves++; });
+    assert.equal(saves, 1, 'result retry must not duplicate history');
+    assert.equal(stopRemoteReplay(device), false);
+
+    const queuedResult = sendRemoteCommand(device, 'replay');
+    assert.equal(stopRemoteReplay(device), true);
+    const queued = pollRemoteCommand({ agentId, token })!;
+    assert.equal(queued.cancelled, true, 'cancel before poll survives delivery');
+    completeRemoteCommand({ agentId, token, commandId: queued.id, ok: true }); await queuedResult;
+
+    const lateResult = sendRemoteCommand(device, 'replay', { script: { id: 'late-script' } });
+    const rejected = assert.rejects(lateResult, /心跳超时/);
+    const late = pollRemoteCommand({ agentId, token })!;
+    advance(45001); await rejected;
+    assert.deepEqual(heartbeat().cancelledCommandIds, [late.id], 'reconnecting agent stops expired replay');
+    const input = { agentId, token, commandId: late.id, ok: true, data: { history: {} } };
+    assert.throws(() => completeRemoteCommand(input, () => { throw new Error('disk busy'); }), /disk busy/);
+    completeRemoteCommand(input, command => { assert.equal((command.payload?.script as { id: string }).id, 'late-script'); saves++; });
+    completeRemoteCommand(input, () => { saves++; });
+    assert.equal(saves, 2, 'late result is saved once even after a temporary persistence failure');
+    assert.deepEqual(heartbeat().cancelledCommandIds, []);
+  } finally {
+    globalThis.setTimeout = originalSetTimeout; globalThis.clearTimeout = originalClearTimeout; Date.now = originalNow;
+  }
+});

package/server/remote-agents/registry.ts

@@ -3,7 +3,9 @@ import type { RemoteAgentDevice, RemoteAndroidDevice, RemoteCommand, RemoteComma
 const REMOTE_DEVICE_PREFIX = 'remote:';
 const AGENT_TTL_MS = 15_000;
 const COMMAND_TIMEOUT_MS = 15_000;
-const REPLAY_COMMAND_TIMEOUT_MS = 10 * 60_000;
+// 回放由代理心跳续期，运行时长不受固定十分钟限制。
+const REPLAY_COMMAND_TIMEOUT_MS = 45_000;
+const LATE_RESULT_TTL_MS = 24 * 60 * 60_000;
 
 type RegisteredAgent = {
   id: string;
@@ -14,6 +16,9 @@ type RegisteredAgent = {
 };
 
 type PendingCommand = RemoteCommand & {
+  agentId: string;
+  delivered: boolean;
+  cancelRequested: boolean;
   resolve: (result: unknown) => void;
   reject: (error: Error) => void;
   timer: ReturnType<typeof setTimeout>;
@@ -22,6 +27,24 @@ type PendingCommand = RemoteCommand & {
 const agents = new Map<string, RegisteredAgent>();
 const queues = new Map<string, RemoteCommand[]>();
 const pending = new Map<string, PendingCommand>();
+// ponytail: 当前进程保留离线回放身份 24 小时；跨服务重启补交需要持久化任务表。
+const lateReplays = new Map<string, { command: RemoteCommand; agentId: string; expiresAt: number }>();
+function pruneLateReplays() {
+  for (const [id, receipt] of lateReplays) if (receipt.expiresAt <= Date.now()) lateReplays.delete(id);
+}
+
+export function stopRemoteReplay(deviceId: string) {
+  const target = parseRemoteDeviceId(deviceId);
+  if (!target) return false;
+  let stopped = false;
+  for (const command of pending.values()) {
+    if (command.type === 'replay' && command.agentId === target.agentId && command.deviceId === target.deviceSerial) {
+      command.cancelRequested = true;
+      stopped = true;
+    }
+  }
+  return stopped;
+}
 
 function validateToken(token?: string) {
   const expected = process.env.REMOTE_AGENT_TOKEN || '';
@@ -70,6 +93,17 @@ export function registerRemoteAgent(input: {
     devices: input.devices || [],
     lastSeenAt: Date.now(),
   });
+  pruneLateReplays();
+  const cancelledCommandIds: string[] = [];
+  for (const command of pending.values()) {
+    if (command.agentId !== agentId || command.type !== 'replay') continue;
+    command.timer.refresh();
+    if (command.cancelRequested) cancelledCommandIds.push(command.id);
+  }
+  for (const receipt of lateReplays.values()) {
+    if (receipt.agentId === agentId) cancelledCommandIds.push(receipt.command.id);
+  }
+  return { cancelledCommandIds };
 }
 
 export function listRemoteAndroidDevices(): RemoteAndroidDevice[] {
@@ -88,15 +122,27 @@ export function listRemoteAndroidDevices(): RemoteAndroidDevice[] {
 export function pollRemoteCommand(input: { agentId: string; token?: string }) {
   validateToken(input.token);
   const queue = queues.get(input.agentId) || [];
-  return queue.shift() || null;
+  const command = queue.shift();
+  if (!command) return null;
+  const task = pending.get(command.id);
+  if (!task) return null;
+  task.delivered = true;
+  return { ...command, cancelled: task.cancelRequested };
 }
 
 export function completeRemoteCommand(input: {
   agentId: string;
   token?: string;
-} & RemoteCommandResult) {
+} & RemoteCommandResult, saveResult?: (command: RemoteCommand) => void) {
   validateToken(input.token);
+  pruneLateReplays();
   const command = pending.get(input.commandId);
+  const late = lateReplays.get(input.commandId);
+  if (!command && !late) return;
+  if ((command?.agentId ?? late?.agentId) !== input.agentId) throw new Error('远程命令不属于当前代理');
+  // 先落库再确认；保存失败时保留任务身份，让代理重试上报。
+  if (input.ok) saveResult?.(command ?? late!.command);
+  lateReplays.delete(input.commandId);
   if (!command) return;
   pending.delete(input.commandId);
   clearTimeout(command.timer);
@@ -112,6 +158,10 @@ export function sendRemoteCommand(deviceId: string, type: RemoteCommandType, pay
   if (!parsed) throw new Error('远程设备 ID 无效');
   const agent = agents.get(parsed.agentId);
   if (!agent || !isOnline(agent)) throw new Error('远程设备代理已离线');
+  if (type === 'replay' && [...pending.values()].some(command =>
+    command.type === 'replay' && command.agentId === parsed.agentId && command.deviceId === parsed.deviceSerial)) {
+    throw new Error('该设备已有回放任务正在执行');
+  }
   const commandId = `remote_cmd_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
   const command: RemoteCommand = {
     id: commandId,
@@ -123,12 +173,17 @@ export function sendRemoteCommand(deviceId: string, type: RemoteCommandType, pay
   return new Promise<unknown>((resolve, reject) => {
     const timeoutMs = type === 'replay' ? REPLAY_COMMAND_TIMEOUT_MS : COMMAND_TIMEOUT_MS;
     const timer = setTimeout(() => {
+      const task = pending.get(commandId);
       pending.delete(commandId);
+      if (type === 'replay' && task?.delivered) {
+        pruneLateReplays();
+        lateReplays.set(commandId, { command, agentId: parsed.agentId, expiresAt: Date.now() + LATE_RESULT_TTL_MS });
+      }
       const queue = queues.get(parsed.agentId) || [];
       queues.set(parsed.agentId, queue.filter((item) => item.id !== commandId));
-      reject(new Error('远程设备命令超时'));
+      reject(new Error(type === 'replay' ? '远程代理心跳超时，恢复连接后将终止任务并补交结果' : '远程设备命令超时'));
     }, timeoutMs);
-    pending.set(commandId, { ...command, resolve, reject, timer });
+    pending.set(commandId, { ...command, agentId: parsed.agentId, delivered: false, cancelRequested: false, resolve, reject, timer });
     const queue = queues.get(parsed.agentId) || [];
     queue.push(command);
     queues.set(parsed.agentId, queue);

package/server/remote-agents/replay-integration.test.ts

@@ -0,0 +1,79 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createServer } from 'node:http';
+import { spawn } from 'node:child_process';
+import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+test('real agent receives stop during replay and retries result delivery without replaying', { skip: process.platform === 'win32', timeout: 25000 }, async () => {
+  const root = await mkdtemp(join(tmpdir(), 'remote-replay-'));
+  const env = { ...process.env };
+  process.env.ANDROID_MIDSCENE_DATA_ROOT = join(root, 'central');
+  process.env.REMOTE_AGENT_TOKEN = 'test-only-token';
+  const { handleRemoteAgentRequest } = await import('./routes');
+  const { handleAppiumRecorderRequest } = await import('../appium-recorder/routes');
+  const { listRemoteAndroidDevices } = await import('./registry');
+  const { saveAppiumRecordedScript } = await import('../appium-recorder/repository');
+  const { listRunHistory } = await import('../appium-recorder/run-history');
+  let sessions = 0, deletes = 0, keys = 0, resultAttempts = 0;
+  const server = createServer(async (req, res) => {
+    if (req.url === '/session') {
+      sessions++; res.setHeader('Content-Type', 'application/json'); res.end('{"value":{"sessionId":"test-session"}}'); return;
+    }
+    if (req.url?.startsWith('/session/')) {
+      if (req.method === 'DELETE') deletes++;
+      if (req.url.endsWith('/press_keycode')) keys++;
+      res.setHeader('Content-Type', 'application/json'); res.end('{"value":{}}'); return;
+    }
+    if (req.url === '/api/remote-agents/result' && ++resultAttempts === 1) {
+      req.resume(); res.statusCode = 503; res.end('{"message":"temporary failure"}'); return;
+    }
+    if (await handleRemoteAgentRequest(req, res)) return;
+    if (await handleAppiumRecorderRequest(req, res, '')) return;
+    res.statusCode = 404; res.end();
+  });
+  let agent: ReturnType<typeof spawn> | undefined;
+  const waitFor = async (check: () => boolean) => {
+    const until = Date.now() + 12000;
+    while (!check()) { assert.ok(Date.now() < until, 'agent action completed within deadline'); await new Promise(resolve => setTimeout(resolve, 25)); }
+  };
+  try {
+    const sdk = join(root, 'sdk'), bin = join(sdk, 'platform-tools');
+    await mkdir(bin, { recursive: true });
+    await writeFile(join(bin, 'adb'), '#!/usr/bin/env node\nif(process.argv.includes("devices")) console.log("List of devices attached\\nfake-device device model:Test");\n', { mode: 0o755 });
+    await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve));
+    const base = `http://127.0.0.1:${(server.address() as { port: number }).port}`;
+    const script = saveAppiumRecordedScript({ name: 'remote-test', appPackage: 'example.test', steps: [
+      { id: 'wait', type: 'delay', label: 'wait', timeoutMs: 60000 },
+      { id: 'home', type: 'key', label: 'Home', keyCode: 3 },
+    ] });
+    agent = spawn(process.execPath, ['--import', 'tsx', resolve('remote-agent/index.ts'), '--server', base, '--agent-id', 'integration-agent'], {
+      env: { ...process.env, ANDROID_MIDSCENE_DATA_ROOT: join(root, 'agent'), ANDROID_HOME: sdk, ANDROID_SDK_ROOT: sdk, APPIUM_SERVER_URL: base, PATH: `${bin}:${process.env.PATH}` },
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let stderr = ''; agent.stderr?.on('data', chunk => { stderr += chunk; });
+    await waitFor(() => listRemoteAndroidDevices().length > 0);
+    const deviceId = listRemoteAndroidDevices()[0]!.id;
+    const post = (path: string, data: unknown) => fetch(base + path, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(data), signal: AbortSignal.timeout(18000) });
+    const running = post(`/api/appium-recorder/scripts/${script.id}/replay`, { deviceId, reportSummaryEnabled: false }).then(response => response.json() as Promise<{ stopped: boolean }>);
+    await waitFor(() => sessions === 1);
+    const stop = await (await post('/api/appium-recorder/replay/stop', { deviceId })).json() as { stopped: boolean };
+    assert.equal(stop.stopped, true);
+    const result = await running;
+    assert.equal(result.stopped, true, stderr);
+    assert.equal(sessions, 1, 'retrying the result never replays device actions');
+    assert.equal(deletes, 1); assert.equal(keys, 0, 'Home must not run after cancellation');
+    assert.equal(resultAttempts, 2, 'temporary result failure is retried');
+    const history = listRunHistory(script.id);
+    assert.equal(history.length, 1); assert.equal(history[0]?.status, 'stopped'); assert.equal(history[0]?.deviceId, deviceId);
+  } finally {
+    if (agent && agent.exitCode === null) {
+      const exited = new Promise<void>(resolve => agent!.once('exit', () => resolve()));
+      agent.kill('SIGKILL'); await exited;
+    }
+    server.closeAllConnections(); await new Promise<void>(resolve => server.close(() => resolve()));
+    for (const key of ['ANDROID_MIDSCENE_DATA_ROOT', 'REMOTE_AGENT_TOKEN']) { if (env[key] === undefined) delete process.env[key]; else process.env[key] = env[key]; }
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/server/remote-agents/routes.ts

@@ -1,6 +1,8 @@
+import { saveRunHistory } from '../appium-recorder/run-history';
+import type { RunDetail } from '../../src/appium-recorder/run-history';
 import { readBody, requestErrorStatus } from '../request-body';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { completeRemoteCommand, listRemoteAndroidDevices, pollRemoteCommand, registerRemoteAgent } from './registry';
+import { completeRemoteCommand, makeRemoteDeviceId, listRemoteAndroidDevices, pollRemoteCommand, registerRemoteAgent } from './registry';
 import type { RemoteAgentDevice } from './protocol';
 
 function sendJson(res: ServerResponse, payload: unknown, statusCode = 200) {
@@ -29,14 +31,14 @@ export async function handleRemoteAgentRequest(req: IncomingMessage, res: Server
         token?: string;
         devices?: RemoteAgentDevice[];
       }>(req);
-      registerRemoteAgent({
+      const control = registerRemoteAgent({
         agentId: parsed.agentId || '',
         agentName: parsed.agentName,
         version: parsed.version,
         token: parsed.token,
         devices: parsed.devices || [],
       });
-      sendJson(res, { success: true });
+      sendJson(res, { success: true, ...control });
       return true;
     }
 
@@ -65,6 +67,11 @@ export async function handleRemoteAgentRequest(req: IncomingMessage, res: Server
         ok: parsed.ok === true,
         data: parsed.data,
         error: parsed.error,
+      }, command => {
+        const result = parsed.data as { history?: RunDetail } | undefined;
+        if (command.type !== 'replay' || !result?.history) return;
+        const script = command.payload?.script as { id: string };
+        saveRunHistory({ ...result.history, scriptId: script.id, deviceId: makeRemoteDeviceId(parsed.agentId!, command.deviceId) });
       });
       sendJson(res, { success: true });
       return true;

package/src/App.vue

@@ -110,8 +110,9 @@ const { isRunningScript, isStoppingScript, executionLog, executionProcess, lastR
 const visitedMenus = reactive(new Set<MenuKey>([activeMenu.value]));
 const openMenus = ref<MenuKey[]>([...menuKeys]);
 const visibleMenuItems = computed(() => openMenus.value.map(key => menuItems.find(item => item.key === key)!));
-function closeMenu(key: MenuKey) {
+async function closeMenu(key: MenuKey) {
   if (openMenus.value.length === 1) return;
+  if (key === 'generator' && !(await confirmUnsavedGeneratorNavigation())) return;
   const index = openMenus.value.indexOf(key);
   openMenus.value.splice(index, 1);
   if (activeMenu.value === key) activeMenu.value = openMenus.value[Math.max(0, index - 1)];
@@ -144,6 +145,23 @@ const appPromptPrefix = computed(() => {
 const effectiveSourcePrompt = computed(() => `${appPromptPrefix.value}${sourcePrompt.value}`.trim());
 const generatedCodeFromSteps = computed(() => buildScript(form, steps.value));
 const generatedCode = computed(() => generatedCodeOverride.value ?? generatedCodeFromSteps.value);
+const generatorContentSnapshot = computed(() => JSON.stringify({
+  form: {
+    promptTitle: form.promptTitle,
+    testName: form.testName,
+    appPresetId: form.appPresetId,
+  },
+  sourcePrompt: sourcePrompt.value,
+  steps: steps.value,
+  generatedCodeOverride: generatedCodeOverride.value,
+  generatedCodeDraft: generatedCodeEditing.value ? generatedCodeDraft.value : '',
+}));
+const savedGeneratorSnapshot = shallowRef('');
+const generatorHasUnsavedContent = computed(() => (
+  showGeneratedCode.value
+  && Boolean(generatedCode.value.trim())
+  && generatorContentSnapshot.value !== savedGeneratorSnapshot.value
+));
 const selectedScript = computed(() => savedScripts.value.find((item) => item.id === selectedScriptId.value));
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 const deviceActions = [
@@ -155,8 +173,11 @@ const deviceActions = [
   { key: 'tasks', label: '任务', icon: tasksIcon, keyCode: 187 },
 ] as const;
 
-const selectMenu = (key: string) => {
-  activeMenu.value = key as MenuKey;
+const selectMenu = async (key: string) => {
+  const nextMenu = key as MenuKey;
+  if (nextMenu === activeMenu.value) return;
+  if (activeMenu.value === 'generator' && !(await confirmUnsavedGeneratorNavigation())) return;
+  activeMenu.value = nextMenu;
 };
 
 const resetGeneratedCodeEditor = () => {
@@ -166,11 +187,6 @@ const resetGeneratedCodeEditor = () => {
   generatedCodeEditSaving.value = false;
 };
 
-watch(activeGeneratorMode, () => {
-  showGeneratedCode.value = false;
-  resetGeneratedCodeEditor();
-});
-
 function formatScriptTime(value: string) {
   if (!value) return '';
   const date = new Date(value);
@@ -455,16 +471,16 @@ const buildSourcePromptForSave = () => {
 
 const saveCurrentScript = async () => {
   const validInput = validateCurrentGeneratorInputs();
-  if (!validInput) return;
+  if (!validInput) return false;
 
   if (generatedCodeEditing.value) {
     ElMessage.error('请先保存或撤回代码修改');
-    return;
+    return false;
   }
 
   if (!showGeneratedCode.value || !generatedCode.value.trim()) {
     ElMessage.error('请先点击 AI 生成，生成代码后再保存脚本');
-    return;
+    return false;
   }
 
   const { scriptName, promptTitle } = validInput;
@@ -478,7 +494,7 @@ const saveCurrentScript = async () => {
         cancelButtonText: '取消',
       });
     } catch {
-      return;
+      return false;
     }
   }
 
@@ -495,10 +511,34 @@ const saveCurrentScript = async () => {
     });
 
     await loadSavedScripts(payload.script?.id || '');
+    savedGeneratorSnapshot.value = generatorContentSnapshot.value;
     await sleep(Math.max(0, 1200 - (Date.now() - startedAt)));
     closeActionDialog();
+    return true;
   } catch (error) {
     failActionDialog(error instanceof Error ? error.message : '保存脚本失败');
+    return false;
+  }
+};
+
+const confirmUnsavedGeneratorNavigation = async () => {
+  if (!generatorHasUnsavedContent.value) return true;
+
+  try {
+    await ElMessageBox.confirm(
+      '当前生成内容尚未保存。可以先保存脚本，或暂不保存并继续切换页面。',
+      '未保存的测试脚本',
+      {
+        type: 'warning',
+        confirmButtonText: '保存脚本',
+        cancelButtonText: '暂不保存',
+        distinguishCancelAndClose: true,
+        closeOnClickModal: false,
+      },
+    );
+    return await saveCurrentScript();
+  } catch (action) {
+    return action === 'cancel';
   }
 };
 
@@ -554,7 +594,7 @@ const generateWithModel = async () => {
   errorMessage.value = '';
   const controller = new AbortController();
   aiGenerateAbortController = controller;
-  openActionDialog('AI生成', {
+  openActionDialog('AI 生成', {
     canRunInBackground: true,
     canCancel: true,
     cancelText: '终止',
@@ -674,7 +714,7 @@ watch(activeMenu, menu => {
   if (!openMenus.value.includes(menu)) openMenus.value.push(menu);
 }, { flush: 'sync' });
 const warnBeforeUnload = (event: BeforeUnloadEvent) => {
-  if (!appiumAutoSave.dirty.value) return;
+  if (!appiumAutoSave.dirty.value && !generatorHasUnsavedContent.value) return;
   event.preventDefault();
   event.returnValue = '';
 };
@@ -695,7 +735,9 @@ onUnmounted(() => {
     <el-dialog
       v-model="actionDialog.visible"
       :title="actionDialog.title"
-      width="360px"
+      width="min(440px, calc(100vw - 32px))"
+      align-center
+      append-to-body
       :close-on-click-modal="false"
       :close-on-press-escape="!actionDialog.loading"
       :show-close="!actionDialog.loading"
@@ -712,7 +754,7 @@ onUnmounted(() => {
         <div v-if="actionDialog.loading" class="action-dialog__footer-actions">
           <el-button
             v-if="actionDialog.canCancel"
-            class="action-dialog__footer-button action-dialog__footer-button--secondary"
+            class="action-dialog__footer-button"
             :icon="VideoPause"
             :loading="actionDialog.canceling"
             @click="stopGenerateWithModel"
@@ -721,7 +763,8 @@ onUnmounted(() => {
           </el-button>
           <el-button
             v-if="actionDialog.canRunInBackground"
-            class="action-dialog__footer-button action-dialog__footer-button--primary"
+            type="primary"
+            class="action-dialog__footer-button"
             @click="sendActionDialogToBackground"
           >
             后台处理
@@ -729,7 +772,8 @@ onUnmounted(() => {
         </div>
         <el-button
           v-else
-          class="action-dialog__footer-button action-dialog__footer-button--primary"
+          type="primary"
+          class="action-dialog__footer-button"
           @click="closeActionDialog"
         >
           关闭

package/src/style.css

@@ -68,38 +68,33 @@ select {
   display: flex;
   align-items: center;
   justify-content: center;
-  gap: 8px;
-  min-height: 56px;
-  padding: 4px 0;
-  color: #303133;
+  gap: 10px;
+  min-height: 72px;
+  padding: 8px 0;
+  color: var(--ui-text);
   font-size: 14px;
 }
 
 .action-dialog__spinner {
-  font-size: 16px;
+  color: var(--ui-primary);
+  font-size: 18px;
   animation: action-dialog-spin 1s linear infinite;
 }
 
 .action-dialog__error {
-  min-height: 0;
-  padding: 4px 0 2px;
-  color: #f56c6c;
+  min-height: 72px;
+  padding: 14px 16px;
+  border: 1px solid #ffd6d6;
+  border-radius: var(--ui-radius-control);
+  background: #fff5f5;
+  color: var(--ui-danger);
   font-size: 13px;
   line-height: 1.6;
   white-space: pre-wrap;
 }
 
-.action-dialog .el-dialog__header {
-  margin-right: 0;
-  padding: 14px 16px 6px;
-}
-
 .action-dialog .el-dialog__body {
-  padding: 8px 16px 6px;
-}
-
-.action-dialog .el-dialog__footer {
-  padding: 6px 16px 14px;
+  padding-bottom: 14px;
 }
 
 .action-dialog__footer-actions {
@@ -110,44 +105,13 @@ select {
 }
 
 .action-dialog__footer-button.el-button {
-  min-width: 88px;
-  height: 34px;
-  padding: 0 16px;
-  border-radius: 7px;
-  font-size: 14px;
-  font-weight: 700;
+  min-width: 104px;
 }
 
 .action-dialog__footer-button.el-button + .action-dialog__footer-button.el-button {
   margin-left: 0;
 }
 
-.action-dialog__footer-button--secondary.el-button {
-  border-color: #e5e7eb;
-  background: #fff;
-  color: #8b95a5;
-}
-
-.action-dialog__footer-button--secondary.el-button:hover,
-.action-dialog__footer-button--secondary.el-button:focus {
-  border-color: #d7dce5;
-  background: #f8fafc;
-  color: #6b7280;
-}
-
-.action-dialog__footer-button--primary.el-button {
-  border-color: #ffd436;
-  background: #ffd436;
-  color: #111827;
-}
-
-.action-dialog__footer-button--primary.el-button:hover,
-.action-dialog__footer-button--primary.el-button:focus {
-  border-color: #ffca1f;
-  background: #ffca1f;
-  color: #111827;
-}
-
 @keyframes action-dialog-spin {
   from {
     transform: rotate(0deg);
@@ -1298,7 +1262,7 @@ select {
 
 .appium-replay-dialog.el-dialog {
   display: flex;
-  padding: 16px;
+  padding: 0;
   height: min(620px, calc(100vh - 64px));
   min-width: 420px;
   min-height: 280px;
@@ -1318,16 +1282,16 @@ select {
   flex: 1 1 auto;
   min-height: 0;
   overflow: hidden;
-  padding: 8px 0 0;
+  padding: 16px 20px 0;
 }
 
 .appium-replay-dialog > .el-dialog__header {
-  padding: 0 0 16px;
-  border-bottom: 0;
+  padding: 18px 20px 14px;
+  border-bottom: 1px solid var(--ui-border);
 }
 
 .appium-replay-dialog > .el-dialog__footer {
-  padding: 16px 0 0;
+  padding: 12px 20px 18px;
 }
 
 .appium-replay-dialog .appium-replay-output {
@@ -3592,22 +3556,22 @@ body {
   flex-direction: column;
   height: 86dvh;
   max-height: calc(100dvh - 32px);
-  overflow: visible;
-  padding: 16px;
-  border: 0;
-  border-radius: 4px;
-  box-shadow: var(--el-box-shadow);
+  overflow: hidden;
+  padding: 0;
+  border: 1px solid var(--ui-border);
+  border-radius: var(--ui-radius);
+  box-shadow: 0 18px 48px rgba(15, 23, 42, 0.18);
 }
 
 .appium-flow-dialog .el-dialog__header {
   flex: none;
-  padding: 0 0 16px;
-  border-bottom: 0;
+  padding: 18px 20px 14px;
+  border-bottom: 1px solid var(--ui-border);
 }
 
 .appium-flow-dialog .el-dialog__title {
-  font-size: var(--el-dialog-title-font-size);
-  font-weight: 400;
+  font-size: 16px;
+  font-weight: 650;
 }
 
 .appium-flow-dialog .el-dialog__body {
@@ -3615,7 +3579,7 @@ body {
   flex-direction: column;
   flex: 1;
   min-height: 0;
-  padding: 8px 0 0;
+  padding: 16px 20px 20px;
 }
 
 .appium-flow-dialog__toolbar { flex: none; }