@nlabs/lex 1.52.18 → 1.52.22

package/.github/copilot-instructions.md

@@ -0,0 +1,194 @@
+# Lex: AI Coding Agent Instructions
+
+## Project Overview
+Lex is a zero-configuration React development CLI that provides a complete development environment with AI-powered features. It uses SWC for lightning-fast compilation and includes Jest testing, Storybook integration, and intelligent code assistance.
+
+## Architecture & Key Components
+
+### Core Structure
+- **Source**: `src/` - TypeScript source code
+- **Compiled**: `lib/` - SWC-compiled JavaScript output
+- **Commands**: `src/commands/` - Individual command modules (build, dev, test, ai, etc.)
+- **Utils**: `src/utils/` - Shared utilities (file operations, logging, AI services)
+- **Config**: `LexConfig.ts` - Configuration management and defaults
+
+### Build System
+- **Compiler**: SWC (10-100x faster than Babel)
+- **Bundler**: Webpack (configurable, defaults to SWC for speed)
+- **Testing**: Jest with jsdom environment
+- **Linting**: ESLint with AI-powered auto-fixes
+
+## Critical Workflows
+
+### Development Server
+```bash
+lex dev --open  # Start hot-reloading dev server
+lex dev --bundleAnalyzer  # Analyze bundle size
+```
+
+### Building & Compilation
+```bash
+lex build --mode production  # Production build
+lex compile --watch  # Watch mode compilation
+```
+
+### Testing
+```bash
+lex test --watch  # Run tests in watch mode
+lex test --generate  # AI-generated test cases
+lex test --analyze  # AI test coverage analysis
+```
+
+### AI Features
+```bash
+lex ai --task generate --prompt "Create a React component"
+lex ai --task explain --file src/components/Button.tsx
+lex lint --fix  # AI-powered ESLint fixes
+```
+
+## Configuration Patterns
+
+### lex.config.js Structure
+```javascript
+export default {
+  ai: {
+    provider: 'openai', // 'openai' | 'anthropic' | 'cursor' | 'none'
+    apiKey: process.env.OPENAI_API_KEY,
+    model: 'gpt-4o',
+    maxTokens: 4000
+  },
+  useTypescript: true,
+  preset: 'web', // 'web' | 'node' | 'lambda'
+  sourcePath: './src',
+  outputPath: './lib'
+}
+```
+
+### Command Implementation Pattern
+```typescript
+// src/commands/example/example.ts
+import {Command} from 'commander';
+import {LexConfig} from '../../LexConfig.js';
+
+export const example = new Command('example')
+  .option('--option <value>', 'Description')
+  .action(async (options) => {
+    const config = LexConfig.config || {};
+    // Implementation
+  });
+```
+
+## Code Conventions
+
+### File Organization
+- Commands: One file per command in `src/commands/[name]/`
+- Utils: Shared functions in `src/utils/`
+- Types: Centralized in `src/types.ts`
+- Config: All configuration logic in `LexConfig.ts`
+
+### Error Handling
+```typescript
+try {
+  // Operation
+} catch (error) {
+  log(`${chalk.red('Error:')} ${error.message}`, 'error');
+  return {error: error.message};
+}
+```
+
+### Logging
+```typescript
+import {log} from '../utils/log.js';
+log('Success message', 'success');
+log('Info message', 'info');
+log('Warning message', 'warning');
+log('Error message', 'error');
+```
+
+### AI Integration
+- Use `callAIService()` from `utils/aiService.ts`
+- Support multiple providers (OpenAI, Anthropic, Cursor)
+- Include project context when relevant
+- Handle provider-specific authentication
+
+## Testing Patterns
+
+### Unit Tests
+```typescript
+// Use Jest with jsdom for DOM testing
+import {render, screen} from '@testing-library/react';
+import {Button} from './Button.js';
+
+describe('Button', () => {
+  it('renders correctly', () => {
+    render(<Button>Click me</Button>);
+    expect(screen.getByText('Click me')).toBeInTheDocument();
+  });
+});
+```
+
+### CLI Command Testing
+```typescript
+// Mock commander and test command actions
+import {example} from './example.js';
+
+describe('example command', () => {
+  it('handles options correctly', async () => {
+    // Test implementation
+  });
+});
+```
+
+## Key Files to Reference
+
+- [`src/lex.ts`](src/lex.ts) - Main CLI entry point and command registration
+- [`src/LexConfig.ts`](src/LexConfig.ts) - Configuration management
+- [`src/commands/ai/ai.ts`](src/commands/ai/ai.ts) - AI command implementation
+- [`src/utils/aiService.ts`](src/utils/aiService.ts) - AI service integrations
+- [`package.json`](package.json) - Dependencies and scripts
+- [`README.md`](README.md) - User documentation
+
+## Common Patterns
+
+### Async Command Handlers
+```typescript
+.action(async (options) => {
+  try {
+    await someAsyncOperation(options);
+    process.exit(0);
+  } catch (error) {
+    log(`Error: ${error.message}`, 'error');
+    process.exit(1);
+  }
+})
+```
+
+### Configuration Merging
+```typescript
+import {deepMerge} from '../utils/deepMerge.js';
+const finalConfig = deepMerge(defaultConfig, userConfig);
+```
+
+### File Operations
+```typescript
+import {readFile, writeFile} from '../utils/file.js';
+// Use utility functions instead of fs directly
+```
+
+## AI-Specific Guidelines
+
+- Always check for AI provider configuration before making API calls
+- Include relevant file/directory context in prompts
+- Handle rate limits and API errors gracefully
+- Support both streaming and non-streaming responses
+- Use temperature 0.1 for code generation tasks
+
+## Development Tips
+
+- Use `npm run build` to compile TypeScript to JavaScript
+- Use `npm run lint` to check code quality
+- Use `npm run test` for unit tests
+- Commands should be stateless and configurable
+- Prefer functional programming patterns
+- Document complex logic with comments
+- Follow existing naming conventions (camelCase for variables, PascalCase for types)

package/lib/commands/serverless/serverless.js

@@ -636,7 +636,7 @@ const loadEnvFile = (envPath)=>{
     return envVars;
 };
 export const serverless = async (cmd, callback = ()=>({}))=>{
-    const { cliName = 'Lex', config, debug = false, host = 'localhost', httpPort = 5000, httpsPort = 5001, quiet = false, remove = false, test = false, usePublicIp, variables, wsPort = 5002 } = cmd;
+    const { cliName = 'Lex', config, debug = false, host: cliHost, httpPort: cliHttpPort, httpsPort: cliHttpsPort, quiet = false, remove = false, test = false, usePublicIp, variables, wsPort: cliWsPort } = cmd;
     const spinner = createSpinner(quiet);
     log(`${cliName} starting serverless development server...`, 'info', quiet);
     await LexConfig.parseConfig(cmd);
@@ -736,15 +736,28 @@ export const serverless = async (cmd, callback = ()=>({}))=>{
     // Don't exit, continue with empty config
     }
     // Merge config with command line options
+    // Determine effective host/ports with correct precedence: CLI > config > defaults
+    const configOffline = serverlessConfig.custom?.['serverless-offline'] || {};
+    const effectiveHost = cliHost ?? configOffline.host ?? 'localhost';
+    const toNumber = (v, fallback)=>{
+        if (v === undefined || v === null || v === '') {
+            return fallback;
+        }
+        const n = typeof v === 'number' ? v : parseInt(String(v));
+        return Number.isFinite(n) ? n : fallback;
+    };
+    const effectiveHttpPort = toNumber(cliHttpPort ?? configOffline.httpPort, 5000);
+    const effectiveHttpsPort = toNumber(cliHttpsPort ?? configOffline.httpsPort, 5001);
+    const effectiveWsPort = toNumber(cliWsPort ?? configOffline.wsPort, 5002);
     const finalConfig = {
         ...serverlessConfig,
         custom: {
             'serverless-offline': {
                 cors: serverlessConfig.custom?.['serverless-offline']?.cors !== false,
-                host: serverlessConfig.custom?.['serverless-offline']?.host || host,
-                httpPort: serverlessConfig.custom?.['serverless-offline']?.httpPort || httpPort,
-                httpsPort: serverlessConfig.custom?.['serverless-offline']?.httpsPort || httpsPort,
-                wsPort: serverlessConfig.custom?.['serverless-offline']?.wsPort || wsPort
+                host: effectiveHost,
+                httpPort: effectiveHttpPort,
+                httpsPort: effectiveHttpsPort,
+                wsPort: effectiveWsPort
             }
         }
     };
@@ -807,4 +820,4 @@ export const serverless = async (cmd, callback = ()=>({}))=>{
     }
 };
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/serverless/serverless.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport boxen from 'boxen';\nimport chalk from 'chalk';\nimport express from 'express';\nimport {readFileSync, existsSync, mkdirSync, writeFileSync} from 'fs';\nimport {homedir} from 'os';\nimport {resolve as pathResolve, join, isAbsolute} from 'path';\nimport {pathToFileURL} from 'url';\nimport {WebSocketServer} from 'ws';\n\nimport {LexConfig, getPackageDir} from '../../LexConfig.js';\nimport {createSpinner, removeFiles} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface ServerlessOptions {\n  readonly cliName?: string;\n  readonly config?: string;\n  readonly debug?: boolean;\n  readonly host?: string;\n  readonly httpPort?: number;\n  readonly httpsPort?: number;\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly test?: boolean;\n  readonly usePublicIp?: boolean;\n  readonly variables?: string;\n  readonly wsPort?: number;\n}\n\nexport type ServerlessCallback = (status: number)=> void;\n\ninterface PublicIpCache {\n  ip: string;\n  timestamp: number;\n}\n\ninterface ServerlessHandler {\n  readonly handler: string;\n  readonly events?: Array<{\n    readonly http?: {\n      readonly cors?: boolean;\n      readonly method?: string;\n      readonly path?: string;\n    };\n    readonly websocket?: {\n      readonly route?: string;\n    };\n  }>;\n}\n\ninterface ServerlessConfig {\n  readonly custom?: {\n    readonly 'serverless-offline'?: {\n      readonly cors?: boolean;\n      readonly host?: string;\n      readonly httpPort?: number;\n      readonly httpsPort?: number;\n      readonly wsPort?: number;\n    };\n  };\n  readonly functions?: Record<string, ServerlessHandler>;\n}\n\nconst getCacheDir = (): string => {\n  const cacheDir = join(homedir(), '.lex-cache');\n  if(!existsSync(cacheDir)) {\n    mkdirSync(cacheDir, {recursive: true});\n  }\n  return cacheDir;\n};\n\nconst getCachePath = (): string => join(getCacheDir(), 'public-ip.json');\n\nconst readPublicIpCache = (): PublicIpCache | null => {\n  const cachePath = getCachePath();\n  if(!existsSync(cachePath)) {\n    return null;\n  }\n\n  try {\n    const cacheData = readFileSync(cachePath, 'utf8');\n    const cache: PublicIpCache = JSON.parse(cacheData);\n\n    // Check if cache is older than 1 week\n    const oneWeekMs = 7 * 24 * 60 * 60 * 1000;\n    if(Date.now() - cache.timestamp > oneWeekMs) {\n      return null;\n    }\n\n    return cache;\n  } catch{\n    return null;\n  }\n};\n\nconst writePublicIpCache = (ip: string): void => {\n  const cachePath = getCachePath();\n  const cache: PublicIpCache = {\n    ip,\n    timestamp: Date.now()\n  };\n  writeFileSync(cachePath, JSON.stringify(cache, null, 2));\n};\n\nconst fetchPublicIp = (forceRefresh: boolean = false): Promise<string | undefined> => new Promise((resolve) => {\n  if(!forceRefresh) {\n    const cached = readPublicIpCache();\n    if(cached) {\n      resolve(cached.ip);\n      return;\n    }\n  }\n\n  // Use fetch instead of https\n  fetch('https://api.ipify.org')\n    .then((res) => res.text())\n    .then((data) => {\n      const ip = data.trim();\n      if(ip) {\n        writePublicIpCache(ip);\n      }\n      resolve(ip);\n    })\n    .catch(() => resolve(undefined));\n});\n\nconst displayServerStatus = (\n  httpPort: number,\n  httpsPort: number,\n  wsPort: number,\n  host: string,\n  quiet: boolean,\n  publicIp?: string\n) => {\n  if(quiet) {\n    return;\n  }\n\n  const httpUrl = `http://${host}:${httpPort}`;\n  const httpsUrl = `https://${host}:${httpsPort}`;\n  const wsUrl = `ws://${host}:${wsPort}`;\n  const wssUrl = `wss://${host}:${wsPort}`;\n\n  let urlLines = `${chalk.green('HTTP:')}      ${chalk.underline(httpUrl)}\\n`;\n  urlLines += `${chalk.green('HTTPS:')}     ${chalk.underline(httpsUrl)}\\n`;\n  urlLines += `${chalk.green('WebSocket:')} ${chalk.underline(wsUrl)}\\n`;\n  urlLines += `${chalk.green('WSS:')}       ${chalk.underline(wssUrl)}\\n`;\n\n  if(publicIp) {\n    urlLines += `\\n${chalk.green('Public:')}    ${chalk.underline(`http://${publicIp}:${httpPort}`)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('🚀 Serverless Development Server Running')}\\n\\n${urlLines}\\n` +\n    `${chalk.yellow('Press Ctrl+C to stop the server')}`,\n    {\n      backgroundColor: '#1a1a1a',\n      borderColor: 'cyan',\n      borderStyle: 'round',\n      margin: 1,\n      padding: 1\n    }\n  );\n\n  console.log(`\\n${statusBox}\\n`);\n};\n\nconst loadHandler = async (handlerPath: string, outputDir: string) => {\n  try {\n    console.log(`[Serverless] Parsing handler path: ${handlerPath}`);\n\n    // Parse AWS Lambda handler format: \"path/to/file.exportName\" or \"file.exportName\"\n    // Examples: \"index.handler\", \"handlers/api.handler\", \"src/index.default\"\n    const handlerParts = handlerPath.split('.');\n    console.log('[Serverless] Handler parts after split:', handlerParts);\n\n    let filePath: string;\n    let exportName: string | null = null;\n\n    if(handlerParts.length > 1) {\n      // AWS Lambda format: \"file.exportName\"\n      // Take the last part as export name, rest as file path\n      // Handle cases like \"index.handler\" -> file: \"index\", export: \"handler\"\n      // Or \"handlers/api.handler\" -> file: \"handlers/api\", export: \"handler\"\n      exportName = handlerParts[handlerParts.length - 1] || null;\n      filePath = handlerParts.slice(0, -1).join('.');\n      console.log(`[Serverless] Parsed AWS Lambda format - filePath: \"${filePath}\", exportName: \"${exportName}\"`);\n    } else {\n      // Simple format: just the file path\n      filePath = handlerPath;\n      console.log(`[Serverless] Simple format - filePath: \"${filePath}\"`);\n    }\n\n    // Ensure filePath doesn't have the export name in it\n    if(filePath.includes('.handler') || filePath.includes('.default')) {\n      console.error(`[Serverless] WARNING: filePath still contains export name! filePath: \"${filePath}\"`);\n      // Try to fix it - remove the last part if it looks like an export name\n      const pathParts = filePath.split('.');\n      if(pathParts.length > 1) {\n        const lastPart = pathParts[pathParts.length - 1];\n        if(['handler', 'default', 'index'].includes(lastPart) && !exportName) {\n          exportName = lastPart;\n          filePath = pathParts.slice(0, -1).join('.');\n          console.log(`[Serverless] Fixed - filePath: \"${filePath}\", exportName: \"${exportName}\"`);\n        }\n      }\n    }\n\n    // Handle both relative paths and absolute paths\n    let fullPath: string;\n    if(isAbsolute(filePath)) {\n      fullPath = filePath;\n    } else {\n      fullPath = pathResolve(outputDir, filePath);\n    }\n    console.log(`[Serverless] Resolved fullPath (before extensions): ${fullPath}`);\n\n    // Try different extensions if file doesn't exist\n    if(!existsSync(fullPath)) {\n      const extensions = ['.js', '.mjs', '.cjs'];\n      const pathWithoutExt = fullPath.replace(/\\.(js|mjs|cjs)$/, '');\n      console.log(`[Serverless] Trying extensions. Base path: ${pathWithoutExt}`);\n      for(const ext of extensions) {\n        const candidatePath = pathWithoutExt + ext;\n        console.log(`[Serverless] Checking: ${candidatePath} (exists: ${existsSync(candidatePath)})`);\n        if(existsSync(candidatePath)) {\n          fullPath = candidatePath;\n          console.log(`[Serverless] Found file with extension: ${fullPath}`);\n          break;\n        }\n      }\n    } else {\n      console.log(`[Serverless] File exists without trying extensions: ${fullPath}`);\n    }\n\n    console.log(`[Serverless] Final fullPath: ${fullPath}`);\n    console.log(`[Serverless] Export name: ${exportName || 'default/handler'}`);\n    console.log(`[Serverless] File exists: ${existsSync(fullPath)}`);\n\n    if(!existsSync(fullPath)) {\n      console.error(`[Serverless] Handler file not found: ${fullPath}`);\n      console.error(`[Serverless] Output directory: ${outputDir}`);\n      console.error(`[Serverless] Handler path from config: ${handlerPath}`);\n      throw new Error(`Handler file not found: ${fullPath}`);\n    }\n\n    // Dynamic import of the handler with better error handling\n    // Add .js extension if importing TypeScript compiled output\n    const importPath = fullPath.endsWith('.ts') ? fullPath.replace(/\\.ts$/, '.js') : fullPath;\n\n    try {\n      // Convert to file:// URL for ES module imports (required for absolute paths)\n      // Use pathToFileURL to ensure proper file:// URL format\n      const importUrl = pathToFileURL(importPath).href;\n      console.log(`[Serverless] Importing handler from: ${importUrl}`);\n      console.log(`[Serverless] File path: ${importPath}`);\n\n      // Use import() with the file URL\n      // Note: If the handler file has import errors (like missing dependencies),\n      // those will surface here, but that's a handler code issue, not a loader issue\n      const handlerModule = await import(importUrl);\n      console.log(`[Serverless] Handler module loaded successfully. Exports: ${Object.keys(handlerModule).join(', ')}`);\n\n      // Get the handler based on export name or try defaults\n      let handler: any;\n      if(exportName) {\n        handler = handlerModule[exportName];\n        if(!handler) {\n          console.error(`[Serverless] Export \"${exportName}\" not found in module. Available exports: ${Object.keys(handlerModule).join(', ')}`);\n          return null;\n        }\n      } else {\n        // Try default, handler, or the module itself\n        handler = handlerModule.default || handlerModule.handler || handlerModule;\n      }\n\n      console.log(`[Serverless] Handler found: ${typeof handler}, isFunction: ${typeof handler === 'function'}`);\n\n      if(typeof handler !== 'function') {\n        console.error(`[Serverless] Handler is not a function. Type: ${typeof handler}, Value:`, handler);\n        return null;\n      }\n\n      return handler;\n    } catch(importError: any) {\n      console.error(`[Serverless] Import error for handler ${handlerPath}:`, importError.message);\n      console.error('[Serverless] Import error stack:', importError.stack);\n\n      // Check if this is a dependency resolution error (common with ES modules)\n      if(importError.message && importError.message.includes('Cannot find module')) {\n        console.error('[Serverless] This appears to be a dependency resolution error.');\n        console.error('[Serverless] The handler file exists, but one of its imports is failing.');\n        console.error('[Serverless] Check that all dependencies in the handler file are properly installed.');\n        console.error(`[Serverless] Handler file: ${importPath}`);\n        console.error('[Serverless] Make sure the handler and its dependencies are compiled correctly.');\n      }\n\n      return null;\n    }\n  } catch(error: any) {\n    console.error(`[Serverless] Error loading handler ${handlerPath}:`, error.message);\n    console.error('[Serverless] Error stack:', error.stack);\n    return null;\n  }\n};\n\nconst captureConsoleLogs = (handler: (event: any, context: any)=> Promise<any>, quiet: boolean) => {\n  if(quiet) {\n    return handler;\n  }\n\n  return async (event: any, context: any) => {\n    // Capture console.log, console.error, etc.\n    const originalConsoleLog = console.log;\n    const originalConsoleError = console.error;\n    const originalConsoleWarn = console.warn;\n    const originalConsoleInfo = console.info;\n\n    const logs: string[] = [];\n\n    console.log = (...args: any[]) => {\n      logs.push(`[LOG] ${args.join(' ')}`);\n      originalConsoleLog(...args);\n    };\n\n    console.error = (...args: any[]) => {\n      logs.push(`[ERROR] ${args.join(' ')}`);\n      originalConsoleError(...args);\n    };\n\n    console.warn = (...args: any[]) => {\n      logs.push(`[WARN] ${args.join(' ')}`);\n      originalConsoleWarn(...args);\n    };\n\n    console.info = (...args: any[]) => {\n      logs.push(`[INFO] ${args.join(' ')}`);\n      originalConsoleInfo(...args);\n    };\n\n    try {\n      const result = await handler(event, context);\n\n      // Output captured logs\n      if(logs.length > 0) {\n        console.log(chalk.gray('--- Handler Console Output ---'));\n        logs.forEach((log) => console.log(chalk.gray(log)));\n        console.log(chalk.gray('--- End Handler Console Output ---'));\n      }\n\n      return result;\n    } finally {\n      // Restore original console methods\n      console.log = originalConsoleLog;\n      console.error = originalConsoleError;\n      console.warn = originalConsoleWarn;\n      console.info = originalConsoleInfo;\n    }\n  };\n};\n\nconst createExpressServer = async (\n  config: ServerlessConfig,\n  outputDir: string,\n  httpPort: number,\n  host: string,\n  quiet: boolean,\n  debug: boolean\n) => {\n  const app = express();\n\n  // Enable CORS\n  app.use((req, res, next) => {\n    res.header('Access-Control-Allow-Origin', '*');\n    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');\n    res.header('Access-Control-Allow-Headers', '*');\n    res.header('Access-Control-Allow-Credentials', 'true');\n\n    if(req.method === 'OPTIONS') {\n      res.sendStatus(200);\n    } else {\n      next();\n    }\n  });\n\n  // Parse JSON bodies\n  app.use(express.json());\n\n  // Load GraphQL handler\n  const loadGraphQLSchema = async () => {\n    try {\n      // Try to find a GraphQL handler\n      let graphqlHandler = null;\n\n      if(config.functions) {\n        for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event.http && event.http.path) {\n                // Look for GraphQL endpoints\n                if(event.http.path === '/public' || event.http.path === '/graphql') {\n                  graphqlHandler = await loadHandler(functionConfig.handler, outputDir);\n                  break;\n                }\n              }\n            }\n          }\n          if(graphqlHandler) {\n            break;\n          }\n        }\n      }\n\n      if(graphqlHandler) {\n        log('Found GraphQL handler', 'info', quiet);\n        return graphqlHandler;\n      }\n      return null;\n    } catch(error) {\n      log(`Error loading GraphQL handler: ${error.message}`, 'error', quiet);\n      return null;\n    }\n  };\n\n  // Set up GraphQL handler for GraphQL requests\n  try {\n    const graphqlHandler = await loadGraphQLSchema();\n    if(graphqlHandler) {\n      // Find the GraphQL path from the serverless config\n      let graphqlPath = '/graphql'; // default fallback\n\n      if(config.functions) {\n        for(const [_functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event?.http?.path) {\n                graphqlPath = event.http.path;\n                break;\n              }\n            }\n          }\n          if(graphqlPath !== '/graphql') {\n            break;\n          }\n        }\n      }\n\n      // Set up GraphQL endpoint with enhanced console.log capture\n      app.use(graphqlPath, async (req, res) => {\n        // GraphQL Debug Logging\n        if(debug && req.body && req.body.query) {\n          log('🔍 GraphQL Debug Mode: Analyzing request...', 'info', false);\n          log(`📝 GraphQL Query: ${req.body.query}`, 'info', false);\n          if(req.body.variables) {\n            log(`📊 GraphQL Variables: ${JSON.stringify(req.body.variables, null, 2)}`, 'info', false);\n          }\n          if(req.body.operationName) {\n            log(`🏷️  GraphQL Operation: ${req.body.operationName}`, 'info', false);\n          }\n        }\n\n        // Enhanced console.log capture\n        const originalConsoleLog = console.log;\n        const logs: string[] = [];\n\n        console.log = (...args) => {\n          const logMessage = args.map((arg) =>\n            (typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg))\n          ).join(' ');\n          logs.push(logMessage);\n          originalConsoleLog(`[GraphQL] ${logMessage}`);\n        };\n\n        // Create context for the handler\n        const context = {\n          awsRequestId: 'test-request-id',\n          functionName: 'graphql',\n          functionVersion: '$LATEST',\n          getRemainingTimeInMillis: () => 30000,\n          invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:graphql',\n          logGroupName: '/aws/lambda/graphql',\n          logStreamName: 'test-log-stream',\n          req,\n          res\n        };\n\n        // Wrap handler with console log capture\n        const wrappedHandler = captureConsoleLogs(graphqlHandler, quiet);\n\n        try {\n          // Call the handler with GraphQL parameters\n          const result = await wrappedHandler({\n            body: JSON.stringify(req.body),\n            headers: req.headers,\n            httpMethod: 'POST',\n            path: graphqlPath,\n            queryStringParameters: {}\n          }, context);\n\n          // Restore console.log\n          console.log = originalConsoleLog;\n\n          // Handle the result\n          if(result && typeof result === 'object' && result.statusCode) {\n            res.status(result.statusCode);\n            if(result.headers) {\n              Object.entries(result.headers).forEach(([key, value]) => {\n                res.setHeader(key, String(value));\n              });\n            }\n            res.send(result.body);\n          } else {\n            res.json(result);\n          }\n        } catch(error) {\n          // Restore console.log\n          console.log = originalConsoleLog;\n          log(`GraphQL handler error: ${error.message}`, 'error', false);\n          res.status(500).json({error: error.message});\n        }\n      });\n\n      log(`GraphQL endpoint available at http://${host}:${httpPort}${graphqlPath}`, 'info', quiet);\n    }\n  } catch(error) {\n    log(`Error setting up GraphQL: ${error.message}`, 'error', quiet);\n  }\n\n  // Fallback for non-GraphQL routes - handle all remaining routes\n  app.use('/', async (req, res) => {\n    try {\n      const url = req.url || '/';\n      const method = req.method || 'GET';\n      const pathname = req.path || url.split('?')[0]; // Extract pathname without query string\n\n      // Always log requests (not affected by quiet flag for debugging)\n      console.log(`[Serverless] ${method} ${url} (pathname: ${pathname})`);\n\n      // Find matching function\n      let matchedFunction = null;\n\n      if(config.functions) {\n        const functionNames = Object.keys(config.functions);\n        console.log(`[Serverless] Available functions: ${functionNames.join(', ')}`);\n        console.log('[Serverless] Config functions:', JSON.stringify(config.functions, null, 2));\n\n        for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event.http) {\n                const eventPath = event.http.path || '/';\n                const eventMethod = (event.http.method || 'GET').toUpperCase();\n                const requestMethod = method.toUpperCase();\n\n                console.log(`[Serverless] Checking function ${functionName}: path=\"${eventPath}\", method=\"${eventMethod}\" against pathname=\"${pathname}\", method=\"${requestMethod}\"`);\n\n                // Improved path matching - compare pathname without query string\n                // Normalize paths (remove trailing slashes for comparison)\n                const normalizedEventPath = eventPath.replace(/\\/$/, '') || '/';\n                const normalizedPathname = pathname.replace(/\\/$/, '') || '/';\n\n                if(normalizedEventPath === normalizedPathname && eventMethod === requestMethod) {\n                  matchedFunction = functionName;\n                  console.log(`[Serverless] ✓ Matched function: ${matchedFunction}`);\n                  break;\n                }\n              }\n            }\n          }\n          if(matchedFunction) {\n            break;\n          }\n        }\n      } else {\n        console.log('[Serverless] No functions found in config');\n      }\n\n      if(matchedFunction && config.functions[matchedFunction]) {\n        // Resolve handler path relative to output directory\n        const handlerPath = config.functions[matchedFunction].handler;\n        console.log(`[Serverless] Loading handler: ${handlerPath} from outputDir: ${outputDir}`);\n        const handler = await loadHandler(handlerPath, outputDir);\n\n        if(handler) {\n          console.log(`[Serverless] Handler loaded successfully, type: ${typeof handler}`);\n          const wrappedHandler = captureConsoleLogs(handler, quiet);\n\n          const event = {\n            body: req.body,\n            headers: req.headers,\n            httpMethod: method,\n            path: url,\n            queryStringParameters: req.query\n          };\n\n          const context = {\n            awsRequestId: 'test-request-id',\n            functionName: matchedFunction,\n            functionVersion: '$LATEST',\n            getRemainingTimeInMillis: () => 30000,\n            invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,\n            logGroupName: `/aws/lambda/${matchedFunction}`,\n            logStreamName: 'test-log-stream',\n            memoryLimitInMB: '128'\n          };\n\n          try {\n            console.log('[Serverless] Calling handler with event:', JSON.stringify(event, null, 2));\n            const result = await wrappedHandler(event, context);\n            console.log('[Serverless] Handler returned:', JSON.stringify(result, null, 2));\n\n            if(result && typeof result === 'object' && result.statusCode) {\n              res.status(result.statusCode);\n              if(result.headers) {\n                Object.entries(result.headers).forEach(([key, value]) => {\n                  res.setHeader(key, String(value));\n                });\n              }\n              res.send(result.body);\n            } else {\n              res.json(result);\n            }\n          } catch(error: any) {\n            console.error('[Serverless] Handler error:', error.message);\n            console.error('[Serverless] Handler error stack:', error.stack);\n            log(`Handler error: ${error.message}`, 'error', false);\n            res.status(500).json({error: error.message});\n          }\n        } else {\n          console.error(`[Serverless] Handler not found for function: ${matchedFunction}`);\n          console.error(`[Serverless] Handler path: ${handlerPath}, Output dir: ${outputDir}`);\n          res.status(404).json({error: 'Handler not found'});\n        }\n      } else {\n        console.error(`[Serverless] Function not found for pathname: ${pathname}, method: ${method}`);\n        console.error(`[Serverless] Available functions: ${config.functions ? Object.keys(config.functions).join(', ') : 'none'}`);\n        res.status(404).json({error: 'Function not found'});\n      }\n    } catch(error) {\n      log(`Route handling error: ${error.message}`, 'error', false);\n      res.status(500).json({error: error.message});\n    }\n  });\n\n  return app;\n};\n\nconst createWebSocketServer = (\n  config: ServerlessConfig,\n  outputDir: string,\n  wsPort: number,\n  quiet: boolean,\n  debug: boolean\n) => {\n  const wss = new WebSocketServer({port: wsPort});\n\n  wss.on('connection', async (ws, req) => {\n    log(`WebSocket connection established: ${req.url}`, 'info', false);\n\n    ws.on('message', async (message) => {\n      try {\n        const data = JSON.parse(message.toString());\n\n        // Find matching WebSocket function\n        let matchedFunction = null;\n\n        if(config.functions) {\n          for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n            if(functionConfig.events) {\n              for(const event of functionConfig.events) {\n                if(event.websocket) {\n                  const route = event.websocket.route || '$connect';\n                  if(route === '$default' || route === data.action) {\n                    matchedFunction = functionName;\n                    break;\n                  }\n                }\n              }\n            }\n            if(matchedFunction) {\n              break;\n            }\n          }\n        }\n\n        if(matchedFunction && config.functions[matchedFunction]) {\n          const handler = await loadHandler(config.functions[matchedFunction].handler, outputDir);\n\n          if(handler) {\n            // Wrap handler with console log capture\n            const wrappedHandler = captureConsoleLogs(handler, quiet);\n            const event = {\n              body: data.body || null,\n              requestContext: {\n                apiGateway: {\n                  endpoint: `ws://localhost:${wsPort}`\n                },\n                connectionId: 'test-connection-id',\n                routeKey: data.action || '$default'\n              }\n            };\n\n            const context = {\n              awsRequestId: 'test-request-id',\n              functionName: matchedFunction,\n              functionVersion: '$LATEST',\n              getRemainingTimeInMillis: () => 30000,\n              invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,\n              logGroupName: `/aws/lambda/${matchedFunction}`,\n              logStreamName: 'test-log-stream',\n              memoryLimitInMB: '128'\n            };\n\n            const result = await wrappedHandler(event, context);\n\n            // Handle Lambda response format for WebSocket\n            if(result && typeof result === 'object' && result.statusCode) {\n              // This is a Lambda response object, extract the body\n              const body = result.body || '';\n              ws.send(body);\n            } else {\n              // This is a direct response, stringify it\n              ws.send(JSON.stringify(result));\n            }\n          } else {\n            ws.send(JSON.stringify({error: 'Handler not found'}));\n          }\n        } else {\n          ws.send(JSON.stringify({error: 'WebSocket function not found'}));\n        }\n      } catch(error) {\n        log(`WebSocket error: ${error.message}`, 'error', false);\n        ws.send(JSON.stringify({error: error.message}));\n      }\n    });\n\n    ws.on('close', () => {\n      log('WebSocket connection closed', 'info', false);\n    });\n  });\n\n  return wss;\n};\n\nconst loadEnvFile = (envPath: string): Record<string, string> => {\n  const envVars: Record<string, string> = {};\n\n  if(!existsSync(envPath)) {\n    return envVars;\n  }\n\n  try {\n    const envContent = readFileSync(envPath, 'utf8');\n    const lines = envContent.split('\\n');\n\n    for(const line of lines) {\n      const trimmedLine = line.trim();\n\n      // Skip empty lines and comments\n      if(!trimmedLine || trimmedLine.startsWith('#')) {\n        continue;\n      }\n\n      // Parse KEY=value format\n      const equalIndex = trimmedLine.indexOf('=');\n      if(equalIndex > 0) {\n        const key = trimmedLine.substring(0, equalIndex).trim();\n        const value = trimmedLine.substring(equalIndex + 1).trim();\n\n        // Remove quotes if present\n        const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\n\n        if(key) {\n          envVars[key] = cleanValue;\n        }\n      }\n    }\n  } catch(error) {\n    log(`Warning: Could not load .env file at ${envPath}: ${error.message}`, 'warn', false);\n  }\n\n  return envVars;\n};\n\nexport const serverless = async (\n  cmd: ServerlessOptions,\n  callback: ServerlessCallback = () => ({})\n): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    debug = false,\n    host = 'localhost',\n    httpPort = 5000,\n    httpsPort = 5001,\n    quiet = false,\n    remove = false,\n    test = false,\n    usePublicIp,\n    variables,\n    wsPort = 5002\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} starting serverless development server...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath} = LexConfig.config;\n\n  // Load environment variables from .env files\n  const envPaths = [\n    pathResolve(process.cwd(), '.env'),\n    pathResolve(process.cwd(), '.env.local'),\n    pathResolve(process.cwd(), '.env.development')\n  ];\n\n  let envVars: Record<string, string> = {};\n\n  // Load from .env files in order (later files override earlier ones)\n  for(const envPath of envPaths) {\n    const fileEnvVars = loadEnvFile(envPath);\n    if(Object.keys(fileEnvVars).length > 0) {\n      log(`Loaded environment variables from: ${envPath}`, 'info', quiet);\n    }\n    envVars = {...envVars, ...fileEnvVars};\n  }\n\n  // Start with default NODE_ENV and loaded .env variables\n  let variablesObj: object = {NODE_ENV: 'development', ...envVars};\n\n  // Override with command line variables if provided\n  if(variables) {\n    try {\n      const cliVars = JSON.parse(variables);\n      variablesObj = {...variablesObj, ...cliVars};\n    } catch(_error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  // If in test mode, exit early after loading environment variables\n  if(test) {\n    log('Test mode: Environment variables loaded, exiting', 'info', quiet);\n    callback(0);\n    return 0;\n  }\n\n  if(remove) {\n    spinner.start('Cleaning output directory...');\n    await removeFiles(outputFullPath || '');\n    spinner.succeed('Successfully cleaned output directory!');\n  }\n\n  // Load serverless configuration\n  let serverlessConfig: ServerlessConfig = {};\n\n  try {\n    // Use getPackageDir to handle npm workspaces correctly\n    const packageDir = getPackageDir();\n\n    // Try multiple config file formats\n    const configFormats = config ? [config] : [\n      pathResolve(packageDir, 'lex.config.mjs'),\n      pathResolve(packageDir, 'lex.config.js'),\n      pathResolve(packageDir, 'lex.config.cjs'),\n      pathResolve(packageDir, 'lex.config.ts')\n    ];\n\n    let configPath: string | null = null;\n    for(const candidatePath of configFormats) {\n      if(existsSync(candidatePath)) {\n        configPath = candidatePath;\n        break;\n      }\n    }\n\n    if(configPath) {\n      log(`Loading serverless config from: ${configPath}`, 'info', quiet);\n      const configModule = await import(configPath);\n      serverlessConfig = configModule.default?.serverless || configModule.serverless || {};\n      log('Serverless config loaded successfully', 'info', quiet);\n      const functionNames = Object.keys(serverlessConfig.functions || {});\n      log(`Loaded functions: ${functionNames.length > 0 ? functionNames.join(', ') : 'none'}`, 'info', quiet);\n\n      // Debug: Print full config if debug mode\n      if(debug) {\n        log(`Full serverless config: ${JSON.stringify(serverlessConfig, null, 2)}`, 'info', false);\n      }\n    } else {\n      log(`No serverless config found. Tried: ${configFormats.join(', ')}`, 'warn', quiet);\n    }\n  } catch(error) {\n    log(`Error loading serverless config: ${error.message}`, 'error', quiet);\n    if(debug) {\n      log(`Config error stack: ${error.stack}`, 'error', false);\n    }\n    // Don't exit, continue with empty config\n  }\n\n  // Merge config with command line options\n  const finalConfig: ServerlessConfig = {\n    ...serverlessConfig,\n    custom: {\n      'serverless-offline': {\n        cors: serverlessConfig.custom?.['serverless-offline']?.cors !== false,\n        host: serverlessConfig.custom?.['serverless-offline']?.host || host,\n        httpPort: serverlessConfig.custom?.['serverless-offline']?.httpPort || httpPort,\n        httpsPort: serverlessConfig.custom?.['serverless-offline']?.httpsPort || httpsPort,\n        wsPort: serverlessConfig.custom?.['serverless-offline']?.wsPort || wsPort\n      }\n    }\n  };\n\n  const outputDir = outputFullPath || 'lib';\n  log(`Using output directory: ${outputDir}`, 'info', quiet);\n\n  try {\n    spinner.start('Starting serverless development server...');\n\n    const httpPort = finalConfig.custom!['serverless-offline']!.httpPort!;\n    const wsPort = finalConfig.custom!['serverless-offline']!.wsPort!;\n    const host = finalConfig.custom!['serverless-offline']!.host!;\n\n    log(`Creating HTTP server on ${host}:${httpPort}`, 'info', quiet);\n    log(`Creating WebSocket server on port ${wsPort}`, 'info', quiet);\n\n    // Create Express server\n    const expressApp = await createExpressServer(\n      finalConfig,\n      outputDir,\n      httpPort,\n      host,\n      quiet,\n      debug\n    );\n\n    // Create WebSocket server\n    const wsServer = createWebSocketServer(\n      finalConfig,\n      outputDir,\n      wsPort,\n      quiet,\n      debug\n    );\n\n    // Handle server errors\n    wsServer.on('error', (error) => {\n      log(`WebSocket server error: ${error.message}`, 'error', quiet);\n      spinner.fail('Failed to start WebSocket server.');\n      callback(1);\n      return;\n    });\n\n    // Start Express server\n    const server = expressApp.listen(httpPort, host, () => {\n      spinner.succeed('Serverless development server started.');\n\n      displayServerStatus(\n        httpPort,\n        finalConfig.custom!['serverless-offline']!.httpsPort!,\n        wsPort,\n        host,\n        quiet\n      );\n\n      fetchPublicIp(usePublicIp).then((publicIp) => {\n        if(publicIp) {\n          displayServerStatus(\n            httpPort,\n            finalConfig.custom!['serverless-offline']!.httpsPort!,\n            wsPort,\n            host,\n            quiet,\n            publicIp\n          );\n        }\n      });\n    });\n\n    // Handle Express server errors\n    server.on('error', (error) => {\n      log(`Express server error: ${error.message}`, 'error', quiet);\n      spinner.fail('Failed to start Express server.');\n      callback(1);\n      return;\n    });\n\n    // Handle graceful shutdown\n    const shutdown = () => {\n      log('\\nShutting down serverless development server...', 'info', quiet);\n      server.close();\n      wsServer.close();\n      callback(0);\n    };\n\n    process.on('SIGINT', shutdown);\n    process.on('SIGTERM', shutdown);\n\n    // Keep the process alive\n    process.stdin.resume();\n\n    log('Serverless development server is running. Press Ctrl+C to stop.', 'info', quiet);\n\n    // Don't call callback here, let the process stay alive\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    spinner.fail('Failed to start serverless development server.');\n    callback(1);\n    return 1;\n  }\n};"],"names":["boxen","chalk","express","readFileSync","existsSync","mkdirSync","writeFileSync","homedir","resolve","pathResolve","join","isAbsolute","pathToFileURL","WebSocketServer","LexConfig","getPackageDir","createSpinner","removeFiles","log","getCacheDir","cacheDir","recursive","getCachePath","readPublicIpCache","cachePath","cacheData","cache","JSON","parse","oneWeekMs","Date","now","timestamp","writePublicIpCache","ip","stringify","fetchPublicIp","forceRefresh","Promise","cached","fetch","then","res","text","data","trim","catch","undefined","displayServerStatus","httpPort","httpsPort","wsPort","host","quiet","publicIp","httpUrl","httpsUrl","wsUrl","wssUrl","urlLines","green","underline","statusBox","cyan","bold","yellow","backgroundColor","borderColor","borderStyle","margin","padding","console","loadHandler","handlerPath","outputDir","handlerParts","split","filePath","exportName","length","slice","includes","error","pathParts","lastPart","fullPath","extensions","pathWithoutExt","replace","ext","candidatePath","Error","importPath","endsWith","importUrl","href","handlerModule","Object","keys","handler","default","importError","message","stack","captureConsoleLogs","event","context","originalConsoleLog","originalConsoleError","originalConsoleWarn","warn","originalConsoleInfo","info","logs","args","push","result","gray","forEach","createExpressServer","config","debug","app","use","req","next","header","method","sendStatus","json","loadGraphQLSchema","graphqlHandler","functions","functionName","functionConfig","entries","events","http","path","graphqlPath","_functionName","body","query","variables","operationName","logMessage","map","arg","String","awsRequestId","functionVersion","getRemainingTimeInMillis","invokedFunctionArn","logGroupName","logStreamName","wrappedHandler","headers","httpMethod","queryStringParameters","statusCode","status","key","value","setHeader","send","url","pathname","matchedFunction","functionNames","eventPath","eventMethod","toUpperCase","requestMethod","normalizedEventPath","normalizedPathname","memoryLimitInMB","createWebSocketServer","wss","port","on","ws","toString","websocket","route","action","requestContext","apiGateway","endpoint","connectionId","routeKey","loadEnvFile","envPath","envVars","envContent","lines","line","trimmedLine","startsWith","equalIndex","indexOf","substring","cleanValue","serverless","cmd","callback","cliName","remove","test","usePublicIp","spinner","parseConfig","outputFullPath","envPaths","process","cwd","fileEnvVars","variablesObj","NODE_ENV","cliVars","_error","env","start","succeed","serverlessConfig","packageDir","configFormats","configPath","configModule","finalConfig","custom","cors","expressApp","wsServer","fail","server","listen","shutdown","close","stdin","resume"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/commands/serverless/serverless.ts"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport boxen from 'boxen';\nimport chalk from 'chalk';\nimport express from 'express';\nimport {readFileSync, existsSync, mkdirSync, writeFileSync} from 'fs';\nimport {homedir} from 'os';\nimport {resolve as pathResolve, join, isAbsolute} from 'path';\nimport {pathToFileURL} from 'url';\nimport {WebSocketServer} from 'ws';\n\nimport {LexConfig, getPackageDir} from '../../LexConfig.js';\nimport {createSpinner, removeFiles} from '../../utils/app.js';\nimport {log} from '../../utils/log.js';\n\nexport interface ServerlessOptions {\n  readonly cliName?: string;\n  readonly config?: string;\n  readonly debug?: boolean;\n  readonly host?: string;\n  readonly httpPort?: number;\n  readonly httpsPort?: number;\n  readonly quiet?: boolean;\n  readonly remove?: boolean;\n  readonly test?: boolean;\n  readonly usePublicIp?: boolean;\n  readonly variables?: string;\n  readonly wsPort?: number;\n}\n\nexport type ServerlessCallback = (status: number)=> void;\n\ninterface PublicIpCache {\n  ip: string;\n  timestamp: number;\n}\n\ninterface ServerlessHandler {\n  readonly handler: string;\n  readonly events?: Array<{\n    readonly http?: {\n      readonly cors?: boolean;\n      readonly method?: string;\n      readonly path?: string;\n    };\n    readonly websocket?: {\n      readonly route?: string;\n    };\n  }>;\n}\n\ninterface ServerlessConfig {\n  readonly custom?: {\n    readonly 'serverless-offline'?: {\n      readonly cors?: boolean;\n      readonly host?: string;\n      readonly httpPort?: number;\n      readonly httpsPort?: number;\n      readonly wsPort?: number;\n    };\n  };\n  readonly functions?: Record<string, ServerlessHandler>;\n}\n\nconst getCacheDir = (): string => {\n  const cacheDir = join(homedir(), '.lex-cache');\n  if(!existsSync(cacheDir)) {\n    mkdirSync(cacheDir, {recursive: true});\n  }\n  return cacheDir;\n};\n\nconst getCachePath = (): string => join(getCacheDir(), 'public-ip.json');\n\nconst readPublicIpCache = (): PublicIpCache | null => {\n  const cachePath = getCachePath();\n  if(!existsSync(cachePath)) {\n    return null;\n  }\n\n  try {\n    const cacheData = readFileSync(cachePath, 'utf8');\n    const cache: PublicIpCache = JSON.parse(cacheData);\n\n    // Check if cache is older than 1 week\n    const oneWeekMs = 7 * 24 * 60 * 60 * 1000;\n    if(Date.now() - cache.timestamp > oneWeekMs) {\n      return null;\n    }\n\n    return cache;\n  } catch{\n    return null;\n  }\n};\n\nconst writePublicIpCache = (ip: string): void => {\n  const cachePath = getCachePath();\n  const cache: PublicIpCache = {\n    ip,\n    timestamp: Date.now()\n  };\n  writeFileSync(cachePath, JSON.stringify(cache, null, 2));\n};\n\nconst fetchPublicIp = (forceRefresh: boolean = false): Promise<string | undefined> => new Promise((resolve) => {\n  if(!forceRefresh) {\n    const cached = readPublicIpCache();\n    if(cached) {\n      resolve(cached.ip);\n      return;\n    }\n  }\n\n  // Use fetch instead of https\n  fetch('https://api.ipify.org')\n    .then((res) => res.text())\n    .then((data) => {\n      const ip = data.trim();\n      if(ip) {\n        writePublicIpCache(ip);\n      }\n      resolve(ip);\n    })\n    .catch(() => resolve(undefined));\n});\n\nconst displayServerStatus = (\n  httpPort: number,\n  httpsPort: number,\n  wsPort: number,\n  host: string,\n  quiet: boolean,\n  publicIp?: string\n) => {\n  if(quiet) {\n    return;\n  }\n\n  const httpUrl = `http://${host}:${httpPort}`;\n  const httpsUrl = `https://${host}:${httpsPort}`;\n  const wsUrl = `ws://${host}:${wsPort}`;\n  const wssUrl = `wss://${host}:${wsPort}`;\n\n  let urlLines = `${chalk.green('HTTP:')}      ${chalk.underline(httpUrl)}\\n`;\n  urlLines += `${chalk.green('HTTPS:')}     ${chalk.underline(httpsUrl)}\\n`;\n  urlLines += `${chalk.green('WebSocket:')} ${chalk.underline(wsUrl)}\\n`;\n  urlLines += `${chalk.green('WSS:')}       ${chalk.underline(wssUrl)}\\n`;\n\n  if(publicIp) {\n    urlLines += `\\n${chalk.green('Public:')}    ${chalk.underline(`http://${publicIp}:${httpPort}`)}\\n`;\n  }\n\n  const statusBox = boxen(\n    `${chalk.cyan.bold('🚀 Serverless Development Server Running')}\\n\\n${urlLines}\\n` +\n    `${chalk.yellow('Press Ctrl+C to stop the server')}`,\n    {\n      backgroundColor: '#1a1a1a',\n      borderColor: 'cyan',\n      borderStyle: 'round',\n      margin: 1,\n      padding: 1\n    }\n  );\n\n  console.log(`\\n${statusBox}\\n`);\n};\n\nconst loadHandler = async (handlerPath: string, outputDir: string) => {\n  try {\n    console.log(`[Serverless] Parsing handler path: ${handlerPath}`);\n\n    // Parse AWS Lambda handler format: \"path/to/file.exportName\" or \"file.exportName\"\n    // Examples: \"index.handler\", \"handlers/api.handler\", \"src/index.default\"\n    const handlerParts = handlerPath.split('.');\n    console.log('[Serverless] Handler parts after split:', handlerParts);\n\n    let filePath: string;\n    let exportName: string | null = null;\n\n    if(handlerParts.length > 1) {\n      // AWS Lambda format: \"file.exportName\"\n      // Take the last part as export name, rest as file path\n      // Handle cases like \"index.handler\" -> file: \"index\", export: \"handler\"\n      // Or \"handlers/api.handler\" -> file: \"handlers/api\", export: \"handler\"\n      exportName = handlerParts[handlerParts.length - 1] || null;\n      filePath = handlerParts.slice(0, -1).join('.');\n      console.log(`[Serverless] Parsed AWS Lambda format - filePath: \"${filePath}\", exportName: \"${exportName}\"`);\n    } else {\n      // Simple format: just the file path\n      filePath = handlerPath;\n      console.log(`[Serverless] Simple format - filePath: \"${filePath}\"`);\n    }\n\n    // Ensure filePath doesn't have the export name in it\n    if(filePath.includes('.handler') || filePath.includes('.default')) {\n      console.error(`[Serverless] WARNING: filePath still contains export name! filePath: \"${filePath}\"`);\n      // Try to fix it - remove the last part if it looks like an export name\n      const pathParts = filePath.split('.');\n      if(pathParts.length > 1) {\n        const lastPart = pathParts[pathParts.length - 1];\n        if(['handler', 'default', 'index'].includes(lastPart) && !exportName) {\n          exportName = lastPart;\n          filePath = pathParts.slice(0, -1).join('.');\n          console.log(`[Serverless] Fixed - filePath: \"${filePath}\", exportName: \"${exportName}\"`);\n        }\n      }\n    }\n\n    // Handle both relative paths and absolute paths\n    let fullPath: string;\n    if(isAbsolute(filePath)) {\n      fullPath = filePath;\n    } else {\n      fullPath = pathResolve(outputDir, filePath);\n    }\n    console.log(`[Serverless] Resolved fullPath (before extensions): ${fullPath}`);\n\n    // Try different extensions if file doesn't exist\n    if(!existsSync(fullPath)) {\n      const extensions = ['.js', '.mjs', '.cjs'];\n      const pathWithoutExt = fullPath.replace(/\\.(js|mjs|cjs)$/, '');\n      console.log(`[Serverless] Trying extensions. Base path: ${pathWithoutExt}`);\n      for(const ext of extensions) {\n        const candidatePath = pathWithoutExt + ext;\n        console.log(`[Serverless] Checking: ${candidatePath} (exists: ${existsSync(candidatePath)})`);\n        if(existsSync(candidatePath)) {\n          fullPath = candidatePath;\n          console.log(`[Serverless] Found file with extension: ${fullPath}`);\n          break;\n        }\n      }\n    } else {\n      console.log(`[Serverless] File exists without trying extensions: ${fullPath}`);\n    }\n\n    console.log(`[Serverless] Final fullPath: ${fullPath}`);\n    console.log(`[Serverless] Export name: ${exportName || 'default/handler'}`);\n    console.log(`[Serverless] File exists: ${existsSync(fullPath)}`);\n\n    if(!existsSync(fullPath)) {\n      console.error(`[Serverless] Handler file not found: ${fullPath}`);\n      console.error(`[Serverless] Output directory: ${outputDir}`);\n      console.error(`[Serverless] Handler path from config: ${handlerPath}`);\n      throw new Error(`Handler file not found: ${fullPath}`);\n    }\n\n    // Dynamic import of the handler with better error handling\n    // Add .js extension if importing TypeScript compiled output\n    const importPath = fullPath.endsWith('.ts') ? fullPath.replace(/\\.ts$/, '.js') : fullPath;\n\n    try {\n      // Convert to file:// URL for ES module imports (required for absolute paths)\n      // Use pathToFileURL to ensure proper file:// URL format\n      const importUrl = pathToFileURL(importPath).href;\n      console.log(`[Serverless] Importing handler from: ${importUrl}`);\n      console.log(`[Serverless] File path: ${importPath}`);\n\n      // Use import() with the file URL\n      // Note: If the handler file has import errors (like missing dependencies),\n      // those will surface here, but that's a handler code issue, not a loader issue\n      const handlerModule = await import(importUrl);\n      console.log(`[Serverless] Handler module loaded successfully. Exports: ${Object.keys(handlerModule).join(', ')}`);\n\n      // Get the handler based on export name or try defaults\n      let handler: any;\n      if(exportName) {\n        handler = handlerModule[exportName];\n        if(!handler) {\n          console.error(`[Serverless] Export \"${exportName}\" not found in module. Available exports: ${Object.keys(handlerModule).join(', ')}`);\n          return null;\n        }\n      } else {\n        // Try default, handler, or the module itself\n        handler = handlerModule.default || handlerModule.handler || handlerModule;\n      }\n\n      console.log(`[Serverless] Handler found: ${typeof handler}, isFunction: ${typeof handler === 'function'}`);\n\n      if(typeof handler !== 'function') {\n        console.error(`[Serverless] Handler is not a function. Type: ${typeof handler}, Value:`, handler);\n        return null;\n      }\n\n      return handler;\n    } catch(importError: any) {\n      console.error(`[Serverless] Import error for handler ${handlerPath}:`, importError.message);\n      console.error('[Serverless] Import error stack:', importError.stack);\n\n      // Check if this is a dependency resolution error (common with ES modules)\n      if(importError.message && importError.message.includes('Cannot find module')) {\n        console.error('[Serverless] This appears to be a dependency resolution error.');\n        console.error('[Serverless] The handler file exists, but one of its imports is failing.');\n        console.error('[Serverless] Check that all dependencies in the handler file are properly installed.');\n        console.error(`[Serverless] Handler file: ${importPath}`);\n        console.error('[Serverless] Make sure the handler and its dependencies are compiled correctly.');\n      }\n\n      return null;\n    }\n  } catch(error: any) {\n    console.error(`[Serverless] Error loading handler ${handlerPath}:`, error.message);\n    console.error('[Serverless] Error stack:', error.stack);\n    return null;\n  }\n};\n\nconst captureConsoleLogs = (handler: (event: any, context: any)=> Promise<any>, quiet: boolean) => {\n  if(quiet) {\n    return handler;\n  }\n\n  return async (event: any, context: any) => {\n    // Capture console.log, console.error, etc.\n    const originalConsoleLog = console.log;\n    const originalConsoleError = console.error;\n    const originalConsoleWarn = console.warn;\n    const originalConsoleInfo = console.info;\n\n    const logs: string[] = [];\n\n    console.log = (...args: any[]) => {\n      logs.push(`[LOG] ${args.join(' ')}`);\n      originalConsoleLog(...args);\n    };\n\n    console.error = (...args: any[]) => {\n      logs.push(`[ERROR] ${args.join(' ')}`);\n      originalConsoleError(...args);\n    };\n\n    console.warn = (...args: any[]) => {\n      logs.push(`[WARN] ${args.join(' ')}`);\n      originalConsoleWarn(...args);\n    };\n\n    console.info = (...args: any[]) => {\n      logs.push(`[INFO] ${args.join(' ')}`);\n      originalConsoleInfo(...args);\n    };\n\n    try {\n      const result = await handler(event, context);\n\n      // Output captured logs\n      if(logs.length > 0) {\n        console.log(chalk.gray('--- Handler Console Output ---'));\n        logs.forEach((log) => console.log(chalk.gray(log)));\n        console.log(chalk.gray('--- End Handler Console Output ---'));\n      }\n\n      return result;\n    } finally {\n      // Restore original console methods\n      console.log = originalConsoleLog;\n      console.error = originalConsoleError;\n      console.warn = originalConsoleWarn;\n      console.info = originalConsoleInfo;\n    }\n  };\n};\n\nconst createExpressServer = async (\n  config: ServerlessConfig,\n  outputDir: string,\n  httpPort: number,\n  host: string,\n  quiet: boolean,\n  debug: boolean\n) => {\n  const app = express();\n\n  // Enable CORS\n  app.use((req, res, next) => {\n    res.header('Access-Control-Allow-Origin', '*');\n    res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');\n    res.header('Access-Control-Allow-Headers', '*');\n    res.header('Access-Control-Allow-Credentials', 'true');\n\n    if(req.method === 'OPTIONS') {\n      res.sendStatus(200);\n    } else {\n      next();\n    }\n  });\n\n  // Parse JSON bodies\n  app.use(express.json());\n\n  // Load GraphQL handler\n  const loadGraphQLSchema = async () => {\n    try {\n      // Try to find a GraphQL handler\n      let graphqlHandler = null;\n\n      if(config.functions) {\n        for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event.http && event.http.path) {\n                // Look for GraphQL endpoints\n                if(event.http.path === '/public' || event.http.path === '/graphql') {\n                  graphqlHandler = await loadHandler(functionConfig.handler, outputDir);\n                  break;\n                }\n              }\n            }\n          }\n          if(graphqlHandler) {\n            break;\n          }\n        }\n      }\n\n      if(graphqlHandler) {\n        log('Found GraphQL handler', 'info', quiet);\n        return graphqlHandler;\n      }\n      return null;\n    } catch(error) {\n      log(`Error loading GraphQL handler: ${error.message}`, 'error', quiet);\n      return null;\n    }\n  };\n\n  // Set up GraphQL handler for GraphQL requests\n  try {\n    const graphqlHandler = await loadGraphQLSchema();\n    if(graphqlHandler) {\n      // Find the GraphQL path from the serverless config\n      let graphqlPath = '/graphql'; // default fallback\n\n      if(config.functions) {\n        for(const [_functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event?.http?.path) {\n                graphqlPath = event.http.path;\n                break;\n              }\n            }\n          }\n          if(graphqlPath !== '/graphql') {\n            break;\n          }\n        }\n      }\n\n      // Set up GraphQL endpoint with enhanced console.log capture\n      app.use(graphqlPath, async (req, res) => {\n        // GraphQL Debug Logging\n        if(debug && req.body && req.body.query) {\n          log('🔍 GraphQL Debug Mode: Analyzing request...', 'info', false);\n          log(`📝 GraphQL Query: ${req.body.query}`, 'info', false);\n          if(req.body.variables) {\n            log(`📊 GraphQL Variables: ${JSON.stringify(req.body.variables, null, 2)}`, 'info', false);\n          }\n          if(req.body.operationName) {\n            log(`🏷️  GraphQL Operation: ${req.body.operationName}`, 'info', false);\n          }\n        }\n\n        // Enhanced console.log capture\n        const originalConsoleLog = console.log;\n        const logs: string[] = [];\n\n        console.log = (...args) => {\n          const logMessage = args.map((arg) =>\n            (typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg))\n          ).join(' ');\n          logs.push(logMessage);\n          originalConsoleLog(`[GraphQL] ${logMessage}`);\n        };\n\n        // Create context for the handler\n        const context = {\n          awsRequestId: 'test-request-id',\n          functionName: 'graphql',\n          functionVersion: '$LATEST',\n          getRemainingTimeInMillis: () => 30000,\n          invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:graphql',\n          logGroupName: '/aws/lambda/graphql',\n          logStreamName: 'test-log-stream',\n          req,\n          res\n        };\n\n        // Wrap handler with console log capture\n        const wrappedHandler = captureConsoleLogs(graphqlHandler, quiet);\n\n        try {\n          // Call the handler with GraphQL parameters\n          const result = await wrappedHandler({\n            body: JSON.stringify(req.body),\n            headers: req.headers,\n            httpMethod: 'POST',\n            path: graphqlPath,\n            queryStringParameters: {}\n          }, context);\n\n          // Restore console.log\n          console.log = originalConsoleLog;\n\n          // Handle the result\n          if(result && typeof result === 'object' && result.statusCode) {\n            res.status(result.statusCode);\n            if(result.headers) {\n              Object.entries(result.headers).forEach(([key, value]) => {\n                res.setHeader(key, String(value));\n              });\n            }\n            res.send(result.body);\n          } else {\n            res.json(result);\n          }\n        } catch(error) {\n          // Restore console.log\n          console.log = originalConsoleLog;\n          log(`GraphQL handler error: ${error.message}`, 'error', false);\n          res.status(500).json({error: error.message});\n        }\n      });\n\n      log(`GraphQL endpoint available at http://${host}:${httpPort}${graphqlPath}`, 'info', quiet);\n    }\n  } catch(error) {\n    log(`Error setting up GraphQL: ${error.message}`, 'error', quiet);\n  }\n\n  // Fallback for non-GraphQL routes - handle all remaining routes\n  app.use('/', async (req, res) => {\n    try {\n      const url = req.url || '/';\n      const method = req.method || 'GET';\n      const pathname = req.path || url.split('?')[0]; // Extract pathname without query string\n\n      // Always log requests (not affected by quiet flag for debugging)\n      console.log(`[Serverless] ${method} ${url} (pathname: ${pathname})`);\n\n      // Find matching function\n      let matchedFunction = null;\n\n      if(config.functions) {\n        const functionNames = Object.keys(config.functions);\n        console.log(`[Serverless] Available functions: ${functionNames.join(', ')}`);\n        console.log('[Serverless] Config functions:', JSON.stringify(config.functions, null, 2));\n\n        for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n          if(functionConfig.events) {\n            for(const event of functionConfig.events) {\n              if(event.http) {\n                const eventPath = event.http.path || '/';\n                const eventMethod = (event.http.method || 'GET').toUpperCase();\n                const requestMethod = method.toUpperCase();\n\n                console.log(`[Serverless] Checking function ${functionName}: path=\"${eventPath}\", method=\"${eventMethod}\" against pathname=\"${pathname}\", method=\"${requestMethod}\"`);\n\n                // Improved path matching - compare pathname without query string\n                // Normalize paths (remove trailing slashes for comparison)\n                const normalizedEventPath = eventPath.replace(/\\/$/, '') || '/';\n                const normalizedPathname = pathname.replace(/\\/$/, '') || '/';\n\n                if(normalizedEventPath === normalizedPathname && eventMethod === requestMethod) {\n                  matchedFunction = functionName;\n                  console.log(`[Serverless] ✓ Matched function: ${matchedFunction}`);\n                  break;\n                }\n              }\n            }\n          }\n          if(matchedFunction) {\n            break;\n          }\n        }\n      } else {\n        console.log('[Serverless] No functions found in config');\n      }\n\n      if(matchedFunction && config.functions[matchedFunction]) {\n        // Resolve handler path relative to output directory\n        const handlerPath = config.functions[matchedFunction].handler;\n        console.log(`[Serverless] Loading handler: ${handlerPath} from outputDir: ${outputDir}`);\n        const handler = await loadHandler(handlerPath, outputDir);\n\n        if(handler) {\n          console.log(`[Serverless] Handler loaded successfully, type: ${typeof handler}`);\n          const wrappedHandler = captureConsoleLogs(handler, quiet);\n\n          const event = {\n            body: req.body,\n            headers: req.headers,\n            httpMethod: method,\n            path: url,\n            queryStringParameters: req.query\n          };\n\n          const context = {\n            awsRequestId: 'test-request-id',\n            functionName: matchedFunction,\n            functionVersion: '$LATEST',\n            getRemainingTimeInMillis: () => 30000,\n            invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,\n            logGroupName: `/aws/lambda/${matchedFunction}`,\n            logStreamName: 'test-log-stream',\n            memoryLimitInMB: '128'\n          };\n\n          try {\n            console.log('[Serverless] Calling handler with event:', JSON.stringify(event, null, 2));\n            const result = await wrappedHandler(event, context);\n            console.log('[Serverless] Handler returned:', JSON.stringify(result, null, 2));\n\n            if(result && typeof result === 'object' && result.statusCode) {\n              res.status(result.statusCode);\n              if(result.headers) {\n                Object.entries(result.headers).forEach(([key, value]) => {\n                  res.setHeader(key, String(value));\n                });\n              }\n              res.send(result.body);\n            } else {\n              res.json(result);\n            }\n          } catch(error: any) {\n            console.error('[Serverless] Handler error:', error.message);\n            console.error('[Serverless] Handler error stack:', error.stack);\n            log(`Handler error: ${error.message}`, 'error', false);\n            res.status(500).json({error: error.message});\n          }\n        } else {\n          console.error(`[Serverless] Handler not found for function: ${matchedFunction}`);\n          console.error(`[Serverless] Handler path: ${handlerPath}, Output dir: ${outputDir}`);\n          res.status(404).json({error: 'Handler not found'});\n        }\n      } else {\n        console.error(`[Serverless] Function not found for pathname: ${pathname}, method: ${method}`);\n        console.error(`[Serverless] Available functions: ${config.functions ? Object.keys(config.functions).join(', ') : 'none'}`);\n        res.status(404).json({error: 'Function not found'});\n      }\n    } catch(error) {\n      log(`Route handling error: ${error.message}`, 'error', false);\n      res.status(500).json({error: error.message});\n    }\n  });\n\n  return app;\n};\n\nconst createWebSocketServer = (\n  config: ServerlessConfig,\n  outputDir: string,\n  wsPort: number,\n  quiet: boolean,\n  debug: boolean\n) => {\n  const wss = new WebSocketServer({port: wsPort});\n\n  wss.on('connection', async (ws, req) => {\n    log(`WebSocket connection established: ${req.url}`, 'info', false);\n\n    ws.on('message', async (message) => {\n      try {\n        const data = JSON.parse(message.toString());\n\n        // Find matching WebSocket function\n        let matchedFunction = null;\n\n        if(config.functions) {\n          for(const [functionName, functionConfig] of Object.entries(config.functions)) {\n            if(functionConfig.events) {\n              for(const event of functionConfig.events) {\n                if(event.websocket) {\n                  const route = event.websocket.route || '$connect';\n                  if(route === '$default' || route === data.action) {\n                    matchedFunction = functionName;\n                    break;\n                  }\n                }\n              }\n            }\n            if(matchedFunction) {\n              break;\n            }\n          }\n        }\n\n        if(matchedFunction && config.functions[matchedFunction]) {\n          const handler = await loadHandler(config.functions[matchedFunction].handler, outputDir);\n\n          if(handler) {\n            // Wrap handler with console log capture\n            const wrappedHandler = captureConsoleLogs(handler, quiet);\n            const event = {\n              body: data.body || null,\n              requestContext: {\n                apiGateway: {\n                  endpoint: `ws://localhost:${wsPort}`\n                },\n                connectionId: 'test-connection-id',\n                routeKey: data.action || '$default'\n              }\n            };\n\n            const context = {\n              awsRequestId: 'test-request-id',\n              functionName: matchedFunction,\n              functionVersion: '$LATEST',\n              getRemainingTimeInMillis: () => 30000,\n              invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,\n              logGroupName: `/aws/lambda/${matchedFunction}`,\n              logStreamName: 'test-log-stream',\n              memoryLimitInMB: '128'\n            };\n\n            const result = await wrappedHandler(event, context);\n\n            // Handle Lambda response format for WebSocket\n            if(result && typeof result === 'object' && result.statusCode) {\n              // This is a Lambda response object, extract the body\n              const body = result.body || '';\n              ws.send(body);\n            } else {\n              // This is a direct response, stringify it\n              ws.send(JSON.stringify(result));\n            }\n          } else {\n            ws.send(JSON.stringify({error: 'Handler not found'}));\n          }\n        } else {\n          ws.send(JSON.stringify({error: 'WebSocket function not found'}));\n        }\n      } catch(error) {\n        log(`WebSocket error: ${error.message}`, 'error', false);\n        ws.send(JSON.stringify({error: error.message}));\n      }\n    });\n\n    ws.on('close', () => {\n      log('WebSocket connection closed', 'info', false);\n    });\n  });\n\n  return wss;\n};\n\nconst loadEnvFile = (envPath: string): Record<string, string> => {\n  const envVars: Record<string, string> = {};\n\n  if(!existsSync(envPath)) {\n    return envVars;\n  }\n\n  try {\n    const envContent = readFileSync(envPath, 'utf8');\n    const lines = envContent.split('\\n');\n\n    for(const line of lines) {\n      const trimmedLine = line.trim();\n\n      // Skip empty lines and comments\n      if(!trimmedLine || trimmedLine.startsWith('#')) {\n        continue;\n      }\n\n      // Parse KEY=value format\n      const equalIndex = trimmedLine.indexOf('=');\n      if(equalIndex > 0) {\n        const key = trimmedLine.substring(0, equalIndex).trim();\n        const value = trimmedLine.substring(equalIndex + 1).trim();\n\n        // Remove quotes if present\n        const cleanValue = value.replace(/^[\"']|[\"']$/g, '');\n\n        if(key) {\n          envVars[key] = cleanValue;\n        }\n      }\n    }\n  } catch(error) {\n    log(`Warning: Could not load .env file at ${envPath}: ${error.message}`, 'warn', false);\n  }\n\n  return envVars;\n};\n\nexport const serverless = async (\n  cmd: ServerlessOptions,\n  callback: ServerlessCallback = () => ({})\n): Promise<number> => {\n  const {\n    cliName = 'Lex',\n    config,\n    debug = false,\n    host: cliHost,\n    httpPort: cliHttpPort,\n    httpsPort: cliHttpsPort,\n    quiet = false,\n    remove = false,\n    test = false,\n    usePublicIp,\n    variables,\n    wsPort: cliWsPort\n  } = cmd;\n\n  const spinner = createSpinner(quiet);\n\n  log(`${cliName} starting serverless development server...`, 'info', quiet);\n\n  await LexConfig.parseConfig(cmd);\n\n  const {outputFullPath} = LexConfig.config;\n\n  // Load environment variables from .env files\n  const envPaths = [\n    pathResolve(process.cwd(), '.env'),\n    pathResolve(process.cwd(), '.env.local'),\n    pathResolve(process.cwd(), '.env.development')\n  ];\n\n  let envVars: Record<string, string> = {};\n\n  // Load from .env files in order (later files override earlier ones)\n  for(const envPath of envPaths) {\n    const fileEnvVars = loadEnvFile(envPath);\n    if(Object.keys(fileEnvVars).length > 0) {\n      log(`Loaded environment variables from: ${envPath}`, 'info', quiet);\n    }\n    envVars = {...envVars, ...fileEnvVars};\n  }\n\n  // Start with default NODE_ENV and loaded .env variables\n  let variablesObj: object = {NODE_ENV: 'development', ...envVars};\n\n  // Override with command line variables if provided\n  if(variables) {\n    try {\n      const cliVars = JSON.parse(variables);\n      variablesObj = {...variablesObj, ...cliVars};\n    } catch(_error) {\n      log(`\\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);\n      callback(1);\n      return 1;\n    }\n  }\n\n  process.env = {...process.env, ...variablesObj};\n\n  // If in test mode, exit early after loading environment variables\n  if(test) {\n    log('Test mode: Environment variables loaded, exiting', 'info', quiet);\n    callback(0);\n    return 0;\n  }\n\n  if(remove) {\n    spinner.start('Cleaning output directory...');\n    await removeFiles(outputFullPath || '');\n    spinner.succeed('Successfully cleaned output directory!');\n  }\n\n  // Load serverless configuration\n  let serverlessConfig: ServerlessConfig = {};\n\n  try {\n    // Use getPackageDir to handle npm workspaces correctly\n    const packageDir = getPackageDir();\n\n    // Try multiple config file formats\n    const configFormats = config ? [config] : [\n      pathResolve(packageDir, 'lex.config.mjs'),\n      pathResolve(packageDir, 'lex.config.js'),\n      pathResolve(packageDir, 'lex.config.cjs'),\n      pathResolve(packageDir, 'lex.config.ts')\n    ];\n\n    let configPath: string | null = null;\n    for(const candidatePath of configFormats) {\n      if(existsSync(candidatePath)) {\n        configPath = candidatePath;\n        break;\n      }\n    }\n\n    if(configPath) {\n      log(`Loading serverless config from: ${configPath}`, 'info', quiet);\n      const configModule = await import(configPath);\n      serverlessConfig = configModule.default?.serverless || configModule.serverless || {};\n      log('Serverless config loaded successfully', 'info', quiet);\n      const functionNames = Object.keys(serverlessConfig.functions || {});\n      log(`Loaded functions: ${functionNames.length > 0 ? functionNames.join(', ') : 'none'}`, 'info', quiet);\n\n      // Debug: Print full config if debug mode\n      if(debug) {\n        log(`Full serverless config: ${JSON.stringify(serverlessConfig, null, 2)}`, 'info', false);\n      }\n    } else {\n      log(`No serverless config found. Tried: ${configFormats.join(', ')}`, 'warn', quiet);\n    }\n  } catch(error) {\n    log(`Error loading serverless config: ${error.message}`, 'error', quiet);\n    if(debug) {\n      log(`Config error stack: ${error.stack}`, 'error', false);\n    }\n    // Don't exit, continue with empty config\n  }\n\n  // Merge config with command line options\n  // Determine effective host/ports with correct precedence: CLI > config > defaults\n  const configOffline = serverlessConfig.custom?.['serverless-offline'] || {};\n  const effectiveHost = (cliHost ?? configOffline.host ?? 'localhost') as string;\n  const toNumber = (v: any, fallback: number): number => {\n    if(v === undefined || v === null || v === '') {\n      return fallback;\n    }\n\n    const n = typeof v === 'number' ? v : parseInt(String(v));\n    return Number.isFinite(n) ? n : fallback;\n  };\n  const effectiveHttpPort = toNumber(cliHttpPort ?? configOffline.httpPort, 5000);\n  const effectiveHttpsPort = toNumber(cliHttpsPort ?? configOffline.httpsPort, 5001);\n  const effectiveWsPort = toNumber(cliWsPort ?? configOffline.wsPort, 5002);\n\n  const finalConfig: ServerlessConfig = {\n    ...serverlessConfig,\n    custom: {\n      'serverless-offline': {\n        cors: serverlessConfig.custom?.['serverless-offline']?.cors !== false,\n        host: effectiveHost,\n        httpPort: effectiveHttpPort,\n        httpsPort: effectiveHttpsPort,\n        wsPort: effectiveWsPort\n      }\n    }\n  };\n\n  const outputDir = outputFullPath || 'lib';\n  log(`Using output directory: ${outputDir}`, 'info', quiet);\n\n  try {\n    spinner.start('Starting serverless development server...');\n\n    const httpPort = finalConfig.custom!['serverless-offline']!.httpPort!;\n    const wsPort = finalConfig.custom!['serverless-offline']!.wsPort!;\n    const host = finalConfig.custom!['serverless-offline']!.host!;\n\n    log(`Creating HTTP server on ${host}:${httpPort}`, 'info', quiet);\n    log(`Creating WebSocket server on port ${wsPort}`, 'info', quiet);\n\n    // Create Express server\n    const expressApp = await createExpressServer(\n      finalConfig,\n      outputDir,\n      httpPort,\n      host,\n      quiet,\n      debug\n    );\n\n    // Create WebSocket server\n    const wsServer = createWebSocketServer(\n      finalConfig,\n      outputDir,\n      wsPort,\n      quiet,\n      debug\n    );\n\n    // Handle server errors\n    wsServer.on('error', (error) => {\n      log(`WebSocket server error: ${error.message}`, 'error', quiet);\n      spinner.fail('Failed to start WebSocket server.');\n      callback(1);\n      return;\n    });\n\n    // Start Express server\n    const server = expressApp.listen(httpPort, host, () => {\n      spinner.succeed('Serverless development server started.');\n\n      displayServerStatus(\n        httpPort,\n        finalConfig.custom!['serverless-offline']!.httpsPort!,\n        wsPort,\n        host,\n        quiet\n      );\n\n      fetchPublicIp(usePublicIp).then((publicIp) => {\n        if(publicIp) {\n          displayServerStatus(\n            httpPort,\n            finalConfig.custom!['serverless-offline']!.httpsPort!,\n            wsPort,\n            host,\n            quiet,\n            publicIp\n          );\n        }\n      });\n    });\n\n    // Handle Express server errors\n    server.on('error', (error) => {\n      log(`Express server error: ${error.message}`, 'error', quiet);\n      spinner.fail('Failed to start Express server.');\n      callback(1);\n      return;\n    });\n\n    // Handle graceful shutdown\n    const shutdown = () => {\n      log('\\nShutting down serverless development server...', 'info', quiet);\n      server.close();\n      wsServer.close();\n      callback(0);\n    };\n\n    process.on('SIGINT', shutdown);\n    process.on('SIGTERM', shutdown);\n\n    // Keep the process alive\n    process.stdin.resume();\n\n    log('Serverless development server is running. Press Ctrl+C to stop.', 'info', quiet);\n\n    // Don't call callback here, let the process stay alive\n    return 0;\n  } catch(error) {\n    log(`\\n${cliName} Error: ${error.message}`, 'error', quiet);\n    spinner.fail('Failed to start serverless development server.');\n    callback(1);\n    return 1;\n  }\n};"],"names":["boxen","chalk","express","readFileSync","existsSync","mkdirSync","writeFileSync","homedir","resolve","pathResolve","join","isAbsolute","pathToFileURL","WebSocketServer","LexConfig","getPackageDir","createSpinner","removeFiles","log","getCacheDir","cacheDir","recursive","getCachePath","readPublicIpCache","cachePath","cacheData","cache","JSON","parse","oneWeekMs","Date","now","timestamp","writePublicIpCache","ip","stringify","fetchPublicIp","forceRefresh","Promise","cached","fetch","then","res","text","data","trim","catch","undefined","displayServerStatus","httpPort","httpsPort","wsPort","host","quiet","publicIp","httpUrl","httpsUrl","wsUrl","wssUrl","urlLines","green","underline","statusBox","cyan","bold","yellow","backgroundColor","borderColor","borderStyle","margin","padding","console","loadHandler","handlerPath","outputDir","handlerParts","split","filePath","exportName","length","slice","includes","error","pathParts","lastPart","fullPath","extensions","pathWithoutExt","replace","ext","candidatePath","Error","importPath","endsWith","importUrl","href","handlerModule","Object","keys","handler","default","importError","message","stack","captureConsoleLogs","event","context","originalConsoleLog","originalConsoleError","originalConsoleWarn","warn","originalConsoleInfo","info","logs","args","push","result","gray","forEach","createExpressServer","config","debug","app","use","req","next","header","method","sendStatus","json","loadGraphQLSchema","graphqlHandler","functions","functionName","functionConfig","entries","events","http","path","graphqlPath","_functionName","body","query","variables","operationName","logMessage","map","arg","String","awsRequestId","functionVersion","getRemainingTimeInMillis","invokedFunctionArn","logGroupName","logStreamName","wrappedHandler","headers","httpMethod","queryStringParameters","statusCode","status","key","value","setHeader","send","url","pathname","matchedFunction","functionNames","eventPath","eventMethod","toUpperCase","requestMethod","normalizedEventPath","normalizedPathname","memoryLimitInMB","createWebSocketServer","wss","port","on","ws","toString","websocket","route","action","requestContext","apiGateway","endpoint","connectionId","routeKey","loadEnvFile","envPath","envVars","envContent","lines","line","trimmedLine","startsWith","equalIndex","indexOf","substring","cleanValue","serverless","cmd","callback","cliName","cliHost","cliHttpPort","cliHttpsPort","remove","test","usePublicIp","cliWsPort","spinner","parseConfig","outputFullPath","envPaths","process","cwd","fileEnvVars","variablesObj","NODE_ENV","cliVars","_error","env","start","succeed","serverlessConfig","packageDir","configFormats","configPath","configModule","configOffline","custom","effectiveHost","toNumber","v","fallback","n","parseInt","Number","isFinite","effectiveHttpPort","effectiveHttpsPort","effectiveWsPort","finalConfig","cors","expressApp","wsServer","fail","server","listen","shutdown","close","stdin","resume"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.52.18",
+  "version": "1.52.22",
   "description": "Lex",
   "license": "MIT",
   "type": "module",
@@ -93,16 +93,16 @@
     "@babel/runtime-corejs3": "^7.28.4",
     "@mdx-js/loader": "^3.1.1",
     "@nlabs/webpack-plugin-static-site": "*",
-    "@storybook/addon-docs": "^10.1.10",
-    "@storybook/addon-links": "^10.1.10",
+    "@storybook/addon-docs": "^10.1.11",
+    "@storybook/addon-links": "^10.1.11",
     "@storybook/addon-postcss": "^2.0.0",
     "@storybook/addon-styling-webpack": "^3.0.0",
-    "@storybook/addon-themes": "^10.1.10",
+    "@storybook/addon-themes": "^10.1.11",
     "@storybook/addon-webpack5-compiler-babel": "^4.0.0",
-    "@storybook/cli": "^10.1.10",
-    "@storybook/react": "^10.1.10",
-    "@storybook/react-webpack5": "^10.1.10",
-    "@swc/core": "^1.15.7",
+    "@storybook/cli": "^10.1.11",
+    "@storybook/react": "^10.1.11",
+    "@storybook/react-webpack5": "^10.1.11",
+    "@swc/core": "^1.15.8",
     "@tailwindcss/nesting": "^0.0.0-insiders.565cd3e",
     "@tailwindcss/postcss": "4.1.18",
     "@testing-library/jest-dom": "^6.9.1",
@@ -111,10 +111,10 @@
     "autoprefixer": "^10.4.23",
     "babel-jest": "^30.2.0",
     "babel-loader": "^10.0.0",
-    "babel-plugin-transform-import-meta": "^2.1.0",
+    "babel-plugin-transform-import-meta": "^2.3.3",
     "boxen": "8.0.1",
     "buffer": "^6.0.3",
-    "caniuse-lite": "1.0.30001761",
+    "caniuse-lite": "1.0.30001763",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
     "compare-versions": "^6.1.1",
@@ -153,7 +153,7 @@
     "luxon": "^3.7.2",
     "math-expression-evaluator": "^2.0.7",
     "mini-css-extract-plugin": "^2.9.4",
-    "npm-check-updates": "^19.2.0",
+    "npm-check-updates": "^19.3.1",
     "openai": "^6.15.0",
     "ora": "9.0.0",
     "os-browserify": "^0.3.0",
@@ -169,7 +169,7 @@
     "postcss-loader": "^8.2.0",
     "postcss-nesting": "^13.0.2",
     "postcss-percentage": "^0.0.0",
-    "postcss-preset-env": "^10.5.0",
+    "postcss-preset-env": "^10.6.0",
     "postcss-simple-vars": "^7.0.1",
     "postcss-svgo": "7.1.0",
     "postcss-url": "10.1.3",
@@ -183,7 +183,7 @@
     "rimraf": "^6.1.2",
     "semver": "^7.7.3",
     "source-map-loader": "^5.0.0",
-    "storybook": "^10.1.10",
+    "storybook": "^10.1.11",
     "stream-browserify": "^3.0.0",
     "stream-http": "^3.2.0",
     "style-loader": "^4.0.0",
@@ -197,11 +197,11 @@
     "util": "^0.12.5",
     "vm-browserify": "^1.1.2",
     "webpack": "5.104.1",
-    "webpack-bundle-analyzer": "^5.1.0",
+    "webpack-bundle-analyzer": "^5.1.1",
     "webpack-cli": "^6.0.1",
     "webpack-merge": "^6.0.1",
     "webpack-plugin-serve": "^1.6.0",
-    "ws": "^8.18.3"
+    "ws": "^8.19.0"
   },
   "devDependencies": {
     "@swc/cli": "^0.7.9",
@@ -219,13 +219,14 @@
   "overrides": {
     "cheerio": "^1.1.2",
     "cross-spawn": "^7.0.6",
-    "css-select": "^5.2.2",
-    "got": "^14.6.5",
+    "css-select": "^6.0.0",
+    "got": "^14.6.6",
     "http-cache-semantics": "^4.2.0",
     "http-proxy-middleware": "^3.0.5",
     "lodash.pick": "^4.4.0",
     "nth-check": "^2.1.1",
     "postcss": "^8.5.6",
+    "qs": "^6.14.1",
     "semver-regex": "^4.0.5",
     "tmp": "^0.2.5"
   },