@quantiya/codevibe-claude-plugin 1.0.8 → 1.0.10

package/node_modules/@quantiya/codevibe-core/dist/auth/auth-service.js

@@ -41,11 +41,13 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.authService = exports.AuthService = void 0;
 const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
 const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const config_1 = require("../config");
 const keychain_1 = require("../keychain");
 const logger_1 = require("../logger");
+const fetch_helpers_1 = require("./fetch-helpers");
 const CALLBACK_PORT = 8080;
 const CALLBACK_PATH = '/callback';
 const REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
@@ -61,10 +63,154 @@ class AuthService {
         return AuthService.instance;
     }
     /**
-     * Open URL in default browser
+     * Open URL in the user's default browser. Cross-platform: macOS, Linux,
+     * WSL, Windows. Always prints the URL to stdout first as a fallback —
+     * if no browser-opening command is available, the user can copy-paste.
+     *
+     * On WSL, prefers opening the Windows host browser via WSL interop
+     * (wslview → cmd.exe → powershell.exe) before falling back to xdg-open.
      */
     openBrowser(url) {
-        (0, child_process_1.spawn)('open', [url], { detached: true, stdio: 'ignore' }).unref();
+        // Always print the URL first so users can copy-paste if automatic
+        // browser-opening fails (especially important on headless WSL setups).
+        console.log('');
+        console.log('Opening your browser for sign-in...');
+        console.log('If your browser does not open automatically, visit this URL manually:');
+        console.log(`  ${url}`);
+        console.log('');
+        const attempts = this.getBrowserCommands();
+        this.tryBrowserCommand(attempts, url, 0);
+    }
+    /**
+     * Returns the list of browser-opening commands to try in order, based on
+     * the current platform. On WSL, returns WSL interop commands first so the
+     * Windows browser opens (which is what users actually want on WSL).
+     */
+    getBrowserCommands() {
+        const platform = process.platform;
+        if (platform === 'darwin') {
+            return [{ cmd: 'open', fixedArgs: [] }];
+        }
+        if (platform === 'win32') {
+            // cmd's start needs an empty title as the first arg so that URLs
+            // containing special characters aren't misinterpreted as the title.
+            return [{ cmd: 'cmd', fixedArgs: ['/c', 'start', ''] }];
+        }
+        // Linux or WSL
+        const attempts = [];
+        if (this.isRunningInWSL()) {
+            // Prefer opening the Windows host browser via WSL interop.
+            attempts.push({ cmd: 'wslview', fixedArgs: [] });
+            attempts.push({ cmd: 'cmd.exe', fixedArgs: ['/c', 'start', ''] });
+            attempts.push({
+                cmd: 'powershell.exe',
+                fixedArgs: ['-NoProfile', '-Command', 'Start-Process'],
+            });
+        }
+        // Fall back to generic Linux openers
+        attempts.push({ cmd: 'xdg-open', fixedArgs: [] });
+        return attempts;
+    }
+    /**
+     * Detect whether we're running inside WSL (1 or 2). Returns false on
+     * any non-Linux platform or if /proc/sys/kernel/osrelease is not readable.
+     */
+    isRunningInWSL() {
+        if (process.platform !== 'linux')
+            return false;
+        try {
+            const osRelease = fs.readFileSync('/proc/sys/kernel/osrelease', 'utf8');
+            return /microsoft|wsl/i.test(osRelease);
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Try each browser-opening command in order. Advances to the next fallback on:
+     *   - Spawn failure (ENOENT / the command not being installed)
+     *   - Synchronous throw from spawn()
+     *   - Runtime failure where the command spawns but exits with a non-zero
+     *     code (e.g. wslview when WSL interop is disabled, xdg-open when no
+     *     default browser is registered, cmd.exe failing to launch start)
+     *   - Process terminated by signal
+     *
+     * Stays on the current command when:
+     *   - Process exits with code 0 (success)
+     *   - Process is still running after 3 seconds (assumed success — opener
+     *     is doing real work like launching a slow app, not hung)
+     *
+     * If all attempts exhaust, logs at debug level — the user still has the
+     * sign-in URL printed to stdout as a copy-paste fallback.
+     */
+    tryBrowserCommand(attempts, url, index) {
+        if (index >= attempts.length) {
+            logger_1.logger.debug('[AuthService] No browser-opening command succeeded. ' +
+                'User must open the sign-in URL manually (printed to stdout above).');
+            return;
+        }
+        const attempt = attempts[index];
+        const args = [...attempt.fixedArgs, url];
+        let settled = false;
+        // Helper to advance exactly once — guards against both 'error' and 'exit'
+        // events firing for the same child, or the timeout racing with an event.
+        const advance = (reason) => {
+            if (settled)
+                return;
+            settled = true;
+            logger_1.logger.debug(`[AuthService] Browser command '${attempt.cmd}' ${reason}; trying next fallback`);
+            this.tryBrowserCommand(attempts, url, index + 1);
+        };
+        // Helper to mark this attempt as successful so no future event handlers
+        // fire tryBrowserCommand on the next index.
+        const stopTrying = (reason) => {
+            if (settled)
+                return;
+            settled = true;
+            logger_1.logger.debug(`[AuthService] Browser command '${attempt.cmd}' ${reason}`);
+        };
+        let child;
+        try {
+            child = (0, child_process_1.spawn)(attempt.cmd, args, {
+                detached: true,
+                stdio: 'ignore',
+            });
+        }
+        catch (err) {
+            advance(`threw synchronously: ${err?.message || err}`);
+            return;
+        }
+        // Fires when the OS cannot spawn the process at all (most commonly ENOENT
+        // for "command not found"). The process never actually ran.
+        child.on('error', (err) => {
+            advance(`failed to spawn: ${err?.message || err}`);
+        });
+        // Fires after the spawned process exits. code === 0 is success (opener
+        // delegated cleanly and returned). Non-zero code or a signal means the
+        // opener failed at runtime — we fall through to the next fallback.
+        child.on('exit', (code, signal) => {
+            if (code === 0) {
+                stopTrying('exited successfully');
+            }
+            else if (signal) {
+                advance(`terminated by signal ${signal}`);
+            }
+            else {
+                advance(`exited with code ${code}`);
+            }
+        });
+        // If the opener is still running after 3 seconds, it is almost certainly
+        // doing real work (launching a slow browser, waiting for Windows interop)
+        // rather than hung. Stop trying more fallbacks so we don't spawn multiple
+        // browsers. The child keeps running independently because detached:true.
+        const timer = setTimeout(() => {
+            stopTrying('still running after 3s, assuming success');
+        }, 3000);
+        // Don't let the timer itself keep the Node event loop alive.
+        timer.unref();
+        // Detach the child from the parent's event loop so Node doesn't block
+        // on its exit. Exit handler still fires if/when the child actually exits.
+        child.unref();
     }
     /**
      * Generate state for CSRF protection
@@ -98,11 +244,11 @@ class AuthService {
             code: code,
             redirect_uri: REDIRECT_URI,
         });
-        const response = await fetch(tokenUrl, {
+        const response = await (0, fetch_helpers_1.fetchWithDiagnostics)(tokenUrl, {
             method: 'POST',
             headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
             body: params.toString(),
-        });
+        }, 'Token exchange');
         if (!response.ok) {
             const errorText = await response.text();
             throw new Error(`Token exchange failed: ${response.status} ${errorText}`);
@@ -135,11 +281,11 @@ class AuthService {
             client_id: config.aws.cognitoClientId,
             refresh_token: refreshToken,
         });
-        const response = await fetch(tokenUrl, {
+        const response = await (0, fetch_helpers_1.fetchWithDiagnostics)(tokenUrl, {
             method: 'POST',
             headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
             body: params.toString(),
-        });
+        }, 'Token refresh');
         if (!response.ok) {
             throw new Error(`Token refresh failed: ${response.status}`);
         }
@@ -209,14 +355,22 @@ class AuthService {
                     }, 500);
                 }
                 catch (err) {
+                    // HTML-escape the error message so newlines and special chars
+                    // render safely. Multi-line diagnostic messages (from
+                    // fetchWithDiagnostics) need <pre> to preserve formatting.
+                    const safeMessage = String(err?.message || err)
+                        .replace(/&/g, '&amp;')
+                        .replace(/</g, '&lt;')
+                        .replace(/>/g, '&gt;');
                     res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
                     res.end(`
             <!DOCTYPE html>
             <html>
             <head><title>Error</title></head>
-            <body style="font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;">
-              <h1 style="color: #ef4444;">&#10007; Authentication Failed</h1>
-              <p>${err.message}</p>
+            <body style="font-family: system-ui; max-width: 720px; margin: 50px auto; padding: 0 16px;">
+              <h1 style="color: #ef4444; text-align: center;">&#10007; Authentication Failed</h1>
+              <pre style="background: #f4f4f5; padding: 16px; border-radius: 8px; white-space: pre-wrap; word-wrap: break-word; font-size: 13px; line-height: 1.5;">${safeMessage}</pre>
+              <p style="text-align: center; color: #71717a; margin-top: 24px;">You can close this window and try again in your terminal.</p>
             </body>
             </html>
           `);
@@ -307,4 +461,4 @@ class AuthService {
 }
 exports.AuthService = AuthService;
 exports.authService = AuthService.getInstance();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-service.js","sourceRoot":"","sources":["../../src/auth/auth-service.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// auth-service.ts\n// CodeVibe Core\n//\n// OAuth authentication service\n//\n\nimport * as crypto from 'crypto';\nimport * as http from 'http';\nimport { spawn } from 'child_process';\nimport { getConfig, getEnvironment } from '../config';\nimport { keychainManager } from '../keychain';\nimport { logger } from '../logger';\nimport { TokenData } from '../types';\n\nconst CALLBACK_PORT = 8080;\nconst CALLBACK_PATH = '/callback';\nconst REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;\n\n/**\n * Authentication service for OAuth flows\n */\nexport class AuthService {\n  private static instance: AuthService;\n\n  private constructor() {}\n\n  static getInstance(): AuthService {\n    if (!AuthService.instance) {\n      AuthService.instance = new AuthService();\n    }\n    return AuthService.instance;\n  }\n\n  /**\n   * Open URL in default browser\n   */\n  private openBrowser(url: string): void {\n    spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();\n  }\n\n  /**\n   * Generate state for CSRF protection\n   */\n  private generateState(): string {\n    return crypto.randomBytes(32).toString('hex');\n  }\n\n  /**\n   * Build authorization URL\n   */\n  private buildAuthUrl(state: string): string {\n    const config = getConfig();\n    const params = new URLSearchParams({\n      client_id: config.aws.cognitoClientId,\n      response_type: 'code',\n      scope: 'email openid profile',\n      redirect_uri: REDIRECT_URI,\n      state: state,\n    });\n\n    return `https://${config.aws.cognitoDomain}/oauth2/authorize?${params.toString()}`;\n  }\n\n  /**\n   * Exchange authorization code for tokens\n   */\n  private async exchangeCodeForTokens(code: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    refreshToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'authorization_code',\n      client_id: config.aws.cognitoClientId,\n      code: code,\n      redirect_uri: REDIRECT_URI,\n    });\n\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body: params.toString(),\n    });\n\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      refresh_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      refreshToken: data.refresh_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Decode JWT payload\n   */\n  private decodeJwt(token: string): any {\n    const parts = token.split('.');\n    if (parts.length !== 3) throw new Error('Invalid JWT');\n    return JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));\n  }\n\n  /**\n   * Refresh tokens\n   */\n  async refreshTokens(refreshToken: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'refresh_token',\n      client_id: config.aws.cognitoClientId,\n      refresh_token: refreshToken,\n    });\n\n    const response = await fetch(tokenUrl, {\n      method: 'POST',\n      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n      body: params.toString(),\n    });\n\n    if (!response.ok) {\n      throw new Error(`Token refresh failed: ${response.status}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Login via OAuth browser flow\n   */\n  async login(): Promise<TokenData | null> {\n    // Check if already logged in\n    const existing = await keychainManager.getTokens(getEnvironment());\n    if (existing && !keychainManager.isTokenExpired(existing)) {\n      return existing;\n    }\n\n    const state = this.generateState();\n    const authUrl = this.buildAuthUrl(state);\n\n    return new Promise((resolve, reject) => {\n      const server = http.createServer(async (req, res) => {\n        if (!req.url?.startsWith(CALLBACK_PATH)) {\n          res.writeHead(404);\n          res.end('Not found');\n          return;\n        }\n\n        try {\n          const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);\n          const code = url.searchParams.get('code');\n          const returnedState = url.searchParams.get('state');\n          const error = url.searchParams.get('error');\n\n          if (error) {\n            throw new Error(`OAuth error: ${error}`);\n          }\n\n          if (returnedState !== state) {\n            throw new Error('State mismatch');\n          }\n\n          if (!code) {\n            throw new Error('No authorization code');\n          }\n\n          const tokens = await this.exchangeCodeForTokens(code);\n          const idPayload = this.decodeJwt(tokens.idToken);\n\n          const tokenData: TokenData = {\n            accessToken: tokens.accessToken,\n            idToken: tokens.idToken,\n            refreshToken: tokens.refreshToken,\n            expiresAt: Date.now() + (tokens.expiresIn * 1000),\n            userId: idPayload.sub,\n            email: idPayload.email || 'unknown',\n          };\n\n          await keychainManager.setTokens(tokenData, getEnvironment());\n\n          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Success</title></head>\n            <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n              <h1 style=\"color: #22c55e;\">&#10003; Authentication Successful</h1>\n              <p>You can close this window.</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => resolve(tokenData));\n          }, 500);\n        } catch (err: any) {\n          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Error</title></head>\n            <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n              <h1 style=\"color: #ef4444;\">&#10007; Authentication Failed</h1>\n              <p>${err.message}</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => reject(err));\n          }, 500);\n        }\n      });\n\n      server.on('error', (err: any) => {\n        if (err.code === 'EADDRINUSE') {\n          reject(new Error(`Port ${CALLBACK_PORT} is in use`));\n        } else {\n          reject(err);\n        }\n      });\n\n      server.listen(CALLBACK_PORT, 'localhost', () => {\n        logger.info('[AuthService] Callback server started');\n        this.openBrowser(authUrl);\n      });\n\n      // Timeout\n      setTimeout(() => {\n        server.close(() => reject(new Error('Login timeout')));\n      }, 2 * 60 * 1000);\n    });\n  }\n\n  /**\n   * Logout\n   */\n  async logout(): Promise<boolean> {\n    const config = getConfig();\n    const deleted = await keychainManager.deleteTokens(getEnvironment());\n\n    if (deleted) {\n      // Start temporary server to handle signout callback\n      return new Promise((resolve) => {\n        const server = http.createServer((req, res) => {\n          if (req.url?.startsWith('/signout')) {\n            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n            res.end(`\n              <!DOCTYPE html>\n              <html>\n              <head><title>Signed Out</title></head>\n              <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n                <h1 style=\"color: #22c55e;\">&#10003; Signed Out</h1>\n                <p>You can close this window.</p>\n              </body>\n              </html>\n            `);\n\n            setTimeout(() => {\n              server.close(() => resolve(true));\n            }, 500);\n          } else {\n            res.writeHead(404);\n            res.end('Not found');\n          }\n        });\n\n        server.on('error', () => {\n          resolve(true); // Still return true since tokens were deleted\n        });\n\n        server.listen(CALLBACK_PORT, 'localhost', () => {\n          const logoutUrl = `https://${config.aws.cognitoDomain}/logout?` +\n            `client_id=${config.aws.cognitoClientId}&` +\n            `logout_uri=${encodeURIComponent(REDIRECT_URI.replace('/callback', '/signout'))}`;\n\n          this.openBrowser(logoutUrl);\n        });\n\n        // Timeout after 30 seconds\n        setTimeout(() => {\n          server.close(() => resolve(true));\n        }, 30 * 1000);\n      });\n    }\n\n    return deleted;\n  }\n\n  /**\n   * Get current auth status\n   */\n  async getStatus(): Promise<{ authenticated: boolean; tokens?: TokenData }> {\n    const tokens = await keychainManager.getTokens(getEnvironment());\n    if (!tokens) {\n      return { authenticated: false };\n    }\n\n    return {\n      authenticated: !keychainManager.isTokenExpired(tokens),\n      tokens,\n    };\n  }\n}\n\nexport const authService = AuthService.getInstance();\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"auth-service.js","sourceRoot":"","sources":["../../src/auth/auth-service.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// auth-service.ts\n// CodeVibe Core\n//\n// OAuth authentication service\n//\n\nimport * as crypto from 'crypto';\nimport * as fs from 'fs';\nimport * as http from 'http';\nimport { spawn } from 'child_process';\nimport { getConfig, getEnvironment } from '../config';\nimport { keychainManager } from '../keychain';\nimport { logger } from '../logger';\nimport { TokenData } from '../types';\nimport { fetchWithDiagnostics } from './fetch-helpers';\n\nconst CALLBACK_PORT = 8080;\nconst CALLBACK_PATH = '/callback';\nconst REDIRECT_URI = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;\n\n/**\n * Authentication service for OAuth flows\n */\nexport class AuthService {\n  private static instance: AuthService;\n\n  private constructor() {}\n\n  static getInstance(): AuthService {\n    if (!AuthService.instance) {\n      AuthService.instance = new AuthService();\n    }\n    return AuthService.instance;\n  }\n\n  /**\n   * Open URL in the user's default browser. Cross-platform: macOS, Linux,\n   * WSL, Windows. Always prints the URL to stdout first as a fallback —\n   * if no browser-opening command is available, the user can copy-paste.\n   *\n   * On WSL, prefers opening the Windows host browser via WSL interop\n   * (wslview → cmd.exe → powershell.exe) before falling back to xdg-open.\n   */\n  private openBrowser(url: string): void {\n    // Always print the URL first so users can copy-paste if automatic\n    // browser-opening fails (especially important on headless WSL setups).\n    console.log('');\n    console.log('Opening your browser for sign-in...');\n    console.log('If your browser does not open automatically, visit this URL manually:');\n    console.log(`  ${url}`);\n    console.log('');\n\n    const attempts = this.getBrowserCommands();\n    this.tryBrowserCommand(attempts, url, 0);\n  }\n\n  /**\n   * Returns the list of browser-opening commands to try in order, based on\n   * the current platform. On WSL, returns WSL interop commands first so the\n   * Windows browser opens (which is what users actually want on WSL).\n   */\n  private getBrowserCommands(): Array<{ cmd: string; fixedArgs: string[] }> {\n    const platform = process.platform;\n\n    if (platform === 'darwin') {\n      return [{ cmd: 'open', fixedArgs: [] }];\n    }\n\n    if (platform === 'win32') {\n      // cmd's start needs an empty title as the first arg so that URLs\n      // containing special characters aren't misinterpreted as the title.\n      return [{ cmd: 'cmd', fixedArgs: ['/c', 'start', ''] }];\n    }\n\n    // Linux or WSL\n    const attempts: Array<{ cmd: string; fixedArgs: string[] }> = [];\n\n    if (this.isRunningInWSL()) {\n      // Prefer opening the Windows host browser via WSL interop.\n      attempts.push({ cmd: 'wslview', fixedArgs: [] });\n      attempts.push({ cmd: 'cmd.exe', fixedArgs: ['/c', 'start', ''] });\n      attempts.push({\n        cmd: 'powershell.exe',\n        fixedArgs: ['-NoProfile', '-Command', 'Start-Process'],\n      });\n    }\n\n    // Fall back to generic Linux openers\n    attempts.push({ cmd: 'xdg-open', fixedArgs: [] });\n\n    return attempts;\n  }\n\n  /**\n   * Detect whether we're running inside WSL (1 or 2). Returns false on\n   * any non-Linux platform or if /proc/sys/kernel/osrelease is not readable.\n   */\n  private isRunningInWSL(): boolean {\n    if (process.platform !== 'linux') return false;\n    try {\n      const osRelease = fs.readFileSync('/proc/sys/kernel/osrelease', 'utf8');\n      return /microsoft|wsl/i.test(osRelease);\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Try each browser-opening command in order. Advances to the next fallback on:\n   *   - Spawn failure (ENOENT / the command not being installed)\n   *   - Synchronous throw from spawn()\n   *   - Runtime failure where the command spawns but exits with a non-zero\n   *     code (e.g. wslview when WSL interop is disabled, xdg-open when no\n   *     default browser is registered, cmd.exe failing to launch start)\n   *   - Process terminated by signal\n   *\n   * Stays on the current command when:\n   *   - Process exits with code 0 (success)\n   *   - Process is still running after 3 seconds (assumed success — opener\n   *     is doing real work like launching a slow app, not hung)\n   *\n   * If all attempts exhaust, logs at debug level — the user still has the\n   * sign-in URL printed to stdout as a copy-paste fallback.\n   */\n  private tryBrowserCommand(\n    attempts: Array<{ cmd: string; fixedArgs: string[] }>,\n    url: string,\n    index: number\n  ): void {\n    if (index >= attempts.length) {\n      logger.debug(\n        '[AuthService] No browser-opening command succeeded. ' +\n          'User must open the sign-in URL manually (printed to stdout above).'\n      );\n      return;\n    }\n\n    const attempt = attempts[index];\n    const args = [...attempt.fixedArgs, url];\n    let settled = false;\n\n    // Helper to advance exactly once — guards against both 'error' and 'exit'\n    // events firing for the same child, or the timeout racing with an event.\n    const advance = (reason: string) => {\n      if (settled) return;\n      settled = true;\n      logger.debug(\n        `[AuthService] Browser command '${attempt.cmd}' ${reason}; trying next fallback`\n      );\n      this.tryBrowserCommand(attempts, url, index + 1);\n    };\n\n    // Helper to mark this attempt as successful so no future event handlers\n    // fire tryBrowserCommand on the next index.\n    const stopTrying = (reason: string) => {\n      if (settled) return;\n      settled = true;\n      logger.debug(`[AuthService] Browser command '${attempt.cmd}' ${reason}`);\n    };\n\n    let child;\n    try {\n      child = spawn(attempt.cmd, args, {\n        detached: true,\n        stdio: 'ignore',\n      });\n    } catch (err: any) {\n      advance(`threw synchronously: ${err?.message || err}`);\n      return;\n    }\n\n    // Fires when the OS cannot spawn the process at all (most commonly ENOENT\n    // for \"command not found\"). The process never actually ran.\n    child.on('error', (err: any) => {\n      advance(`failed to spawn: ${err?.message || err}`);\n    });\n\n    // Fires after the spawned process exits. code === 0 is success (opener\n    // delegated cleanly and returned). Non-zero code or a signal means the\n    // opener failed at runtime — we fall through to the next fallback.\n    child.on('exit', (code: number | null, signal: string | null) => {\n      if (code === 0) {\n        stopTrying('exited successfully');\n      } else if (signal) {\n        advance(`terminated by signal ${signal}`);\n      } else {\n        advance(`exited with code ${code}`);\n      }\n    });\n\n    // If the opener is still running after 3 seconds, it is almost certainly\n    // doing real work (launching a slow browser, waiting for Windows interop)\n    // rather than hung. Stop trying more fallbacks so we don't spawn multiple\n    // browsers. The child keeps running independently because detached:true.\n    const timer = setTimeout(() => {\n      stopTrying('still running after 3s, assuming success');\n    }, 3000);\n    // Don't let the timer itself keep the Node event loop alive.\n    timer.unref();\n\n    // Detach the child from the parent's event loop so Node doesn't block\n    // on its exit. Exit handler still fires if/when the child actually exits.\n    child.unref();\n  }\n\n  /**\n   * Generate state for CSRF protection\n   */\n  private generateState(): string {\n    return crypto.randomBytes(32).toString('hex');\n  }\n\n  /**\n   * Build authorization URL\n   */\n  private buildAuthUrl(state: string): string {\n    const config = getConfig();\n    const params = new URLSearchParams({\n      client_id: config.aws.cognitoClientId,\n      response_type: 'code',\n      scope: 'email openid profile',\n      redirect_uri: REDIRECT_URI,\n      state: state,\n    });\n\n    return `https://${config.aws.cognitoDomain}/oauth2/authorize?${params.toString()}`;\n  }\n\n  /**\n   * Exchange authorization code for tokens\n   */\n  private async exchangeCodeForTokens(code: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    refreshToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'authorization_code',\n      client_id: config.aws.cognitoClientId,\n      code: code,\n      redirect_uri: REDIRECT_URI,\n    });\n\n    const response = await fetchWithDiagnostics(\n      tokenUrl,\n      {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n        body: params.toString(),\n      },\n      'Token exchange'\n    );\n\n    if (!response.ok) {\n      const errorText = await response.text();\n      throw new Error(`Token exchange failed: ${response.status} ${errorText}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      refresh_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      refreshToken: data.refresh_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Decode JWT payload\n   */\n  private decodeJwt(token: string): any {\n    const parts = token.split('.');\n    if (parts.length !== 3) throw new Error('Invalid JWT');\n    return JSON.parse(Buffer.from(parts[1], 'base64').toString('utf-8'));\n  }\n\n  /**\n   * Refresh tokens\n   */\n  async refreshTokens(refreshToken: string): Promise<{\n    accessToken: string;\n    idToken: string;\n    expiresIn: number;\n  }> {\n    const config = getConfig();\n    const tokenUrl = `https://${config.aws.cognitoDomain}/oauth2/token`;\n\n    const params = new URLSearchParams({\n      grant_type: 'refresh_token',\n      client_id: config.aws.cognitoClientId,\n      refresh_token: refreshToken,\n    });\n\n    const response = await fetchWithDiagnostics(\n      tokenUrl,\n      {\n        method: 'POST',\n        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },\n        body: params.toString(),\n      },\n      'Token refresh'\n    );\n\n    if (!response.ok) {\n      throw new Error(`Token refresh failed: ${response.status}`);\n    }\n\n    const data = await response.json() as {\n      access_token: string;\n      id_token: string;\n      expires_in: number;\n    };\n\n    return {\n      accessToken: data.access_token,\n      idToken: data.id_token,\n      expiresIn: data.expires_in,\n    };\n  }\n\n  /**\n   * Login via OAuth browser flow\n   */\n  async login(): Promise<TokenData | null> {\n    // Check if already logged in\n    const existing = await keychainManager.getTokens(getEnvironment());\n    if (existing && !keychainManager.isTokenExpired(existing)) {\n      return existing;\n    }\n\n    const state = this.generateState();\n    const authUrl = this.buildAuthUrl(state);\n\n    return new Promise((resolve, reject) => {\n      const server = http.createServer(async (req, res) => {\n        if (!req.url?.startsWith(CALLBACK_PATH)) {\n          res.writeHead(404);\n          res.end('Not found');\n          return;\n        }\n\n        try {\n          const url = new URL(req.url, `http://localhost:${CALLBACK_PORT}`);\n          const code = url.searchParams.get('code');\n          const returnedState = url.searchParams.get('state');\n          const error = url.searchParams.get('error');\n\n          if (error) {\n            throw new Error(`OAuth error: ${error}`);\n          }\n\n          if (returnedState !== state) {\n            throw new Error('State mismatch');\n          }\n\n          if (!code) {\n            throw new Error('No authorization code');\n          }\n\n          const tokens = await this.exchangeCodeForTokens(code);\n          const idPayload = this.decodeJwt(tokens.idToken);\n\n          const tokenData: TokenData = {\n            accessToken: tokens.accessToken,\n            idToken: tokens.idToken,\n            refreshToken: tokens.refreshToken,\n            expiresAt: Date.now() + (tokens.expiresIn * 1000),\n            userId: idPayload.sub,\n            email: idPayload.email || 'unknown',\n          };\n\n          await keychainManager.setTokens(tokenData, getEnvironment());\n\n          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Success</title></head>\n            <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n              <h1 style=\"color: #22c55e;\">&#10003; Authentication Successful</h1>\n              <p>You can close this window.</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => resolve(tokenData));\n          }, 500);\n        } catch (err: any) {\n          // HTML-escape the error message so newlines and special chars\n          // render safely. Multi-line diagnostic messages (from\n          // fetchWithDiagnostics) need <pre> to preserve formatting.\n          const safeMessage = String(err?.message || err)\n            .replace(/&/g, '&amp;')\n            .replace(/</g, '&lt;')\n            .replace(/>/g, '&gt;');\n\n          res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });\n          res.end(`\n            <!DOCTYPE html>\n            <html>\n            <head><title>Error</title></head>\n            <body style=\"font-family: system-ui; max-width: 720px; margin: 50px auto; padding: 0 16px;\">\n              <h1 style=\"color: #ef4444; text-align: center;\">&#10007; Authentication Failed</h1>\n              <pre style=\"background: #f4f4f5; padding: 16px; border-radius: 8px; white-space: pre-wrap; word-wrap: break-word; font-size: 13px; line-height: 1.5;\">${safeMessage}</pre>\n              <p style=\"text-align: center; color: #71717a; margin-top: 24px;\">You can close this window and try again in your terminal.</p>\n            </body>\n            </html>\n          `);\n\n          setTimeout(() => {\n            server.close(() => reject(err));\n          }, 500);\n        }\n      });\n\n      server.on('error', (err: any) => {\n        if (err.code === 'EADDRINUSE') {\n          reject(new Error(`Port ${CALLBACK_PORT} is in use`));\n        } else {\n          reject(err);\n        }\n      });\n\n      server.listen(CALLBACK_PORT, 'localhost', () => {\n        logger.info('[AuthService] Callback server started');\n        this.openBrowser(authUrl);\n      });\n\n      // Timeout\n      setTimeout(() => {\n        server.close(() => reject(new Error('Login timeout')));\n      }, 2 * 60 * 1000);\n    });\n  }\n\n  /**\n   * Logout\n   */\n  async logout(): Promise<boolean> {\n    const config = getConfig();\n    const deleted = await keychainManager.deleteTokens(getEnvironment());\n\n    if (deleted) {\n      // Start temporary server to handle signout callback\n      return new Promise((resolve) => {\n        const server = http.createServer((req, res) => {\n          if (req.url?.startsWith('/signout')) {\n            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });\n            res.end(`\n              <!DOCTYPE html>\n              <html>\n              <head><title>Signed Out</title></head>\n              <body style=\"font-family: system-ui; max-width: 600px; margin: 50px auto; text-align: center;\">\n                <h1 style=\"color: #22c55e;\">&#10003; Signed Out</h1>\n                <p>You can close this window.</p>\n              </body>\n              </html>\n            `);\n\n            setTimeout(() => {\n              server.close(() => resolve(true));\n            }, 500);\n          } else {\n            res.writeHead(404);\n            res.end('Not found');\n          }\n        });\n\n        server.on('error', () => {\n          resolve(true); // Still return true since tokens were deleted\n        });\n\n        server.listen(CALLBACK_PORT, 'localhost', () => {\n          const logoutUrl = `https://${config.aws.cognitoDomain}/logout?` +\n            `client_id=${config.aws.cognitoClientId}&` +\n            `logout_uri=${encodeURIComponent(REDIRECT_URI.replace('/callback', '/signout'))}`;\n\n          this.openBrowser(logoutUrl);\n        });\n\n        // Timeout after 30 seconds\n        setTimeout(() => {\n          server.close(() => resolve(true));\n        }, 30 * 1000);\n      });\n    }\n\n    return deleted;\n  }\n\n  /**\n   * Get current auth status\n   */\n  async getStatus(): Promise<{ authenticated: boolean; tokens?: TokenData }> {\n    const tokens = await keychainManager.getTokens(getEnvironment());\n    if (!tokens) {\n      return { authenticated: false };\n    }\n\n    return {\n      authenticated: !keychainManager.isTokenExpired(tokens),\n      tokens,\n    };\n  }\n}\n\nexport const authService = AuthService.getInstance();\n"]}

package/node_modules/@quantiya/codevibe-core/dist/auth/fetch-helpers.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Wraps fetch() and rewrites "fetch failed" errors to include the underlying
+ * cause and a user-actionable diagnostic tip when possible. Non-network errors
+ * and HTTP error responses (non-2xx) are not affected — the caller still
+ * handles response.ok checks themselves.
+ *
+ * @param url The URL to fetch
+ * @param init Standard fetch init options
+ * @param context Optional short label (e.g. "token exchange") for the error message
+ */
+export declare function fetchWithDiagnostics(url: string, init?: any, context?: string): Promise<Response>;

package/node_modules/@quantiya/codevibe-core/dist/auth/fetch-helpers.js

@@ -0,0 +1,165 @@
+"use strict";
+//
+// fetch-helpers.ts
+// CodeVibe Core
+//
+// Wrapper around Node's built-in fetch() that surfaces the underlying cause
+// of "fetch failed" errors with platform-specific diagnostic tips.
+//
+// Background: Node 18+'s built-in fetch (via undici) throws a generic
+// TypeError with message "fetch failed" for all network-level errors (DNS
+// failures, timeouts, TLS issues, etc.). The real cause is buried in the
+// error's .cause property. This wrapper unpacks that cause and returns a
+// detailed, actionable error message — critical for WSL users where fetch
+// failures are common and usually fixable with known workarounds.
+//
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithDiagnostics = fetchWithDiagnostics;
+const dns = __importStar(require("dns"));
+const fs = __importStar(require("fs"));
+// Node 17+ changed the default DNS result order from 'ipv4first' to
+// 'verbatim' (RFC-compliant but problematic for hosts with broken IPv6).
+// On WSL Ubuntu specifically, the kernel often advertises IPv6 addresses
+// via getaddrinfo even though the WSL network namespace has no route to
+// the IPv6 internet — causing every IPv6 connection attempt to fail with
+// EHOSTUNREACH. curl handles this via Happy Eyeballs fallback, but undici
+// (Node's built-in fetch) does not, and throws "fetch failed" without
+// ever trying IPv4.
+//
+// We apply 'ipv4first' ONLY when running inside WSL. On macOS, native
+// Linux, and Windows we leave Node's default ('verbatim') alone — those
+// platforms have healthy dual-stack networking and the current behavior
+// is correct. Narrowly scoping the override to WSL means zero behavioral
+// change for non-WSL users (including IPv6-only networks where ipv4first
+// would add first-connection latency).
+//
+// This runs as a side effect of importing codevibe-core's fetch-helpers,
+// which happens early in every plugin's startup path. Documented here
+// so future maintainers understand why there's a side effect on import.
+if (isRunningInWSL()) {
+    try {
+        dns.setDefaultResultOrder('ipv4first');
+    }
+    catch {
+        // Older Node versions (< 18.6) don't expose setDefaultResultOrder;
+        // skip silently. Users on those versions can still set the
+        // NODE_OPTIONS="--dns-result-order=ipv4first" environment variable
+        // manually if they hit IPv6 issues.
+    }
+}
+/**
+ * Detect whether we're running inside WSL (1 or 2). Returns false on any
+ * non-Linux platform or if /proc/sys/kernel/osrelease is not readable.
+ * Duplicated from auth-service.ts as a module-level helper so it can run
+ * at import time, before any class is instantiated.
+ */
+function isRunningInWSL() {
+    if (process.platform !== 'linux')
+        return false;
+    try {
+        const osRelease = fs.readFileSync('/proc/sys/kernel/osrelease', 'utf8');
+        return /microsoft|wsl/i.test(osRelease);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Wraps fetch() and rewrites "fetch failed" errors to include the underlying
+ * cause and a user-actionable diagnostic tip when possible. Non-network errors
+ * and HTTP error responses (non-2xx) are not affected — the caller still
+ * handles response.ok checks themselves.
+ *
+ * @param url The URL to fetch
+ * @param init Standard fetch init options
+ * @param context Optional short label (e.g. "token exchange") for the error message
+ */
+async function fetchWithDiagnostics(url, init, context) {
+    try {
+        return await fetch(url, init);
+    }
+    catch (err) {
+        // Node's undici wraps real errors in err.cause
+        const causeCode = err?.cause?.code;
+        const causeMessage = err?.cause?.message;
+        const causeSummary = causeCode || causeMessage || err?.message || 'unknown';
+        const tip = getDiagnosticTip(causeCode);
+        const contextLabel = context ? `${context}: ` : '';
+        const platformInfo = `Node ${process.version} on ${process.platform}`;
+        const detailLines = [
+            `${contextLabel}Cannot reach ${url}`,
+            `  Underlying error: ${causeSummary}`,
+        ];
+        if (tip) {
+            detailLines.push(`  Suggested fix: ${tip}`);
+        }
+        detailLines.push(`  Platform: ${platformInfo}`);
+        const detailedError = new Error(detailLines.join('\n'));
+        // Preserve the original error as cause so callers can still inspect it
+        detailedError.cause = err;
+        throw detailedError;
+    }
+}
+/**
+ * Map common Node network error codes to user-actionable diagnostic hints.
+ * Returns null if the code isn't one we recognize.
+ */
+function getDiagnosticTip(errorCode) {
+    if (!errorCode)
+        return null;
+    switch (errorCode) {
+        case 'ENOTFOUND':
+        case 'EAI_AGAIN':
+            return 'DNS resolution failed. On WSL Ubuntu, check /etc/resolv.conf, or try running with NODE_OPTIONS="--dns-result-order=ipv4first".';
+        case 'ETIMEDOUT':
+        case 'ECONNREFUSED':
+        case 'ECONNRESET':
+        case 'EHOSTUNREACH':
+        case 'ENETUNREACH':
+            return 'Network unreachable. On WSL Ubuntu, try NODE_OPTIONS="--dns-result-order=ipv4first" (WSL\'s IPv6 is often broken). If behind a corporate proxy, set HTTPS_PROXY.';
+        case 'CERT_HAS_EXPIRED':
+        case 'CERT_NOT_YET_VALID':
+            return 'TLS certificate time error — likely system clock drift. On WSL, run `sudo hwclock -s`, or shut down WSL from PowerShell with `wsl --shutdown` and restart.';
+        case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY':
+        case 'SELF_SIGNED_CERT_IN_CHAIN':
+        case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE':
+        case 'DEPTH_ZERO_SELF_SIGNED_CERT':
+            return 'Corporate HTTPS proxy detected — the TLS cert is not trusted by Node. Set NODE_EXTRA_CA_CERTS=/path/to/corporate-ca.pem, or configure HTTPS_PROXY if a proxy is required.';
+        default:
+            return null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fetch-helpers.js","sourceRoot":"","sources":["../../src/auth/fetch-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["//\n// fetch-helpers.ts\n// CodeVibe Core\n//\n// Wrapper around Node's built-in fetch() that surfaces the underlying cause\n// of \"fetch failed\" errors with platform-specific diagnostic tips.\n//\n// Background: Node 18+'s built-in fetch (via undici) throws a generic\n// TypeError with message \"fetch failed\" for all network-level errors (DNS\n// failures, timeouts, TLS issues, etc.). The real cause is buried in the\n// error's .cause property. This wrapper unpacks that cause and returns a\n// detailed, actionable error message — critical for WSL users where fetch\n// failures are common and usually fixable with known workarounds.\n//\n\nimport * as dns from 'dns';\nimport * as fs from 'fs';\n\n// Node 17+ changed the default DNS result order from 'ipv4first' to\n// 'verbatim' (RFC-compliant but problematic for hosts with broken IPv6).\n// On WSL Ubuntu specifically, the kernel often advertises IPv6 addresses\n// via getaddrinfo even though the WSL network namespace has no route to\n// the IPv6 internet — causing every IPv6 connection attempt to fail with\n// EHOSTUNREACH. curl handles this via Happy Eyeballs fallback, but undici\n// (Node's built-in fetch) does not, and throws \"fetch failed\" without\n// ever trying IPv4.\n//\n// We apply 'ipv4first' ONLY when running inside WSL. On macOS, native\n// Linux, and Windows we leave Node's default ('verbatim') alone — those\n// platforms have healthy dual-stack networking and the current behavior\n// is correct. Narrowly scoping the override to WSL means zero behavioral\n// change for non-WSL users (including IPv6-only networks where ipv4first\n// would add first-connection latency).\n//\n// This runs as a side effect of importing codevibe-core's fetch-helpers,\n// which happens early in every plugin's startup path. Documented here\n// so future maintainers understand why there's a side effect on import.\nif (isRunningInWSL()) {\n  try {\n    dns.setDefaultResultOrder('ipv4first');\n  } catch {\n    // Older Node versions (< 18.6) don't expose setDefaultResultOrder;\n    // skip silently. Users on those versions can still set the\n    // NODE_OPTIONS=\"--dns-result-order=ipv4first\" environment variable\n    // manually if they hit IPv6 issues.\n  }\n}\n\n/**\n * Detect whether we're running inside WSL (1 or 2). Returns false on any\n * non-Linux platform or if /proc/sys/kernel/osrelease is not readable.\n * Duplicated from auth-service.ts as a module-level helper so it can run\n * at import time, before any class is instantiated.\n */\nfunction isRunningInWSL(): boolean {\n  if (process.platform !== 'linux') return false;\n  try {\n    const osRelease = fs.readFileSync('/proc/sys/kernel/osrelease', 'utf8');\n    return /microsoft|wsl/i.test(osRelease);\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Wraps fetch() and rewrites \"fetch failed\" errors to include the underlying\n * cause and a user-actionable diagnostic tip when possible. Non-network errors\n * and HTTP error responses (non-2xx) are not affected — the caller still\n * handles response.ok checks themselves.\n *\n * @param url The URL to fetch\n * @param init Standard fetch init options\n * @param context Optional short label (e.g. \"token exchange\") for the error message\n */\nexport async function fetchWithDiagnostics(\n  url: string,\n  init?: any,\n  context?: string\n): Promise<Response> {\n  try {\n    return await fetch(url, init);\n  } catch (err: any) {\n    // Node's undici wraps real errors in err.cause\n    const causeCode: string | undefined = err?.cause?.code;\n    const causeMessage: string | undefined = err?.cause?.message;\n    const causeSummary = causeCode || causeMessage || err?.message || 'unknown';\n\n    const tip = getDiagnosticTip(causeCode);\n    const contextLabel = context ? `${context}: ` : '';\n    const platformInfo = `Node ${process.version} on ${process.platform}`;\n\n    const detailLines: string[] = [\n      `${contextLabel}Cannot reach ${url}`,\n      `  Underlying error: ${causeSummary}`,\n    ];\n    if (tip) {\n      detailLines.push(`  Suggested fix: ${tip}`);\n    }\n    detailLines.push(`  Platform: ${platformInfo}`);\n\n    const detailedError = new Error(detailLines.join('\\n'));\n    // Preserve the original error as cause so callers can still inspect it\n    (detailedError as any).cause = err;\n    throw detailedError;\n  }\n}\n\n/**\n * Map common Node network error codes to user-actionable diagnostic hints.\n * Returns null if the code isn't one we recognize.\n */\nfunction getDiagnosticTip(errorCode?: string): string | null {\n  if (!errorCode) return null;\n\n  switch (errorCode) {\n    case 'ENOTFOUND':\n    case 'EAI_AGAIN':\n      return 'DNS resolution failed. On WSL Ubuntu, check /etc/resolv.conf, or try running with NODE_OPTIONS=\"--dns-result-order=ipv4first\".';\n\n    case 'ETIMEDOUT':\n    case 'ECONNREFUSED':\n    case 'ECONNRESET':\n    case 'EHOSTUNREACH':\n    case 'ENETUNREACH':\n      return 'Network unreachable. On WSL Ubuntu, try NODE_OPTIONS=\"--dns-result-order=ipv4first\" (WSL\\'s IPv6 is often broken). If behind a corporate proxy, set HTTPS_PROXY.';\n\n    case 'CERT_HAS_EXPIRED':\n    case 'CERT_NOT_YET_VALID':\n      return 'TLS certificate time error — likely system clock drift. On WSL, run `sudo hwclock -s`, or shut down WSL from PowerShell with `wsl --shutdown` and restart.';\n\n    case 'UNABLE_TO_GET_ISSUER_CERT_LOCALLY':\n    case 'SELF_SIGNED_CERT_IN_CHAIN':\n    case 'UNABLE_TO_VERIFY_LEAF_SIGNATURE':\n    case 'DEPTH_ZERO_SELF_SIGNED_CERT':\n      return 'Corporate HTTPS proxy detected — the TLS cert is not trusted by Node. Set NODE_EXTRA_CA_CERTS=/path/to/corporate-ca.pem, or configure HTTPS_PROXY if a proxy is required.';\n\n    default:\n      return null;\n  }\n}\n"]}

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quantiya/codevibe-claude-plugin",
-  "version": "1.0.8",
-  "description": "Mobile companion for Claude Code - monitor and control your Claude Code sessions from your iPhone with CodeVibe",
+  "version": "1.0.10",
+  "description": "Mobile companion for Claude Code - monitor and control your Claude Code sessions from your phone with CodeVibe",
   "main": "dist/server.js",
   "bin": {
     "codevibe-claude": "./bin/codevibe-claude"
@@ -22,7 +22,7 @@
     "dev": "ts-node src/server.ts",
     "start": "node dist/server.js",
     "watch": "tsc --watch",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --config jest.config.js --forceExit"
   },
   "repository": {
     "type": "git",
@@ -53,7 +53,7 @@
     "darwin"
   ],
   "dependencies": {
-    "@quantiya/codevibe-core": "^1.0.2",
+    "@quantiya/codevibe-core": "^1.0.3",
     "dotenv": "^16.6.1",
     "express": "^5.1.0",
     "graphql": "^16.12.0",
@@ -70,9 +70,12 @@
   ],
   "devDependencies": {
     "@types/express": "^5.0.5",
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.10.1",
     "@types/uuid": "^10.0.0",
     "@types/ws": "^8.18.1",
+    "jest": "^30.3.0",
+    "ts-jest": "^29.4.9",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },