@nlabs/lex 1.49.4 → 1.50.0

package/lib/commands/serverless/serverless.js

@@ -1,630 +1,656 @@
-import boxen from "boxen";
-import chalk from "chalk";
-import express from "express";
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { resolve as pathResolve, join } from "path";
-import { WebSocketServer } from "ws";
-import { LexConfig } from "../../LexConfig.js";
-import { createSpinner, removeFiles } from "../../utils/app.js";
-import { log } from "../../utils/log.js";
-const getCacheDir = () => {
-  const cacheDir = join(homedir(), ".lex-cache");
-  if (!existsSync(cacheDir)) {
-    mkdirSync(cacheDir, { recursive: true });
-  }
-  return cacheDir;
-};
-const getCachePath = () => join(getCacheDir(), "public-ip.json");
-const readPublicIpCache = () => {
-  const cachePath = getCachePath();
-  if (!existsSync(cachePath)) {
-    return null;
-  }
-  try {
-    const cacheData = readFileSync(cachePath, "utf8");
-    const cache = JSON.parse(cacheData);
-    const oneWeekMs = 7 * 24 * 60 * 60 * 1e3;
-    if (Date.now() - cache.timestamp > oneWeekMs) {
-      return null;
-    }
-    return cache;
-  } catch {
-    return null;
-  }
-};
-const writePublicIpCache = (ip) => {
-  const cachePath = getCachePath();
-  const cache = {
-    ip,
-    timestamp: Date.now()
-  };
-  writeFileSync(cachePath, JSON.stringify(cache, null, 2));
-};
-const fetchPublicIp = (forceRefresh = false) => new Promise((resolve) => {
-  if (!forceRefresh) {
-    const cached = readPublicIpCache();
-    if (cached) {
-      resolve(cached.ip);
-      return;
-    }
-  }
-  fetch("https://api.ipify.org").then((res) => res.text()).then((data) => {
-    const ip = data.trim();
-    if (ip) {
-      writePublicIpCache(ip);
-    }
-    resolve(ip);
-  }).catch(() => resolve(void 0));
-});
-const displayServerStatus = (httpPort, httpsPort, wsPort, host, quiet, publicIp) => {
-  if (quiet) {
-    return;
-  }
-  const httpUrl = `http://${host}:${httpPort}`;
-  const httpsUrl = `https://${host}:${httpsPort}`;
-  const wsUrl = `ws://${host}:${wsPort}`;
-  const wssUrl = `wss://${host}:${wsPort}`;
-  let urlLines = `${chalk.green("HTTP:")}      ${chalk.underline(httpUrl)}
-`;
-  urlLines += `${chalk.green("HTTPS:")}     ${chalk.underline(httpsUrl)}
-`;
-  urlLines += `${chalk.green("WebSocket:")} ${chalk.underline(wsUrl)}
-`;
-  urlLines += `${chalk.green("WSS:")}       ${chalk.underline(wssUrl)}
-`;
-  if (publicIp) {
-    urlLines += `
-${chalk.green("Public:")}    ${chalk.underline(`http://${publicIp}:${httpPort}`)}
-`;
-  }
-  const statusBox = boxen(
-    `${chalk.cyan.bold("\u{1F680} Serverless Development Server Running")}
-
-${urlLines}
-${chalk.yellow("Press Ctrl+C to stop the server")}`,
-    {
-      backgroundColor: "#1a1a1a",
-      borderColor: "cyan",
-      borderStyle: "round",
-      margin: 1,
-      padding: 1
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import boxen from 'boxen';
+import chalk from 'chalk';
+import express from 'express';
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { resolve as pathResolve, join } from 'path';
+import { WebSocketServer } from 'ws';
+import { LexConfig } from '../../LexConfig.js';
+import { createSpinner, removeFiles } from '../../utils/app.js';
+import { log } from '../../utils/log.js';
+const getCacheDir = ()=>{
+    const cacheDir = join(homedir(), '.lex-cache');
+    if (!existsSync(cacheDir)) {
+        mkdirSync(cacheDir, {
+            recursive: true
+        });
     }
-  );
-  console.log(`
-${statusBox}
-`);
+    return cacheDir;
 };
-const loadHandler = async (handlerPath, outputDir) => {
-  try {
-    const fullPath = pathResolve(outputDir, handlerPath);
-    log(`Loading handler from: ${fullPath}`, "info", false);
-    if (!existsSync(fullPath)) {
-      throw new Error(`Handler file not found: ${fullPath}`);
+const getCachePath = ()=>join(getCacheDir(), 'public-ip.json');
+const readPublicIpCache = ()=>{
+    const cachePath = getCachePath();
+    if (!existsSync(cachePath)) {
+        return null;
     }
     try {
-      const handlerModule = await import(fullPath);
-      log(`Handler module loaded: ${Object.keys(handlerModule)}`, "info", false);
-      const handler = handlerModule.default || handlerModule.handler || handlerModule;
-      log(`Handler found: ${typeof handler}`, "info", false);
-      return handler;
-    } catch (importError) {
-      log(`Import error for handler ${handlerPath}: ${importError.message}`, "error", false);
-      return null;
+        const cacheData = readFileSync(cachePath, 'utf8');
+        const cache = JSON.parse(cacheData);
+        // Check if cache is older than 1 week
+        const oneWeekMs = 7 * 24 * 60 * 60 * 1000;
+        if (Date.now() - cache.timestamp > oneWeekMs) {
+            return null;
+        }
+        return cache;
+    } catch  {
+        return null;
     }
-  } catch (error) {
-    log(`Error loading handler ${handlerPath}: ${error.message}`, "error", false);
-    return null;
-  }
 };
-const captureConsoleLogs = (handler, quiet) => {
-  if (quiet) {
-    return handler;
-  }
-  return async (event, context) => {
-    const originalConsoleLog = console.log;
-    const originalConsoleError = console.error;
-    const originalConsoleWarn = console.warn;
-    const originalConsoleInfo = console.info;
-    const logs = [];
-    console.log = (...args) => {
-      logs.push(`[LOG] ${args.join(" ")}`);
-      originalConsoleLog(...args);
-    };
-    console.error = (...args) => {
-      logs.push(`[ERROR] ${args.join(" ")}`);
-      originalConsoleError(...args);
-    };
-    console.warn = (...args) => {
-      logs.push(`[WARN] ${args.join(" ")}`);
-      originalConsoleWarn(...args);
+const writePublicIpCache = (ip)=>{
+    const cachePath = getCachePath();
+    const cache = {
+        ip,
+        timestamp: Date.now()
     };
-    console.info = (...args) => {
-      logs.push(`[INFO] ${args.join(" ")}`);
-      originalConsoleInfo(...args);
-    };
-    try {
-      const result = await handler(event, context);
-      if (logs.length > 0) {
-        console.log(chalk.gray("--- Handler Console Output ---"));
-        logs.forEach((log2) => console.log(chalk.gray(log2)));
-        console.log(chalk.gray("--- End Handler Console Output ---"));
-      }
-      return result;
-    } finally {
-      console.log = originalConsoleLog;
-      console.error = originalConsoleError;
-      console.warn = originalConsoleWarn;
-      console.info = originalConsoleInfo;
-    }
-  };
+    writeFileSync(cachePath, JSON.stringify(cache, null, 2));
 };
-const createExpressServer = async (config, outputDir, httpPort, host, quiet, debug) => {
-  const app = express();
-  app.use((req, res, next) => {
-    res.header("Access-Control-Allow-Origin", "*");
-    res.header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-    res.header("Access-Control-Allow-Headers", "*");
-    res.header("Access-Control-Allow-Credentials", "true");
-    if (req.method === "OPTIONS") {
-      res.sendStatus(200);
-    } else {
-      next();
-    }
-  });
-  app.use(express.json());
-  const loadGraphQLSchema = async () => {
-    try {
-      let graphqlHandler = null;
-      if (config.functions) {
-        for (const [functionName, functionConfig] of Object.entries(config.functions)) {
-          if (functionConfig.events) {
-            for (const event of functionConfig.events) {
-              if (event.http && event.http.path) {
-                if (event.http.path === "/public" || event.http.path === "/graphql") {
-                  graphqlHandler = await loadHandler(functionConfig.handler, outputDir);
-                  break;
-                }
-              }
+const fetchPublicIp = (forceRefresh = false)=>new Promise((resolve)=>{
+        if (!forceRefresh) {
+            const cached = readPublicIpCache();
+            if (cached) {
+                resolve(cached.ip);
+                return;
             }
-          }
-          if (graphqlHandler) {
-            break;
-          }
         }
-      }
-      if (graphqlHandler) {
-        log("Found GraphQL handler", "info", quiet);
-        return graphqlHandler;
-      }
-      return null;
-    } catch (error) {
-      log(`Error loading GraphQL handler: ${error.message}`, "error", quiet);
-      return null;
-    }
-  };
-  try {
-    const graphqlHandler = await loadGraphQLSchema();
-    if (graphqlHandler) {
-      let graphqlPath = "/graphql";
-      if (config.functions) {
-        for (const [_functionName, functionConfig] of Object.entries(config.functions)) {
-          if (functionConfig.events) {
-            for (const event of functionConfig.events) {
-              if (event?.http?.path) {
-                graphqlPath = event.http.path;
-                break;
-              }
+        // Use fetch instead of https
+        fetch('https://api.ipify.org').then((res)=>res.text()).then((data)=>{
+            const ip = data.trim();
+            if (ip) {
+                writePublicIpCache(ip);
             }
-          }
-          if (graphqlPath !== "/graphql") {
-            break;
-          }
+            resolve(ip);
+        }).catch(()=>resolve(undefined));
+    });
+const displayServerStatus = (httpPort, httpsPort, wsPort, host, quiet, publicIp)=>{
+    if (quiet) {
+        return;
+    }
+    const httpUrl = `http://${host}:${httpPort}`;
+    const httpsUrl = `https://${host}:${httpsPort}`;
+    const wsUrl = `ws://${host}:${wsPort}`;
+    const wssUrl = `wss://${host}:${wsPort}`;
+    let urlLines = `${chalk.green('HTTP:')}      ${chalk.underline(httpUrl)}\n`;
+    urlLines += `${chalk.green('HTTPS:')}     ${chalk.underline(httpsUrl)}\n`;
+    urlLines += `${chalk.green('WebSocket:')} ${chalk.underline(wsUrl)}\n`;
+    urlLines += `${chalk.green('WSS:')}       ${chalk.underline(wssUrl)}\n`;
+    if (publicIp) {
+        urlLines += `\n${chalk.green('Public:')}    ${chalk.underline(`http://${publicIp}:${httpPort}`)}\n`;
+    }
+    const statusBox = boxen(`${chalk.cyan.bold('🚀 Serverless Development Server Running')}\n\n${urlLines}\n` + `${chalk.yellow('Press Ctrl+C to stop the server')}`, {
+        backgroundColor: '#1a1a1a',
+        borderColor: 'cyan',
+        borderStyle: 'round',
+        margin: 1,
+        padding: 1
+    });
+    console.log(`\n${statusBox}\n`);
+};
+const loadHandler = async (handlerPath, outputDir)=>{
+    try {
+        const fullPath = pathResolve(outputDir, handlerPath);
+        log(`Loading handler from: ${fullPath}`, 'info', false);
+        if (!existsSync(fullPath)) {
+            throw new Error(`Handler file not found: ${fullPath}`);
         }
-      }
-      app.use(graphqlPath, async (req, res) => {
-        if (debug && req.body && req.body.query) {
-          log("\u{1F50D} GraphQL Debug Mode: Analyzing request...", "info", false);
-          log(`\u{1F4DD} GraphQL Query: ${req.body.query}`, "info", false);
-          if (req.body.variables) {
-            log(`\u{1F4CA} GraphQL Variables: ${JSON.stringify(req.body.variables, null, 2)}`, "info", false);
-          }
-          if (req.body.operationName) {
-            log(`\u{1F3F7}\uFE0F  GraphQL Operation: ${req.body.operationName}`, "info", false);
-          }
+        // Dynamic import of the handler with better error handling
+        try {
+            const handlerModule = await import(fullPath);
+            log(`Handler module loaded: ${Object.keys(handlerModule)}`, 'info', false);
+            const handler = handlerModule.default || handlerModule.handler || handlerModule;
+            log(`Handler found: ${typeof handler}`, 'info', false);
+            return handler;
+        } catch (importError) {
+            log(`Import error for handler ${handlerPath}: ${importError.message}`, 'error', false);
+            return null;
         }
+    } catch (error) {
+        log(`Error loading handler ${handlerPath}: ${error.message}`, 'error', false);
+        return null;
+    }
+};
+const captureConsoleLogs = (handler, quiet)=>{
+    if (quiet) {
+        return handler;
+    }
+    return async (event, context)=>{
+        // Capture console.log, console.error, etc.
         const originalConsoleLog = console.log;
+        const originalConsoleError = console.error;
+        const originalConsoleWarn = console.warn;
+        const originalConsoleInfo = console.info;
         const logs = [];
-        console.log = (...args) => {
-          const logMessage = args.map(
-            (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
-          ).join(" ");
-          logs.push(logMessage);
-          originalConsoleLog(`[GraphQL] ${logMessage}`);
+        console.log = (...args)=>{
+            logs.push(`[LOG] ${args.join(' ')}`);
+            originalConsoleLog(...args);
+        };
+        console.error = (...args)=>{
+            logs.push(`[ERROR] ${args.join(' ')}`);
+            originalConsoleError(...args);
+        };
+        console.warn = (...args)=>{
+            logs.push(`[WARN] ${args.join(' ')}`);
+            originalConsoleWarn(...args);
         };
-        const context = {
-          awsRequestId: "test-request-id",
-          functionName: "graphql",
-          functionVersion: "$LATEST",
-          getRemainingTimeInMillis: () => 3e4,
-          invokedFunctionArn: "arn:aws:lambda:us-east-1:123456789012:function:graphql",
-          logGroupName: "/aws/lambda/graphql",
-          logStreamName: "test-log-stream",
-          req,
-          res
+        console.info = (...args)=>{
+            logs.push(`[INFO] ${args.join(' ')}`);
+            originalConsoleInfo(...args);
         };
-        const wrappedHandler = captureConsoleLogs(graphqlHandler, quiet);
         try {
-          const result = await wrappedHandler({
-            body: JSON.stringify(req.body),
-            headers: req.headers,
-            httpMethod: "POST",
-            path: graphqlPath,
-            queryStringParameters: {}
-          }, context);
-          console.log = originalConsoleLog;
-          if (result && typeof result === "object" && result.statusCode) {
-            res.status(result.statusCode);
-            if (result.headers) {
-              Object.entries(result.headers).forEach(([key, value]) => {
-                res.setHeader(key, String(value));
-              });
+            const result = await handler(event, context);
+            // Output captured logs
+            if (logs.length > 0) {
+                console.log(chalk.gray('--- Handler Console Output ---'));
+                logs.forEach((log)=>console.log(chalk.gray(log)));
+                console.log(chalk.gray('--- End Handler Console Output ---'));
             }
-            res.send(result.body);
-          } else {
-            res.json(result);
-          }
-        } catch (error) {
-          console.log = originalConsoleLog;
-          log(`GraphQL handler error: ${error.message}`, "error", false);
-          res.status(500).json({ error: error.message });
+            return result;
+        } finally{
+            // Restore original console methods
+            console.log = originalConsoleLog;
+            console.error = originalConsoleError;
+            console.warn = originalConsoleWarn;
+            console.info = originalConsoleInfo;
         }
-      });
-      log(`GraphQL endpoint available at http://${host}:${httpPort}${graphqlPath}`, "info", quiet);
-    }
-  } catch (error) {
-    log(`Error setting up GraphQL: ${error.message}`, "error", quiet);
-  }
-  app.use("/", async (req, res) => {
-    try {
-      const url = req.url || "/";
-      const method = req.method || "GET";
-      const pathname = req.path || url.split("?")[0];
-      log(`${method} ${url} (pathname: ${pathname})`, "info", false);
-      let matchedFunction = null;
-      if (config.functions) {
-        for (const [functionName, functionConfig] of Object.entries(config.functions)) {
-          if (functionConfig.events) {
-            for (const event of functionConfig.events) {
-              if (event.http) {
-                const eventPath = event.http.path || "/";
-                const eventMethod = event.http.method || "GET";
-                if (eventPath && eventPath === pathname && eventMethod === method) {
-                  matchedFunction = functionName;
-                  break;
+    };
+};
+const createExpressServer = async (config, outputDir, httpPort, host, quiet, debug)=>{
+    const app = express();
+    // Enable CORS
+    app.use((req, res, next)=>{
+        res.header('Access-Control-Allow-Origin', '*');
+        res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+        res.header('Access-Control-Allow-Headers', '*');
+        res.header('Access-Control-Allow-Credentials', 'true');
+        if (req.method === 'OPTIONS') {
+            res.sendStatus(200);
+        } else {
+            next();
+        }
+    });
+    // Parse JSON bodies
+    app.use(express.json());
+    // Load GraphQL handler
+    const loadGraphQLSchema = async ()=>{
+        try {
+            // Try to find a GraphQL handler
+            let graphqlHandler = null;
+            if (config.functions) {
+                for (const [functionName, functionConfig] of Object.entries(config.functions)){
+                    if (functionConfig.events) {
+                        for (const event of functionConfig.events){
+                            if (event.http && event.http.path) {
+                                // Look for GraphQL endpoints
+                                if (event.http.path === '/public' || event.http.path === '/graphql') {
+                                    graphqlHandler = await loadHandler(functionConfig.handler, outputDir);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (graphqlHandler) {
+                        break;
+                    }
                 }
-              }
             }
-          }
-          if (matchedFunction) {
-            break;
-          }
+            if (graphqlHandler) {
+                log('Found GraphQL handler', 'info', quiet);
+                return graphqlHandler;
+            }
+            return null;
+        } catch (error) {
+            log(`Error loading GraphQL handler: ${error.message}`, 'error', quiet);
+            return null;
         }
-      }
-      if (matchedFunction && config.functions[matchedFunction]) {
-        const handlerPath = config.functions[matchedFunction].handler;
-        const handler = await loadHandler(handlerPath, outputDir);
-        if (handler) {
-          const wrappedHandler = captureConsoleLogs(handler, quiet);
-          const event = {
-            body: req.body,
-            headers: req.headers,
-            httpMethod: method,
-            path: url,
-            queryStringParameters: req.query
-          };
-          const context = {
-            awsRequestId: "test-request-id",
-            functionName: matchedFunction,
-            functionVersion: "$LATEST",
-            getRemainingTimeInMillis: () => 3e4,
-            invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,
-            logGroupName: `/aws/lambda/${matchedFunction}`,
-            logStreamName: "test-log-stream",
-            memoryLimitInMB: "128"
-          };
-          try {
-            const result = await wrappedHandler(event, context);
-            if (result && typeof result === "object" && result.statusCode) {
-              res.status(result.statusCode);
-              if (result.headers) {
-                Object.entries(result.headers).forEach(([key, value]) => {
-                  res.setHeader(key, String(value));
-                });
-              }
-              res.send(result.body);
-            } else {
-              res.json(result);
+    };
+    // Set up GraphQL handler for GraphQL requests
+    try {
+        const graphqlHandler = await loadGraphQLSchema();
+        if (graphqlHandler) {
+            // Find the GraphQL path from the serverless config
+            let graphqlPath = '/graphql'; // default fallback
+            if (config.functions) {
+                for (const [_functionName, functionConfig] of Object.entries(config.functions)){
+                    if (functionConfig.events) {
+                        for (const event of functionConfig.events){
+                            if (event?.http?.path) {
+                                graphqlPath = event.http.path;
+                                break;
+                            }
+                        }
+                    }
+                    if (graphqlPath !== '/graphql') {
+                        break;
+                    }
+                }
             }
-          } catch (error) {
-            log(`Handler error: ${error.message}`, "error", false);
-            res.status(500).json({ error: error.message });
-          }
-        } else {
-          res.status(404).json({ error: "Handler not found" });
+            // Set up GraphQL endpoint with enhanced console.log capture
+            app.use(graphqlPath, async (req, res)=>{
+                // GraphQL Debug Logging
+                if (debug && req.body && req.body.query) {
+                    log('🔍 GraphQL Debug Mode: Analyzing request...', 'info', false);
+                    log(`📝 GraphQL Query: ${req.body.query}`, 'info', false);
+                    if (req.body.variables) {
+                        log(`📊 GraphQL Variables: ${JSON.stringify(req.body.variables, null, 2)}`, 'info', false);
+                    }
+                    if (req.body.operationName) {
+                        log(`🏷️  GraphQL Operation: ${req.body.operationName}`, 'info', false);
+                    }
+                }
+                // Enhanced console.log capture
+                const originalConsoleLog = console.log;
+                const logs = [];
+                console.log = (...args)=>{
+                    const logMessage = args.map((arg)=>typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)).join(' ');
+                    logs.push(logMessage);
+                    originalConsoleLog(`[GraphQL] ${logMessage}`);
+                };
+                // Create context for the handler
+                const context = {
+                    awsRequestId: 'test-request-id',
+                    functionName: 'graphql',
+                    functionVersion: '$LATEST',
+                    getRemainingTimeInMillis: ()=>30000,
+                    invokedFunctionArn: 'arn:aws:lambda:us-east-1:123456789012:function:graphql',
+                    logGroupName: '/aws/lambda/graphql',
+                    logStreamName: 'test-log-stream',
+                    req,
+                    res
+                };
+                // Wrap handler with console log capture
+                const wrappedHandler = captureConsoleLogs(graphqlHandler, quiet);
+                try {
+                    // Call the handler with GraphQL parameters
+                    const result = await wrappedHandler({
+                        body: JSON.stringify(req.body),
+                        headers: req.headers,
+                        httpMethod: 'POST',
+                        path: graphqlPath,
+                        queryStringParameters: {}
+                    }, context);
+                    // Restore console.log
+                    console.log = originalConsoleLog;
+                    // Handle the result
+                    if (result && typeof result === 'object' && result.statusCode) {
+                        res.status(result.statusCode);
+                        if (result.headers) {
+                            Object.entries(result.headers).forEach(([key, value])=>{
+                                res.setHeader(key, String(value));
+                            });
+                        }
+                        res.send(result.body);
+                    } else {
+                        res.json(result);
+                    }
+                } catch (error) {
+                    // Restore console.log
+                    console.log = originalConsoleLog;
+                    log(`GraphQL handler error: ${error.message}`, 'error', false);
+                    res.status(500).json({
+                        error: error.message
+                    });
+                }
+            });
+            log(`GraphQL endpoint available at http://${host}:${httpPort}${graphqlPath}`, 'info', quiet);
         }
-      } else {
-        res.status(404).json({ error: "Function not found" });
-      }
     } catch (error) {
-      log(`Route handling error: ${error.message}`, "error", false);
-      res.status(500).json({ error: error.message });
+        log(`Error setting up GraphQL: ${error.message}`, 'error', quiet);
     }
-  });
-  return app;
-};
-const createWebSocketServer = (config, outputDir, wsPort, quiet, debug) => {
-  const wss = new WebSocketServer({ port: wsPort });
-  wss.on("connection", async (ws, req) => {
-    log(`WebSocket connection established: ${req.url}`, "info", false);
-    ws.on("message", async (message) => {
-      try {
-        const data = JSON.parse(message.toString());
-        let matchedFunction = null;
-        if (config.functions) {
-          for (const [functionName, functionConfig] of Object.entries(config.functions)) {
-            if (functionConfig.events) {
-              for (const event of functionConfig.events) {
-                if (event.websocket) {
-                  const route = event.websocket.route || "$connect";
-                  if (route === "$default" || route === data.action) {
-                    matchedFunction = functionName;
-                    break;
-                  }
+    // Fallback for non-GraphQL routes - handle all remaining routes
+    app.use('/', async (req, res)=>{
+        try {
+            const url = req.url || '/';
+            const method = req.method || 'GET';
+            const pathname = req.path || url.split('?')[0]; // Extract pathname without query string
+            log(`${method} ${url} (pathname: ${pathname})`, 'info', false);
+            // Find matching function
+            let matchedFunction = null;
+            if (config.functions) {
+                for (const [functionName, functionConfig] of Object.entries(config.functions)){
+                    if (functionConfig.events) {
+                        for (const event of functionConfig.events){
+                            if (event.http) {
+                                const eventPath = event.http.path || '/';
+                                const eventMethod = event.http.method || 'GET';
+                                // Improved path matching - compare pathname without query string
+                                if (eventPath && eventPath === pathname && eventMethod === method) {
+                                    matchedFunction = functionName;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    if (matchedFunction) {
+                        break;
+                    }
                 }
-              }
             }
-            if (matchedFunction) {
-              break;
-            }
-          }
-        }
-        if (matchedFunction && config.functions[matchedFunction]) {
-          const handler = await loadHandler(config.functions[matchedFunction].handler, outputDir);
-          if (handler) {
-            const wrappedHandler = captureConsoleLogs(handler, quiet);
-            const event = {
-              body: data.body || null,
-              requestContext: {
-                apiGateway: {
-                  endpoint: `ws://localhost:${wsPort}`
-                },
-                connectionId: "test-connection-id",
-                routeKey: data.action || "$default"
-              }
-            };
-            const context = {
-              awsRequestId: "test-request-id",
-              functionName: matchedFunction,
-              functionVersion: "$LATEST",
-              getRemainingTimeInMillis: () => 3e4,
-              invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,
-              logGroupName: `/aws/lambda/${matchedFunction}`,
-              logStreamName: "test-log-stream",
-              memoryLimitInMB: "128"
-            };
-            const result = await wrappedHandler(event, context);
-            if (result && typeof result === "object" && result.statusCode) {
-              const body = result.body || "";
-              ws.send(body);
+            if (matchedFunction && config.functions[matchedFunction]) {
+                // Resolve handler path relative to output directory
+                const handlerPath = config.functions[matchedFunction].handler;
+                const handler = await loadHandler(handlerPath, outputDir);
+                if (handler) {
+                    const wrappedHandler = captureConsoleLogs(handler, quiet);
+                    const event = {
+                        body: req.body,
+                        headers: req.headers,
+                        httpMethod: method,
+                        path: url,
+                        queryStringParameters: req.query
+                    };
+                    const context = {
+                        awsRequestId: 'test-request-id',
+                        functionName: matchedFunction,
+                        functionVersion: '$LATEST',
+                        getRemainingTimeInMillis: ()=>30000,
+                        invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,
+                        logGroupName: `/aws/lambda/${matchedFunction}`,
+                        logStreamName: 'test-log-stream',
+                        memoryLimitInMB: '128'
+                    };
+                    try {
+                        const result = await wrappedHandler(event, context);
+                        if (result && typeof result === 'object' && result.statusCode) {
+                            res.status(result.statusCode);
+                            if (result.headers) {
+                                Object.entries(result.headers).forEach(([key, value])=>{
+                                    res.setHeader(key, String(value));
+                                });
+                            }
+                            res.send(result.body);
+                        } else {
+                            res.json(result);
+                        }
+                    } catch (error) {
+                        log(`Handler error: ${error.message}`, 'error', false);
+                        res.status(500).json({
+                            error: error.message
+                        });
+                    }
+                } else {
+                    res.status(404).json({
+                        error: 'Handler not found'
+                    });
+                }
             } else {
-              ws.send(JSON.stringify(result));
+                res.status(404).json({
+                    error: 'Function not found'
+                });
             }
-          } else {
-            ws.send(JSON.stringify({ error: "Handler not found" }));
-          }
-        } else {
-          ws.send(JSON.stringify({ error: "WebSocket function not found" }));
+        } catch (error) {
+            log(`Route handling error: ${error.message}`, 'error', false);
+            res.status(500).json({
+                error: error.message
+            });
         }
-      } catch (error) {
-        log(`WebSocket error: ${error.message}`, "error", false);
-        ws.send(JSON.stringify({ error: error.message }));
-      }
     });
-    ws.on("close", () => {
-      log("WebSocket connection closed", "info", false);
+    return app;
+};
+const createWebSocketServer = (config, outputDir, wsPort, quiet, debug)=>{
+    const wss = new WebSocketServer({
+        port: wsPort
+    });
+    wss.on('connection', async (ws, req)=>{
+        log(`WebSocket connection established: ${req.url}`, 'info', false);
+        ws.on('message', async (message)=>{
+            try {
+                const data = JSON.parse(message.toString());
+                // Find matching WebSocket function
+                let matchedFunction = null;
+                if (config.functions) {
+                    for (const [functionName, functionConfig] of Object.entries(config.functions)){
+                        if (functionConfig.events) {
+                            for (const event of functionConfig.events){
+                                if (event.websocket) {
+                                    const route = event.websocket.route || '$connect';
+                                    if (route === '$default' || route === data.action) {
+                                        matchedFunction = functionName;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (matchedFunction) {
+                            break;
+                        }
+                    }
+                }
+                if (matchedFunction && config.functions[matchedFunction]) {
+                    const handler = await loadHandler(config.functions[matchedFunction].handler, outputDir);
+                    if (handler) {
+                        // Wrap handler with console log capture
+                        const wrappedHandler = captureConsoleLogs(handler, quiet);
+                        const event = {
+                            body: data.body || null,
+                            requestContext: {
+                                apiGateway: {
+                                    endpoint: `ws://localhost:${wsPort}`
+                                },
+                                connectionId: 'test-connection-id',
+                                routeKey: data.action || '$default'
+                            }
+                        };
+                        const context = {
+                            awsRequestId: 'test-request-id',
+                            functionName: matchedFunction,
+                            functionVersion: '$LATEST',
+                            getRemainingTimeInMillis: ()=>30000,
+                            invokedFunctionArn: `arn:aws:lambda:us-east-1:123456789012:function:${matchedFunction}`,
+                            logGroupName: `/aws/lambda/${matchedFunction}`,
+                            logStreamName: 'test-log-stream',
+                            memoryLimitInMB: '128'
+                        };
+                        const result = await wrappedHandler(event, context);
+                        // Handle Lambda response format for WebSocket
+                        if (result && typeof result === 'object' && result.statusCode) {
+                            // This is a Lambda response object, extract the body
+                            const body = result.body || '';
+                            ws.send(body);
+                        } else {
+                            // This is a direct response, stringify it
+                            ws.send(JSON.stringify(result));
+                        }
+                    } else {
+                        ws.send(JSON.stringify({
+                            error: 'Handler not found'
+                        }));
+                    }
+                } else {
+                    ws.send(JSON.stringify({
+                        error: 'WebSocket function not found'
+                    }));
+                }
+            } catch (error) {
+                log(`WebSocket error: ${error.message}`, 'error', false);
+                ws.send(JSON.stringify({
+                    error: error.message
+                }));
+            }
+        });
+        ws.on('close', ()=>{
+            log('WebSocket connection closed', 'info', false);
+        });
     });
-  });
-  return wss;
+    return wss;
 };
-const loadEnvFile = (envPath) => {
-  const envVars = {};
-  if (!existsSync(envPath)) {
-    return envVars;
-  }
-  try {
-    const envContent = readFileSync(envPath, "utf8");
-    const lines = envContent.split("\n");
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      if (!trimmedLine || trimmedLine.startsWith("#")) {
-        continue;
-      }
-      const equalIndex = trimmedLine.indexOf("=");
-      if (equalIndex > 0) {
-        const key = trimmedLine.substring(0, equalIndex).trim();
-        const value = trimmedLine.substring(equalIndex + 1).trim();
-        const cleanValue = value.replace(/^["']|["']$/g, "");
-        if (key) {
-          envVars[key] = cleanValue;
+const loadEnvFile = (envPath)=>{
+    const envVars = {};
+    if (!existsSync(envPath)) {
+        return envVars;
+    }
+    try {
+        const envContent = readFileSync(envPath, 'utf8');
+        const lines = envContent.split('\n');
+        for (const line of lines){
+            const trimmedLine = line.trim();
+            // Skip empty lines and comments
+            if (!trimmedLine || trimmedLine.startsWith('#')) {
+                continue;
+            }
+            // Parse KEY=value format
+            const equalIndex = trimmedLine.indexOf('=');
+            if (equalIndex > 0) {
+                const key = trimmedLine.substring(0, equalIndex).trim();
+                const value = trimmedLine.substring(equalIndex + 1).trim();
+                // Remove quotes if present
+                const cleanValue = value.replace(/^["']|["']$/g, '');
+                if (key) {
+                    envVars[key] = cleanValue;
+                }
+            }
         }
-      }
+    } catch (error) {
+        log(`Warning: Could not load .env file at ${envPath}: ${error.message}`, 'warn', false);
     }
-  } catch (error) {
-    log(`Warning: Could not load .env file at ${envPath}: ${error.message}`, "warn", false);
-  }
-  return envVars;
+    return envVars;
 };
-const serverless = async (cmd, callback = () => ({})) => {
-  const {
-    cliName = "Lex",
-    config,
-    debug = false,
-    host = "localhost",
-    httpPort = 3e3,
-    httpsPort = 3001,
-    quiet = false,
-    remove = false,
-    test = false,
-    usePublicIp,
-    variables,
-    wsPort = 3002
-  } = cmd;
-  const spinner = createSpinner(quiet);
-  log(`${cliName} starting serverless development server...`, "info", quiet);
-  await LexConfig.parseConfig(cmd);
-  const { outputFullPath } = LexConfig.config;
-  const envPaths = [
-    pathResolve(process.cwd(), ".env"),
-    pathResolve(process.cwd(), ".env.local"),
-    pathResolve(process.cwd(), ".env.development")
-  ];
-  let envVars = {};
-  for (const envPath of envPaths) {
-    const fileEnvVars = loadEnvFile(envPath);
-    if (Object.keys(fileEnvVars).length > 0) {
-      log(`Loaded environment variables from: ${envPath}`, "info", quiet);
+export const serverless = async (cmd, callback = ()=>({}))=>{
+    const { cliName = 'Lex', config, debug = false, host = 'localhost', httpPort = 3000, httpsPort = 3001, quiet = false, remove = false, test = false, usePublicIp, variables, wsPort = 3002 } = cmd;
+    const spinner = createSpinner(quiet);
+    log(`${cliName} starting serverless development server...`, 'info', quiet);
+    await LexConfig.parseConfig(cmd);
+    const { outputFullPath } = LexConfig.config;
+    // Load environment variables from .env files
+    const envPaths = [
+        pathResolve(process.cwd(), '.env'),
+        pathResolve(process.cwd(), '.env.local'),
+        pathResolve(process.cwd(), '.env.development')
+    ];
+    let envVars = {};
+    // Load from .env files in order (later files override earlier ones)
+    for (const envPath of envPaths){
+        const fileEnvVars = loadEnvFile(envPath);
+        if (Object.keys(fileEnvVars).length > 0) {
+            log(`Loaded environment variables from: ${envPath}`, 'info', quiet);
+        }
+        envVars = {
+            ...envVars,
+            ...fileEnvVars
+        };
     }
-    envVars = { ...envVars, ...fileEnvVars };
-  }
-  let variablesObj = { NODE_ENV: "development", ...envVars };
-  if (variables) {
-    try {
-      const cliVars = JSON.parse(variables);
-      variablesObj = { ...variablesObj, ...cliVars };
-    } catch (_error) {
-      log(`
-${cliName} Error: Environment variables option is not a valid JSON object.`, "error", quiet);
-      callback(1);
-      return 1;
+    // Start with default NODE_ENV and loaded .env variables
+    let variablesObj = {
+        NODE_ENV: 'development',
+        ...envVars
+    };
+    // Override with command line variables if provided
+    if (variables) {
+        try {
+            const cliVars = JSON.parse(variables);
+            variablesObj = {
+                ...variablesObj,
+                ...cliVars
+            };
+        } catch (_error) {
+            log(`\n${cliName} Error: Environment variables option is not a valid JSON object.`, 'error', quiet);
+            callback(1);
+            return 1;
+        }
     }
-  }
-  process.env = { ...process.env, ...variablesObj };
-  if (test) {
-    log("Test mode: Environment variables loaded, exiting", "info", quiet);
-    callback(0);
-    return 0;
-  }
-  if (remove) {
-    spinner.start("Cleaning output directory...");
-    await removeFiles(outputFullPath || "");
-    spinner.succeed("Successfully cleaned output directory!");
-  }
-  let serverlessConfig = {};
-  try {
-    const configPath = config || pathResolve(process.cwd(), "lex.config.mjs");
-    log(`Loading serverless config from: ${configPath}`, "info", quiet);
-    if (existsSync(configPath)) {
-      const configModule = await import(configPath);
-      serverlessConfig = configModule.default?.serverless || configModule.serverless || {};
-      log("Serverless config loaded successfully", "info", quiet);
-      log(`Loaded functions: ${Object.keys(serverlessConfig.functions || {}).join(", ")}`, "info", quiet);
-    } else {
-      log(`No serverless config found at ${configPath}, using defaults`, "warn", quiet);
+    process.env = {
+        ...process.env,
+        ...variablesObj
+    };
+    // If in test mode, exit early after loading environment variables
+    if (test) {
+        log('Test mode: Environment variables loaded, exiting', 'info', quiet);
+        callback(0);
+        return 0;
     }
-  } catch (error) {
-    log(`Error loading serverless config: ${error.message}`, "error", quiet);
-  }
-  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
-      }
+    if (remove) {
+        spinner.start('Cleaning output directory...');
+        await removeFiles(outputFullPath || '');
+        spinner.succeed('Successfully cleaned output directory!');
     }
-  };
-  const outputDir = outputFullPath || "lib";
-  log(`Using output directory: ${outputDir}`, "info", quiet);
-  try {
-    spinner.start("Starting serverless development server...");
-    const httpPort2 = finalConfig.custom["serverless-offline"].httpPort;
-    const wsPort2 = finalConfig.custom["serverless-offline"].wsPort;
-    const host2 = finalConfig.custom["serverless-offline"].host;
-    log(`Creating HTTP server on ${host2}:${httpPort2}`, "info", quiet);
-    log(`Creating WebSocket server on port ${wsPort2}`, "info", quiet);
-    const expressApp = await createExpressServer(
-      finalConfig,
-      outputDir,
-      httpPort2,
-      host2,
-      quiet,
-      debug
-    );
-    const wsServer = createWebSocketServer(
-      finalConfig,
-      outputDir,
-      wsPort2,
-      quiet,
-      debug
-    );
-    wsServer.on("error", (error) => {
-      log(`WebSocket server error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to start WebSocket server.");
-      callback(1);
-      return;
-    });
-    const server = expressApp.listen(httpPort2, host2, () => {
-      spinner.succeed("Serverless development server started.");
-      displayServerStatus(
-        httpPort2,
-        finalConfig.custom["serverless-offline"].httpsPort,
-        wsPort2,
-        host2,
-        quiet
-      );
-      fetchPublicIp(usePublicIp).then((publicIp) => {
-        if (publicIp) {
-          displayServerStatus(
-            httpPort2,
-            finalConfig.custom["serverless-offline"].httpsPort,
-            wsPort2,
-            host2,
-            quiet,
-            publicIp
-          );
+    // Load serverless configuration
+    let serverlessConfig = {};
+    try {
+        const configPath = config || pathResolve(process.cwd(), 'lex.config.mjs');
+        log(`Loading serverless config from: ${configPath}`, 'info', quiet);
+        if (existsSync(configPath)) {
+            const configModule = await import(configPath);
+            serverlessConfig = configModule.default?.serverless || configModule.serverless || {};
+            log('Serverless config loaded successfully', 'info', quiet);
+            log(`Loaded functions: ${Object.keys(serverlessConfig.functions || {}).join(', ')}`, 'info', quiet);
+        } else {
+            log(`No serverless config found at ${configPath}, using defaults`, 'warn', quiet);
+        }
+    } catch (error) {
+        log(`Error loading serverless config: ${error.message}`, 'error', quiet);
+    // Don't exit, continue with empty config
+    }
+    // Merge config with command line options
+    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
+            }
         }
-      });
-    });
-    server.on("error", (error) => {
-      log(`Express server error: ${error.message}`, "error", quiet);
-      spinner.fail("Failed to start Express server.");
-      callback(1);
-      return;
-    });
-    const shutdown = () => {
-      log("\nShutting down serverless development server...", "info", quiet);
-      server.close();
-      wsServer.close();
-      callback(0);
     };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-    process.stdin.resume();
-    log("Serverless development server is running. Press Ctrl+C to stop.", "info", quiet);
-    return 0;
-  } catch (error) {
-    log(`
-${cliName} Error: ${error.message}`, "error", quiet);
-    spinner.fail("Failed to start serverless development server.");
-    callback(1);
-    return 1;
-  }
-};
-export {
-  serverless
+    const outputDir = outputFullPath || 'lib';
+    log(`Using output directory: ${outputDir}`, 'info', quiet);
+    try {
+        spinner.start('Starting serverless development server...');
+        const httpPort = finalConfig.custom['serverless-offline'].httpPort;
+        const wsPort = finalConfig.custom['serverless-offline'].wsPort;
+        const host = finalConfig.custom['serverless-offline'].host;
+        log(`Creating HTTP server on ${host}:${httpPort}`, 'info', quiet);
+        log(`Creating WebSocket server on port ${wsPort}`, 'info', quiet);
+        // Create Express server
+        const expressApp = await createExpressServer(finalConfig, outputDir, httpPort, host, quiet, debug);
+        // Create WebSocket server
+        const wsServer = createWebSocketServer(finalConfig, outputDir, wsPort, quiet, debug);
+        // Handle server errors
+        wsServer.on('error', (error)=>{
+            log(`WebSocket server error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed to start WebSocket server.');
+            callback(1);
+            return;
+        });
+        // Start Express server
+        const server = expressApp.listen(httpPort, host, ()=>{
+            spinner.succeed('Serverless development server started.');
+            displayServerStatus(httpPort, finalConfig.custom['serverless-offline'].httpsPort, wsPort, host, quiet);
+            fetchPublicIp(usePublicIp).then((publicIp)=>{
+                if (publicIp) {
+                    displayServerStatus(httpPort, finalConfig.custom['serverless-offline'].httpsPort, wsPort, host, quiet, publicIp);
+                }
+            });
+        });
+        // Handle Express server errors
+        server.on('error', (error)=>{
+            log(`Express server error: ${error.message}`, 'error', quiet);
+            spinner.fail('Failed to start Express server.');
+            callback(1);
+            return;
+        });
+        // Handle graceful shutdown
+        const shutdown = ()=>{
+            log('\nShutting down serverless development server...', 'info', quiet);
+            server.close();
+            wsServer.close();
+            callback(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        // Keep the process alive
+        process.stdin.resume();
+        log('Serverless development server is running. Press Ctrl+C to stop.', 'info', quiet);
+        // Don't call callback here, let the process stay alive
+        return 0;
+    } catch (error) {
+        log(`\n${cliName} Error: ${error.message}`, 'error', quiet);
+        spinner.fail('Failed to start serverless development server.');
+        callback(1);
+        return 1;
+    }
 };
-//# 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} from 'path';\nimport {WebSocketServer} from 'ws';\n\nimport {LexConfig} 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('\uD83D\uDE80 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    const fullPath = pathResolve(outputDir, handlerPath);\n    log(`Loading handler from: ${fullPath}`, 'info', false);\n\n    if(!existsSync(fullPath)) {\n      throw new Error(`Handler file not found: ${fullPath}`);\n    }\n\n    // Dynamic import of the handler with better error handling\n    try {\n      const handlerModule = await import(fullPath);\n      log(`Handler module loaded: ${Object.keys(handlerModule)}`, 'info', false);\n\n      const handler = handlerModule.default || handlerModule.handler || handlerModule;\n      log(`Handler found: ${typeof handler}`, 'info', false);\n\n      return handler;\n    } catch (importError) {\n      log(`Import error for handler ${handlerPath}: ${importError.message}`, 'error', false);\n      return null;\n    }\n  } catch (error) {\n    log(`Error loading handler ${handlerPath}: ${error.message}`, 'error', false);\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('\uD83D\uDD0D GraphQL Debug Mode: Analyzing request...', 'info', false);\n          log(`\uD83D\uDCDD GraphQL Query: ${req.body.query}`, 'info', false);\n          if(req.body.variables) {\n            log(`\uD83D\uDCCA GraphQL Variables: ${JSON.stringify(req.body.variables, null, 2)}`, 'info', false);\n          }\n          if(req.body.operationName) {\n            log(`\uD83C\uDFF7\uFE0F  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      log(`${method} ${url} (pathname: ${pathname})`, 'info', false);\n\n      // Find matching 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.http) {\n                const eventPath = event.http.path || '/';\n                const eventMethod = event.http.method || 'GET';\n\n                // Improved path matching - compare pathname without query string\n                if(eventPath && eventPath === pathname && eventMethod === method) {\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        // Resolve handler path relative to output directory\n        const handlerPath = config.functions[matchedFunction].handler;\n        const handler = await loadHandler(handlerPath, outputDir);\n\n        if(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            const result = await wrappedHandler(event, context);\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) {\n            log(`Handler error: ${error.message}`, 'error', false);\n            res.status(500).json({error: error.message});\n          }\n        } else {\n          res.status(404).json({error: 'Handler not found'});\n        }\n      } else {\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 = 3000,\n    httpsPort = 3001,\n    quiet = false,\n    remove = false,\n    test = false,\n    usePublicIp,\n    variables,\n    wsPort = 3002\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    const configPath = config || pathResolve(process.cwd(), 'lex.config.mjs');\n    log(`Loading serverless config from: ${configPath}`, 'info', quiet);\n\n    if(existsSync(configPath)) {\n      const configModule = await import(configPath);\n      serverlessConfig = configModule.default?.serverless || configModule.serverless || {};\n      log('Serverless config loaded successfully', 'info', quiet);\n      log(`Loaded functions: ${Object.keys(serverlessConfig.functions || {}).join(', ')}`, 'info', quiet);\n    } else {\n      log(`No serverless config found at ${configPath}, using defaults`, 'warn', quiet);\n    }\n  } catch (error) {\n    log(`Error loading serverless config: ${error.message}`, 'error', quiet);\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};"],
  "mappings": "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",
  "names": ["log", "httpPort", "wsPort", "host"]
}

+
+//# 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} from 'path';\nimport {WebSocketServer} from 'ws';\n\nimport {LexConfig} 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    const fullPath = pathResolve(outputDir, handlerPath);\n    log(`Loading handler from: ${fullPath}`, 'info', false);\n\n    if(!existsSync(fullPath)) {\n      throw new Error(`Handler file not found: ${fullPath}`);\n    }\n\n    // Dynamic import of the handler with better error handling\n    try {\n      const handlerModule = await import(fullPath);\n      log(`Handler module loaded: ${Object.keys(handlerModule)}`, 'info', false);\n\n      const handler = handlerModule.default || handlerModule.handler || handlerModule;\n      log(`Handler found: ${typeof handler}`, 'info', false);\n\n      return handler;\n    } catch(importError) {\n      log(`Import error for handler ${handlerPath}: ${importError.message}`, 'error', false);\n      return null;\n    }\n  } catch(error) {\n    log(`Error loading handler ${handlerPath}: ${error.message}`, 'error', false);\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      log(`${method} ${url} (pathname: ${pathname})`, 'info', false);\n\n      // Find matching 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.http) {\n                const eventPath = event.http.path || '/';\n                const eventMethod = event.http.method || 'GET';\n\n                // Improved path matching - compare pathname without query string\n                if(eventPath && eventPath === pathname && eventMethod === method) {\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        // Resolve handler path relative to output directory\n        const handlerPath = config.functions[matchedFunction].handler;\n        const handler = await loadHandler(handlerPath, outputDir);\n\n        if(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            const result = await wrappedHandler(event, context);\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) {\n            log(`Handler error: ${error.message}`, 'error', false);\n            res.status(500).json({error: error.message});\n          }\n        } else {\n          res.status(404).json({error: 'Handler not found'});\n        }\n      } else {\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 = 3000,\n    httpsPort = 3001,\n    quiet = false,\n    remove = false,\n    test = false,\n    usePublicIp,\n    variables,\n    wsPort = 3002\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    const configPath = config || pathResolve(process.cwd(), 'lex.config.mjs');\n    log(`Loading serverless config from: ${configPath}`, 'info', quiet);\n\n    if(existsSync(configPath)) {\n      const configModule = await import(configPath);\n      serverlessConfig = configModule.default?.serverless || configModule.serverless || {};\n      log('Serverless config loaded successfully', 'info', quiet);\n      log(`Loaded functions: ${Object.keys(serverlessConfig.functions || {}).join(', ')}`, 'info', quiet);\n    } else {\n      log(`No serverless config found at ${configPath}, using defaults`, 'warn', quiet);\n    }\n  } catch(error) {\n    log(`Error loading serverless config: ${error.message}`, 'error', quiet);\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","WebSocketServer","LexConfig","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","fullPath","Error","handlerModule","Object","keys","handler","default","importError","message","error","captureConsoleLogs","event","context","originalConsoleLog","originalConsoleError","originalConsoleWarn","warn","originalConsoleInfo","info","logs","args","push","result","length","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","split","matchedFunction","eventPath","eventMethod","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","replace","serverless","cmd","callback","cliName","remove","test","usePublicIp","spinner","parseConfig","outputFullPath","envPaths","process","cwd","fileEnvVars","variablesObj","NODE_ENV","cliVars","_error","env","start","succeed","serverlessConfig","configPath","configModule","finalConfig","custom","cors","expressApp","wsServer","fail","server","listen","shutdown","close","stdin","resume"],"mappings":"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"}