fix(runtime): avoid loading disabled integrations

src/core/services/overlay-runtime-init.test.ts

@@ -0,0 +1,100 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { initializeOverlayRuntime } from './overlay-runtime-init';
+
+test('initializeOverlayRuntime skips Anki integration when ankiConnect.enabled is false', () => {
+  let createdIntegrations = 0;
+  let startedIntegrations = 0;
+  let setIntegrationCalls = 0;
+
+  initializeOverlayRuntime({
+    backendOverride: null,
+    createMainWindow: () => {},
+    registerGlobalShortcuts: () => {},
+    updateVisibleOverlayBounds: () => {},
+    isVisibleOverlayVisible: () => false,
+    updateVisibleOverlayVisibility: () => {},
+    getOverlayWindows: () => [],
+    syncOverlayShortcuts: () => {},
+    setWindowTracker: () => {},
+    getMpvSocketPath: () => '/tmp/mpv.sock',
+    createWindowTracker: () => null,
+    getResolvedConfig: () => ({
+      ankiConnect: { enabled: false } as never,
+    }),
+    getSubtitleTimingTracker: () => ({}),
+    getMpvClient: () => ({
+      send: () => {},
+    }),
+    getRuntimeOptionsManager: () => ({
+      getEffectiveAnkiConnectConfig: (config) => config as never,
+    }),
+    createAnkiIntegration: () => {
+      createdIntegrations += 1;
+      return {
+        start: () => {
+          startedIntegrations += 1;
+        },
+      };
+    },
+    setAnkiIntegration: () => {
+      setIntegrationCalls += 1;
+    },
+    showDesktopNotification: () => {},
+    createFieldGroupingCallback: () => async () => 'auto',
+    getKnownWordCacheStatePath: () => '/tmp/known-words-cache.json',
+  });
+
+  assert.equal(createdIntegrations, 0);
+  assert.equal(startedIntegrations, 0);
+  assert.equal(setIntegrationCalls, 0);
+});
+
+test('initializeOverlayRuntime starts Anki integration when ankiConnect.enabled is true', () => {
+  let createdIntegrations = 0;
+  let startedIntegrations = 0;
+  let setIntegrationCalls = 0;
+
+  initializeOverlayRuntime({
+    backendOverride: null,
+    createMainWindow: () => {},
+    registerGlobalShortcuts: () => {},
+    updateVisibleOverlayBounds: () => {},
+    isVisibleOverlayVisible: () => false,
+    updateVisibleOverlayVisibility: () => {},
+    getOverlayWindows: () => [],
+    syncOverlayShortcuts: () => {},
+    setWindowTracker: () => {},
+    getMpvSocketPath: () => '/tmp/mpv.sock',
+    createWindowTracker: () => null,
+    getResolvedConfig: () => ({
+      ankiConnect: { enabled: true } as never,
+    }),
+    getSubtitleTimingTracker: () => ({}),
+    getMpvClient: () => ({
+      send: () => {},
+    }),
+    getRuntimeOptionsManager: () => ({
+      getEffectiveAnkiConnectConfig: (config) => config as never,
+    }),
+    createAnkiIntegration: (args) => {
+      createdIntegrations += 1;
+      assert.equal(args.config.enabled, true);
+      return {
+        start: () => {
+          startedIntegrations += 1;
+        },
+      };
+    },
+    setAnkiIntegration: () => {
+      setIntegrationCalls += 1;
+    },
+    showDesktopNotification: () => {},
+    createFieldGroupingCallback: () => async () => 'manual',
+    getKnownWordCacheStatePath: () => '/tmp/known-words-cache.json',
+  });
+
+  assert.equal(createdIntegrations, 1);
+  assert.equal(startedIntegrations, 1);
+  assert.equal(setIntegrationCalls, 1);
+});

src/core/services/overlay-runtime-init.ts

@@ -1,5 +1,4 @@
 import { BrowserWindow } from 'electron';
-import { AnkiIntegration } from '../../anki-integration';
 import { BaseWindowTracker, createWindowTracker } from '../../window-trackers';
 import {
   AnkiConnectConfig,
@@ -8,6 +7,40 @@ import {
   WindowGeometry,
 } from '../../types';
 
+type AnkiIntegrationLike = {
+  start: () => void;
+};
+
+type CreateAnkiIntegrationArgs = {
+  config: AnkiConnectConfig;
+  subtitleTimingTracker: unknown;
+  mpvClient: { send?: (payload: { command: string[] }) => void };
+  showDesktopNotification: (title: string, options: { body?: string; icon?: string }) => void;
+  createFieldGroupingCallback: () => (
+    data: KikuFieldGroupingRequestData,
+  ) => Promise<KikuFieldGroupingChoice>;
+  knownWordCacheStatePath: string;
+};
+
+function createDefaultAnkiIntegration(args: CreateAnkiIntegrationArgs): AnkiIntegrationLike {
+  const { AnkiIntegration } = require('../../anki-integration') as typeof import('../../anki-integration');
+  return new AnkiIntegration(
+    args.config,
+    args.subtitleTimingTracker as never,
+    args.mpvClient as never,
+    (text: string) => {
+      if (args.mpvClient && typeof args.mpvClient.send === 'function') {
+        args.mpvClient.send({
+          command: ['show-text', text, '3000'],
+        });
+      }
+    },
+    args.showDesktopNotification,
+    args.createFieldGroupingCallback(),
+    args.knownWordCacheStatePath,
+  );
+}
+
 export function initializeOverlayRuntime(options: {
   backendOverride: string | null;
   createMainWindow: () => void;
@@ -18,6 +51,10 @@ export function initializeOverlayRuntime(options: {
   getOverlayWindows: () => BrowserWindow[];
   syncOverlayShortcuts: () => void;
   setWindowTracker: (tracker: BaseWindowTracker | null) => void;
+  createWindowTracker?: (
+    override?: string | null,
+    targetMpvSocketPath?: string | null,
+  ) => BaseWindowTracker | null;
   getMpvSocketPath: () => string;
   getResolvedConfig: () => { ankiConnect?: AnkiConnectConfig };
   getSubtitleTimingTracker: () => unknown | null;
@@ -33,11 +70,13 @@ export function initializeOverlayRuntime(options: {
     data: KikuFieldGroupingRequestData,
   ) => Promise<KikuFieldGroupingChoice>;
   getKnownWordCacheStatePath: () => string;
+  createAnkiIntegration?: (args: CreateAnkiIntegrationArgs) => AnkiIntegrationLike;
 }): void {
   options.createMainWindow();
   options.registerGlobalShortcuts();
 
-  const windowTracker = createWindowTracker(options.backendOverride, options.getMpvSocketPath());
+  const createWindowTrackerHandler = options.createWindowTracker ?? createWindowTracker;
+  const windowTracker = createWindowTrackerHandler(options.backendOverride, options.getMpvSocketPath());
   options.setWindowTracker(windowTracker);
   if (windowTracker) {
     windowTracker.onGeometryChange = (geometry: WindowGeometry) => {
@@ -63,25 +102,24 @@ export function initializeOverlayRuntime(options: {
   const mpvClient = options.getMpvClient();
   const runtimeOptionsManager = options.getRuntimeOptionsManager();
 
-  if (config.ankiConnect && subtitleTimingTracker && mpvClient && runtimeOptionsManager) {
+  if (
+    config.ankiConnect?.enabled === true &&
+    subtitleTimingTracker &&
+    mpvClient &&
+    runtimeOptionsManager
+  ) {
     const effectiveAnkiConfig = runtimeOptionsManager.getEffectiveAnkiConnectConfig(
       config.ankiConnect,
     );
-    const integration = new AnkiIntegration(
-      effectiveAnkiConfig,
-      subtitleTimingTracker as never,
-      mpvClient as never,
-      (text: string) => {
-        if (mpvClient && typeof mpvClient.send === 'function') {
-          mpvClient.send({
-            command: ['show-text', text, '3000'],
-          });
-        }
-      },
-      options.showDesktopNotification,
-      options.createFieldGroupingCallback(),
-      options.getKnownWordCacheStatePath(),
-    );
+    const createAnkiIntegration = options.createAnkiIntegration ?? createDefaultAnkiIntegration;
+    const integration = createAnkiIntegration({
+      config: effectiveAnkiConfig,
+      subtitleTimingTracker,
+      mpvClient,
+      showDesktopNotification: options.showDesktopNotification,
+      createFieldGroupingCallback: options.createFieldGroupingCallback,
+      knownWordCacheStatePath: options.getKnownWordCacheStatePath(),
+    });
     integration.start();
     options.setAnkiIntegration(integration);
   }