@optimizely/ocp-local-env 1.0.0-beta.10

package/dist/src/server.js

@@ -0,0 +1,735 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const express_1 = __importDefault(require("express"));
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const open_1 = __importDefault(require("open"));
+const os_1 = __importDefault(require("os"));
+// Import our components
+const watcher_1 = require("./executor/watcher");
+const app_discovery_1 = require("./server/app-discovery");
+const api_1 = require("./server/api");
+const config_1 = require("./server/config");
+const LocalConfigStore_1 = require("./local_engine/storage/LocalConfigStore");
+const LocalSettingsStore_1 = require("./local_engine/storage/LocalSettingsStore");
+const LifecycleExecutor_1 = require("./executor/LifecycleExecutor");
+const FunctionExecutor_1 = require("./executor/FunctionExecutor");
+const SourceExecutor_1 = require("./executor/SourceExecutor");
+const LogManager_1 = require("./logging/LogManager");
+/**
+ * Wait for the dev server to be fully ready
+ */
+async function waitForServerReady(baseUrl) {
+    console.log('Waiting for dev server to fully initialize...');
+    const maxAttempts = 30; // 30 attempts with 200ms delay = 6 seconds max
+    const delayMs = 200;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            // Check both health and app endpoints
+            const healthUrl = `${baseUrl}/devserver/api/health`;
+            const appUrl = `${baseUrl}/devserver/api/app`;
+            const [healthResponse, appResponse] = await Promise.all([
+                fetch(healthUrl),
+                fetch(appUrl)
+            ]);
+            if (healthResponse.ok && appResponse.ok) {
+                const healthData = await healthResponse.json();
+                const appData = await appResponse.json();
+                // Verify health status and app has valid data
+                if (healthData.status === 'ok' && appData.name && appData.name !== 'unknown') {
+                    console.log(`Dev server is ready! (attempt ${attempt}/${maxAttempts})`);
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            // Server not ready yet, continue waiting
+        }
+        // Wait before next attempt
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+    console.warn('Dev server may not be fully ready, but proceeding with browser open...');
+}
+async function startServer() {
+    // Create Express app
+    const app = (0, express_1.default)();
+    const server = http_1.default.createServer(app);
+    // Parse JSON requests
+    app.use(express_1.default.json());
+    // Serve static files for dev server
+    app.use("/devserver/static", express_1.default.static(path_1.default.join(__dirname, "../public")));
+    // Serve static files
+    app.use(express_1.default.static(path_1.default.join(__dirname, "../public")));
+    // Use the configured app root directory
+    const appRootDir = path_1.default.resolve(config_1.config.app.rootDir);
+    console.log(`Looking for OCP app in: ${appRootDir}`);
+    const ocpApp = await (0, app_discovery_1.discoverApp)(appRootDir);
+    if (!ocpApp) {
+        console.error(`No OCP app found in ${appRootDir}. Make sure app.yml exists.`);
+        process.exit(1);
+    }
+    console.log(`Found OCP app: ${ocpApp.manifest.meta.display_name} v${ocpApp.manifest.meta.version}`);
+    // Set up file watcher
+    const watcher = new watcher_1.AppWatcher(appRootDir);
+    // Set up config store
+    const configStore = new LocalConfigStore_1.LocalConfigStore(appRootDir);
+    // Set up settings store
+    const settingsStore = LocalSettingsStore_1.LocalSettingsStore.getInstance(appRootDir);
+    // Set up lifecycle executor
+    const lifecycleExecutor = new LifecycleExecutor_1.LifecycleExecutor(appRootDir, ocpApp, settingsStore, configStore, config_1.config.account, watcher);
+    // Set up function executor
+    const functionExecutor = new FunctionExecutor_1.FunctionExecutor(appRootDir, ocpApp, settingsStore, configStore, config_1.config.account, watcher);
+    // Config endpoint for runtime configuration
+    app.get('/devserver/api/config', (req, res) => {
+        res.json({
+            showZaiusAdminSections: process.env.SHOW_ZAIUS_ADMIN_SECTIONS === 'true'
+        });
+    });
+    // Set up API routes with /devserver prefix
+    app.use("/devserver/api", (0, api_1.createApiRoutes)(ocpApp, watcher, configStore));
+    // Set up v1 API routes at root level
+    const { createV1Routes } = require("./server/api/v1");
+    app.use("/v1", createV1Routes(ocpApp, watcher, configStore, lifecycleExecutor, settingsStore));
+    // Serve assets from the app directory
+    app.get("/assets/overview.md", (req, res) => {
+        const overviewPath = path_1.default.join(appRootDir, "assets", "directory", "overview.md");
+        // Check if the file exists
+        if (fs_1.default.existsSync(overviewPath)) {
+            // Set content type for markdown
+            res.setHeader("Content-Type", "text/markdown; charset=utf-8");
+            // Send the file
+            res.sendFile(overviewPath);
+        }
+        else {
+            // Return 404 if file doesn't exist
+            res.status(404).json({
+                error: {
+                    message: "Overview file not found",
+                    code: "FILE_NOT_FOUND",
+                },
+            });
+        }
+    });
+    app.get("/assets/settings.yml", (req, res) => {
+        const settingsPath = path_1.default.join(appRootDir, "forms", "settings.yml");
+        // Check if the file exists
+        if (fs_1.default.existsSync(settingsPath)) {
+            try {
+                // Read the file content
+                const fileContent = fs_1.default.readFileSync(settingsPath);
+                // Set content type for plain text
+                res.setHeader("Content-Type", "application/x-yaml");
+                // Return just the base64 content
+                res.send(fileContent);
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: {
+                        message: "Error reading settings file",
+                        code: "FILE_READ_ERROR",
+                    },
+                });
+            }
+        }
+        else {
+            // Return 404 if file doesn't exist
+            res.status(404).json({
+                error: {
+                    message: "Settings file not found",
+                    code: "FILE_NOT_FOUND",
+                },
+            });
+        }
+    });
+    app.get("/assets/icon.svg", (req, res) => {
+        const iconPath = path_1.default.join(appRootDir, "assets", "icon.svg");
+        // Check if the file exists
+        if (fs_1.default.existsSync(iconPath)) {
+            // Set content type for SVG
+            res.setHeader("Content-Type", "image/svg+xml");
+            // Send the file
+            res.sendFile(iconPath);
+        }
+        else {
+            // Return 404 if file doesn't exist
+            res.status(404).json({
+                error: {
+                    message: "Icon file not found",
+                    code: "FILE_NOT_FOUND",
+                },
+            });
+        }
+    });
+    app.get("/assets/logo.svg", (req, res) => {
+        const logoPath = path_1.default.join(appRootDir, "assets", "logo.svg");
+        // Check if the file exists
+        if (fs_1.default.existsSync(logoPath)) {
+            // Set content type for SVG
+            res.setHeader("Content-Type", "image/svg+xml");
+            // Send the file
+            res.sendFile(logoPath);
+        }
+        else {
+            // Return 404 if file doesn't exist
+            res.status(404).json({
+                error: {
+                    message: "Logo file not found",
+                    code: "FILE_NOT_FOUND",
+                },
+            });
+        }
+    });
+    // Source webhook handler
+    async function handleSourceWebhook(req, res, ocpApp, configStore) {
+        const { app_id, source_id, guid } = req.params;
+        const logger = LogManager_1.LogManager.getInstance();
+        try {
+            // Validate app_id
+            if (app_id !== ocpApp.manifest.meta.app_id) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'APP_NOT_FOUND'
+                    }
+                });
+            }
+            // Validate source exists
+            const sources = ocpApp.manifest.sources || {};
+            if (!sources[source_id]) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'SOURCE_NOT_FOUND'
+                    }
+                });
+            }
+            // Validate GUID
+            const storedGuid = configStore.getSourceGuid(source_id);
+            if (!storedGuid) {
+                // Generate and store GUID on first webhook
+                configStore.setSourceGuid(source_id, guid);
+            }
+            else if (storedGuid !== guid) {
+                return res.status(403).json({
+                    error: {
+                        message: 'Invalid webhook GUID',
+                        code: 'INVALID_GUID'
+                    }
+                });
+            }
+            // Build webhook request
+            const sourceExecutor = new SourceExecutor_1.SourceExecutor(ocpApp, configStore);
+            const webhookRequest = {
+                sourceId: source_id,
+                guid: guid,
+                method: req.method,
+                fullpath: req.url,
+                path: req.params[0] || '', // Wildcard path
+                params: req.query,
+                headers: Object.entries(req.headers),
+                body: req.body
+            };
+            const result = await sourceExecutor.executeSourceWebhook(webhookRequest);
+            // Send response
+            res.status(result.status);
+            // Handle headers - SDK returns headers as an object, not an array
+            if (result.headers) {
+                if (Array.isArray(result.headers)) {
+                    // If it's already an array of tuples
+                    result.headers.forEach(([key, value]) => {
+                        res.setHeader(key, value);
+                    });
+                }
+                else {
+                    // If it's an object, convert to entries
+                    Object.entries(result.headers).forEach(([key, value]) => {
+                        if (value !== undefined) {
+                            res.setHeader(key, String(value));
+                        }
+                    });
+                }
+            }
+            res.send(result.body);
+        }
+        catch (error) {
+            logger.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Source, 'Source webhook execution failed', {
+                id: source_id,
+                operation: 'webhook',
+                error,
+                errorMessage: error.message,
+                errorStack: error.stack
+            });
+            console.error('Source webhook error details:', {
+                sourceId: source_id,
+                error: error,
+                message: error.message,
+                stack: error.stack
+            });
+            res.status(500).json({
+                error: {
+                    message: 'Unexpected error during webhook execution',
+                    code: 'EXECUTION_ERROR',
+                    details: error.message || 'Internal server error',
+                    stack: error.stack
+                }
+            });
+        }
+    }
+    // Set up production-like function execution routes
+    // Format: /functions/<app_id>/<function_id>/<guid> and /functions/<app_id>/<function_id>/<guid>/*
+    const handleFunctionExecution = async (req, res) => {
+        const { app_id, function_id, guid } = req.params;
+        const payload = req.body;
+        const logManager = LogManager_1.LogManager.getInstance();
+        logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Executing function: ${app_id}/${function_id} (${req.method})`, {
+            id: function_id,
+            method: req.method
+        });
+        try {
+            // Extract path information for InternalRequest
+            const remainingPath = req.params[0] || ''; // Everything after GUID
+            const fullpath = req.path.replace(/^\/functions/, ''); // Remove /functions prefix
+            const path = remainingPath ? `/${remainingPath}` : '/'; // Path for function code
+            logManager.debug(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Path handling: originalPath=${req.path}, fullpath=${fullpath}, path=${path}`, {
+                id: function_id,
+                path
+            });
+            // Validate app_id matches current app
+            if (app_id !== ocpApp.manifest.meta.app_id) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'APP_NOT_FOUND'
+                    }
+                });
+            }
+            // Validate function exists
+            const functions = ocpApp.manifest.functions || {};
+            if (!functions[function_id]) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'FUNCTION_NOT_FOUND'
+                    }
+                });
+            }
+            // Validate app is installed
+            if (!configStore.isInstalled()) {
+                return res.status(403).json({
+                    error: {
+                        message: 'App must be installed to execute functions',
+                        code: 'APP_NOT_INSTALLED'
+                    }
+                });
+            }
+            // Validate GUID matches stored GUID for this function
+            const expectedGuid = configStore.getFunctionGuid(function_id);
+            if (guid !== expectedGuid) {
+                return res.status(403).json({
+                    error: {
+                        message: 'Invalid function GUID',
+                        code: 'INVALID_GUID'
+                    }
+                });
+            }
+            // Prepare function execution request
+            const functionRequest = {
+                functionId: function_id,
+                method: req.method,
+                fullpath,
+                path,
+                params: req.query,
+                headers: Object.entries(req.headers),
+                body: payload
+            };
+            // Execute function using FunctionExecutor
+            const executionResult = await functionExecutor.executeFunction(functionRequest);
+            if (executionResult.success) {
+                logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Function executed successfully: ${function_id} (${executionResult.executionTime}ms)`, {
+                    id: function_id,
+                    executionTime: executionResult.executionTime,
+                    status: executionResult.status || 200
+                });
+                // Set response headers if provided
+                if (executionResult.headers) {
+                    for (const [key, value] of executionResult.headers) {
+                        res.set(key, value);
+                    }
+                }
+                // Return successful function execution result
+                const status = executionResult.status || 200;
+                if (executionResult.body !== null && executionResult.body !== undefined) {
+                    // Function returned a specific response body
+                    if (Buffer.isBuffer(executionResult.body) || Array.isArray(executionResult.body)) {
+                        // Binary response
+                        res.status(status).send(Buffer.from(executionResult.body));
+                    }
+                    else {
+                        // JSON response
+                        res.status(status).json(executionResult.body);
+                    }
+                }
+                else {
+                    // No specific body, return execution info
+                    res.status(status).json({
+                        result: "Function executed successfully",
+                        logs: executionResult.logs,
+                        executionTime: executionResult.executionTime
+                    });
+                }
+            }
+            else {
+                logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Function execution failed: ${function_id} - ${executionResult.error?.message}`, {
+                    id: function_id,
+                    error: executionResult.error,
+                    errorMessage: executionResult.error?.message
+                });
+                // Return standardized error response for function execution failures
+                res.status(500).send("Unexpected error during webhook execution");
+            }
+        }
+        catch (error) {
+            logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Error executing function ${function_id}`, {
+                id: function_id,
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error)
+            });
+            res.status(500).send("Unexpected error during webhook execution");
+        }
+    };
+    // Global function execution handler (no GUID)
+    const handleGlobalFunctionExecution = async (req, res) => {
+        const { app_id, function_id } = req.params;
+        const payload = req.body;
+        const logManager = LogManager_1.LogManager.getInstance();
+        logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Executing global function: ${app_id}/${function_id} (${req.method})`, {
+            id: function_id,
+            method: req.method
+        });
+        try {
+            // Extract path information for InternalRequest
+            const remainingPath = req.params[0] || ''; // Everything after function_id
+            const fullpath = req.path.replace(/^\/functions/, ''); // Remove /functions prefix
+            const path = remainingPath ? `/${remainingPath}` : '/'; // Path for function code
+            logManager.debug(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Path handling: originalPath=${req.path}, fullpath=${fullpath}, path=${path}`, {
+                id: function_id,
+                path
+            });
+            // Validate app_id matches current app
+            if (app_id !== ocpApp.manifest.meta.app_id) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'APP_NOT_FOUND'
+                    }
+                });
+            }
+            // Validate function exists and is global
+            const functions = ocpApp.manifest.functions || {};
+            if (!functions[function_id]) {
+                return res.status(404).json({
+                    error: {
+                        message: 'Unable to find webhook with given request parameters',
+                        code: 'FUNCTION_NOT_FOUND'
+                    }
+                });
+            }
+            if (!functions[function_id].global) {
+                return res.status(403).json({
+                    error: {
+                        message: `Function '${function_id}' is not a global function`,
+                        code: 'NOT_GLOBAL_FUNCTION'
+                    }
+                });
+            }
+            // Validate app is installed
+            if (!configStore.isInstalled()) {
+                return res.status(403).json({
+                    error: {
+                        message: 'App must be installed to execute functions',
+                        code: 'APP_NOT_INSTALLED'
+                    }
+                });
+            }
+            // Prepare function execution request
+            const functionRequest = {
+                functionId: function_id,
+                method: req.method,
+                fullpath,
+                path,
+                params: req.query,
+                headers: Object.entries(req.headers),
+                body: payload
+            };
+            // Execute function using FunctionExecutor
+            const executionResult = await functionExecutor.executeFunction(functionRequest);
+            if (executionResult.success) {
+                logManager.info(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Global function executed successfully: ${function_id} (${executionResult.executionTime}ms)`, {
+                    id: function_id,
+                    executionTime: executionResult.executionTime,
+                    status: executionResult.status || 200
+                });
+                // Set response headers if provided
+                if (executionResult.headers) {
+                    for (const [key, value] of executionResult.headers) {
+                        res.set(key, value);
+                    }
+                }
+                // Return successful function execution result
+                const status = executionResult.status || 200;
+                if (executionResult.body !== null && executionResult.body !== undefined) {
+                    // Function returned a specific response body
+                    if (Buffer.isBuffer(executionResult.body) || Array.isArray(executionResult.body)) {
+                        // Binary response
+                        res.status(status).send(Buffer.from(executionResult.body));
+                    }
+                    else {
+                        // JSON response
+                        res.status(status).json(executionResult.body);
+                    }
+                }
+                else {
+                    // No specific body, return execution info
+                    res.status(status).json({
+                        result: "Function executed successfully",
+                        logs: executionResult.logs,
+                        executionTime: executionResult.executionTime
+                    });
+                }
+            }
+            else {
+                logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Global function execution failed: ${function_id} - ${executionResult.error?.message}`, {
+                    id: function_id,
+                    error: executionResult.error,
+                    errorMessage: executionResult.error?.message
+                });
+                // Return standardized error response for function execution failures
+                res.status(500).send("Unexpected error during webhook execution");
+            }
+        }
+        catch (error) {
+            logManager.error(LogManager_1.LogSource.System, LogManager_1.LogCategory.Function, `Error executing global function ${function_id}`, {
+                id: function_id,
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error)
+            });
+            res.status(500).send("Unexpected error during webhook execution");
+        }
+    };
+    // Register function routes for all HTTP methods
+    app.get("/functions/:app_id/:function_id/:guid", handleFunctionExecution);
+    app.post("/functions/:app_id/:function_id/:guid", handleFunctionExecution);
+    app.put("/functions/:app_id/:function_id/:guid", handleFunctionExecution);
+    app.delete("/functions/:app_id/:function_id/:guid", handleFunctionExecution);
+    app.patch("/functions/:app_id/:function_id/:guid", handleFunctionExecution);
+    app.get("/functions/:app_id/:function_id/:guid/*", handleFunctionExecution);
+    app.post("/functions/:app_id/:function_id/:guid/*", handleFunctionExecution);
+    app.put("/functions/:app_id/:function_id/:guid/*", handleFunctionExecution);
+    app.delete("/functions/:app_id/:function_id/:guid/*", handleFunctionExecution);
+    app.patch("/functions/:app_id/:function_id/:guid/*", handleFunctionExecution);
+    // Register source webhook routes for all HTTP methods
+    app.get("/sources/:app_id/:source_id/:guid", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.post("/sources/:app_id/:source_id/:guid", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.put("/sources/:app_id/:source_id/:guid", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.delete("/sources/:app_id/:source_id/:guid", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.patch("/sources/:app_id/:source_id/:guid", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.get("/sources/:app_id/:source_id/:guid/*", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.post("/sources/:app_id/:source_id/:guid/*", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.put("/sources/:app_id/:source_id/:guid/*", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.delete("/sources/:app_id/:source_id/:guid/*", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    app.patch("/sources/:app_id/:source_id/:guid/*", (req, res) => handleSourceWebhook(req, res, ocpApp, configStore));
+    // Register global function routes (no GUID) for all HTTP methods
+    app.get("/functions/:app_id/:function_id", handleGlobalFunctionExecution);
+    app.post("/functions/:app_id/:function_id", handleGlobalFunctionExecution);
+    app.put("/functions/:app_id/:function_id", handleGlobalFunctionExecution);
+    app.delete("/functions/:app_id/:function_id", handleGlobalFunctionExecution);
+    app.patch("/functions/:app_id/:function_id", handleGlobalFunctionExecution);
+    app.get("/functions/:app_id/:function_id/*", handleGlobalFunctionExecution);
+    app.post("/functions/:app_id/:function_id/*", handleGlobalFunctionExecution);
+    app.put("/functions/:app_id/:function_id/*", handleGlobalFunctionExecution);
+    app.delete("/functions/:app_id/:function_id/*", handleGlobalFunctionExecution);
+    app.patch("/functions/:app_id/:function_id/*", handleGlobalFunctionExecution);
+    // Middleware to modify JavaScript responses containing IFRAME_PARENT_ORIGIN
+    app.use(async (req, res, next) => {
+        // Skip proxy for /devserver routes, /v1 API routes, /assets routes, /functions routes, /sources routes, and client-side routes
+        if (req.path.startsWith("/devserver") ||
+            req.path.startsWith("/v1") ||
+            req.path.startsWith("/assets") ||
+            req.path.startsWith("/functions") ||
+            req.path.startsWith("/sources") ||
+            req.path === "/" ||
+            req.path.startsWith("/settings") ||
+            req.path.startsWith("/jobs") ||
+            req.path.startsWith("/destinations")) {
+            return next();
+        }
+        // For JavaScript files, we need to potentially modify the content
+        const isJSRequest = req.path.endsWith(".js") ||
+            req.headers.accept?.includes("javascript") ||
+            req.get("content-type")?.includes("javascript");
+        if (isJSRequest) {
+            try {
+                // Fetch from the target directly
+                const targetUrl = `https://directory.zaius.com${req.path}${req.url.includes("?") ? req.url.substring(req.url.indexOf("?")) : ""}`;
+                const response = await fetch(targetUrl, {
+                    method: req.method,
+                    headers: {
+                        ...req.headers,
+                        host: "directory.zaius.com",
+                    },
+                });
+                if (response.ok) {
+                    const content = await response.text();
+                    const host = req.get("host") || `${config_1.config.server.host}:${config_1.config.server.port}`;
+                    const protocol = req.secure ? "https" : "http";
+                    // Replace the IFRAME_PARENT_ORIGIN logic with our local origin
+                    let modifiedContent = content.replace(/targetOrigin:[a-zA-Z0-9]*,/g, `targetOrigin:'http://${config_1.config.server.host}:${config_1.config.server.port}',`);
+                    modifiedContent = modifiedContent.replace(/e\.host=\["api"\]\.concat\(t\)\.join\("\."\)/g, `e.host='${config_1.config.server.host}:${config_1.config.server.port}'`);
+                    console.log(content.match(/e\.host=.{0,40}/g));
+                    console.log(modifiedContent.match(/e\.host=.{0,40}/g));
+                    // Set response headers
+                    response.headers.forEach((value, key) => {
+                        if (key !== "content-length" && key !== "content-encoding") {
+                            res.set(key, value);
+                        }
+                    });
+                    res.send(modifiedContent);
+                    return;
+                }
+            }
+            catch (error) {
+                console.error("Error fetching JS file:", error);
+            }
+        }
+        // For all other requests, use the normal proxy
+        (0, http_proxy_middleware_1.createProxyMiddleware)({
+            target: "https://directory.zaius.com",
+            changeOrigin: true,
+            secure: true,
+        })(req, res, next);
+    });
+    // Serve the React app for client-side routing (must be last to not interfere with API routes)
+    // This catches all routes that aren't handled by previous middleware/routes
+    app.get("*", (req, res) => {
+        // Only serve index.html for non-API routes
+        // API routes are already handled above: /devserver/api/*, /v1/*, /functions/*, /sources/*, /app/*, /assets/*
+        res.sendFile(path_1.default.resolve(__dirname, "../public/index.html"));
+    });
+    // Start the file watcher first
+    watcher.start();
+    // Trigger initial build asynchronously (non-blocking)
+    const logger = LogManager_1.LogManager.getInstance();
+    logger.logBuildEvent('started');
+    watcher.triggerBuild().catch(error => {
+        logger.logBuildEvent('error', {
+            error: error instanceof Error ? error : new Error(String(error)),
+            errorMessage: 'Initial build failed, check your app code'
+        });
+        // Don't exit - let user fix code and watcher will rebuild automatically
+    });
+    // Set up server error handling before attempting to listen
+    server.on('error', (error) => {
+        if (error.code === 'EADDRINUSE') {
+            console.error('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+            console.error(`Port ${config_1.config.server.port} is already in use.`);
+            console.error('');
+            console.error('To fix this issue, you can:');
+            console.error(`  1. Stop the process using port ${config_1.config.server.port}`);
+            console.error(`  2. Use a different port: ocp-local-env --port <port>`);
+            console.error(`  3. Set OCP_LOCAL_PORT environment variable`);
+            console.error('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n');
+        }
+        else {
+            // For other server errors, display error message
+            console.error('\nFailed to start server:', error.message);
+        }
+        // Clean up resources before exit
+        watcher.stop();
+        process.exit(1);
+    });
+    // Start the server
+    const port = config_1.config.server.port;
+    server.listen(port, async () => {
+        const url = `http://localhost:${port}`;
+        console.log(`OCP Local Testing Tool running at ${url}`);
+        // Auto-open browser unless disabled, and only once per session
+        const shouldOpenBrowser = process.env.OCP_LOCAL_OPEN_BROWSER !== "false";
+        if (shouldOpenBrowser) {
+            // Use a temporary flag file to ensure browser opens only once per session
+            const flagFile = path_1.default.join(os_1.default.tmpdir(), `ocp-local-env-browser-opened-${port}`);
+            if (!fs_1.default.existsSync(flagFile)) {
+                try {
+                    // Wait for the dev server to be ready before opening browser
+                    console.log('Waiting for dev server to be ready...');
+                    await waitForServerReady(url);
+                    // Create flag file to prevent multiple opens
+                    fs_1.default.writeFileSync(flagFile, 'opened');
+                    console.log('Opening browser...');
+                    await (0, open_1.default)(url);
+                    // Clean up flag file on process exit
+                    process.on('exit', () => {
+                        try {
+                            if (fs_1.default.existsSync(flagFile)) {
+                                fs_1.default.unlinkSync(flagFile);
+                            }
+                        }
+                        catch (e) {
+                            // Ignore cleanup errors
+                        }
+                    });
+                }
+                catch (error) {
+                    console.warn('Failed to open browser automatically:', error instanceof Error ? error.message : String(error));
+                    console.log(`Please open your browser manually and go to: ${url}`);
+                }
+            }
+        }
+        else {
+            console.log(`Open your browser and go to: ${url}`);
+        }
+    });
+    // Handle shutdown
+    const shutdown = async () => {
+        console.log("Shutting down...");
+        // Stop watcher
+        watcher.stop();
+        // Cleanup IPC connections
+        try {
+            await lifecycleExecutor.cleanup();
+            await functionExecutor.cleanup();
+            console.log("IPC connections cleaned up");
+        }
+        catch (e) {
+            console.warn("Error during IPC cleanup:", e);
+        }
+        // Close server
+        server.close();
+        // Clean up browser flag file
+        try {
+            const flagFile = path_1.default.join(os_1.default.tmpdir(), `ocp-local-env-browser-opened-${port}`);
+            if (fs_1.default.existsSync(flagFile)) {
+                fs_1.default.unlinkSync(flagFile);
+            }
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+// Start the server when this file is executed directly
+if (require.main === module) {
+    startServer().catch((error) => {
+        console.error('Failed to start server:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=server.js.map