feat(scanner): validate elevated live automation

src/features/scan/components/DiagnosticsView.tsx

@@ -1,8 +1,7 @@
-import { useRef, useState, type ChangeEvent } from "react";
+import { useState } from "react";
 import { AlertTriangle, Download, Play, Upload, Wrench } from "lucide-react";
 import type { CaptureResult } from "../../../types/global";
 import type { ScanViewControllerResult } from "../types";
-import { goodDatabaseToStoredArtifacts, type GoodImportDatabase } from "../../../lib/goodInterop";
 import { FieldConfidenceList } from "./ScanResultCards";
 import { useScanDiagnosticsModalModel } from "./modals/hooks/useScanDiagnosticsModalModel";
 import { useScanDetailsModalModel } from "./modals/hooks/useScanDetailsModalModel";
@@ -59,7 +58,6 @@ export function DiagnosticsView({ controller, latestCapture, captureStatus, onDe
   });
 
   const [interopStatus, setInteropStatus] = useState("");
-  const fileInputRef = useRef<HTMLInputElement>(null);
 
   const handleExportGood = async () => {
     setInteropStatus("Exportiere GOOD...");
@@ -71,27 +69,20 @@ export function DiagnosticsView({ controller, latestCapture, captureStatus, onDe
     );
   };
 
-  const handleImportGood = async (event: ChangeEvent<HTMLInputElement>) => {
-    const file = event.target.files?.[0];
-    event.target.value = "";
-    if (!file) return;
-    try {
-      const database = JSON.parse(await file.text()) as GoodImportDatabase;
-      const records = goodDatabaseToStoredArtifacts(database);
-      if (records.length === 0) {
-        setInteropStatus("Keine gueltigen Artifacts in der Datei gefunden.");
-        return;
-      }
-      setInteropStatus(`Importiere ${records.length} Artifacts...`);
-      const result = await controller.importGoodArtifacts(records);
-      setInteropStatus(
-        result.ok
-          ? `Importiert: ${result.added} neu, ${result.updated} aktualisiert.`
-          : "Import fehlgeschlagen (App im Electron-Fenster oeffnen).",
-      );
-    } catch {
-      setInteropStatus("Datei ist kein gueltiges GOOD/JSON.");
+  const handleImportGood = async () => {
+    setInteropStatus("Waehle GOOD-Datei...");
+    const result = await controller.importGoodFromFile();
+    if (result.canceled) {
+      setInteropStatus("GOOD-Import abgebrochen.");
+      return;
     }
+    setInteropStatus(
+      result.ok
+        ? `Importiert: ${result.added} neu, ${result.updated} aktualisiert (${result.count} gelesen).`
+        : result.error === "No valid GOOD artifacts found."
+          ? "Keine gueltigen Artifacts in der Datei gefunden."
+          : "Import fehlgeschlagen (Datei ist kein gueltiges GOOD/JSON oder Bridge fehlt).",
+    );
   };
 
   return (
@@ -182,11 +173,10 @@ export function DiagnosticsView({ controller, latestCapture, captureStatus, onDe
               <Download size={15} />
               GOOD exportieren
             </button>
-            <button className="ghost-button" onClick={() => fileInputRef.current?.click()} disabled={!controller.canGoodInterop}>
+            <button className="ghost-button" onClick={handleImportGood} disabled={!controller.canGoodInterop}>
               <Upload size={15} />
               GOOD importieren
             </button>
-            <input ref={fileInputRef} type="file" accept="application/json,.json" hidden onChange={handleImportGood} />
           </div>
         </div>
         <p className="scanner-subcopy">

src/features/scan/hooks/scanViewReviewHelpers.ts

@@ -244,7 +244,7 @@ export async function persistParsedArtifact(
     return false;
   }
   try {
-    const result = await artifactRepo.saveMany([toStoredArtifact(parsed, source, needsReview)]);
+    const result = await artifactRepo.saveMany([toStoredArtifact(parsed, source, needsReview, capture?.locked)]);
     if (result?.ok) {
       setStoredTotal(result.total);
       void onStoredArtifactsChanged?.();
@@ -297,6 +297,7 @@ export async function saveReviewSample(
       })),
       inventoryGrid: capture.inventoryGrid,
       inventoryCount: capture.inventoryCount,
+      locked: capture.locked,
       ocr: capture.ocr,
     },
     parsed,

src/features/scan/hooks/scanViewScanActions.ts

@@ -45,6 +45,10 @@ export interface ScanActionContext {
   focusDashboard: () => Promise<void>;
 }
 
+export interface VisibleGridScanOptions {
+  scanLimit?: number;
+}
+
 function buildScanSignature(parsed: ParsedArtifactCandidate) {
   return `${parsed.name}-${parsed.slot}-${parsed.mainStat}-${parsed.mainValue}-${parsed.level ?? 0}`;
 }
@@ -146,7 +150,7 @@ export async function runAutoReviewScan(context: ScanActionContext): Promise<voi
   appendAutomationLog(`manual scan finished: ${stats.parsed} parsed, ${stats.stored} stored, ${stats.review} review`);
 }
 
-export async function runVisibleGridScan(context: ScanActionContext): Promise<void> {
+export async function runVisibleGridScan(context: ScanActionContext, options: VisibleGridScanOptions = {}): Promise<void> {
   const {
     autoScanRunning,
     bridgeReady,
@@ -167,11 +171,12 @@ export async function runVisibleGridScan(context: ScanActionContext): Promise<vo
     persistParsedArtifact,
     saveReviewSample,
     shouldFlagArtifactForReview,
-    scanLimit,
+    scanLimit: configuredScanLimit,
     skipRows,
     detectedInventoryCount,
     focusDashboard,
   } = context;
+  const scanLimit = typeof options.scanLimit === "number" ? clampScanLimit(options.scanLimit) : configuredScanLimit;
 
   if (autoScanRunning || !bridgeReady || !selectedSourceId || !automationRepo?.focusGenshinForScanStart || !automationRepo?.focusGenshin || !automationRepo?.clickScreen || !automationRepo?.scrollScreen) return;
 

src/features/scan/hooks/useScanCommandListener.ts

@@ -1,5 +1,7 @@
 import { useEffect } from "react";
 import type { AutomationRepositoryPort } from "../../../infrastructure/repositories/rendererBridgeRepositoryTypes";
+import type { ScannerCommand } from "../../../types/global";
+import type { VisibleGridScanOptions } from "./scanViewScanActions";
 
 interface ScanCommandListenerInput {
   automationRepo?: AutomationRepositoryPort;
@@ -7,7 +9,7 @@ interface ScanCommandListenerInput {
   isScanning: boolean;
   selectedSourceId: string;
   requestScanStop: (reason: string) => void;
-  runVisibleGridScan: () => Promise<void>;
+  runVisibleGridScan: (options?: VisibleGridScanOptions) => Promise<void>;
 }
 
 export function useScanCommandListener({
@@ -20,15 +22,16 @@ export function useScanCommandListener({
 }: ScanCommandListenerInput) {
   useEffect(() => {
     if (!automationRepo?.onCommand) return;
-    return automationRepo.onCommand((command: "start-auto" | "stop") => {
+    return automationRepo.onCommand((command: ScannerCommand) => {
       if (command === "stop") {
         requestScanStop("Hotkey/Dev-Stop gedrueckt.");
         return;
       }
-      if (command === "start-auto" && !autoScanRunning && !isScanning && selectedSourceId) {
-        void runVisibleGridScan();
+      const commandType = typeof command === "string" ? command : command.type;
+      if (commandType === "start-auto" && !autoScanRunning && !isScanning && selectedSourceId) {
+        const options = typeof command === "string" ? undefined : { scanLimit: command.scanLimit };
+        void runVisibleGridScan(options);
       }
     });
   }, [automationRepo, autoScanRunning, isScanning, selectedSourceId, requestScanStop, runVisibleGridScan]);
 }
-

src/features/scan/hooks/useScanViewActions.ts

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo } from "react";
 import type { Dispatch, MutableRefObject, SetStateAction } from "react";
-import { runAutoReviewScan as runAutoReviewScanAction, runVisibleGridScan as runVisibleGridScanAction } from "./scanViewScanActions";
+import { runAutoReviewScan as runAutoReviewScanAction, runVisibleGridScan as runVisibleGridScanAction, type VisibleGridScanOptions } from "./scanViewScanActions";
 import {
   initializeLearningState,
   loadReviewQueue as loadReviewQueueFromRepo,
@@ -77,7 +77,7 @@ export interface ScanViewActionResult {
   loadReviewQueue: () => Promise<void>;
   openReviewQueue: () => Promise<void>;
   runAutoReviewScan: () => Promise<void>;
-  runVisibleGridScan: () => Promise<void>;
+  runVisibleGridScan: (options?: VisibleGridScanOptions) => Promise<void>;
 }
 
 export function useScanViewActions(input: ScanViewActionInput): ScanViewActionResult {
@@ -262,11 +262,11 @@ export function useScanViewActions(input: ScanViewActionInput): ScanViewActionRe
     await runAutoReviewScanAction(scanActionContext);
   }, [autoScanRunning, canCaptureSource, selectedSourceId, scanActionContext]);
 
-  const runVisibleGridScan = useCallback(async () => {
+  const runVisibleGridScan = useCallback(async (options: VisibleGridScanOptions = {}) => {
     if (autoScanRunning || !bridgeReady || !selectedSourceId || !automationRepo?.clickScreen || !automationRepo?.scrollScreen) {
       return;
     }
-    await runVisibleGridScanAction(scanActionContext);
+    await runVisibleGridScanAction(scanActionContext, options);
   }, [
     autoScanRunning,
     bridgeReady,

src/features/scan/hooks/useScanViewController.ts

@@ -17,7 +17,7 @@ import { emptyAutoScanStats, resolveScanTargetCount, type AutoScanStats, type Sc
 import type { ScanViewProps, ScanViewControllerResult } from "../types";
 import type { CaptureResult, ClickResult, ReviewSampleRecord } from "../../../types/global";
 import type { StoredArtifactRecord } from "../../../types/storage";
-import { storedArtifactsToGood } from "../../../lib/goodInterop";
+import { goodDatabaseToStoredArtifacts, type GoodImportDatabase, storedArtifactsToGood } from "../../../lib/goodInterop";
 import { createRendererRepositories } from "../../../infrastructure/repositories/rendererBridgeRepositories";
 
 export function useScanViewController({
@@ -174,6 +174,23 @@ export function useScanViewController({
     return { ok: Boolean(result.ok), added: result.added ?? 0, updated: result.updated ?? 0 };
   }, [artifactRepo, onStoredArtifactsChanged]);
 
+  const importGoodFromFile = useCallback(async () => {
+    if (!exportRepo?.importGoodFile || !artifactRepo?.saveMany) {
+      return { ok: false, added: 0, updated: 0, count: 0, error: "GOOD import is unavailable." };
+    }
+    const fileResult = await exportRepo.importGoodFile();
+    if (fileResult.canceled) return { ok: false, added: 0, updated: 0, count: 0, canceled: true };
+    if (!fileResult.ok) {
+      return { ok: false, added: 0, updated: 0, count: 0, path: fileResult.path, error: fileResult.error };
+    }
+    const records = goodDatabaseToStoredArtifacts(fileResult.database as GoodImportDatabase);
+    if (records.length === 0) {
+      return { ok: false, added: 0, updated: 0, count: 0, path: fileResult.path, error: "No valid GOOD artifacts found." };
+    }
+    const saved = await importGoodArtifacts(records);
+    return { ...saved, count: records.length, path: fileResult.path };
+  }, [artifactRepo, exportRepo, importGoodArtifacts]);
+
   useScanViewStateSync({
     artifactRepo,
     latestCapture,
@@ -253,6 +270,7 @@ export function useScanViewController({
     runVisibleGridScan,
     canGoodInterop,
     exportGoodFromStore,
+    importGoodFromFile,
     importGoodArtifacts,
   };
 }

src/features/scan/types.ts

@@ -82,5 +82,6 @@ export interface ScanViewControllerResult {
   runVisibleGridScan: () => Promise<void>;
   canGoodInterop: boolean;
   exportGoodFromStore: () => Promise<{ ok: boolean; path?: string; count: number }>;
+  importGoodFromFile: () => Promise<{ ok: boolean; added: number; updated: number; count: number; canceled?: boolean; path?: string; error?: string }>;
   importGoodArtifacts: (records: StoredArtifactRecord[]) => Promise<{ ok: boolean; added: number; updated: number }>;
 }