added proxy health check, bug fix, ux improvements, added proxy lists, bump version 1.1.0

Author: nbox

package-lock.json

@@ -1,19 +1,21 @@
 {
   "name": "api-key-health-checker",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Desktop app to validate API keys for OpenAI, Gemini, YouTube, and custom endpoints with batch checks, rate limits, and reports.",
   "license": "BSD-3-Clause",
   "author": "nbox (https://github.com/nbox)",
   "main": "dist/main/main.js",
   "scripts": {
-    "dev": "concurrently -k \"vite\" \"tsc -p tsconfig.main.json -w\" \"wait-on dist/main/main.js && electron .\"",
+    "dev": "concurrently -k \"vite\" \"tsc -p tsconfig.main.json -w\" \"wait-on http://localhost:5173 dist/main/main.js && electron .\"",
     "build": "tsc -p tsconfig.main.json && vite build",
     "preview": "vite preview",
     "pack": "npm run build && electron-builder --dir",
     "dist": "node -e \"const fs=require('fs'); for (const p of ['dist','release']) { if (fs.existsSync(p)) fs.rmSync(p,{recursive:true,force:true}); }\" && npm run build && electron-builder"
   },
   "dependencies": {
+    "http-proxy-agent": "^5.0.0",
     "iconv-lite": "^0.6.3",
+    "https-proxy-agent": "^5.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0"
   },
@@ -24,12 +26,12 @@
     "@vitejs/plugin-react": "^4.2.1",
     "autoprefixer": "^10.4.17",
     "concurrently": "^8.2.2",
-    "electron": "^30.0.1",
-    "electron-builder": "^24.13.3",
+    "electron": "^40.0.0",
+    "electron-builder": "^26.6.0",
     "postcss": "^8.4.35",
     "tailwindcss": "^3.4.1",
     "typescript": "^5.4.2",
-    "vite": "^5.1.4",
+    "vite": "^6.4.1",
     "wait-on": "^7.2.0"
   },
   "build": {

package.json

@@ -129,6 +129,7 @@ export class ProcessManager {
     const run = new ProcessRun({
       id: processId,
       name: payload.name,
+      serviceId: payload.serviceId,
       keys: payload.keys,
       method: payload.settings.method,
       settings: payload.settings,

src/main/engine/processManager.ts

@@ -5,9 +5,11 @@ import type {
   ProcessProgressEvent,
   ProcessSettings,
   ProcessStatus,
-  CustomServiceConfig
+  CustomServiceConfig,
+  ServiceId
 } from "../../shared/types";
 import { maskKey, sanitizeErrorMessage } from "../../shared/mask";
+import { decodeProxyKey } from "../../shared/proxy";
 import type { ServiceAdapter } from "../services/types";
 import { RateLimiter } from "./rateLimiter";
 import { randomBetween, sleep } from "./utils";
@@ -21,6 +23,7 @@ interface ProcessEvents {
 export interface ProcessRunOptions {
   id: string;
   name: string;
+  serviceId: ServiceId;
   keys: string[];
   method: CheckMethod;
   settings: ProcessSettings;
@@ -40,6 +43,7 @@ export class ProcessRun {
   private customConfig?: CustomServiceConfig;
   private rateLimiter: RateLimiter;
   private events: ProcessEvents;
+  private isProxyService: boolean;
   private status: ProcessStatus = "Running";
   private queueIndex = 0;
   private activeCount = 0;
@@ -52,6 +56,7 @@ export class ProcessRun {
   constructor(options: ProcessRunOptions) {
     this.id = options.id;
     this.name = options.name;
+    this.isProxyService = options.serviceId === "proxy";
     this.keys = options.keys;
     this.method = options.method;
     this.settings = options.settings;
@@ -61,6 +66,20 @@ export class ProcessRun {
     this.events = options.events;
   }
 
+  private buildProxyMeta(
+    proxyType: CheckResult["proxyType"] | undefined,
+    overrides?: { checkMode?: CheckResult["checkMode"]; targetUrl?: CheckResult["targetUrl"] }
+  ) {
+    if (!this.isProxyService) {
+      return { proxyType };
+    }
+    return {
+      proxyType,
+      checkMode: overrides?.checkMode ?? this.settings.proxy?.checkMode,
+      targetUrl: overrides?.targetUrl ?? this.settings.proxy?.targetUrl
+    };
+  }
+
   start() {
     this.status = "Running";
     this.emitProgress();
@@ -151,7 +170,9 @@ export class ProcessRun {
     this.abortControllers.set(keyIndex, controller);
     this.activeCount += 1;
 
-    const maskedKey = maskKey(key);
+    const proxyInfo = decodeProxyKey(key);
+    const displayKey = proxyInfo?.proxy ?? key;
+    const maskedKey = this.isProxyService ? displayKey : maskKey(displayKey);
     let result: CheckResult;
 
     try {
@@ -162,14 +183,15 @@ export class ProcessRun {
         await sleep(delayMs);
       }
 
-      result = await this.runWithRetries(key, controller.signal);
+      result = await this.runWithRetries(key, controller.signal, proxyInfo ?? undefined);
     } catch (error) {
       const message = error instanceof Error ? error.message : "Unexpected error";
       result = {
         status: "UNKNOWN_ERROR",
         latencyMs: 0,
         errorMessage: sanitizeErrorMessage(message),
-        checkedAt: new Date().toISOString()
+        checkedAt: new Date().toISOString(),
+        ...this.buildProxyMeta(proxyInfo?.proxyType)
       };
     } finally {
       this.activeCount -= 1;
@@ -180,7 +202,7 @@ export class ProcessRun {
     this.events.onLog({
       processId: this.id,
       keyIndex,
-      keyFull: key,
+      keyFull: displayKey,
       keyMasked: maskedKey,
       method: this.method,
       result
@@ -190,13 +212,18 @@ export class ProcessRun {
     this.schedule();
   }
 
-  private async runWithRetries(key: string, signal: AbortSignal): Promise<CheckResult> {
+  private async runWithRetries(
+    key: string,
+    signal: AbortSignal,
+    proxyInfo?: { proxyType: CheckResult["proxyType"] }
+  ): Promise<CheckResult> {
     let attempt = 0;
     let lastResult: CheckResult = {
       status: "UNKNOWN_ERROR",
       latencyMs: 0,
       checkedAt: new Date().toISOString(),
-      errorMessage: "No response"
+      errorMessage: "No response",
+      ...this.buildProxyMeta(proxyInfo?.proxyType)
     };
 
     while (attempt <= this.settings.retries) {
@@ -206,7 +233,8 @@ export class ProcessRun {
           latencyMs: 0,
           checkedAt: new Date().toISOString(),
           errorCode: "cancelled",
-          errorMessage: "Cancelled by user"
+          errorMessage: "Cancelled by user",
+          ...this.buildProxyMeta(proxyInfo?.proxyType)
         };
       }
 
@@ -217,7 +245,8 @@ export class ProcessRun {
         timeoutMs: this.settings.timeoutMs,
         signal,
         customConfig: this.customConfig,
-        openAiOrgId: this.settings.openAiOrgId
+        openAiOrgId: this.settings.openAiOrgId,
+        proxySettings: this.settings.proxy
       });
 
       if (this.stopped || signal.aborted) {
@@ -226,7 +255,8 @@ export class ProcessRun {
           latencyMs: 0,
           checkedAt: new Date().toISOString(),
           errorCode: "cancelled",
-          errorMessage: "Cancelled by user"
+          errorMessage: "Cancelled by user",
+          ...this.buildProxyMeta(proxyInfo?.proxyType)
         };
       }
 
@@ -236,7 +266,11 @@ export class ProcessRun {
         latencyMs: adapterResult.latencyMs,
         errorCode: adapterResult.errorCode,
         errorMessage: adapterResult.errorMessage,
-        checkedAt: new Date().toISOString()
+        checkedAt: new Date().toISOString(),
+        ...this.buildProxyMeta(adapterResult.proxyType ?? proxyInfo?.proxyType, {
+          checkMode: adapterResult.checkMode,
+          targetUrl: adapterResult.targetUrl
+        })
       };
 
       if (!adapterResult.retryable || attempt === this.settings.retries) {

src/main/engine/processRun.ts

@@ -9,6 +9,7 @@ import type { ExportFormat, ReportPayload } from "../shared/types";
 
 let mainWindow: BrowserWindow | null = null;
 let processManager: ProcessManager | null = null;
+const proxyAggregatorControllers = new Map<string, AbortController>();
 
 function createWindow() {
   mainWindow = new BrowserWindow({
@@ -52,6 +53,44 @@ function requireManager() {
   return processManager;
 }
 
+async function fetchTextWithTimeout(
+  url: string,
+  timeoutMs: number,
+  signal?: AbortSignal
+) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  const onAbort = () => controller.abort();
+  if (signal) {
+    if (signal.aborted) {
+      controller.abort();
+    } else {
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }
+  try {
+    const response = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": "API Key Health Checker"
+      }
+    });
+    if (!response.ok) {
+      return { error: `HTTP ${response.status}` };
+    }
+    const text = await response.text();
+    return { text };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to fetch";
+    return { error: sanitizeErrorMessage(message) };
+  } finally {
+    clearTimeout(timeoutId);
+    if (signal) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  }
+}
+
 function registerIpcHandlers() {
   ipcMain.handle("get-app-version", () => app.getVersion());
 
@@ -125,6 +164,57 @@ function registerIpcHandlers() {
   );
 
   ipcMain.handle("list-history", () => requireManager().listHistory());
+
+  ipcMain.handle(
+    "fetch-proxy-aggregators",
+    async (
+      _event,
+      payload: { urls: string[]; timeoutMs?: number; requestId?: string }
+    ) => {
+      const timeoutMs = Math.max(1000, payload.timeoutMs ?? 10000);
+      const requestId = payload.requestId ?? "";
+      const controller = new AbortController();
+      if (requestId) {
+        proxyAggregatorControllers.set(requestId, controller);
+      }
+      const results = await Promise.all(
+        (payload.urls || []).map(async (url) => {
+          if (controller.signal.aborted) {
+            return { url, error: "Cancelled" };
+          }
+          try {
+            new URL(url);
+          } catch {
+            return { url, error: "Invalid URL" };
+          }
+          const { text, error } = await fetchTextWithTimeout(
+            url,
+            timeoutMs,
+            controller.signal
+          );
+          if (controller.signal.aborted) {
+            return { url, error: "Cancelled" };
+          }
+          if (error) {
+            return { url, error };
+          }
+          return { url, content: text ?? "" };
+        })
+      );
+
+      if (requestId) {
+        proxyAggregatorControllers.delete(requestId);
+      }
+      return { results, cancelled: controller.signal.aborted };
+    }
+  );
+
+  ipcMain.handle("cancel-proxy-aggregators", (_event, payload: { requestId: string }) => {
+    const controller = proxyAggregatorControllers.get(payload.requestId);
+    if (controller) {
+      controller.abort();
+    }
+  });
 }
 
 app.whenReady().then(() => {

src/main/main.ts

@@ -4,6 +4,13 @@ import type { ExportFormat, ReportPayload } from "../shared/types";
 contextBridge.exposeInMainWorld("api", {
   getAppVersion: () => ipcRenderer.invoke("get-app-version"),
   openKeyFile: (payload: { encoding: string }) => ipcRenderer.invoke("open-key-file", payload),
+  fetchProxyAggregators: (payload: {
+    urls: string[];
+    timeoutMs?: number;
+    requestId?: string;
+  }) => ipcRenderer.invoke("fetch-proxy-aggregators", payload),
+  cancelProxyAggregators: (payload: { requestId: string }) =>
+    ipcRenderer.invoke("cancel-proxy-aggregators", payload),
   startCheck: (payload: unknown) => ipcRenderer.invoke("start-check", payload),
   pauseProcess: (processId: string) => ipcRenderer.invoke("pause-check", processId),
   resumeProcess: (processId: string) => ipcRenderer.invoke("resume-check", processId),

src/main/preload.ts

@@ -20,7 +20,10 @@ function buildCsv(payload: ReportPayload, includeFull: boolean) {
     "latency_ms",
     "error_code",
     "error_message",
-    "checked_at"
+    "checked_at",
+    "proxy_type",
+    "check_mode",
+    "target_url"
   ].filter(Boolean) as string[];
 
   const lines = [headers.join(",")];
@@ -36,7 +39,10 @@ function buildCsv(payload: ReportPayload, includeFull: boolean) {
       String(item.latencyMs ?? 0),
       item.errorCode ?? "",
       sanitizeErrorMessage(item.errorMessage ?? ""),
-      item.checkedAt
+      item.checkedAt,
+      item.proxyType ?? "",
+      item.checkMode ?? "",
+      item.targetUrl ?? ""
     );
     lines.push(row.map(csvEscape).join(","));
   }
@@ -53,7 +59,10 @@ function buildJson(payload: ReportPayload, includeFull: boolean) {
       latency_ms: item.latencyMs,
       error_code: item.errorCode ?? null,
       error_message: sanitizeErrorMessage(item.errorMessage ?? ""),
-      checked_at: item.checkedAt
+      checked_at: item.checkedAt,
+      proxy_type: item.proxyType ?? null,
+      check_mode: item.checkMode ?? null,
+      target_url: item.targetUrl ?? null
     };
 
     if (includeFull) {

src/main/report.ts

@@ -3,8 +3,15 @@ import { openAiAdapter } from "./openai";
 import { geminiAdapter } from "./gemini";
 import { youtubeAdapter } from "./youtube";
 import { customAdapter } from "./custom";
+import { proxyAdapter } from "./proxy";
 
-const adapters: ServiceAdapter[] = [openAiAdapter, geminiAdapter, youtubeAdapter, customAdapter];
+const adapters: ServiceAdapter[] = [
+  openAiAdapter,
+  geminiAdapter,
+  youtubeAdapter,
+  proxyAdapter,
+  customAdapter
+];
 
 export function getServiceAdapter(id: ServiceAdapter["id"]) {
   return adapters.find((adapter) => adapter.id === id);