Feat better text detection

manifest.config.ts

@@ -36,6 +36,7 @@ export default defineManifest({
     },
   ],
   permissions: ['sidePanel', 'tabs', 'storage', 'contextMenus'],
+  optional_host_permissions: ['https://*/*', 'http://*/*'],
   side_panel: {
     default_path: 'src/sidepanel/index.html',
   },

src/background/main.ts

@@ -1,7 +1,12 @@
 import { STORAGE_KEYS } from '../shared/constants.ts';
-import { initializeStorage, onStorageChange } from '../shared/utils/storage.ts';
+import { initializeStorage, onStorageChange, getStorageValue } from '../shared/utils/storage.ts';
 import { logger } from '../services/logger.ts';
-import { handleProofreadRequest, resetProofreaderServices } from './proofreader-proxy.ts';
+import {
+  handleProofreadRequest,
+  resetProofreaderServices,
+  updateModelSourceCache,
+} from './proofreader-proxy.ts';
+import { getApiProvider } from '../services/api-proofreader.ts';
 
 import type {
   IssuesUpdatePayload,
@@ -13,6 +18,8 @@ import type {
   ProofreadRequestMessage,
   ProofreaderBusyStateRequestMessage,
   ProofreaderBusyStateResponseMessage,
+  ApiTestConnectionResponse,
+  ApiFetchModelsResponse,
 } from '../shared/messages/issues.ts';
 import { serializeError } from '../shared/utils/serialize.ts';
 import { handleSidepanelToggleEvent } from './sidepanel-button-handler.ts';
@@ -285,14 +292,25 @@ function registerBadgeListeners(): void {
     void updateActionBadge();
   });
 
+  onStorageChange(STORAGE_KEYS.MODEL_SOURCE, (newValue) => {
+    updateModelSourceCache(newValue);
+    resetProofreaderServices();
+  });
+
+  onStorageChange(STORAGE_KEYS.API_CONFIG, () => {
+    resetProofreaderServices();
+  });
+
   badgeListenersRegistered = true;
 }
 
 registerBadgeListeners();
 void updateActionBadge();
+void getStorageValue(STORAGE_KEYS.MODEL_SOURCE).then(updateModelSourceCache);
 
 chrome.runtime.onInstalled.addListener(async (details) => {
   await initializeStorage();
+  updateModelSourceCache(await getStorageValue(STORAGE_KEYS.MODEL_SOURCE));
   logger.info({ reason: details?.reason }, 'Proofly extension installed and storage initialized');
 
   chrome.contextMenus.create({
@@ -316,6 +334,7 @@ chrome.runtime.onInstalled.addListener(async (details) => {
 
 chrome.runtime.onStartup.addListener(async () => {
   await initializeStorage();
+  updateModelSourceCache(await getStorageValue(STORAGE_KEYS.MODEL_SOURCE));
   logger.info('Proofly extension started');
 
   registerBadgeListeners();
@@ -390,6 +409,45 @@ chrome.runtime.onMessage.addListener((message: ProoflyMessage, sender, sendRespo
     return handleSidepanelToggleEvent(sendResponse, sender, message);
   }
 
+  if (message.type === 'proofly:api-test-connection') {
+    getStorageValue(STORAGE_KEYS.API_CONFIG)
+      .then((apiConfig) => {
+        const provider = getApiProvider(apiConfig.type);
+        return provider.testConnection(apiConfig);
+      })
+      .then((result) => {
+        sendResponse({
+          ok: result.ok,
+          message: result.message,
+        } satisfies ApiTestConnectionResponse);
+      })
+      .catch((error) => {
+        sendResponse({
+          ok: false,
+          message: error instanceof Error ? error.message : 'Unknown error',
+        } satisfies ApiTestConnectionResponse);
+      });
+    return true;
+  }
+
+  if (message.type === 'proofly:api-fetch-models') {
+    getStorageValue(STORAGE_KEYS.API_CONFIG)
+      .then((apiConfig) => {
+        const provider = getApiProvider(apiConfig.type);
+        return provider.fetchModels(apiConfig);
+      })
+      .then((models) => {
+        sendResponse({ ok: true, models } satisfies ApiFetchModelsResponse);
+      })
+      .catch((error) => {
+        sendResponse({
+          ok: false,
+          message: error instanceof Error ? error.message : 'Failed to fetch models',
+        } satisfies ApiFetchModelsResponse);
+      });
+    return true;
+  }
+
   return false;
 });
 

src/background/proofreader-proxy.ts

@@ -4,18 +4,29 @@ import {
   createProofreaderAdapter,
   createProofreadingService,
 } from '../services/proofreader.ts';
+import { getApiProvider } from '../services/api-proofreader.ts';
 import type {
   ProofreadRequestMessage,
   ProofreadResponse,
   ProofreadServiceErrorCode,
 } from '../shared/messages/issues.ts';
+import { getStorageValues } from '../shared/utils/storage.ts';
+import { STORAGE_KEYS } from '../shared/constants.ts';
 import { serializeError } from '../shared/utils/serialize.ts';
+import type { ModelSource } from '../shared/types.ts';
 
 const DEFAULT_FALLBACK_LANGUAGE = 'en';
 
 const proofreaderServices = new Map<string, ReturnType<typeof createProofreadingService>>();
+let apiProofreaderService: ReturnType<typeof createProofreadingService> | null = null;
 let activeOperations = 0;
 
+let cachedModelSource: ModelSource = 'local';
+
+export function updateModelSourceCache(source: ModelSource): void {
+  cachedModelSource = source;
+}
+
 const getLanguageCacheKey = (language: string): string =>
   language.trim().toLowerCase() || DEFAULT_FALLBACK_LANGUAGE;
 
@@ -40,6 +51,22 @@ const isUnsupportedLanguageError = (error: unknown): boolean => {
   return message.includes('language options') || message.includes('unsupported language');
 };
 
+async function getOrCreateApiProofreaderService(): Promise<
+  ReturnType<typeof createProofreadingService>
+> {
+  if (apiProofreaderService) {
+    return apiProofreaderService;
+  }
+
+  const { apiConfig } = await getStorageValues([STORAGE_KEYS.API_CONFIG]);
+  logger.info({ model: apiConfig.selectedModel }, 'Initializing API proofreader service');
+
+  const provider = getApiProvider(apiConfig.type);
+  const proofreader = provider.createProofreader(apiConfig);
+  apiProofreaderService = createProofreadingService(proofreader);
+  return apiProofreaderService;
+}
+
 async function getOrCreateProofreaderServiceForLanguage(
   language: string,
   fallbackLanguage: string
@@ -75,10 +102,16 @@ export async function handleProofreadRequest(
 
   activeOperations += 1;
   try {
-    const service = await getOrCreateProofreaderServiceForLanguage(
-      requestedLanguage,
-      normalizedFallback
-    );
+    let service: ReturnType<typeof createProofreadingService>;
+    if (cachedModelSource === 'api') {
+      service = await getOrCreateApiProofreaderService();
+    } else {
+      service = await getOrCreateProofreaderServiceForLanguage(
+        requestedLanguage,
+        normalizedFallback
+      );
+    }
+
     const result = await service.proofread(text);
     logger.info(
       {
@@ -132,6 +165,8 @@ export function resetProofreaderServices(): void {
   }
   proofreaderServices.forEach((service) => service.destroy());
   proofreaderServices.clear();
+  apiProofreaderService?.destroy();
+  apiProofreaderService = null;
 }
 
 export function isProofreaderProxyBusy(): boolean {