@nlabs/lex
Version:
630 lines (629 loc) • 76.4 kB
JavaScript
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
}
);
console.log(`
${statusBox}
`);
};
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}`);
}
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) => {
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);
};
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;
}
};
};
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;
}
}
}
}
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;
}
}
}
if (graphqlPath !== "/graphql") {
break;
}
}
}
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);
}
}
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}`);
};
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
};
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));
});
}
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 });
}
});
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;
}
}
}
}
if (matchedFunction) {
break;
}
}
}
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);
}
} 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 {
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 });
}
});
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;
}
}
}
}
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);
} else {
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;
};
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;
}
}
}
} catch (error) {
log(`Warning: Could not load .env file at ${envPath}: ${error.message}`, "warn", false);
}
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);
}
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;
}
}
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);
}
} 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
}
}
};
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
);
}
});
});
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
};
//# 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(), '.e