android-midscene-automation 0.1.36 → 0.1.38

package/CHANGELOG.md

@@ -1,4 +1,15 @@
 # 更新记录
+## v0.1.38
+- 移除节点类型切换；新节点及未配置的判断等待超时统一为 3000ms，已有自定义时间和延时、长按等操作时长保持不变。
+- 取消 Activity 不匹配时的脚本编辑锁定，不在脚本绑定页面也可编辑节点；页面差异仅作提示，保留录制操作及回放期间的编辑保护。
+- 所有分支节点新增“超时后处理”，可预设终止流程、进入左侧或右侧分支，默认终止；覆盖元素等待、文字匹配、勾选控件等待、AI 识别及图像观察超时，日志和 HTML 报告标明超时分支。正常 false、循环次数上限与超时区分处理，设备断开及 Appium 无响应仍终止。
+
+## v0.1.37
+- 修复元素查找超时未覆盖 Appium 请求的问题，驱动无响应时及时中止并明确报错，不再误判为找不到元素；唯一原生定位优先使用 ID 或 Accessibility ID。
+- 设备预览新增设备信息，展示设备名称、品牌、型号、处理器、Android 版本、物理分辨率及当前分辨率，支持远程设备；问号位于标题右侧，样式与全局变量帮助图标一致。
+- 新增独立“杀死 APP”操作节点，默认使用当前选中应用包名，支持编辑目标包名；停止当前设备用户下的应用进程，不清除应用数据。
+- Midscene 相关模块由 1.12.5 统一升级至 1.12.6。
+
 ## v0.1.36
 - 新合并支持取消：原合并按钮切换为取消合并，还原分支和被删除的重复节点，保留配置编辑；公共流程新增的普通操作可选择保留左侧、右侧或两侧，结构冲突时阻止还原。本地保存还原记录，导出及节点复制不携带历史记录。
 - 启动相册前先停止当前设备用户下的目标相册进程，再重新打开；保留相册自动适配，不清除照片及应用数据，停止失败时明确报错。

package/README.md

@@ -1229,6 +1229,17 @@ Linux: ~/.local/share/android-midscene-automation
 
 # 项目更新记录
 
+## v0.1.38
+- 移除节点类型切换；新节点及未配置的判断等待超时统一为 3000ms，已有自定义时间和延时、长按等操作时长保持不变。
+- 取消 Activity 不匹配时的脚本编辑锁定，不在脚本绑定页面也可编辑节点；页面差异仅作提示，保留录制操作及回放期间的编辑保护。
+- 所有分支节点新增“超时后处理”，可预设终止流程、进入左侧或右侧分支，默认终止；覆盖元素等待、文字匹配、勾选控件等待、AI 识别及图像观察超时，日志和 HTML 报告标明超时分支。正常 false、循环次数上限与超时区分处理，设备断开及 Appium 无响应仍终止。
+
+## v0.1.37
+- 修复元素查找超时未覆盖 Appium 请求的问题，驱动无响应时及时中止并明确报错，不再误判为找不到元素；唯一原生定位优先使用 ID 或 Accessibility ID。
+- 设备预览新增设备信息，展示设备名称、品牌、型号、处理器、Android 版本、物理分辨率及当前分辨率，支持远程设备；问号位于标题右侧，样式与全局变量帮助图标一致。
+- 新增独立“杀死 APP”操作节点，默认使用当前选中应用包名，支持编辑目标包名；停止当前设备用户下的应用进程，不清除应用数据。
+- Midscene 相关模块由 1.12.5 统一升级至 1.12.6。
+
 ## v0.1.36
 - 新合并支持取消：原合并按钮切换为取消合并，还原分支和被删除的重复节点，保留配置编辑；公共流程新增的普通操作可选择保留左侧、右侧或两侧，结构冲突时阻止还原。本地保存还原记录，导出及节点复制不携带历史记录。
 - 启动相册前先停止当前设备用户下的目标相册进程，再重新打开；保留相册自动适配，不清除照片及应用数据，停止失败时明确报错。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "android-midscene-automation",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oooooooko/android-midscene-automation.git"
@@ -38,12 +38,12 @@
   "dependencies": {
     "@dagrejs/dagre": "1.1.5",
     "@element-plus/icons-vue": "2.3.2",
-    "@midscene/android": "https://registry.npmjs.org/@midscene/android/-/android-1.12.5.tgz",
-    "@midscene/android-playground": "https://registry.npmjs.org/@midscene/android-playground/-/android-playground-1.12.5.tgz",
-    "@midscene/core": "https://registry.npmjs.org/@midscene/core/-/core-1.12.5.tgz",
-    "@midscene/playground": "https://registry.npmjs.org/@midscene/playground/-/playground-1.12.5.tgz",
-    "@midscene/shared": "https://registry.npmjs.org/@midscene/shared/-/shared-1.12.5.tgz",
-    "@midscene/web": "https://registry.npmjs.org/@midscene/web/-/web-1.12.5.tgz",
+    "@midscene/android": "https://registry.npmjs.org/@midscene/android/-/android-1.12.6.tgz",
+    "@midscene/android-playground": "https://registry.npmjs.org/@midscene/android-playground/-/android-playground-1.12.6.tgz",
+    "@midscene/core": "https://registry.npmjs.org/@midscene/core/-/core-1.12.6.tgz",
+    "@midscene/playground": "https://registry.npmjs.org/@midscene/playground/-/playground-1.12.6.tgz",
+    "@midscene/shared": "https://registry.npmjs.org/@midscene/shared/-/shared-1.12.6.tgz",
+    "@midscene/web": "https://registry.npmjs.org/@midscene/web/-/web-1.12.6.tgz",
     "@techstark/opencv-js": "5.0.0-release.1",
     "@vitejs/plugin-vue": "6.0.7",
     "@vue-flow/core": "1.48.2",

package/remote-agent/index.ts

@@ -1,5 +1,6 @@
 import { execFile } from 'node:child_process';
 import os from 'node:os';
+import { readAndroidDeviceInfo } from '../server/android-device-info';
 import { readFreshWindowHierarchy } from '../server/appium-recorder/tree-dump';
 import type { RemoteAgentDevice, RemoteCommand } from '../server/remote-agents/protocol';
 import { replayAppiumScript } from '../server/appium-recorder/appium-runner';
@@ -100,6 +101,7 @@ async function handleCommand(command: RemoteCommand) {
     return { base64: image.toString('base64') };
   }
   if (command.type === 'displayInfo') return await getDisplayInfo(command.deviceId);
+  if (command.type === 'deviceInfo') return await readAndroidDeviceInfo(command.deviceId, 'adb');
   if (command.type === 'tree') {
     const [xml, activity] = await Promise.all([
       dumpWindowHierarchy(command.deviceId),

package/server/android-device-info.ts

@@ -0,0 +1,28 @@
+import { execFile } from 'node:child_process';
+import type { AndroidDeviceDetails } from '../src/types';
+
+export function parseAndroidDeviceInfo(properties: string, size: string, deviceName = ''): AndroidDeviceDetails {
+  const values = new Map([...properties.matchAll(/^\[([^\]]+)\]: \[(.*)\]\s*$/gm)].map(match => [match[1], match[2]]));
+  const get = (...keys: string[]) => keys.map(key => values.get(key)?.trim()).find(Boolean) || '';
+  const physical = size.match(/Physical size:\s*(\d+)x(\d+)/i);
+  const current = size.match(/Override size:\s*(\d+)x(\d+)/i) || physical;
+  const resolution = (match: RegExpMatchArray | null) => match ? `${match[1]} × ${match[2]}` : '';
+  return {
+    name: deviceName.trim() && deviceName.trim() !== 'null' ? deviceName.trim() : get('persist.sys.device_name', 'ro.product.marketname', 'ro.product.model'),
+    brand: get('ro.product.brand', 'ro.product.manufacturer'), model: get('ro.product.model'),
+    processor: get('ro.soc.model', 'ro.board.platform', 'ro.hardware'),
+    androidVersion: get('ro.build.version.release'), physicalResolution: resolution(physical), resolution: resolution(current),
+  };
+}
+
+export async function readAndroidDeviceInfo(deviceId: string, adb: string) {
+  const run = (args: string[]) => new Promise<string>((resolve, reject) => {
+    execFile(adb, ['-s', deviceId, 'shell', ...args], { timeout: 4000, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+      if (error) reject(error); else resolve(stdout);
+    });
+  });
+  const properties = await run(['getprop']);
+  const size = await run(['wm', 'size']).catch(() => '');
+  const name = await run(['settings', 'get', 'global', 'device_name']).catch(() => '');
+  return parseAndroidDeviceInfo(properties, size, name);
+}

package/server/appium-recorder/ai-recognition.ts

@@ -1,4 +1,6 @@
 import OpenAI from 'openai';
+import { DEFAULT_NODE_TIMEOUT_MS } from '../../src/appium-recorder/node-timeout';
+import { ConditionTimeoutError } from './condition-timeout';
 import { loadConfig } from '../config';
 import { adbScreenshotBase64 } from './screenshot';
 import {
@@ -35,7 +37,7 @@ export async function recognizeDeviceScreen(input: {
   if (!['http:', 'https:'].includes(baseURL.protocol)) throw new Error('AI 识别模型 Base URL 必须为 HTTP(S) 地址');
   const startedAt = Date.now();
   const timeoutMs = Number.isFinite(input.timeoutMs) && input.timeoutMs! > 0
-    ? Math.min(300000, Math.max(1000, input.timeoutMs!)) : 60000;
+    ? Math.min(300000, Math.max(1000, input.timeoutMs!)) : DEFAULT_NODE_TIMEOUT_MS;
   const deadline = AbortSignal.timeout(timeoutMs);
   const signal = input.signal ? AbortSignal.any([input.signal, deadline]) : deadline;
   signal.throwIfAborted();
@@ -59,7 +61,7 @@ export async function recognizeDeviceScreen(input: {
     return { ...parseAiRecognitionResult(choice.message.content), durationMs: Date.now() - startedAt, imageBase64 };
   } catch (error) {
     if (input.signal?.aborted) throw input.signal.reason;
-    if (deadline.aborted) throw new Error(`AI 识别超时（${timeoutMs}ms）`);
+    if (deadline.aborted) throw new ConditionTimeoutError(`AI 识别超时（${timeoutMs}ms）`);
     // 不透传模型服务的原始响应，避免 API Key 或敏感请求信息进入报告。
     if (error instanceof OpenAI.APIError) throw new Error(`AI 识别模型请求失败（HTTP ${error.status || '连接异常'}），请检查模型配置及图片输入支持`);
     throw error;

package/server/appium-recorder/appium-runner.ts

@@ -11,6 +11,10 @@ import { checkImage } from './image-check';
 import { IMAGE_CHECK_MODES, type ImageCheckResult } from '../../src/appium-recorder/image-check';
 import { formatStageLog } from '../../src/appium-recorder/stage-log';
 import { openGalleryOnDevice } from './open-gallery';
+import { stopAppOnDevice } from './stop-app';
+import { DEFAULT_NODE_TIMEOUT_MS } from '../../src/appium-recorder/node-timeout';
+import { ConditionTimeoutError, AppiumServiceError } from './condition-timeout';
+import { AppiumRequestTimeoutError, timedAppiumFetch, withElementDeadline } from './request-timeout';
 import { textClickSelector } from '../../src/appium-recorder/text-click';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { mkdir, writeFile } from 'node:fs/promises';
@@ -83,6 +87,8 @@ function isReplayStopped(error?: unknown) {
 
 function throwIfReplayStopped(error?: unknown) {
   if (isReplayStopped(error)) throw new ReplayStoppedError();
+  // 驱动失去响应不是“元素不存在”，不能被备用定位或可选步骤吞掉。
+  if (error instanceof AppiumRequestTimeoutError || error instanceof AppiumServiceError) throw error;
 }
 
 function errorDetail(error: unknown) {
@@ -205,16 +211,17 @@ function adbSwipe(deviceId: string, step: Required<AppiumRecordedStepRecord>['sw
   });
 }
 
-function adbText(deviceId: string, args: string[]) {
-  return new Promise<string>((resolve) => {
-    execFile(getAdbCommand(), ['-s', deviceId, ...args], { maxBuffer: 4 * 1024 * 1024 }, (_error, stdout, stderr) => {
+function adbText(deviceId: string, args: string[], strict = false) {
+  return new Promise<string>((resolve, reject) => {
+    execFile(getAdbCommand(), ['-s', deviceId, ...args], { maxBuffer: 4 * 1024 * 1024, timeout: 10000, signal: replayContext.getStore()?.signal }, (error, stdout, stderr) => {
+      if (strict && error) { reject(new AppiumServiceError(`读取设备状态失败：${stderr || error.message}`)); return; }
       resolve((stdout || stderr || '').trim());
     });
   });
 }
 
 async function getCurrentActivity(deviceId: string) {
-  const output = await adbText(deviceId, ['shell', 'dumpsys', 'activity', 'activities']);
+  const output = await adbText(deviceId, ['shell', 'dumpsys', 'activity', 'activities'], true);
   const resumedLine = output
     .split(/\r?\n/)
     .find((line) => /(?:topResumedActivity|ResumedActivity|mResumedActivity)/.test(line));
@@ -231,7 +238,7 @@ async function waitForActivity(deviceId: string, step: AppiumRecordedStepRecord)
   const expectedActivity = step.value || '';
   if (!expectedActivity) throw new Error(`${step.label} 缺少目标 Activity`);
   const startedAt = Date.now();
-  const timeoutMs = step.timeoutMs || 10000;
+  const timeoutMs = step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS;
   let currentActivity = '';
   while (Date.now() - startedAt <= timeoutMs) {
     throwIfReplayStopped();
@@ -239,7 +246,7 @@ async function waitForActivity(deviceId: string, step: AppiumRecordedStepRecord)
     if (currentActivity === expectedActivity) return;
     await wait(500);
   }
-  throw new Error(`${step.label} 等待超时，当前 Activity：${currentActivity || '-'}`);
+  throw new ConditionTimeoutError(`${step.label} 等待超时，当前 Activity：${currentActivity || '-'}`);
 }
 
 async function appendSettingsDiagnostics(lines: string[], deviceId: string) {
@@ -276,30 +283,31 @@ async function appiumRequest<T>(
   if (!options?.ignoreAbort) throwIfReplayStopped();
   context?.appiumLog(`[Appium] 请求：${method} ${path}`);
   let response: Response;
+  let responseText: string;
   try {
-    response = await fetch(requestUrl, {
+    const result = await timedAppiumFetch(requestUrl, {
       ...init,
-      signal: options?.ignoreAbort
-        ? (options.timeoutMs ? AbortSignal.timeout(options.timeoutMs) : undefined)
-        : context?.signal || init?.signal,
+      signal: options?.ignoreAbort ? undefined : context?.signal || init?.signal,
       headers: {
         'Content-Type': 'application/json',
         ...(init?.headers || {}),
       },
-    });
+    }, options?.timeoutMs ?? (path === '/session' && method === 'POST' ? 120000 : 30000));
+    response = result.response;
+    responseText = result.text;
   } catch (error) {
     if (isReplayStopped(error) && !options?.ignoreAbort) {
       context?.appiumLog(`[Appium] 取消：${method} ${path}`);
       throw new ReplayStoppedError();
     }
     context?.appiumLog(`[Appium] 异常：${method} ${path}（${errorDetail(error)}）`);
+    if (error instanceof AppiumRequestTimeoutError) throw error;
     if (isTimeoutError(error)) {
-      throw new Error(`Appium 请求超时 ${requestUrl}，${errorDetail(error)}`);
+      throw new AppiumServiceError(`Appium 请求超时 ${requestUrl}，${errorDetail(error)}`);
     }
-    throw new Error(`无法连接 Appium 服务 ${requestUrl}，${errorDetail(error)}`);
+    throw new AppiumServiceError(`无法连接 Appium 服务 ${requestUrl}，${errorDetail(error)}`);
   }
 
-  const responseText = await response.text();
   context?.appiumLog(`[Appium] 响应：HTTP ${response.status} ${method} ${path}（${Date.now() - startedAt}ms）`);
   const payload = (() => {
     try {
@@ -320,7 +328,8 @@ async function appiumRequest<T>(
       payload.value?.stacktrace || payload.stacktrace ? `堆栈信息：\n${payload.value?.stacktrace || payload.stacktrace}` : '',
       responseText ? `原始响应：\n${responseText}` : '',
     ].filter(Boolean).join('\n');
-    throw new Error(`Appium ${method} ${path} 失败（HTTP ${response.status}）：\n${detail || '未返回错误详情'}`);
+    const ErrorType = ['no such element', 'stale element reference'].includes(payload.value?.error || payload.error || '') ? Error : AppiumServiceError;
+    throw new ErrorType(`Appium ${method} ${path} 失败（HTTP ${response.status}）：\n${detail || '未返回错误详情'}`);
   }
   return payload;
 }
@@ -439,7 +448,11 @@ async function findElementBySelector(
   return elementId;
 }
 
-async function findElement(sessionId: string, step: AppiumRecordedStepRecord) {
+async function findElement(sessionId: string, step: AppiumRecordedStepRecord, timeoutMs = step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS) {
+  return withElementDeadline(timeoutMs, () => findElementWithinDeadline(sessionId, step));
+}
+
+async function findElementWithinDeadline(sessionId: string, step: AppiumRecordedStepRecord) {
   if (!step.selector) throw new Error(`${step.label} 缺少 selector`);
   const attempts: string[] = [];
 
@@ -454,7 +467,9 @@ async function findElement(sessionId: string, step: AppiumRecordedStepRecord) {
     }
   }
 
-  for (const selector of step.selectorChain || []) {
+  // 唯一原生定位优先；非唯一元素仍保留父级与备用 XPath 的精确匹配。
+  const preferPrimary = step.selector.unique === true && ['id', 'accessibilityId'].includes(step.selector.strategy);
+  for (const selector of [...(preferPrimary ? [step.selector] : []), ...(step.selectorChain || [])]) {
     try {
       attempts.push(`${selector.strategy} ${selector.value || ''}`);
       return await findElementBySelector(sessionId, selector);
@@ -502,26 +517,26 @@ async function tapFallback(deviceId: string, step: AppiumRecordedStepRecord) {
 
 async function waitForElement(sessionId: string, step: AppiumRecordedStepRecord) {
   const startedAt = Date.now();
-  const timeoutMs = step.timeoutMs || 10000;
+  const timeoutMs = step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS;
   let lastError: unknown;
   while (Date.now() - startedAt <= timeoutMs) {
     try {
-      return await findElement(sessionId, step);
+      return await findElement(sessionId, step, Math.max(1, timeoutMs - (Date.now() - startedAt)));
     } catch (error) {
       throwIfReplayStopped(error);
       lastError = error;
       await wait(500);
     }
   }
-  throw lastError instanceof Error ? lastError : new Error(`${step.label} 等待超时`);
+  throw new ConditionTimeoutError(`${step.label} 等待元素超时（${timeoutMs}ms）：${errorDetail(lastError)}`);
 }
 
 async function findOptionalElement(sessionId: string, step: AppiumRecordedStepRecord) {
   const startedAt = Date.now();
-  const timeoutMs = step.timeoutMs ?? 2000;
+  const timeoutMs = step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS;
   while (Date.now() - startedAt <= timeoutMs) {
     try {
-      return await findElement(sessionId, step);
+      return await findElement(sessionId, step, Math.max(1, timeoutMs - (Date.now() - startedAt)));
     } catch (error) {
       throwIfReplayStopped(error);
       await wait(250);
@@ -532,17 +547,17 @@ async function findOptionalElement(sessionId: string, step: AppiumRecordedStepRe
 
 async function waitForElementGone(sessionId: string, step: AppiumRecordedStepRecord) {
   const startedAt = Date.now();
-  const timeoutMs = step.timeoutMs || 10000;
+  const timeoutMs = step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS;
   while (Date.now() - startedAt <= timeoutMs) {
     try {
-      await findElement(sessionId, step);
+      await findElement(sessionId, step, Math.max(1, timeoutMs - (Date.now() - startedAt)));
     } catch (error) {
       throwIfReplayStopped(error);
       return;
     }
     await wait(500);
   }
-  throw new Error(`${step.label} 等待消失超时`);
+  throw new ConditionTimeoutError(`${step.label} 等待消失超时`);
 }
 
 async function saveScreenshot(deviceId: string) {
@@ -768,6 +783,10 @@ async function runStep(
     return `ADB 已启动 ${packageName}`;
   }
 
+  if (step.type === 'stopApp') {
+    return stopAppOnDevice(deviceId, step.value || '', replayContext.getStore()?.signal);
+  }
+
   if (step.type === 'clearAppData') {
     const packageName = step.value || '';
     await clearAppDataOnDevice(deviceId, packageName);
@@ -983,7 +1002,7 @@ async function evaluateCondition(sessionId: string, deviceId: string, step: Appi
   }
   if (step.type === 'textClick') {
     const selector = textClickSelector(step);
-    const deadline = Date.now() + Math.max(0, step.timeoutMs ?? 10000);
+    const deadline = Date.now() + Math.max(0, step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS);
     // 查询空结果才是未匹配；通信错误、重复匹配和点击失败走现有异常处理。
     do {
       const payload = await appiumRequest<AppiumValueResponse<Record<string, string>[]>>(`/session/${sessionId}/elements`, {
@@ -998,7 +1017,10 @@ async function evaluateCondition(sessionId: string, deviceId: string, step: Appi
         await appiumRequest(`/session/${sessionId}/element/${id}/click`, { method: 'POST', body: '{}' });
         return true;
       }
-      if (Date.now() >= deadline) return false;
+      if (Date.now() >= deadline) {
+        if (step.timeoutMs === 0) return false;
+        throw new ConditionTimeoutError(`文字点击等待匹配超时（${step.timeoutMs ?? DEFAULT_NODE_TIMEOUT_MS}ms）`);
+      }
       await wait(Math.max(0, Math.min(500, deadline - Date.now())));
     } while (true);
   }
@@ -1014,7 +1036,7 @@ async function evaluateCondition(sessionId: string, deviceId: string, step: Appi
       return true;
     }
     if (step.type === 'assertText' || (step.type === 'assertExists' && step.value)) {
-      const elementId = await findElement(sessionId, step);
+      const elementId = await waitForElement(sessionId, step);
       const payload = await appiumRequest<AppiumValueResponse<string>>(`/session/${sessionId}/element/${elementId}/text`);
       const actualText = payload.value || '';
       const expectedText = step.value || '';
@@ -1026,7 +1048,7 @@ async function evaluateCondition(sessionId: string, deviceId: string, step: Appi
     return true;
   } catch (error) {
     throwIfReplayStopped(error);
-    return false;
+    throw error;
   }
 }
 
@@ -1102,7 +1124,7 @@ async function replayLinkedScript(
           type: 'waitActivity',
           label: step.label,
           value: linkedScript.appActivity,
-          timeoutMs: 10000,
+          timeoutMs: DEFAULT_NODE_TIMEOUT_MS,
         });
       } catch (error) {
         throwIfReplayStopped(error);
@@ -1255,6 +1277,7 @@ async function replayFlowSteps(
           replayContext.getStore()?.imageChecks.push({ ...imageResult, nodeId: step.id, nodeNumber: index + 1, nodeLabel: frameStep.label, scriptName: options.scriptName || '', settings });
           lines.push(`[节点 ${index + 1}] 图像判断：${imageResult.result === null ? '无法判定' : imageResult.result}，${imageResult.message}；${settings}；采样 ${imageResult.sampleCount} 帧，耗时 ${imageResult.durationMs}ms；指标 ${JSON.stringify(imageResult.metrics)}`);
           if (imageResult.result === null) throw new Error(imageResult.message);
+          if (imageResult.timedOut) throw new ConditionTimeoutError(imageResult.message);
         }
         const matched = imageResult ? imageResult.result! : recognition ? recognition.result : await evaluateCondition(sessionId, deviceId, step);
         if (recognition) lines.push(`[节点 ${index + 1}] AI 识别：${recognition.result}，耗时 ${recognition.durationMs}ms${recognition.reason ? `，依据：${recognition.reason}` : ''}`);
@@ -1279,6 +1302,17 @@ async function replayFlowSteps(
           await captureReplayFrame(sessionId, step, index + 1, options.scriptName || '', 'stopped', '已终止');
           throw new ReplayStoppedError();
         }
+        if (error instanceof ConditionTimeoutError && (step.timeoutBranch === 'yes' || step.timeoutBranch === 'no')) {
+          const branch = step.timeoutBranch;
+          const status = `判断超时，按配置进入${branch === 'yes' ? '左' : '右'}侧分支（${flowBranchLabel(step, branch)}）`;
+          lines.push(`[节点 ${index + 1}] ${status}；${error.message}`);
+          await captureReplayFrame(sessionId, frameStep, index + 1, options.scriptName || '', 'after', status);
+          // 循环体必须经过 enter，才能正确记轮次及受最大次数保护。
+          index = step.type === 'loop'
+            ? branch === 'yes' ? traversal.enter(step).next : traversal.exit(step)
+            : traversal.branch(step, branch === 'yes');
+          continue;
+        }
         lines.push(`[节点 ${index + 1}] 失败：${errorDetail(error)}`);
         await captureReplayFrame(sessionId, step, index + 1, options.scriptName || '', 'error', '失败');
         await appendStepDiagnostics(lines, deviceId, step);

package/server/appium-recorder/condition-timeout.ts

@@ -0,0 +1,4 @@
+// 仅业务等待到期使用此错误；设备、通信和配置异常不能按超时分支放行。
+export class ConditionTimeoutError extends Error {}
+
+export class AppiumServiceError extends Error {}

package/server/appium-recorder/image-check.ts

@@ -1,4 +1,6 @@
 import { PNG } from 'pngjs';
+import { AppiumRequestTimeoutError } from './request-timeout';
+import { AppiumServiceError } from './condition-timeout';
 import { validateImageCheck, type ImageCheckConfig, type ImageCheckResult } from '../../src/appium-recorder/image-check';
 import type { AppiumVisualChangeRegion } from '../../src/appium-recorder/types';
 
@@ -138,20 +140,22 @@ export async function checkImage(input: {
         const changed = maximum >= config.ratio;
         if (changed || (result.sampleCount >= 2 && now() - observedAt >= config.durationMs)) {
           result.result = config.expectation === 'present' ? changed : !changed;
+          result.timedOut = !changed && config.expectation === 'present' && config.durationMs > 0;
           break;
         }
       } else {
         consecutive = measurement.matched ? consecutive + 1 : 0;
         result.metrics['连续满足帧数'] = consecutive;
         if (consecutive >= config.consecutive) { result.result = true; break; }
-        if (now() - observedAt >= config.durationMs) { result.result = false; break; }
+        if (now() - observedAt >= config.durationMs) { result.result = false; result.timedOut = config.durationMs > 0; break; }
       }
       await input.wait(Math.min(config.intervalMs, Math.max(1, config.durationMs - (now() - observedAt))));
     }
     if (last) keep('判定帧', last);
-    result.message = result.result ? '条件成立' : '条件不成立';
+    result.message = result.timedOut ? '观察超时，未在规定时间内满足条件' : result.result ? '条件成立' : '条件不成立';
   } catch (error) {
     if (input.signal?.aborted) throw error;
+    if (error instanceof AppiumRequestTimeoutError || error instanceof AppiumServiceError) throw error;
     result.message = `无法判定：${error instanceof Error ? error.message : '图像检测异常'}`;
     result.result = null;
   }

package/server/appium-recorder/report.ts

@@ -605,7 +605,7 @@ function createReplayHtml(input: {
       article.append(title);
       const detail = document.createElement('dl');
       const region = check.region || {};
-      const entries = [['结果', check.result === null ? '无法判定' : String(check.result)], ['配置', check.settings],
+      const entries = [['结果', check.timedOut ? '观察超时' : check.result === null ? '无法判定' : String(check.result)], ['配置', check.settings],
         ['区域', [region.x, region.y, region.width, region.height].join(', ')],
         ['采样', check.sampleCount + ' 帧'], ['耗时', check.durationMs + 'ms'], ['说明', check.message], ...Object.entries(check.metrics)];
       entries.forEach(([key, value]) => {

package/server/appium-recorder/repository.ts

@@ -38,6 +38,7 @@ export type AppiumRecordedStepRecord = {
     | 'swipe'
     | 'screenshot'
     | 'launchApp'
+    | 'stopApp'
     | 'openGallery'
     | 'endFlow'
     | 'loop'
@@ -98,6 +99,7 @@ export type AppiumRecordedStepRecord = {
   returns?: ScriptReturn[];
   keyCode?: number;
   timeoutMs?: number;
+  timeoutBranch?: 'stop' | 'yes' | 'no';
   longPressMode?: 'element' | 'coordinates';
   breakLoopTargetId?: string;
   loop?: {

package/server/appium-recorder/request-timeout.ts

@@ -0,0 +1,25 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const deadline = new AsyncLocalStorage<number>();
+export class AppiumRequestTimeoutError extends Error {}
+
+export function withElementDeadline<T>(timeoutMs: number, action: () => Promise<T>) {
+  return deadline.run(Date.now() + Math.max(1, timeoutMs), action);
+}
+
+// 响应体也受同一个期限约束，避免收到 HTTP 头后继续无限等待。
+export async function timedAppiumFetch(url: string, init: RequestInit, timeoutMs: number) {
+  const remaining = Math.max(1, Math.min(timeoutMs, (deadline.getStore() ?? Infinity) - Date.now()));
+  const timeout = AbortSignal.timeout(Math.ceil(remaining));
+  const signal = init.signal ? AbortSignal.any([init.signal, timeout]) : timeout;
+  try {
+    const response = await fetch(url, { ...init, signal });
+    const text = await response.text();
+    return { response, text };
+  } catch (error) {
+    if (timeout.aborted && !init.signal?.aborted) {
+      throw new AppiumRequestTimeoutError(`设备自动化服务无响应：Appium 请求超过 ${Math.ceil(remaining)}ms，已停止等待（${url}）`);
+    }
+    throw error;
+  }
+}

package/server/appium-recorder/stop-app.ts

@@ -0,0 +1,18 @@
+import { execFile } from 'node:child_process';
+import { getAdbCommand } from '../android-sdk';
+
+export function stopAppOnDevice(deviceId: string, packageName: string, signal?: AbortSignal) {
+  if (!/^[A-Za-z][\w]*(?:\.[A-Za-z][\w]*)+$/.test(packageName)) {
+    throw new Error('杀死 APP 需要有效的应用包名');
+  }
+  // force-stop 只停止指定应用，不使用 pm clear，不删除应用数据。
+  return new Promise<string>((resolve, reject) => {
+    execFile(getAdbCommand(), ['-s', deviceId, 'shell', 'am', 'force-stop', '--user', 'current', packageName],
+      { timeout: 10000, maxBuffer: 1024 * 1024, signal }, (error, stdout, stderr) => {
+        const output = `${stdout || ''}\n${stderr || ''}`.trim();
+        if (error || /Error:|Exception|Permission Denial/i.test(output)) {
+          reject(new Error(`停止 APP 失败（${packageName}）：${output || error?.message}`));
+        } else resolve(`已停止 APP 进程：${packageName}（保留应用数据）`);
+      });
+  });
+}

package/server/http-api.ts

@@ -38,6 +38,7 @@ import { handleAppiumRecorderRequest } from './appium-recorder/routes';
 import { handleRemoteAgentRequest } from './remote-agents/routes';
 import { isRemoteDeviceId, listRemoteAndroidDevices, sendRemoteCommand } from './remote-agents/registry';
 import { getAdbCommand } from './android-sdk';
+import { readAndroidDeviceInfo } from './android-device-info';
 
 async function readBody<T>(req: IncomingMessage) {
   let body = '';
@@ -873,6 +874,24 @@ export function createApiMiddleware() {
       return;
     }
 
+    if (req.url?.startsWith('/api/android-device-info') && req.method === 'GET') {
+      try {
+        const deviceId = getRequestedDeviceId(req) || selectedDeviceId;
+        if (!deviceId) throw new Error('未检测到可用设备');
+        assertDeviceAllowedForRequest(req, deviceId);
+        const details = isRemoteDeviceId(deviceId)
+          ? await sendRemoteCommand(deviceId, 'deviceInfo')
+          : await readAndroidDeviceInfo(deviceId, getAdbCommand());
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.end(JSON.stringify({ deviceId, details }));
+      } catch (error) {
+        res.statusCode = 500;
+        res.setHeader('Content-Type', 'application/json; charset=utf-8');
+        res.end(JSON.stringify({ message: error instanceof Error ? error.message : '读取设备信息失败' }));
+      }
+      return;
+    }
+
     if (req.url?.startsWith('/api/android-display-info') && req.method === 'GET') {
       try {
         const deviceId = getRequestedDeviceId(req) || selectedDeviceId;

package/server/remote-agents/protocol.ts

@@ -8,6 +8,7 @@ export type RemoteAgentDevice = {
 export type RemoteCommandType =
   | 'screenshot'
   | 'displayInfo'
+  | 'deviceInfo'
   | 'tree'
   | 'tap'
   | 'swipe'

package/src/appium-recorder/AppiumPage.vue

@@ -1,6 +1,7 @@
 <script setup lang="ts">
 import { computed, h, onMounted, onUnmounted, provide, reactive, shallowRef, watch } from 'vue';
 import { flowBackgroundKey, normalizeFlowBackground } from './flow-appearance';
+import { DEFAULT_NODE_TIMEOUT_MS } from './node-timeout';
 import { ElForm, ElFormItem, ElInputNumber, ElMessage, ElMessageBox, ElOption, ElSelect } from 'element-plus';
 import { Check, CircleClose, CopyDocument, Delete, Document, Download, Edit, Plus, Refresh, Upload, VideoPlay, View, Clock } from '@element-plus/icons-vue';
 import RunHistoryDialog from './RunHistoryDialog.vue';
@@ -95,46 +96,6 @@ const workspaceRef = shallowRef<InstanceType<typeof RecorderWorkspace>>();
 const historyScript = shallowRef<{ id: string; name: string } | null>(null);
 const AUTO_TREE_REFRESH_INTERVAL_MS = 1800;
 
-const insertableRecorderActions: RecorderAction[] = [
-  'extractVariable',
-  'delay',
-  'tap',
-  'input',
-  'waitFor',
-  'tapIfExists',
-  'inputIfExists',
-  'clearIfExists',
-  'backIfExists',
-  'popupCondition',
-  'checkboxState',
-  'checkedState',
-  'radioButtonState',
-  'aiRecognition',
-  'imageCheck',
-  'textClick',
-  'runScript',
-  'keyBack',
-  'keyHome',
-  'keyRecent',
-  'keyPower',
-  'waitActivity',
-  'swipe',
-  'clearInput',
-  'coordinateTap',
-  'launchApp',
-  'openGallery',
-  'endFlow',
-  'loop',
-  'breakLoop',
-  'clearAppData',
-  'waitDisappear',
-  'longPress',
-  'pinch',
-  'noop',
-  'log',
-  'visualChangeStart',
-  'visualChangeEnd',
-];
 const readonlyFlowActionGroups: FlowActionGroup[] = [];
 const readonlyFlowSelectedIndexes: number[] = [];
 
@@ -293,7 +254,7 @@ const recordingBusy = computed(() => (
   || resolvingNavigation.value
   || Boolean(pendingNavigation.value)
 ));
-const recordingLocked = computed(() => recordingBusy.value || scriptActivityMismatch.value);
+const recordingLocked = computed(() => recordingBusy.value || replaying.value);
 const newScriptDisabled = computed(() => saving.value || replaying.value || recordingBusy.value || launchingApp.value || importingScript.value);
 const overlayBounds = computed(() => flattenNodes(tree.value).flatMap((node) => (
   node.bounds ? [{ id: node.id, ...node.bounds }] : []
@@ -509,7 +470,7 @@ function createStep(type: NodeStepType, node: AppiumNode): AppiumRecordedStep {
       ? [{ strategy: 'xpath', value: node.xpath, unique: true, matchCount: 1 }]
       : undefined,
     fallback: node.bounds ? { strategy: 'bounds', centerX: node.bounds.centerX, centerY: node.bounds.centerY } : undefined,
-    timeoutMs: type === 'waitFor' ? 10000 : undefined,
+    timeoutMs: type === 'waitFor' ? DEFAULT_NODE_TIMEOUT_MS : undefined,
     pageBefore: currentPageSnapshot(node),
     snapshot: {
       text: node.text,
@@ -613,7 +574,7 @@ function createWaitActivityStep(activity: string): AppiumRecordedStep {
     type: 'waitActivity',
     label: `等待 Activity ${activity}`,
     value: activity,
-    timeoutMs: 10000,
+    timeoutMs: DEFAULT_NODE_TIMEOUT_MS,
   };
 }
 
@@ -975,7 +936,7 @@ async function executeFlowStep(index: number) {
     } else if (scriptActivityMismatch.value) {
       ElMessage.warning(`App 已启动，当前页面仍为 ${currentActivity.value || '-'}`);
     } else {
-      ElMessage.success('已进入脚本绑定页面，编辑锁定已解除');
+      ElMessage.success('已进入脚本绑定页面');
     }
   } catch (error) {
     ElMessage.error(error instanceof Error ? error.message : 'App 操作失败');
@@ -1442,13 +1403,13 @@ async function addAction(
     if (!input) return;
     return insertStep({
       id: createStepId(), type: 'aiRecognition', label: 'AI 识别',
-      value: validateAiRecognitionPrompt(input.value), timeoutMs: 60000,
+      value: validateAiRecognitionPrompt(input.value), timeoutMs: DEFAULT_NODE_TIMEOUT_MS,
       flow: { nodeKind: 'condition' },
     }, index, branchTarget);
   }
   if (action === 'textClick') {
     const step = reactive<AppiumRecordedStep>({
-      id: createStepId(), type: 'textClick', label: '文字点击', value: '', timeoutMs: 10000,
+      id: createStepId(), type: 'textClick', label: '文字点击', value: '', timeoutMs: DEFAULT_NODE_TIMEOUT_MS,
       flow: { nodeKind: 'condition', textMatch: 'exact' },
     });
     const result = await ElMessageBox({
@@ -1580,6 +1541,10 @@ async function addAction(
       value: form.appPackage,
     }, index, branchTarget);
   }
+  if (action === 'stopApp') {
+    return insertStep({ id: createStepId(), type: 'stopApp', label: `杀死 APP ${form.appPackage}`,
+      value: form.appPackage, flow: { nodeKind: 'action' } }, index, branchTarget);
+  }
   if (action === 'clearAppData') {
     return insertStep({
       id: `step_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`,
@@ -1612,7 +1577,7 @@ async function addAction(
       ElMessage.warning(`请选择原生 ${controlName} 元素，当前选中：${node.className || '未知类型'}`);
       return;
     }
-    const step = createNodeActionStep(action, action === 'checkedState' ? '判断勾选' : `判断 ${controlName} 状态`, node, { timeoutMs: 2000 });
+    const step = createNodeActionStep(action, action === 'checkedState' ? '判断勾选' : `判断 ${controlName} 状态`, node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS });
     if ((!step.selector?.value || step.selector.strategy === 'bounds') && node.xpath) {
       step.selector = { strategy: 'xpath', value: node.xpath };
       step.contextSelector = undefined;
@@ -1628,13 +1593,13 @@ async function addAction(
     return insertStep(step, index, branchTarget);
   }
   if (action === 'popupCondition') {
-    const step = createNodeActionStep('assertExists', '判断存在', node, { timeoutMs: 2000 });
+    const step = createNodeActionStep('assertExists', '判断存在', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS });
     const inserted = insertStep({ ...step, flow: { nodeKind: 'condition' } }, index, branchTarget);
     ElMessage.success('已添加判断节点，请在节点面板配置是/否分支');
     return inserted;
   }
   if (action === 'tapIfExists') {
-    return insertStep(createNodeActionStep('tapIfExists', '存在则点击', node, { timeoutMs: 2000 }), index, branchTarget);
+    return insertStep(createNodeActionStep('tapIfExists', '存在则点击', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS }), index, branchTarget);
   }
   if (action === 'inputIfExists') {
     const input = await ElMessageBox.prompt('', '存在则输入', {
@@ -1645,16 +1610,16 @@ async function addAction(
     }).catch(() => null);
     if (!input) return;
     return insertStep(
-      createNodeActionStep('inputIfExists', '存在则输入', node, { timeoutMs: 2000, value: input.value }),
+      createNodeActionStep('inputIfExists', '存在则输入', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS, value: input.value }),
       index,
       branchTarget,
     );
   }
   if (action === 'clearIfExists') {
-    return insertStep(createNodeActionStep('clearIfExists', '存在则清空', node, { timeoutMs: 2000 }), index, branchTarget);
+    return insertStep(createNodeActionStep('clearIfExists', '存在则清空', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS }), index, branchTarget);
   }
   if (action === 'backIfExists') {
-    return insertStep(createNodeActionStep('backIfExists', '存在则返回', node, { timeoutMs: 2000 }), index, branchTarget);
+    return insertStep(createNodeActionStep('backIfExists', '存在则返回', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS }), index, branchTarget);
   }
   if (action === 'clearInput') {
     return insertStep(createNodeActionStep('clearInput', '清空输入', node), index, branchTarget);
@@ -1701,7 +1666,7 @@ async function addAction(
     return insertStep({ ...step }, index, branchTarget);
   }
   if (action === 'waitDisappear') {
-    return insertStep(createNodeActionStep('waitDisappear', '等待元素消失', node, { timeoutMs: 10000 }), index, branchTarget);
+    return insertStep(createNodeActionStep('waitDisappear', '等待元素消失', node, { timeoutMs: DEFAULT_NODE_TIMEOUT_MS }), index, branchTarget);
   }
 }
 
@@ -2282,7 +2247,7 @@ watch(
                   v-if="scriptActivityMismatch"
                   class="appium-activity-summary"
                 >
-                  <summary>当前页面与脚本不一致，部分录制操作不可用</summary>
+                  <summary>当前页面与脚本绑定的 Activity 不一致</summary>
                   <div class="appium-activity-lock-alert__details">
                     <div>
                       <strong>脚本绑定</strong>
@@ -2292,7 +2257,7 @@ watch(
                       <strong>当前 Activity</strong>
                       <code>{{ currentActivity || '正在获取' }}</code>
                     </div>
-                    <p>请在录制流程中添加或执行“启动 APP”节点；Activity 匹配后会自动解除编辑锁定。</p>
+                    <p>不影响脚本编辑；如需录制当前页面的组件操作，请确认设备页面及所选组件。</p>
                   </div>
                 </details>
               </section>
@@ -2304,9 +2269,8 @@ watch(
                   :steps="steps"
                   :clipboard-count="flowClipboardCount"
                   :disabled="recordingLocked"
-                  :remove-disabled="recordingBusy"
+                  :remove-disabled="recordingLocked"
                   :merge-disabled="recordingBusy || replaying || saving"
-                  :allowed-locked-actions="scriptActivityMismatch && !recordingBusy ? insertableRecorderActions : []"
                   :launching-step-id="executingAppStepId"
                   @remove="removeStep"
                   @copy="copyFlowNodes"
@@ -2429,6 +2393,8 @@ watch(
 
     <ImageCheckDialog
       v-if="imageCheckDraft?.imageCheck"
+      :timeout-branch="imageCheckDraft.timeoutBranch"
+      @timeout-branch="imageCheckDraft = { ...imageCheckDraft!, timeoutBranch: $event }"
       :config="imageCheckDraft.imageCheck" :device-id="selectedDeviceId"
       :has-element="Boolean(selectedNode?.bounds)" :editing="imageCheckEditing" :picking="imageCheckPicking"
       @update="updateImageCheck" @close="imageCheckDraft = null; imageCheckPicking = false"

package/src/appium-recorder/action-descriptions.ts

@@ -16,6 +16,7 @@ export const actionDescriptions: Record<InsertAction, string> = {
   swipe: '按指定起点、终点和时长滑动屏幕。',
   pinch: '执行双指放大或缩小手势，需要当前页面支持缩放。',
   launchApp: '启动指定应用，可放在流程中途或分支中执行。',
+  stopApp: '停止当前所选包名的 APP 进程，不删除应用或清除数据；可在节点配置中修改目标包名。',
   openGallery: '打开设备相册应用，不自动选择照片或视频。',
   endFlow: '立即结束当前回放流程，后续节点不再执行。',
   loop: '重复执行循环体，支持固定次数或条件退出，必须设置最大次数。',

package/src/appium-recorder/components/BranchTimeoutSettings.vue

@@ -0,0 +1,23 @@
+<script setup lang="ts">
+import type { AppiumRecordedStep } from '../types';
+import { flowBranchLabel } from '../flow-labels';
+defineProps<{ step: AppiumRecordedStep; disabled?: boolean }>();
+defineEmits<{ update: [value: NonNullable<AppiumRecordedStep['timeoutBranch']>] }>();
+</script>
+
+<template>
+  <el-form-item label="超时后处理">
+    <el-select class="branch-timeout-select" size="small" popper-class="branch-timeout-popper" :model-value="step.timeoutBranch || 'stop'" :disabled="disabled" @update:model-value="$emit('update', $event)">
+      <el-option label="未配置分支（超时终止）" value="stop" />
+      <el-option :label="`进入左侧分支（${flowBranchLabel(step, 'yes')}）`" value="yes" />
+      <el-option :label="`进入右侧分支（${flowBranchLabel(step, 'no')}）`" value="no" />
+    </el-select>
+  </el-form-item>
+</template>
+
+<style>
+.el-select.branch-timeout-select { width: 240px; max-width: 100%; flex: none; }
+.branch-timeout-popper .el-select-dropdown__list { padding: 4px 0; }
+.branch-timeout-popper .el-select-dropdown__item { height: 28px; line-height: 28px; padding: 0 12px; font-size: 12px; }
+.branch-timeout-popper .el-select-dropdown__item.is-selected { color: var(--el-color-primary); }
+</style>

package/src/appium-recorder/components/FlowStepEditor.vue

@@ -5,6 +5,8 @@ import { normalizeVisualChangeConfig } from '../visual-change';
 import { longPressMode } from '../long-press';
 import { defaultFlowKind, isBooleanCondition } from '../flow-labels';
 import TextClickSettings from './TextClickSettings.vue';
+import BranchTimeoutSettings from './BranchTimeoutSettings.vue';
+import { DEFAULT_NODE_TIMEOUT_MS } from '../node-timeout';
 import LongPressSettings from './LongPressSettings.vue';
 import StageLogSettings from './StageLogSettings.vue';
 import LoopSettings from './LoopSettings.vue';
@@ -116,8 +118,7 @@ function patchVisualRegion(key: keyof VisualChangeConfig['region'], value: unkno
 }
 
 function patchTimeout(value: unknown) {
-  const timeout = Math.max(0, toInteger(value, props.step.timeoutMs || 0));
-  patchStep({ timeoutMs: timeout || undefined });
+  patchStep({ timeoutMs: value == null || value === '' ? undefined : Math.max(0, toInteger(value, DEFAULT_NODE_TIMEOUT_MS)) });
 }
 
 const showSelector = computed(() => props.step.type !== 'loop' && props.step.selector && (
@@ -152,21 +153,10 @@ function patchSelector(patch: Partial<AppiumSelector>) {
           @update:model-value="patchStep({ note: String($event) || undefined })"
         />
       </el-form-item>
-      <div class="appium-flow-editor__grid">
-        <el-form-item label="节点类型">
-          <el-select
-            :model-value="defaultKind()"
-            :disabled="disabled || isBooleanCondition(step) || step.type === 'extractVariable' || step.type === 'log' || step.type === 'openGallery' || step.type === 'endFlow' || step.type === 'loop' || step.type === 'breakLoop'"
-            @update:model-value="patchFlow({ nodeKind: $event as FlowKind })"
-          >
-            <el-option label="操作" value="action" />
-            <el-option label="判断" value="condition" />
-            <el-option label="校验" value="assertion" />
-          </el-select>
-        </el-form-item>
-        <el-form-item v-if="!['longPress', 'log', 'openGallery', 'endFlow', 'loop', 'breakLoop'].includes(step.type)" label="超时时间 ms">
+      <div>
+        <el-form-item v-if="!['longPress', 'stopApp', 'log', 'openGallery', 'endFlow', 'loop', 'breakLoop'].includes(step.type)" label="超时时间 ms">
           <el-input-number
-            :model-value="step.timeoutMs || undefined"
+            :model-value="step.timeoutMs ?? (step.type === 'delay' ? 1000 : DEFAULT_NODE_TIMEOUT_MS)"
             :disabled="disabled"
             :min="0"
             :max="999999"
@@ -174,9 +164,10 @@ function patchSelector(patch: Partial<AppiumSelector>) {
             @update:model-value="patchTimeout($event)"
           />
         </el-form-item>
+        <BranchTimeoutSettings v-if="defaultKind() === 'condition'" :step="step" :disabled="disabled" @update="patchStep({ timeoutBranch: $event })" />
       </div>
       <LongPressSettings v-if="step.type === 'longPress'" :step="step" :disabled="disabled" @update="patchStep" />
-      <el-form-item v-if="['waitActivity', 'launchApp', 'clearAppData'].includes(step.type)" :label="step.type === 'waitActivity' ? '目标 Activity' : '目标 APP 包名'">
+      <el-form-item v-if="['waitActivity', 'launchApp', 'stopApp', 'clearAppData'].includes(step.type)" :label="step.type === 'waitActivity' ? '目标 Activity' : '目标 APP 包名'">
         <el-input :model-value="step.value || ''" :disabled="disabled" @update:model-value="patchStep({ value: String($event) })" />
       </el-form-item>
       <template v-if="step.type === 'pinch'">

package/src/appium-recorder/components/ImageCheckDialog.vue

@@ -4,9 +4,11 @@ import { ElMessage } from 'element-plus';
 import { Aim, Camera, Upload, QuestionFilled } from '@element-plus/icons-vue';
 import { IMAGE_CHECK_MODES, validateImageCheck, imageTemplateSize, imageTemplateRegionIssue, expandedImageTemplateRegion, type ImageCheckConfig } from '../image-check';
 import { captureImageCheckRegion } from '../api';
+import BranchTimeoutSettings from './BranchTimeoutSettings.vue';
+import type { AppiumRecordedStep } from '../types';
 
-const props = defineProps<{ config: ImageCheckConfig; deviceId: string; hasElement: boolean; editing: boolean; picking: boolean }>();
-const emit = defineEmits<{ update: [config: ImageCheckConfig]; close: []; confirm: []; pick: []; useElement: [] }>();
+const props = defineProps<{ config: ImageCheckConfig; deviceId: string; hasElement: boolean; editing: boolean; picking: boolean; timeoutBranch?: AppiumRecordedStep['timeoutBranch'] }>();
+const emit = defineEmits<{ update: [config: ImageCheckConfig]; timeoutBranch: [value: NonNullable<AppiumRecordedStep['timeoutBranch']>]; close: []; confirm: []; pick: []; useElement: [] }>();
 const busy = ref(false);
 const regionIssue = computed(() => imageTemplateRegionIssue(props.config));
 const expandedRegion = computed(() => expandedImageTemplateRegion(props.config));
@@ -119,10 +121,14 @@ async function upload(event: Event) {
         <el-input :model-value="config.color" maxlength="7" @update:model-value="patch({ color: $event })" />
       </el-form-item>
       <div class="image-check-grid">
-        <el-form-item v-for="field in numericFields" :key="field.key" :label="field.label">
-          <el-input-number :model-value="config[field.key]" :min="field.min" :max="field.max" :step="field.step" controls-position="right" @update:model-value="$event !== undefined && patch({ [field.key]: $event })" />
-        </el-form-item>
+        <template v-for="field in numericFields" :key="field.key">
+          <el-form-item :label="field.label">
+            <el-input-number :model-value="config[field.key]" :min="field.min" :max="field.max" :step="field.step" controls-position="right" @update:model-value="$event !== undefined && patch({ [field.key]: $event })" />
+          </el-form-item>
+          <BranchTimeoutSettings v-if="field.key === 'durationMs'" style="grid-column: 1 / -1" :step="{ id: '', label: '', type: 'imageCheck', timeoutBranch }" :disabled="busy" @update="emit('timeoutBranch', $event)" />
+        </template>
       </div>
+      <BranchTimeoutSettings v-if="config.mode === 'state'" :step="{ id: '', label: '', type: 'imageCheck', timeoutBranch }" :disabled="busy" @update="emit('timeoutBranch', $event)" />
     </el-form>
     <template #footer><el-button :disabled="busy" @click="emit('close')">取消</el-button><el-button type="primary" :disabled="busy" @click="confirm">{{ editing ? '保存' : '添加' }}</el-button></template>
   </el-dialog>

package/src/appium-recorder/components/NestedConditionBranches.vue

@@ -23,6 +23,7 @@ type InsertAction =
   | 'swipe'
   | 'pinch'
   | 'launchApp'
+  | 'stopApp'
   | 'openGallery'
   | 'endFlow'
   | 'loop'
@@ -103,6 +104,7 @@ const actionGroups: Array<{ title: string; actions: Array<{ type: InsertAction;
     title: '设备操作',
     actions: [
       { type: 'launchApp', label: '启动 App' },
+      { type: 'stopApp', label: '杀死 APP' },
       { type: 'keyBack', label: '系统返回' },
       { type: 'keyHome', label: 'Home 键' },
       { type: 'openGallery', label: '启动相册' },
@@ -153,7 +155,7 @@ function typeLabel(step: AppiumRecordedStep) {
     clearIfExists: '存在则清空', backIfExists: '存在则返回', clearInput: '清空',
     waitFor: '等待出现', waitDisappear: '等待消失', assertExists: '断言存在',
     assertText: '断言文本', key: '按键', waitActivity: '等待 Activity', delay: '延时',
-    coordinateTap: '坐标点击', swipe: '滑动', launchApp: '启动 APP', clearAppData: '清理 APP 缓存', longPress: '长按',
+    coordinateTap: '坐标点击', swipe: '滑动', launchApp: '启动 APP', stopApp: '杀死 APP', clearAppData: '清理 APP 缓存', longPress: '长按',
     pinch: '双指缩放', runScript: '连接脚本', screenshot: '截图', visualChange: '检测画面变化',
     noop: '空节点',
     endFlow: '终止流程',

package/src/appium-recorder/components/RecordedSteps.vue

@@ -80,6 +80,7 @@ const insertActionGroups: FlowActionGroup[] = [
       { type: 'pinch', label: '双指缩放' },
       { type: 'clearAppData', label: '清理 App 缓存' },
       { type: 'launchApp', label: '启动 App' },
+      { type: 'stopApp', label: '杀死 APP' },
       { type: 'openGallery', label: '启动相册' },
     ],
   },

package/src/appium-recorder/flow-graph.ts

@@ -24,6 +24,7 @@ export type InsertAction =
   | 'swipe'
   | 'pinch'
   | 'launchApp'
+  | 'stopApp'
   | 'openGallery'
   | 'endFlow'
   | 'loop'

package/src/appium-recorder/flow-labels.ts

@@ -58,6 +58,7 @@ export function flowTypeLabel(step: AppiumRecordedStep) {
     swipe: '滑动',
     screenshot: '截图',
     launchApp: '启动 APP',
+    stopApp: '杀死 APP',
     openGallery: '启动相册',
     endFlow: '终止流程',
     loop: '有界循环',
@@ -98,6 +99,7 @@ export function flowStepMeta(step: AppiumRecordedStep) {
   if (step.type === 'key') return `keyCode ${step.keyCode || ''}`;
   if (step.type === 'waitActivity') return step.value || '';
   if (step.type === 'launchApp') return step.value || '';
+  if (step.type === 'stopApp') return `${step.value || ''}（仅停止进程）`;
   if (step.type === 'clearAppData') return `${step.value || ''}（清除数据与缓存）`;
   if (step.type === 'runScript') return step.value ? `脚本 ${step.value}` : '';
   if (step.type === 'noop') return '';

package/src/appium-recorder/image-check.ts

@@ -1,4 +1,5 @@
 import type { AppiumVisualChangeRegion } from './types';
+import { DEFAULT_NODE_TIMEOUT_MS } from './node-timeout';
 
 export const IMAGE_CHECK_MODES = { template: '模板匹配', state: '图片状态判断', black: '黑屏检测', color: '区域颜色判断', change: '多帧变化检测' } as const;
 export type ImageCheckConfig = {
@@ -20,6 +21,7 @@ export type ImageCheckConfig = {
   consecutive: number;
 };
 export type ImageCheckResult = {
+  timedOut?: boolean;
   result: boolean | null;
   mode: ImageCheckConfig['mode'];
   region: AppiumVisualChangeRegion;
@@ -33,7 +35,7 @@ export type ImageCheckResult = {
 export function createImageCheckConfig(): ImageCheckConfig {
   return { mode: 'template', target: 'region', region: { x: 0, y: 0, width: 100, height: 100 },
     screenWidth: 0, screenHeight: 0, expectation: 'present', threshold: 0.9, minScoreGap: 0.1,
-    color: '#000000', tolerance: 30, ratio: 95, durationMs: 5000, intervalMs: 1000, consecutive: 1 };
+    color: '#000000', tolerance: 30, ratio: 95, durationMs: DEFAULT_NODE_TIMEOUT_MS, intervalMs: 1000, consecutive: 1 };
 }
 
 // 只读取 PNG 头部尺寸，避免为了表单校验解码整张模板。

package/src/appium-recorder/node-timeout.ts

@@ -0,0 +1 @@
+export const DEFAULT_NODE_TIMEOUT_MS = 3000;

package/src/appium-recorder/types.ts

@@ -93,6 +93,7 @@ export type AppiumRecordedStep = {
     | 'swipe'
     | 'screenshot'
     | 'launchApp'
+    | 'stopApp'
     | 'openGallery'
     | 'endFlow'
     | 'loop'
@@ -120,6 +121,7 @@ export type AppiumRecordedStep = {
   returns?: ScriptReturn[];
   keyCode?: number;
   timeoutMs?: number;
+  timeoutBranch?: 'stop' | 'yes' | 'no';
   longPressMode?: 'element' | 'coordinates';
   breakLoopTargetId?: string;
   loop?: {

package/src/components/device/DeviceInfoTooltip.vue

@@ -0,0 +1,55 @@
+<script setup lang="ts">
+import { shallowRef, watch, onBeforeUnmount } from 'vue';
+import { QuestionFilled } from '@element-plus/icons-vue';
+import { APP_BASE } from '../../api';
+import type { AndroidDeviceDetails } from '../../types';
+
+const props = defineProps<{ deviceId: string }>();
+const details = shallowRef<AndroidDeviceDetails>();
+const loading = shallowRef(false);
+const error = shallowRef('');
+let request: AbortController | undefined;
+const fields: [keyof AndroidDeviceDetails, string][] = [
+  ['name', '设备名称'], ['brand', '品牌'], ['model', '型号'], ['processor', '处理器'],
+  ['androidVersion', 'Android 版本'], ['physicalResolution', '物理分辨率'], ['resolution', '分辨率'],
+];
+watch(() => props.deviceId, () => { request?.abort(); request = undefined; details.value = undefined; error.value = ''; loading.value = false; });
+onBeforeUnmount(() => request?.abort());
+async function load() {
+  if (!props.deviceId || loading.value) return;
+  const controller = new AbortController();
+  request = controller; loading.value = true; error.value = '';
+  try {
+    const response = await fetch(`${APP_BASE}/api/android-device-info?deviceId=${encodeURIComponent(props.deviceId)}`, { signal: controller.signal });
+    const payload = await response.json();
+    if (!response.ok) throw new Error(payload.message || '读取设备信息失败');
+    if (request === controller) details.value = payload.details;
+  } catch (cause) {
+    if (request === controller && !controller.signal.aborted) error.value = cause instanceof Error ? cause.message : '读取失败';
+  } finally { if (request === controller) loading.value = false; }
+}
+</script>
+
+<template>
+  <el-tooltip placement="bottom" effect="dark" :show-after="200" @before-show="load">
+    <template #content>
+      <div class="device-info">
+        <div v-if="!deviceId">未选择设备</div>
+        <template v-else>
+          <div v-if="loading">正在读取设备信息…</div>
+          <div v-if="error" role="status">{{ error }}</div>
+          <dl><template v-for="[key, label] in fields" :key="key"><dt>{{ label }}</dt><dd>{{ details?.[key] || '未知' }}</dd></template></dl>
+        </template>
+      </div>
+    </template>
+    <el-button class="device-info-help" :icon="QuestionFilled" text aria-label="设备信息" />
+  </el-tooltip>
+</template>
+
+<style scoped>
+.device-info-help { width: 28px; height: 28px; padding: 0; font-size: 16px; }
+.device-info { max-width: min(340px, calc(100vw - 40px)); font-size: 12px; overflow-wrap: anywhere; }
+.device-info dl { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 6px 14px; margin: 4px 0; }
+.device-info dt { color: #cbd5e1; }
+.device-info dd { margin: 0; }
+</style>

package/src/components/device/DevicePreviewPanel.vue

@@ -2,6 +2,7 @@
 import { computed, onBeforeUnmount, onMounted, ref, shallowRef, watch } from 'vue';
 import { Close, Cpu, FullScreen, Refresh } from '@element-plus/icons-vue';
 import type { AndroidDevice, DeviceAction } from '../../types';
+import DeviceInfoTooltip from './DeviceInfoTooltip.vue';
 
 type DeviceOverlayBounds = {
   id: string;
@@ -293,7 +294,7 @@ function handlePointerCancel(event: PointerEvent) {
   <el-card shadow="never" class="automation-card device-preview-card" :class="{ 'device-preview-card--compact': compact, 'device-preview-card--enlarged': enlarged }">
     <template #header>
       <div class="panel-header">
-        <span>设备预览</span>
+        <div class="device-preview-title"><span>设备预览</span><DeviceInfoTooltip :device-id="selectedDeviceId" /></div>
         <div class="device-status">
           <el-tag v-if="compact" :type="available ? 'success' : 'info'">
             {{ available ? '已连接' : '未连接' }}
@@ -444,6 +445,7 @@ function handlePointerCancel(event: PointerEvent) {
 </template>
 
 <style scoped>
+.device-preview-title { display: flex; align-items: center; gap: 8px; }
 .device-preview-card--compact { display: flex; flex-direction: column; min-height: 0; }
 .device-preview-card--compact :deep(> .el-card__body) { display: flex; flex-direction: column; flex: 1; min-height: 0; overflow: hidden; gap: 8px; }
 .device-preview-card--compact .panel-header { flex-wrap: wrap; gap: 8px; font-size: 14px; }

package/src/types.ts

@@ -147,3 +147,12 @@ export type DeviceAction = {
   icon: string;
   keyCode: number;
 };
+export type AndroidDeviceDetails = {
+  name: string;
+  brand: string;
+  model: string;
+  processor: string;
+  androidVersion: string;
+  physicalResolution: string;
+  resolution: string;
+};