style: fix formatting with Prettier

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

apps/server/src/routes/setup/get-claude-status.ts

@@ -2,36 +2,36 @@
  * Business logic for getting Claude CLI status
  */
 
-import { exec } from "child_process";
-import { promisify } from "util";
-import os from "os";
-import path from "path";
-import fs from "fs/promises";
-import { getApiKey } from "./common.js";
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { getApiKey } from './common.js';
 
 const execAsync = promisify(exec);
 
 export async function getClaudeStatus() {
   let installed = false;
-  let version = "";
-  let cliPath = "";
-  let method = "none";
+  let version = '';
+  let cliPath = '';
+  let method = 'none';
 
-  const isWindows = process.platform === "win32";
+  const isWindows = process.platform === 'win32';
 
   // Try to find Claude CLI using platform-specific command
   try {
     // Use 'where' on Windows, 'which' on Unix-like systems
-    const findCommand = isWindows ? "where claude" : "which claude";
+    const findCommand = isWindows ? 'where claude' : 'which claude';
     const { stdout } = await execAsync(findCommand);
     // 'where' on Windows can return multiple paths - take the first one
     cliPath = stdout.trim().split(/\r?\n/)[0];
     installed = true;
-    method = "path";
+    method = 'path';
 
     // Get version
     try {
-      const { stdout: versionOut } = await execAsync("claude --version");
+      const { stdout: versionOut } = await execAsync('claude --version');
       version = versionOut.trim();
     } catch {
       // Version command might not be available
@@ -40,22 +40,22 @@ export async function getClaudeStatus() {
     // Not in PATH, try common locations based on platform
     const commonPaths = isWindows
       ? (() => {
-          const appData = process.env.APPDATA || path.join(os.homedir(), "AppData", "Roaming");
+          const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
           return [
             // Windows-specific paths
-            path.join(os.homedir(), ".local", "bin", "claude.exe"),
-            path.join(appData, "npm", "claude.cmd"),
-            path.join(appData, "npm", "claude"),
-            path.join(appData, ".npm-global", "bin", "claude.cmd"),
-            path.join(appData, ".npm-global", "bin", "claude"),
+            path.join(os.homedir(), '.local', 'bin', 'claude.exe'),
+            path.join(appData, 'npm', 'claude.cmd'),
+            path.join(appData, 'npm', 'claude'),
+            path.join(appData, '.npm-global', 'bin', 'claude.cmd'),
+            path.join(appData, '.npm-global', 'bin', 'claude'),
           ];
         })()
       : [
           // Unix (Linux/macOS) paths
-          path.join(os.homedir(), ".local", "bin", "claude"),
-          path.join(os.homedir(), ".claude", "local", "claude"),
-          "/usr/local/bin/claude",
-          path.join(os.homedir(), ".npm-global", "bin", "claude"),
+          path.join(os.homedir(), '.local', 'bin', 'claude'),
+          path.join(os.homedir(), '.claude', 'local', 'claude'),
+          '/usr/local/bin/claude',
+          path.join(os.homedir(), '.npm-global', 'bin', 'claude'),
         ];
 
     for (const p of commonPaths) {
@@ -63,7 +63,7 @@ export async function getClaudeStatus() {
         await fs.access(p);
         cliPath = p;
         installed = true;
-        method = "local";
+        method = 'local';
 
         // Get version from this path
         try {
@@ -84,11 +84,11 @@ export async function getClaudeStatus() {
   //       apiKeys.anthropic stores direct API keys for pay-per-use
   let auth = {
     authenticated: false,
-    method: "none" as string,
+    method: 'none' as string,
     hasCredentialsFile: false,
     hasToken: false,
-    hasStoredOAuthToken: !!getApiKey("anthropic_oauth_token"),
-    hasStoredApiKey: !!getApiKey("anthropic"),
+    hasStoredOAuthToken: !!getApiKey('anthropic_oauth_token'),
+    hasStoredApiKey: !!getApiKey('anthropic'),
     hasEnvApiKey: !!process.env.ANTHROPIC_API_KEY,
     // Additional fields for detailed status
     oauthTokenValid: false,
@@ -97,13 +97,13 @@ export async function getClaudeStatus() {
     hasRecentActivity: false,
   };
 
-  const claudeDir = path.join(os.homedir(), ".claude");
+  const claudeDir = path.join(os.homedir(), '.claude');
 
   // Check for recent Claude CLI activity - indicates working authentication
   // The stats-cache.json file is only populated when the CLI is working properly
-  const statsCachePath = path.join(claudeDir, "stats-cache.json");
+  const statsCachePath = path.join(claudeDir, 'stats-cache.json');
   try {
-    const statsContent = await fs.readFile(statsCachePath, "utf-8");
+    const statsContent = await fs.readFile(statsCachePath, 'utf-8');
     const stats = JSON.parse(statsContent);
 
     // Check if there's any activity (which means the CLI is authenticated and working)
@@ -111,26 +111,26 @@ export async function getClaudeStatus() {
       auth.hasRecentActivity = true;
       auth.hasCliAuth = true;
       auth.authenticated = true;
-      auth.method = "cli_authenticated";
+      auth.method = 'cli_authenticated';
     }
   } catch {
     // Stats file doesn't exist or is invalid
   }
 
   // Check for settings.json - indicates CLI has been set up
-  const settingsPath = path.join(claudeDir, "settings.json");
+  const settingsPath = path.join(claudeDir, 'settings.json');
   try {
     await fs.access(settingsPath);
     // If settings exist but no activity, CLI might be set up but not authenticated
     if (!auth.hasCliAuth) {
       // Try to check for other indicators of auth
-      const sessionsDir = path.join(claudeDir, "projects");
+      const sessionsDir = path.join(claudeDir, 'projects');
       try {
         const sessions = await fs.readdir(sessionsDir);
         if (sessions.length > 0) {
           auth.hasCliAuth = true;
           auth.authenticated = true;
-          auth.method = "cli_authenticated";
+          auth.method = 'cli_authenticated';
         }
       } catch {
         // Sessions directory doesn't exist
@@ -143,13 +143,13 @@ export async function getClaudeStatus() {
   // Check for credentials file (OAuth tokens from claude login)
   // Note: Claude CLI may use ".credentials.json" (hidden) or "credentials.json" depending on version/platform
   const credentialsPaths = [
-    path.join(claudeDir, ".credentials.json"),
-    path.join(claudeDir, "credentials.json"),
+    path.join(claudeDir, '.credentials.json'),
+    path.join(claudeDir, 'credentials.json'),
   ];
 
   for (const credentialsPath of credentialsPaths) {
     try {
-      const credentialsContent = await fs.readFile(credentialsPath, "utf-8");
+      const credentialsContent = await fs.readFile(credentialsPath, 'utf-8');
       const credentials = JSON.parse(credentialsContent);
       auth.hasCredentialsFile = true;
 
@@ -158,11 +158,11 @@ export async function getClaudeStatus() {
         auth.hasStoredOAuthToken = true;
         auth.oauthTokenValid = true;
         auth.authenticated = true;
-        auth.method = "oauth_token"; // Stored OAuth token from credentials file
+        auth.method = 'oauth_token'; // Stored OAuth token from credentials file
       } else if (credentials.api_key) {
         auth.apiKeyValid = true;
         auth.authenticated = true;
-        auth.method = "api_key"; // Stored API key in credentials file
+        auth.method = 'api_key'; // Stored API key in credentials file
       }
       break; // Found and processed credentials file
     } catch {
@@ -174,25 +174,25 @@ export async function getClaudeStatus() {
   if (auth.hasEnvApiKey) {
     auth.authenticated = true;
     auth.apiKeyValid = true;
-    auth.method = "api_key_env"; // API key from ANTHROPIC_API_KEY env var
+    auth.method = 'api_key_env'; // API key from ANTHROPIC_API_KEY env var
   }
 
   // In-memory stored OAuth token (from setup wizard - subscription auth)
-  if (!auth.authenticated && getApiKey("anthropic_oauth_token")) {
+  if (!auth.authenticated && getApiKey('anthropic_oauth_token')) {
     auth.authenticated = true;
     auth.oauthTokenValid = true;
-    auth.method = "oauth_token"; // Stored OAuth token from setup wizard
+    auth.method = 'oauth_token'; // Stored OAuth token from setup wizard
   }
 
   // In-memory stored API key (from settings UI - pay-per-use)
-  if (!auth.authenticated && getApiKey("anthropic")) {
+  if (!auth.authenticated && getApiKey('anthropic')) {
     auth.authenticated = true;
     auth.apiKeyValid = true;
-    auth.method = "api_key"; // Manually stored API key
+    auth.method = 'api_key'; // Manually stored API key
   }
 
   return {
-    status: installed ? "installed" : "not_installed",
+    status: installed ? 'installed' : 'not_installed',
     installed,
     method,
     version,

apps/server/src/routes/setup/index.ts

@@ -2,29 +2,29 @@
  * Setup routes - HTTP API for CLI detection, API keys, and platform info
  */
 
-import { Router } from "express";
-import { createClaudeStatusHandler } from "./routes/claude-status.js";
-import { createInstallClaudeHandler } from "./routes/install-claude.js";
-import { createAuthClaudeHandler } from "./routes/auth-claude.js";
-import { createStoreApiKeyHandler } from "./routes/store-api-key.js";
-import { createDeleteApiKeyHandler } from "./routes/delete-api-key.js";
-import { createApiKeysHandler } from "./routes/api-keys.js";
-import { createPlatformHandler } from "./routes/platform.js";
-import { createVerifyClaudeAuthHandler } from "./routes/verify-claude-auth.js";
-import { createGhStatusHandler } from "./routes/gh-status.js";
+import { Router } from 'express';
+import { createClaudeStatusHandler } from './routes/claude-status.js';
+import { createInstallClaudeHandler } from './routes/install-claude.js';
+import { createAuthClaudeHandler } from './routes/auth-claude.js';
+import { createStoreApiKeyHandler } from './routes/store-api-key.js';
+import { createDeleteApiKeyHandler } from './routes/delete-api-key.js';
+import { createApiKeysHandler } from './routes/api-keys.js';
+import { createPlatformHandler } from './routes/platform.js';
+import { createVerifyClaudeAuthHandler } from './routes/verify-claude-auth.js';
+import { createGhStatusHandler } from './routes/gh-status.js';
 
 export function createSetupRoutes(): Router {
   const router = Router();
 
-  router.get("/claude-status", createClaudeStatusHandler());
-  router.post("/install-claude", createInstallClaudeHandler());
-  router.post("/auth-claude", createAuthClaudeHandler());
-  router.post("/store-api-key", createStoreApiKeyHandler());
-  router.post("/delete-api-key", createDeleteApiKeyHandler());
-  router.get("/api-keys", createApiKeysHandler());
-  router.get("/platform", createPlatformHandler());
-  router.post("/verify-claude-auth", createVerifyClaudeAuthHandler());
-  router.get("/gh-status", createGhStatusHandler());
+  router.get('/claude-status', createClaudeStatusHandler());
+  router.post('/install-claude', createInstallClaudeHandler());
+  router.post('/auth-claude', createAuthClaudeHandler());
+  router.post('/store-api-key', createStoreApiKeyHandler());
+  router.post('/delete-api-key', createDeleteApiKeyHandler());
+  router.get('/api-keys', createApiKeysHandler());
+  router.get('/platform', createPlatformHandler());
+  router.post('/verify-claude-auth', createVerifyClaudeAuthHandler());
+  router.get('/gh-status', createGhStatusHandler());
 
   return router;
 }

apps/server/src/routes/setup/routes/auth-claude.ts

@@ -2,8 +2,8 @@
  * POST /auth-claude endpoint - Auth Claude
  */
 
-import type { Request, Response } from "express";
-import { getErrorMessage, logError } from "../common.js";
+import type { Request, Response } from 'express';
+import { getErrorMessage, logError } from '../common.js';
 
 export function createAuthClaudeHandler() {
   return async (_req: Request, res: Response): Promise<void> => {
@@ -11,11 +11,11 @@ export function createAuthClaudeHandler() {
       res.json({
         success: true,
         requiresManualAuth: true,
-        command: "claude login",
+        command: 'claude login',
         message: "Please run 'claude login' in your terminal to authenticate",
       });
     } catch (error) {
-      logError(error, "Auth Claude failed");
+      logError(error, 'Auth Claude failed');
       res.status(500).json({ success: false, error: getErrorMessage(error) });
     }
   };

apps/server/src/routes/setup/routes/claude-status.ts

@@ -2,9 +2,9 @@
  * GET /claude-status endpoint - Get Claude CLI status
  */
 
-import type { Request, Response } from "express";
-import { getClaudeStatus } from "../get-claude-status.js";
-import { getErrorMessage, logError } from "../common.js";
+import type { Request, Response } from 'express';
+import { getClaudeStatus } from '../get-claude-status.js';
+import { getErrorMessage, logError } from '../common.js';
 
 export function createClaudeStatusHandler() {
   return async (_req: Request, res: Response): Promise<void> => {
@@ -15,7 +15,7 @@ export function createClaudeStatusHandler() {
         ...status,
       });
     } catch (error) {
-      logError(error, "Get Claude status failed");
+      logError(error, 'Get Claude status failed');
       res.status(500).json({ success: false, error: getErrorMessage(error) });
     }
   };

apps/server/src/routes/setup/routes/gh-status.ts

@@ -2,24 +2,26 @@
  * GET /gh-status endpoint - Get GitHub CLI status
  */
 
-import type { Request, Response } from "express";
-import { exec } from "child_process";
-import { promisify } from "util";
-import os from "os";
-import path from "path";
-import fs from "fs/promises";
-import { getErrorMessage, logError } from "../common.js";
+import type { Request, Response } from 'express';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import path from 'path';
+import fs from 'fs/promises';
+import { getErrorMessage, logError } from '../common.js';
 
 const execAsync = promisify(exec);
 
 // Extended PATH to include common tool installation locations
 const extendedPath = [
   process.env.PATH,
-  "/opt/homebrew/bin",
-  "/usr/local/bin",
-  "/home/linuxbrew/.linuxbrew/bin",
+  '/opt/homebrew/bin',
+  '/usr/local/bin',
+  '/home/linuxbrew/.linuxbrew/bin',
   `${process.env.HOME}/.local/bin`,
-].filter(Boolean).join(":");
+]
+  .filter(Boolean)
+  .join(':');
 
 const execEnv = {
   ...process.env,
@@ -44,11 +46,11 @@ async function getGhStatus(): Promise<GhStatus> {
     user: null,
   };
 
-  const isWindows = process.platform === "win32";
+  const isWindows = process.platform === 'win32';
 
   // Check if gh CLI is installed
   try {
-    const findCommand = isWindows ? "where gh" : "command -v gh";
+    const findCommand = isWindows ? 'where gh' : 'command -v gh';
     const { stdout } = await execAsync(findCommand, { env: execEnv });
     status.path = stdout.trim().split(/\r?\n/)[0];
     status.installed = true;
@@ -56,14 +58,14 @@ async function getGhStatus(): Promise<GhStatus> {
     // gh not in PATH, try common locations
     const commonPaths = isWindows
       ? [
-          path.join(process.env.LOCALAPPDATA || "", "Programs", "gh", "bin", "gh.exe"),
-          path.join(process.env.ProgramFiles || "", "GitHub CLI", "gh.exe"),
+          path.join(process.env.LOCALAPPDATA || '', 'Programs', 'gh', 'bin', 'gh.exe'),
+          path.join(process.env.ProgramFiles || '', 'GitHub CLI', 'gh.exe'),
         ]
       : [
-          "/opt/homebrew/bin/gh",
-          "/usr/local/bin/gh",
-          path.join(os.homedir(), ".local", "bin", "gh"),
-          "/home/linuxbrew/.linuxbrew/bin/gh",
+          '/opt/homebrew/bin/gh',
+          '/usr/local/bin/gh',
+          path.join(os.homedir(), '.local', 'bin', 'gh'),
+          '/home/linuxbrew/.linuxbrew/bin/gh',
         ];
 
     for (const p of commonPaths) {
@@ -84,30 +86,31 @@ async function getGhStatus(): Promise<GhStatus> {
 
   // Get version
   try {
-    const { stdout } = await execAsync("gh --version", { env: execEnv });
+    const { stdout } = await execAsync('gh --version', { env: execEnv });
     // Extract version from output like "gh version 2.40.1 (2024-01-09)"
     const versionMatch = stdout.match(/gh version ([\d.]+)/);
-    status.version = versionMatch ? versionMatch[1] : stdout.trim().split("\n")[0];
+    status.version = versionMatch ? versionMatch[1] : stdout.trim().split('\n')[0];
   } catch {
     // Version command failed
   }
 
   // Check authentication status
   try {
-    const { stdout } = await execAsync("gh auth status", { env: execEnv });
+    const { stdout } = await execAsync('gh auth status', { env: execEnv });
     // If this succeeds without error, we're authenticated
     status.authenticated = true;
 
     // Try to extract username from output
-    const userMatch = stdout.match(/Logged in to [^\s]+ account ([^\s]+)/i) ||
-                      stdout.match(/Logged in to [^\s]+ as ([^\s]+)/i);
+    const userMatch =
+      stdout.match(/Logged in to [^\s]+ account ([^\s]+)/i) ||
+      stdout.match(/Logged in to [^\s]+ as ([^\s]+)/i);
     if (userMatch) {
       status.user = userMatch[1];
     }
   } catch (error: unknown) {
     // Auth status returns non-zero if not authenticated
     const err = error as { stderr?: string };
-    if (err.stderr?.includes("not logged in")) {
+    if (err.stderr?.includes('not logged in')) {
       status.authenticated = false;
     }
   }
@@ -124,7 +127,7 @@ export function createGhStatusHandler() {
         ...status,
       });
     } catch (error) {
-      logError(error, "Get GitHub CLI status failed");
+      logError(error, 'Get GitHub CLI status failed');
       res.status(500).json({ success: false, error: getErrorMessage(error) });
     }
   };

apps/server/src/routes/setup/routes/install-claude.ts

@@ -2,8 +2,8 @@
  * POST /install-claude endpoint - Install Claude CLI
  */
 
-import type { Request, Response } from "express";
-import { getErrorMessage, logError } from "../common.js";
+import type { Request, Response } from 'express';
+import { getErrorMessage, logError } from '../common.js';
 
 export function createInstallClaudeHandler() {
   return async (_req: Request, res: Response): Promise<void> => {
@@ -13,10 +13,10 @@ export function createInstallClaudeHandler() {
       res.json({
         success: false,
         error:
-          "CLI installation requires terminal access. Please install manually using: npm install -g @anthropic-ai/claude-code",
+          'CLI installation requires terminal access. Please install manually using: npm install -g @anthropic-ai/claude-code',
       });
     } catch (error) {
-      logError(error, "Install Claude CLI failed");
+      logError(error, 'Install Claude CLI failed');
       res.status(500).json({ success: false, error: getErrorMessage(error) });
     }
   };

apps/server/src/routes/setup/routes/platform.ts

@@ -2,9 +2,9 @@
  * GET /platform endpoint - Get platform info
  */
 
-import type { Request, Response } from "express";
-import os from "os";
-import { getErrorMessage, logError } from "../common.js";
+import type { Request, Response } from 'express';
+import os from 'os';
+import { getErrorMessage, logError } from '../common.js';
 
 export function createPlatformHandler() {
   return async (_req: Request, res: Response): Promise<void> => {
@@ -15,12 +15,12 @@ export function createPlatformHandler() {
         platform,
         arch: os.arch(),
         homeDir: os.homedir(),
-        isWindows: platform === "win32",
-        isMac: platform === "darwin",
-        isLinux: platform === "linux",
+        isWindows: platform === 'win32',
+        isMac: platform === 'darwin',
+        isLinux: platform === 'linux',
       });
     } catch (error) {
-      logError(error, "Get platform info failed");
+      logError(error, 'Get platform info failed');
       res.status(500).json({ success: false, error: getErrorMessage(error) });
     }
   };