chore(frontend): introduce prettier + eslint and prune unused code

- Add Prettier 3 with prettier-plugin-organize-imports (sorts/removes unused imports)
- Add ESLint 10 flat config with typescript-eslint + eslint-plugin-vue + eslint-config-prettier
- Add root scripts: format, format:check, lint, lint:fix
- Reformat 257 files across admin-web, ops-web, desktop-client, packages
- Remove unused locals/exports flagged by --noUnusedLocals/--noUnusedParameters
- Fix duplicate localTabLabel key, surrogate-pair regex u-flag, NBSP literal in regex
- Skip server/ (Go) and apps/browser-extension/ (deprecated per ADR)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/desktop-client/src/main/renderer-devtools-proxy.ts

@@ -1,135 +1,142 @@
-import { app, ipcMain } from "electron/main";
-import type { IpcMainEvent, WebContents } from "electron/main";
+import type { IpcMainEvent, WebContents } from 'electron/main'
+import { app, ipcMain } from 'electron/main'
 
 interface RendererProxyRequest {
-  url: string;
-  method: string;
-  headers?: Record<string, string>;
-  body?: string;
+  url: string
+  method: string
+  headers?: Record<string, string>
+  body?: string
 }
 
 interface RendererProxyResponse {
-  ok: boolean;
-  status: number;
-  statusText: string;
-  headers: Record<string, string>;
-  bodyText: string;
-  error?: string;
+  ok: boolean
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  bodyText: string
+  error?: string
 }
 
-let rendererWebContents: WebContents | null = null;
-let requestSequence = 0;
-const pendingRequests = new Map<string, {
-  resolve: (value: RendererProxyResponse) => void;
-  reject: (error: Error) => void;
-  timeout: ReturnType<typeof setTimeout>;
-}>();
-const rendererProxyRequestChannel = "desktop:renderer-devtools-proxy:request";
-const rendererProxyResponseChannel = "desktop:renderer-devtools-proxy:response";
-const rendererDevtoolsProxyEnabled = !app.isPackaged;
+let rendererWebContents: WebContents | null = null
+let requestSequence = 0
+const pendingRequests = new Map<
+  string,
+  {
+    resolve: (value: RendererProxyResponse) => void
+    reject: (error: Error) => void
+    timeout: ReturnType<typeof setTimeout>
+  }
+>()
+const rendererProxyRequestChannel = 'desktop:renderer-devtools-proxy:request'
+const rendererProxyResponseChannel = 'desktop:renderer-devtools-proxy:response'
+const rendererDevtoolsProxyEnabled = !app.isPackaged
 
 if (rendererDevtoolsProxyEnabled) {
-  ipcMain.on(rendererProxyResponseChannel, handleRendererProxyResponse);
+  ipcMain.on(rendererProxyResponseChannel, handleRendererProxyResponse)
 }
 
 export function registerRendererDevtoolsProxyTarget(webContents: WebContents): void {
   if (!rendererDevtoolsProxyEnabled) {
-    return;
+    return
   }
 
-  rendererWebContents = webContents;
-  webContents.once("destroyed", () => {
+  rendererWebContents = webContents
+  webContents.once('destroyed', () => {
     if (rendererWebContents === webContents) {
-      rendererWebContents = null;
+      rendererWebContents = null
     }
-  });
+  })
 }
 
 export function canUseRendererDevtoolsProxy(): boolean {
-  return rendererDevtoolsProxyEnabled
-    && Boolean(rendererWebContents && !rendererWebContents.isDestroyed());
+  return (
+    rendererDevtoolsProxyEnabled &&
+    Boolean(rendererWebContents && !rendererWebContents.isDestroyed())
+  )
 }
 
 export async function rendererDevtoolsFetch(
   request: RendererProxyRequest,
 ): Promise<RendererProxyResponse> {
   if (!rendererDevtoolsProxyEnabled) {
-    throw new Error("renderer_devtools_proxy_unavailable");
+    throw new Error('renderer_devtools_proxy_unavailable')
   }
 
   if (!rendererWebContents || rendererWebContents.isDestroyed()) {
-    throw new Error("renderer_devtools_proxy_unavailable");
+    throw new Error('renderer_devtools_proxy_unavailable')
   }
 
-  const requestId = `renderer-proxy-${Date.now()}-${requestSequence += 1}`;
+  const requestId = `renderer-proxy-${Date.now()}-${(requestSequence += 1)}`
 
   return await new Promise<RendererProxyResponse>((resolve, reject) => {
     const timeout = setTimeout(() => {
-      pendingRequests.delete(requestId);
-      reject(new Error("renderer_devtools_proxy_timeout"));
-    }, 30_000);
+      pendingRequests.delete(requestId)
+      reject(new Error('renderer_devtools_proxy_timeout'))
+    }, 30_000)
 
     pendingRequests.set(requestId, {
       resolve,
       reject,
       timeout,
-    });
+    })
 
     try {
       rendererWebContents?.send(rendererProxyRequestChannel, {
         requestId,
         request,
-      });
+      })
     } catch (error) {
-      clearTimeout(timeout);
-      pendingRequests.delete(requestId);
-      reject(error instanceof Error ? error : new Error("renderer_devtools_proxy_send_failed"));
+      clearTimeout(timeout)
+      pendingRequests.delete(requestId)
+      reject(error instanceof Error ? error : new Error('renderer_devtools_proxy_send_failed'))
     }
-  });
+  })
 }
 
 function handleRendererProxyResponse(
   event: IpcMainEvent,
   payload: {
-    requestId?: unknown;
-    response?: unknown;
+    requestId?: unknown
+    response?: unknown
   },
 ): void {
   if (rendererWebContents && event.sender !== rendererWebContents) {
-    return;
+    return
   }
 
-  const requestId = typeof payload?.requestId === "string" ? payload.requestId : "";
+  const requestId = typeof payload?.requestId === 'string' ? payload.requestId : ''
   if (!requestId) {
-    return;
+    return
   }
 
-  const pending = pendingRequests.get(requestId);
+  const pending = pendingRequests.get(requestId)
   if (!pending) {
-    return;
+    return
   }
 
-  clearTimeout(pending.timeout);
-  pendingRequests.delete(requestId);
+  clearTimeout(pending.timeout)
+  pendingRequests.delete(requestId)
 
-  const response = payload.response;
+  const response = payload.response
   if (!isRendererProxyResponse(response)) {
-    pending.reject(new Error("renderer_devtools_proxy_invalid_response"));
-    return;
+    pending.reject(new Error('renderer_devtools_proxy_invalid_response'))
+    return
   }
 
-  pending.resolve(response);
+  pending.resolve(response)
 }
 
 function isRendererProxyResponse(value: unknown): value is RendererProxyResponse {
-  if (!value || typeof value !== "object") {
-    return false;
+  if (!value || typeof value !== 'object') {
+    return false
   }
 
-  const candidate = value as Partial<RendererProxyResponse>;
-  return typeof candidate.ok === "boolean"
-    && typeof candidate.status === "number"
-    && typeof candidate.statusText === "string"
-    && typeof candidate.bodyText === "string"
-    && Boolean(candidate.headers && typeof candidate.headers === "object");
+  const candidate = value as Partial<RendererProxyResponse>
+  return (
+    typeof candidate.ok === 'boolean' &&
+    typeof candidate.status === 'number' &&
+    typeof candidate.statusText === 'string' &&
+    typeof candidate.bodyText === 'string' &&
+    Boolean(candidate.headers && typeof candidate.headers === 'object')
+  )
 }