android-midscene-automation 0.1.43 → 0.2.2

package/src/composables/use-device-preview.ts

@@ -0,0 +1,279 @@
+import { ref, shallowRef, reactive, watch, onMounted, onScopeDispose, type Ref } from 'vue';
+import * as api from '../api';
+import type { AndroidDevice, MenuKey } from '../types';
+
+export function useDevicePreview(activeMenu: Ref<MenuKey>) {
+  const connectionError = shallowRef('');
+  const reconnecting = shallowRef(false);
+  const playgroundAvailable = ref(false);
+  const playgroundPreviewError = ref('');
+  const playgroundDeviceId = ref('');
+  const playgroundFrameUrl = ref('');
+  const playgroundFrameSignature = ref('');
+  const restartingPlaygroundPreview = shallowRef(false);
+  const devicePreviewUrl = ref('');
+  const devicePreviewMode = ref<'stream' | 'screenshot' | ''>('');
+  const backendOffline = shallowRef(false);
+  const androidDevices = ref<AndroidDevice[]>([]);
+  const deviceInterfaceSize = reactive({ width: 0, height: 0 });
+  const deviceDebug = reactive({
+    rawX: 0,
+    rawY: 0,
+    mappedX: 0,
+    mappedY: 0,
+    action: '',
+    status: 'idle',
+    message: '',
+  });
+  let playgroundPollTimer: number | null = null;
+  let devicePreviewTimer: number | null = null;
+
+  const isBackendFetchError = (error: unknown) => {
+    const message = error instanceof Error ? error.message : String(error || '');
+    return error instanceof TypeError || /Failed to fetch|NetworkError|Load failed/i.test(message);
+  };
+
+  const stopPlaygroundPollTimer = () => {
+    if (!playgroundPollTimer) return;
+    window.clearInterval(playgroundPollTimer);
+    playgroundPollTimer = null;
+  };
+
+  const loadAndroidDevices = async () => {
+    try {
+      const payload = await api.getAndroidDevices();
+      backendOffline.value = false;
+      connectionError.value = "";
+      androidDevices.value = payload.devices || [];
+      playgroundDeviceId.value = payload.currentDeviceId || '';
+      playgroundAvailable.value = androidDevices.value.some((item) => item.status === 'device');
+    } catch (error) {
+      if (isBackendFetchError(error)) {
+        markBackendOffline();
+        return;
+      }
+      connectionError.value = error instanceof Error ? error.message : '读取设备列表失败';
+    }
+  };
+
+  const loadDeviceInterface = async () => {
+    try {
+      const payload = await api.getAndroidDisplayInfo(playgroundDeviceId.value);
+      deviceInterfaceSize.width = Number(payload.width) || 0;
+      deviceInterfaceSize.height = Number(payload.height) || 0;
+    } catch {
+      deviceInterfaceSize.width = 0;
+      deviceInterfaceSize.height = 0;
+    }
+  };
+
+  const loadAdbPreview = () => {
+    if (backendOffline.value) return;
+    if (!playgroundDeviceId.value) {
+      playgroundFrameUrl.value = '';
+      devicePreviewUrl.value = '';
+      devicePreviewMode.value = '';
+      return;
+    }
+
+    playgroundFrameUrl.value = '';
+    devicePreviewUrl.value = `${api.APP_BASE}/api/android-preview?deviceId=${encodeURIComponent(playgroundDeviceId.value)}&t=${Date.now()}`;
+    devicePreviewMode.value = 'screenshot';
+  };
+
+  const refreshAdbPreviewAfterInput = () => {
+    if (devicePreviewMode.value === 'screenshot' && devicePreviewUrl.value) {
+      window.setTimeout(loadAdbPreview, 120);
+    }
+  };
+
+  const refreshDevicePreview = async () => {
+    if (devicePreviewMode.value === 'stream' && playgroundDeviceId.value) {
+      if (restartingPlaygroundPreview.value) return;
+      restartingPlaygroundPreview.value = true;
+      playgroundFrameUrl.value = '';
+      playgroundFrameSignature.value = '';
+      try {
+        await api.restartPlaygroundPreview({ deviceId: playgroundDeviceId.value });
+        restartingPlaygroundPreview.value = false;
+        await loadPlaygroundStatus();
+      } catch (error) {
+        playgroundPreviewError.value = error instanceof Error ? error.message : '重启实时预览失败';
+      } finally {
+        restartingPlaygroundPreview.value = false;
+      }
+      return;
+    }
+    loadAdbPreview();
+  };
+
+  const startDevicePreviewTimer = () => {
+    if (backendOffline.value) return;
+    if (devicePreviewTimer) return;
+    loadAdbPreview();
+    devicePreviewTimer = window.setInterval(loadAdbPreview, 1000);
+  };
+
+  const stopDevicePreviewTimer = () => {
+    if (!devicePreviewTimer) return;
+    window.clearInterval(devicePreviewTimer);
+    devicePreviewTimer = null;
+  };
+
+  const markBackendOffline = () => {
+    if (backendOffline.value) return;
+    backendOffline.value = true;
+    playgroundAvailable.value = false;
+    playgroundFrameUrl.value = '';
+    playgroundFrameSignature.value = '';
+    devicePreviewUrl.value = '';
+    devicePreviewMode.value = '';
+    playgroundPreviewError.value = '本地服务已断开，正在尝试重连。恢复连接后可继续编辑。';
+    connectionError.value = playgroundPreviewError.value;
+    stopDevicePreviewTimer();
+  };
+
+  const loadPlaygroundStatus = async () => {
+    if (backendOffline.value || restartingPlaygroundPreview.value) return;
+    if (!playgroundDeviceId.value) {
+      stopDevicePreviewTimer();
+      playgroundAvailable.value = false;
+      playgroundPreviewError.value = '';
+      playgroundFrameUrl.value = '';
+      playgroundFrameSignature.value = '';
+      devicePreviewUrl.value = '';
+      devicePreviewMode.value = '';
+      return;
+    }
+
+    try {
+      await loadDeviceInterface();
+      if (restartingPlaygroundPreview.value) return;
+      const payload = await api.getPlaygroundStatus();
+      if (restartingPlaygroundPreview.value) return;
+
+      const matchedDevice = !payload.deviceId || payload.deviceId === playgroundDeviceId.value;
+      const hasRealtimeStream = payload.previewKind === 'scrcpy' && payload.sessionConnected === true;
+      const hasPlayground = Boolean(payload.available) && matchedDevice && hasRealtimeStream;
+      playgroundAvailable.value = androidDevices.value.some((item) => item.status === 'device');
+      playgroundPreviewError.value =
+        matchedDevice && !hasRealtimeStream
+          ? payload.previewError || payload.setupState || ''
+          : `未找到设备 ${playgroundDeviceId.value} 对应的 Playground 实例`;
+
+      const nextSignature = `${payload.url || ''}::${playgroundDeviceId.value}`;
+      if (hasPlayground) {
+        stopDevicePreviewTimer();
+        if (nextSignature !== playgroundFrameSignature.value || !playgroundFrameUrl.value) {
+          playgroundFrameSignature.value = nextSignature;
+          playgroundFrameUrl.value = `${api.APP_BASE}/__android_playground__/?ts=${Date.now()}`;
+        }
+        devicePreviewUrl.value = '';
+        devicePreviewMode.value = 'stream';
+        playgroundPreviewError.value = '';
+      }
+
+      if (!hasPlayground) {
+        playgroundFrameUrl.value = '';
+        playgroundFrameSignature.value = '';
+        loadAdbPreview();
+        if (activeMenu.value === 'appium' || activeMenu.value === 'automation') startDevicePreviewTimer();
+      }
+    } catch (error) {
+      if (isBackendFetchError(error)) {
+        markBackendOffline();
+        return;
+      }
+      playgroundAvailable.value = false;
+      playgroundFrameUrl.value = '';
+      playgroundFrameSignature.value = '';
+      loadAdbPreview();
+      if (activeMenu.value === 'appium' || activeMenu.value === 'automation') startDevicePreviewTimer();
+      playgroundPreviewError.value = error instanceof Error ? error.message : '设备预览不可用';
+    }
+  };
+
+  const tapDevice = async (x: number, y: number) => {
+    deviceDebug.action = 'tap';
+    deviceDebug.status = 'pending';
+    try {
+      await api.tapAndroid({
+        deviceId: playgroundDeviceId.value,
+        x,
+        y,
+      });
+      deviceDebug.status = 'ok';
+      deviceDebug.message = 'tap sent';
+      refreshAdbPreviewAfterInput();
+    } catch (error) {
+      deviceDebug.status = 'error';
+      deviceDebug.message = error instanceof Error ? error.message : '点击失败';
+      throw error;
+    }
+  };
+
+  const swipeDevice = async (startX: number, startY: number, endX: number, endY: number, duration = 120) => {
+    deviceDebug.action = 'swipe';
+    deviceDebug.status = 'pending';
+    try {
+      await api.swipeAndroid({
+        deviceId: playgroundDeviceId.value,
+        startX,
+        startY,
+        endX,
+        endY,
+        duration,
+      });
+      deviceDebug.status = 'ok';
+      deviceDebug.message = 'swipe sent';
+      refreshAdbPreviewAfterInput();
+    } catch (error) {
+      deviceDebug.status = 'error';
+      deviceDebug.message = error instanceof Error ? error.message : '滑动失败';
+      throw error;
+    }
+  };
+
+  const switchAndroidDevice = async (deviceId: string) => {
+    try {
+      const payload = await api.setAndroidDevice({ deviceId });
+      playgroundDeviceId.value = payload.currentDeviceId || deviceId;
+      await loadPlaygroundStatus();
+    } catch (error) {
+      playgroundPreviewError.value = error instanceof Error ? error.message : '切换设备失败';
+    }
+  };
+
+  const triggerDeviceKey = async (keyCode: number) => {
+    if (!playgroundDeviceId.value) {
+      return;
+    }
+    try {
+      await api.sendAndroidKeyevent({
+        deviceId: playgroundDeviceId.value,
+        keyCode,
+      });
+      refreshAdbPreviewAfterInput();
+    } catch (error) {
+      playgroundPreviewError.value = error instanceof Error ? error.message : '操作失败';
+    }
+  };
+
+
+  const reconnect = async () => {
+    if (reconnecting.value) return;
+    reconnecting.value = true;
+    try { await loadAndroidDevices(); await loadPlaygroundStatus(); }
+    finally { reconnecting.value = false; }
+  };
+  watch(activeMenu, () => {
+    stopDevicePreviewTimer();
+    if (activeMenu.value === 'appium' || activeMenu.value === 'automation') void loadPlaygroundStatus();
+  });
+  onMounted(() => {
+    void reconnect();
+    playgroundPollTimer = window.setInterval(() => { void reconnect(); }, 5000);
+  });
+  onScopeDispose(() => { stopPlaygroundPollTimer(); stopDevicePreviewTimer(); });
+  return { backendOffline, connectionError, reconnecting, reconnect, playgroundAvailable, playgroundPreviewError, playgroundDeviceId, playgroundFrameUrl, devicePreviewUrl, androidDevices, deviceInterfaceSize, refreshDevicePreview, tapDevice, swipeDevice, switchAndroidDevice, triggerDeviceKey };
+}

package/src/composables/use-initial-resource.ts

@@ -0,0 +1,17 @@
+import { shallowRef } from 'vue';
+
+// Retry only a failed resource, so reconnecting never replaces an edited form.
+export function useInitialResource(name: string, fetch: () => Promise<unknown>) {
+  const loading = shallowRef(false);
+  const error = shallowRef('');
+  const ready = shallowRef(false);
+  async function load() {
+    if (loading.value || ready.value) return;
+    loading.value = true;
+    error.value = '';
+    try { await fetch(); ready.value = true; }
+    catch (reason) { error.value = reason instanceof Error ? reason.message : '请检查服务连接后重试'; }
+    finally { loading.value = false; }
+  }
+  return { name, loading, error, ready, load };
+}

package/src/composables/use-script-execution.ts

@@ -0,0 +1,277 @@
+import { computed, ref, shallowRef, onScopeDispose, type Ref } from 'vue';
+import { ElMessage, ElMessageBox } from 'element-plus';
+import * as api from '../api';
+import type { SavedScript, ExecutionStep, RunScriptStreamEvent } from '../types';
+
+export function useScriptExecution(selectedScript: Ref<SavedScript | undefined>, selectedScriptId: Ref<string>, playgroundDeviceId: Ref<string>, loadSavedScripts: (id?: string) => Promise<void>, getMidsceneModelConfigError: () => string) {
+  const isRunningScript = ref(false);
+  const isStoppingScript = ref(false);
+  const executionLog = ref('');
+  const executionProcess = ref<ExecutionStep[]>([]);
+  const lastRunStatus = ref('');
+  const runStartedAt = shallowRef<number | null>(null);
+  const runningElapsedNow = shallowRef(0);
+  let executionProgressTimer: number | null = null;
+  let scriptRunAbortController: AbortController | null = null;
+  const buildExecutionProcess = (script: SavedScript): ExecutionStep[] => {
+    const activeSteps = (script.steps || []).filter((step) => step.enabled !== false);
+    if (!activeSteps.length) {
+      return [
+        {
+          id: 'script',
+          sourceIndex: 0,
+          title: script.promptTitle || script.name,
+          method: 'script',
+          prompt: script.filePath,
+          status: 'pending',
+          detail: '等待执行脚本',
+        },
+      ];
+    }
+
+    return activeSteps
+      .map((step, index) => ({
+        id: step.id || `${script.id}-${index}`,
+        sourceIndex: index,
+        title: step.label || `步骤 ${index + 1}`,
+        method: step.type,
+        prompt: step.prompt || step.value || '',
+        status: 'pending' as const,
+        detail: '等待前置步骤完成',
+      }))
+      .filter((step) => step.title !== '统一处理弹窗');
+  };
+
+  const markExecutionProcess = (success: boolean, output: string) => {
+    if (!executionProcess.value.length) return;
+    const runningIndex = executionProcess.value.findIndex((step) => step.status === 'running');
+    const errorIndex = executionProcess.value.findIndex((step) => step.status === 'error');
+    const failedIndex = success
+      ? -1
+      : runningIndex >= 0
+        ? runningIndex
+        : errorIndex >= 0
+          ? errorIndex
+          : Math.max(0, executionProcess.value.length - 1);
+    executionProcess.value = executionProcess.value.map((step, index) => {
+      if (success || index < failedIndex) {
+        return { ...step, status: 'success', detail: '执行完成' };
+      }
+      if (index === failedIndex) {
+        return {
+          ...step,
+          status: 'error',
+          detail: output || '执行失败',
+        };
+      }
+      return step;
+    });
+  };
+
+  const formatElapsed = (startedAt: number) => `${Math.max(0, Math.floor((Date.now() - startedAt) / 1000))} 秒`;
+  const formatCompactDuration = (milliseconds: number) => {
+    const totalSeconds = Math.max(0, Math.floor(milliseconds / 1000));
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    return minutes ? `${minutes}m${seconds}s` : `${seconds}s`;
+  };
+  const runningElapsedText = computed(() => {
+    if (lastRunStatus.value !== '执行中' || !runStartedAt.value) return '';
+    return formatCompactDuration(runningElapsedNow.value - runStartedAt.value);
+  });
+
+  const updateRunningStepElapsed = () => {
+    if (runStartedAt.value) {
+      runningElapsedNow.value = Date.now();
+    }
+    executionProcess.value = executionProcess.value.map((step) => {
+      if (step.status !== 'running' || !step.startedAt) {
+        return step;
+      }
+      return {
+        ...step,
+        detail: `执行中，已耗时 ${formatElapsed(step.startedAt)}`,
+      };
+    });
+  };
+
+  const startExecutionProgressTimer = () => {
+    if (executionProgressTimer) {
+      window.clearInterval(executionProgressTimer);
+    }
+    executionProgressTimer = window.setInterval(updateRunningStepElapsed, 1000);
+  };
+
+  const stopExecutionProgressTimer = () => {
+    if (!executionProgressTimer) return;
+    window.clearInterval(executionProgressTimer);
+    executionProgressTimer = null;
+  };
+
+  const appendExecutionStepLog = (event: Extract<RunScriptStreamEvent, { type: 'step' }>) => {
+    const title = event.title || `步骤 ${event.index + 1}`;
+    if (event.status === 'start') {
+      executionLog.value += `[步骤 ${event.index + 1}] 开始：${title}\n`;
+      return;
+    }
+    if (event.status === 'success') {
+      executionLog.value += `[步骤 ${event.index + 1}] 完成：${title}\n`;
+      return;
+    }
+    executionLog.value += `[步骤 ${event.index + 1}] 失败：${title}${event.detail ? `\n${event.detail}` : ''}\n`;
+  };
+
+  const applyRunScriptEvent = (event: RunScriptStreamEvent) => {
+    if (event.type === 'output') {
+      executionLog.value += event.chunk;
+      if (!lastRunStatus.value) {
+        lastRunStatus.value = '执行中';
+      }
+      return;
+    }
+
+    if (event.type === 'error') {
+      executionLog.value += `${event.message}\n`;
+      markExecutionProcess(false, event.message);
+      lastRunStatus.value = '执行失败';
+      return;
+    }
+
+    if (event.type === 'step') {
+      appendExecutionStepLog(event);
+      executionProcess.value = executionProcess.value.map((step) => {
+        if (step.sourceIndex !== event.index) {
+          return step;
+        }
+
+        if (event.status === 'start') {
+          const startedAt = Date.now();
+          return { ...step, status: 'running', startedAt, detail: `执行中，已耗时 ${formatElapsed(startedAt)}` };
+        }
+        if (event.status === 'success') {
+          return { ...step, status: 'success', startedAt: undefined, detail: '执行完成' };
+        }
+        return {
+          ...step,
+          status: 'error',
+          startedAt: undefined,
+          detail: event.detail || '执行失败',
+        };
+      });
+      return;
+    }
+
+    if (event.type === 'done') {
+      if (event.output && !executionLog.value.trim()) {
+        executionLog.value = event.output;
+      }
+      markExecutionProcess(event.success, event.output || executionLog.value);
+      lastRunStatus.value = event.success ? '执行完成' : event.output.includes('脚本执行已停止') ? '已停止' : '执行失败';
+    }
+  };
+
+  const runSelectedScript = async () => {
+    if (isRunningScript.value) return;
+
+    if (!selectedScript.value) {
+      lastRunStatus.value = '请先选择脚本';
+      return;
+    }
+
+    const modelConfigError = getMidsceneModelConfigError();
+    if (modelConfigError) {
+      lastRunStatus.value = '模型配置不完整';
+      executionLog.value = modelConfigError;
+      ElMessage.error('Midscene 模型配置不完整');
+      return;
+    }
+
+    isRunningScript.value = true;
+    isStoppingScript.value = false;
+    runStartedAt.value = Date.now();
+    runningElapsedNow.value = runStartedAt.value;
+    executionLog.value = '';
+    lastRunStatus.value = '执行中';
+
+    try {
+      await loadSavedScripts(selectedScriptId.value);
+      const script = selectedScript.value;
+      if (!script) {
+        throw new Error('脚本不存在');
+      }
+
+      executionProcess.value = buildExecutionProcess(script);
+      if (executionProcess.value[0]) {
+        const startedAt = Date.now();
+        executionProcess.value[0].status = 'running';
+        executionProcess.value[0].startedAt = startedAt;
+        executionProcess.value[0].detail = `执行中，已耗时 ${formatElapsed(startedAt)}`;
+      }
+      startExecutionProgressTimer();
+
+      scriptRunAbortController = new AbortController();
+      await api.runScript(
+        {
+          code: script.code,
+          scriptName: script.name,
+          deviceId: playgroundDeviceId.value,
+          steps: script.steps || [],
+          signal: scriptRunAbortController.signal,
+        },
+        applyRunScriptEvent,
+      );
+
+      if (!lastRunStatus.value) {
+        lastRunStatus.value = '执行完成';
+      }
+      if (!executionLog.value.trim()) {
+        executionLog.value = '执行完成，无输出';
+      }
+    } catch (error) {
+      const isAbortError = error instanceof DOMException && error.name === 'AbortError';
+      executionLog.value = isAbortError ? '脚本执行已停止。' : error instanceof Error ? error.message : '执行失败';
+      markExecutionProcess(false, executionLog.value);
+      lastRunStatus.value = isAbortError ? '已停止' : '执行失败';
+    } finally {
+      stopExecutionProgressTimer();
+      isRunningScript.value = false;
+      isStoppingScript.value = false;
+      runStartedAt.value = null;
+      runningElapsedNow.value = 0;
+      scriptRunAbortController = null;
+    }
+  };
+
+  const stopSelectedScript = async () => {
+    if (!isRunningScript.value || isStoppingScript.value) return;
+
+    try {
+      await ElMessageBox.confirm(
+        '停止后当前脚本进程会立即终止，未完成步骤不会继续执行。确定停止吗？',
+        '确认停止执行',
+        {
+          confirmButtonText: '停止执行',
+          cancelButtonText: '继续执行',
+          type: 'warning',
+          confirmButtonClass: 'el-button--danger',
+        },
+      );
+    } catch {
+      return;
+    }
+
+    isStoppingScript.value = true;
+    lastRunStatus.value = '停止中';
+
+    try {
+      await api.stopScript();
+    } catch (error) {
+      executionLog.value += `${error instanceof Error ? error.message : '停止执行失败'}\n`;
+      scriptRunAbortController?.abort();
+    }
+  };
+
+
+  onScopeDispose(() => { stopExecutionProgressTimer(); scriptRunAbortController?.abort(); });
+  return { isRunningScript, isStoppingScript, executionLog, executionProcess, lastRunStatus, runningElapsedText, runSelectedScript, stopSelectedScript };
+}

package/src/config/credentials.ts

@@ -0,0 +1,2 @@
+// The browser receives this marker instead of a saved API key.
+export const SAVED_API_KEY = '••••••••';

package/src/config/use-appium-auto-save.ts

@@ -1,5 +1,5 @@
 import { resolveReportSummary } from '../appium-recorder/report-summary';
-import { onScopeDispose, shallowRef, watch } from 'vue';
+import { computed, onScopeDispose, shallowRef, watch } from 'vue';
 import type { ConfigForm } from '../types';
 import { isHexColor } from '../appium-recorder/flow-appearance';
 import { resolveAiDeduplication } from '../appium-recorder/ai-deduplication';
@@ -8,7 +8,10 @@ import { resolveAiDeduplication } from '../appium-recorder/ai-deduplication';
 export function useAppiumAutoSave(config: ConfigForm, save: (value: Omit<ConfigForm['appium'], 'model' | 'promptOptimizer'>) => Promise<unknown>, onError: (error: unknown) => void) {
   const saving = shallowRef(false);
   const status = shallowRef('');
-  let initialized = false, saved = '', pending: string | undefined;
+  const saved = shallowRef('');
+  const initialized = shallowRef(false);
+  const failed = shallowRef(false);
+  let pending: string | undefined;
   let timer: ReturnType<typeof setTimeout> | undefined;
   // 模型只能通过“测试并保存”提交，自动保存仅观察其余设置。
   function snapshotSettings() {
@@ -19,7 +22,8 @@ export function useAppiumAutoSave(config: ConfigForm, save: (value: Omit<ConfigF
       customPresets: reportSummary.customPresets,
     } } : {}) });
   }
-  function initialize() { saved = snapshotSettings(); initialized = true; }
+  function initialize() { saved.value = snapshotSettings(); initialized.value = true; }
+  const dirty = computed(() => initialized.value && snapshotSettings() !== saved.value);
   async function flush() {
     if (saving.value || pending === undefined) return;
     saving.value = true;
@@ -27,22 +31,27 @@ export function useAppiumAutoSave(config: ConfigForm, save: (value: Omit<ConfigF
       while (pending !== undefined) {
         const snapshot = pending;
         pending = undefined;
-        if (snapshot === saved) { status.value = '已自动保存'; continue; }
+        if (snapshot === saved.value) { status.value = '已自动保存'; continue; }
         status.value = '正在自动保存…';
         try {
           await save(JSON.parse(snapshot));
-          saved = snapshot;
+          saved.value = snapshot;
+          failed.value = false;
           if (snapshotSettings() === snapshot) status.value = '已自动保存';
         } catch (error) {
-          status.value = '自动保存失败，请重新修改后重试';
+          status.value = '自动保存失败，修改已保留';
+          failed.value = true;
           onError(error);
-          // 不无限重试失败请求；若用户期间有新修改，继续保存最新快照。
+          // 保留失败快照，等待显式重试或下次修改，避免离线时无限请求。
+          pending = pending ?? snapshot;
+          break;
         }
       }
     } finally { saving.value = false; }
   }
-  watch(snapshotSettings, snapshot => {
-    if (!initialized) return;
+  function queue(snapshot: string) {
+    if (!initialized.value) return;
+    failed.value = false;
     clearTimeout(timer);
     pending = undefined;
     const value = config.appium;
@@ -56,7 +65,9 @@ export function useAppiumAutoSave(config: ConfigForm, save: (value: Omit<ConfigF
     pending = snapshot;
     status.value = '等待自动保存…';
     timer = setTimeout(() => { void flush(); }, 350);
-  }, { flush: 'sync' });
+  }
+  watch(snapshotSettings, queue, { flush: 'sync' });
+  function retry() { queue(snapshotSettings()); clearTimeout(timer); return flush(); }
   onScopeDispose(() => { clearTimeout(timer); pending = undefined; });
-  return { initialize, saving, status };
+  return { initialize, saving, status, failed, dirty, retry };
 }