feat: support pro2 reset & import

electron/main.ts

@@ -22,7 +22,7 @@ import {
   type VerifyOcrResult,
 } from './mcp/state';
 import { saveCaptureToDownloads } from './saveCapture';
-import { resolveSequenceStepsById } from './mcp/sequenceResolver';
+import { resolveSequenceStepsByIdForDevice } from './mcp/sequenceSetResolver';
 
 /**
  * Build output directory structure:
@@ -54,8 +54,18 @@ let hasCompletedArmCleanupBeforeQuit = false;
 /** Use bracket notation to avoid vite:define plugin transformation */
 const VITE_DEV_SERVER_URL = process.env['VITE_DEV_SERVER_URL'];
 
+const shouldUseSingleInstanceLock = !VITE_DEV_SERVER_URL;
+const gotSingleInstanceLock = shouldUseSingleInstanceLock
+  ? app.requestSingleInstanceLock()
+  : true;
+
+if (shouldUseSingleInstanceLock && !gotSingleInstanceLock) {
+  app.quit();
+}
+
 interface RendererSequenceExecutionRequestPayload {
   sequenceId: string;
+  deviceTestSetId?: string;
   armState: {
     isConnected: boolean;
     resourceHandle: number;
@@ -365,7 +375,8 @@ async function runMnemonicOcrFromRenderer(
 }
 
 async function runSequenceInRenderer(
-  sequenceId: string
+  sequenceId: string,
+  deviceTestSetId?: string
 ): Promise<RendererSequenceExecutionResult | null> {
   if (!mainWindow) {
     console.warn('Cannot run sequence in renderer: mainWindow is null');
@@ -375,6 +386,7 @@ async function runSequenceInRenderer(
   const armState = getArmState();
   const payload: RendererSequenceExecutionRequestPayload = {
     sequenceId,
+    deviceTestSetId,
     armState: {
       isConnected: armState.isConnected,
       resourceHandle: armState.resourceHandle,
@@ -468,7 +480,24 @@ async function startMcpServer(): Promise<void> {
  * Starts MCP Server for Claude/Cursor integration.
  * On macOS, recreates window when dock icon is clicked with no windows open.
  */
+if (shouldUseSingleInstanceLock && gotSingleInstanceLock) {
+  app.on('second-instance', () => {
+    if (!mainWindow) {
+      return;
+    }
+
+    if (mainWindow.isMinimized()) {
+      mainWindow.restore();
+    }
+    mainWindow.focus();
+  });
+}
+
 app.whenReady().then(async () => {
+  if (!gotSingleInstanceLock) {
+    return;
+  }
+
   createWindow();
 
   // Start MCP Server after window is created
@@ -495,10 +524,20 @@ app.on('window-all-closed', () => {
 
 /** Clean up MCP Server before quitting */
 app.on('before-quit', (event) => {
+  if (shouldUseSingleInstanceLock && !gotSingleInstanceLock) {
+    return;
+  }
+
   if (hasCompletedArmCleanupBeforeQuit) {
     return;
   }
 
+  const armState = getArmState();
+  if (!armState.isConnected || armState.resourceHandle <= 0) {
+    resetArmState();
+    return;
+  }
+
   event.preventDefault();
   void disconnectArmController('application quit').finally(() => {
     hasCompletedArmCleanupBeforeQuit = true;
@@ -536,8 +575,8 @@ ipcMain.handle('http-request', async (_event, url: string) => {
   return performNetRequest(url, 'renderer-http-request');
 });
 
-ipcMain.handle('resolve-sequence-steps', async (_event, sequenceId: string) => {
-  return resolveSequenceStepsById(sequenceId);
+ipcMain.handle('resolve-sequence-steps', async (_event, sequenceId: string, deviceTestSetId?: string) => {
+  return resolveSequenceStepsByIdForDevice(sequenceId, deviceTestSetId);
 });
 
 ipcMain.handle(
@@ -637,6 +676,7 @@ ipcMain.handle(
       imageDataUrl: string;
       layoutHint?: 'mnemonic' | 'verify-options' | 'verify-number' | 'generic';
       expectedWordCount?: number;
+      recVariantCount?: number;
     }
   ) => runPaddleOcrEn(payload)
 );

electron/mcp/index.ts

@@ -43,7 +43,7 @@ import {
   executeMnemonicVerify,
 } from './tools';
 import { ARM_STATUS_URI, getArmStatusResource } from './resources';
-import { getAllSequenceIds } from './sequences';
+import { DEVICE_TEST_SETS, getAllSequenceIds } from './sequenceSets';
 import { sendMcpLog } from './state';
 
 /** MCP Server configuration */
@@ -257,7 +257,11 @@ export class QAAutoHardwareMcpServer {
         inputSchema: executeSequenceSchema,
       },
       async (args) => {
-        sendMcpLog({ type: 'request', action: 'execute-sequence', detail: `Sequence: ${args.sequenceId}` });
+        sendMcpLog({
+          type: 'request',
+          action: 'execute-sequence',
+          detail: `${args.deviceTestSetId ?? 'pro'} / ${args.sequenceId}`,
+        });
         const { output, frame } = await executeExecuteSequence(args, this.httpRequest);
         sendMcpLog({
           type: output.success ? 'response' : 'error',
@@ -673,6 +677,9 @@ export class QAAutoHardwareMcpServer {
         message: ocr.message,
         ocr,
         sequenceIds: getAllSequenceIds(),
+        sequenceSets: Object.fromEntries(
+          DEVICE_TEST_SETS.map((set) => [set.id, getAllSequenceIds(set.id)])
+        ),
         activeSessions: {
           streamable: this.streamableTransports.size,
           sse: this.sseTransports.size,

electron/mcp/ocrScenes.ts

@@ -0,0 +1,6 @@
+export {
+  DEVICE_OCR_SCENES,
+  PRO2_OCR_SCENES,
+  type DeviceOcrScenes,
+  type SequenceOcrSceneConfig,
+} from '../../src/ocr/deviceScenes';

electron/mcp/pro2SequenceResolver.ts

@@ -0,0 +1,97 @@
+import fs from 'fs';
+import path from 'path';
+import {
+  generateSlip39ShareSteps,
+  generateWordSteps,
+  getPageAction,
+  getSequence,
+  pickRandomShares,
+  type AutoSequence,
+  type AutoStep,
+  type MnemonicSource,
+  type PageAction,
+} from './pro2Sequences';
+
+interface MnemonicsData {
+  bip39: Record<string, string>;
+  slip39: Record<string, string>;
+}
+
+function loadMnemonics(): MnemonicsData {
+  const candidates = [
+    path.join(process.cwd(), 'mnemonics.local.json'),
+    path.join(__dirname, '..', '..', 'mnemonics.local.json'),
+  ];
+
+  for (const filePath of candidates) {
+    if (fs.existsSync(filePath)) {
+      try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw) as MnemonicsData;
+      } catch (err) {
+        console.error(`[mnemonics] Failed to parse ${filePath}:`, err);
+      }
+    }
+  }
+
+  console.warn(
+    '[mnemonics] mnemonics.local.json not found. Import-wallet sequences will use placeholder words.\n' +
+    '  Copy mnemonics.example.json -> mnemonics.local.json and fill in your test mnemonics.'
+  );
+  return { bip39: {}, slip39: {} };
+}
+
+const MNEMONICS = loadMnemonics();
+
+function getMnemonicWords(section: 'bip39' | 'slip39', key: string): string[] {
+  const phrase = MNEMONICS[section]?.[key] ?? '';
+  return phrase ? phrase.split(' ') : [];
+}
+
+function resolveMnemonicSource(source: MnemonicSource): AutoStep[] {
+  const shares = source.keys.map((key) => getMnemonicWords(source.section, key));
+
+  switch (source.mode) {
+    case 'single':
+      return generateWordSteps(shares[0] ?? []);
+    case 'shares-all':
+      return generateSlip39ShareSteps(shares);
+    case 'shares-random':
+      return generateSlip39ShareSteps(pickRandomShares(shares, source.pickCount ?? 1));
+    default:
+      return [];
+  }
+}
+
+export function resolvePro2PageActionSteps(action: PageAction): AutoStep[] {
+  if (action.mnemonicSource) {
+    return resolveMnemonicSource(action.mnemonicSource);
+  }
+  if (action.buildSteps) {
+    return action.buildSteps();
+  }
+  return action.steps;
+}
+
+export function resolvePro2SequenceSteps(sequence: AutoSequence): AutoStep[] {
+  const steps: AutoStep[] = [];
+
+  for (const actionId of sequence.actions) {
+    const action = getPageAction(actionId);
+    if (!action) {
+      console.warn(`[pro2-sequence-resolver] Unknown page action ID: ${actionId}`);
+      continue;
+    }
+    steps.push(...resolvePro2PageActionSteps(action));
+  }
+
+  return steps;
+}
+
+export function resolvePro2SequenceStepsById(sequenceId: string): AutoStep[] {
+  const sequence = getSequence(sequenceId);
+  if (!sequence) {
+    throw new Error(`Unknown Pro2 sequence ID: ${sequenceId}`);
+  }
+  return resolvePro2SequenceSteps(sequence);
+}