catalyst-core 0.3.0-beta.4 → 0.3.0-canary.1

package/dist/server/expressServer.js

@@ -1,304 +1,280 @@
-import path from "path"
-import express from "express"
-import bodyParser from "body-parser"
-import compression from "compression"
-import cookieParser from "cookie-parser"
-import expressStaticGzip from "express-static-gzip"
-import { createServer as createViteServer } from "vite"
-import util from "node:util"
-import pc from "picocolors"
-import fs from "fs"
-const { cyan, yellow, green } = pc
-
-import { toMountPathPrefix } from "../vite/resolveDevServerConfig.js"
-import { validateMiddleware, safeCall } from "./utils/validator.js"
-import { botDetectionMiddleware } from "./utils/botDetectionMiddleware.js"
-import { cjsRequire } from "./utils/cjsRequire.js"
-const { addMiddlewares } = await import(path.join(process.env.src_path, "server/server.js"))
+import path from "path";
+import express from "express";
+import bodyParser from "body-parser";
+import compression from "compression";
+import cookieParser from "cookie-parser";
+import expressStaticGzip from "express-static-gzip";
+import { createServer as createViteServer } from "vite";
+import util from "node:util";
+import pc from "ansis";
+import fs from "fs";
+const {
+  cyan,
+  yellow,
+  green
+} = pc;
+import { toMountPathPrefix } from "../vite/resolveDevServerConfig.js";
+import { validateMiddleware, handleError, safeCall } from "./utils/validator.js";
+import { botDetectionMiddleware } from "./utils/botDetectionMiddleware.js";
+import { cjsRequire } from "./utils/cjsRequire.js";
+const {
+  addMiddlewares
+} = await import(path.join(process.env.src_path, "server/server.js"));
 
 // Mount AI route if catalyst-ai is installed
 function mountAIRouter(app) {
-    let aiPackagePath
-    try {
-        aiPackagePath = cjsRequire.resolve("catalyst-ai/route", {
-            paths: [process.env.src_path || process.cwd()],
-        })
-    } catch (resolveErr) {
-        if (resolveErr.code !== "MODULE_NOT_FOUND") {
-            console.error("[catalyst-core/ai] Unexpected error resolving catalyst-ai:", resolveErr)
-        } else {
-            console.debug("[catalyst-core/ai] catalyst-ai not installed — AI routes unavailable")
-        }
-        return
+  let aiPackagePath;
+  try {
+    aiPackagePath = cjsRequire.resolve("catalyst-ai/route", {
+      paths: [process.env.src_path || process.cwd()]
+    });
+  } catch (resolveErr) {
+    if (resolveErr.code !== "MODULE_NOT_FOUND") {
+      console.error("[catalyst-core/ai] Unexpected error resolving catalyst-ai:", resolveErr);
+    } else {
+      console.debug("[catalyst-core/ai] catalyst-ai not installed — AI routes unavailable");
     }
-
+    return;
+  }
+  try {
+    const aiRouter = cjsRequire(aiPackagePath);
+    let aiConfig = {};
     try {
-        const aiRouter = cjsRequire(aiPackagePath)
-        let aiConfig = {}
-        try {
-            const parsedConfig = JSON.parse(process.env.AI_CONFIG || "{}")
-            if (parsedConfig && typeof parsedConfig === "object" && !Array.isArray(parsedConfig)) {
-                aiConfig = parsedConfig
-            } else {
-                console.warn("[catalyst-core/ai] AI_CONFIG must be a JSON object, ignoring it")
-            }
-        } catch (e) {
-            console.warn(`[catalyst-core/ai] Invalid AI_CONFIG JSON, ignoring: ${e.message}`)
-        }
-
-        if (aiConfig.enabled === false) {
-            console.log("[catalyst-core/ai] AI_CONFIG.enabled is false, skipping AI router")
-            return
-        }
-
-        const aiBasePath = aiConfig.basePath || "/ai"
-        console.log(`[catalyst-core/ai] mounting AI router at ${aiBasePath}`)
-        app.use(aiBasePath, aiRouter)
-    } catch (mountErr) {
-        console.error("[catalyst-core/ai] Failed to mount AI router:", mountErr)
+      const parsedConfig = JSON.parse(process.env.AI_CONFIG || "{}");
+      if (parsedConfig && typeof parsedConfig === "object" && !Array.isArray(parsedConfig)) {
+        aiConfig = parsedConfig;
+      } else {
+        console.warn("[catalyst-core/ai] AI_CONFIG must be a JSON object, ignoring it");
+      }
+    } catch (e) {
+      console.warn(`[catalyst-core/ai] Invalid AI_CONFIG JSON, ignoring: ${e.message}`);
     }
+    if (aiConfig.enabled === false) {
+      console.log("[catalyst-core/ai] AI_CONFIG.enabled is false, skipping AI router");
+      return;
+    }
+    const aiBasePath = aiConfig.basePath || "/ai";
+    console.log(`[catalyst-core/ai] mounting AI router at ${aiBasePath}`);
+    app.use(aiBasePath, aiRouter);
+  } catch (mountErr) {
+    console.error("[catalyst-core/ai] Failed to mount AI router:", mountErr);
+  }
 }
 
 // OpenTelemetry is opt-in (OTEL_ENABLE) — mirrors server/renderer/handler.jsx.
 // Passthrough no-op middleware when disabled or packages aren't installed.
-let responseFlushMiddleware = () => (_req, _res, next) => next()
+let responseFlushMiddleware = () => (_req, _res, next) => next();
+// config.json booleans survive the process.env swap in loadEnvironmentVariables(),
+// so this is genuinely true at runtime when config sets OTEL_ENABLE: true. The cast
+// exists only because TS types process.env values as string | undefined.
 if (process.env.OTEL_ENABLE === true) {
-    try {
-        const otel = await import("../otel.js")
-        responseFlushMiddleware = otel.responseFlushMiddleware
-    } catch {
-        // otel packages not installed — continue without the flush span
-    }
+  try {
+    const otel = await import("../otel.js");
+    responseFlushMiddleware = otel.responseFlushMiddleware;
+  } catch {
+    // otel packages not installed — continue without the flush span
+  }
 }
-
-const SSR_SERVICE = process.env.SERVICE_NAME || `pwa-${process.env.APPLICATION}-node-server`
+const SSR_SERVICE = process.env.SERVICE_NAME || `pwa-${process.env.APPLICATION}-node-server`;
 
 // ─── Load app-defined server lifecycle hooks ──────────────────────────────────
-let onServerError
+let onServerError;
 try {
-    const hooks = await import(path.join(process.env.src_path, "server/index.js"))
-    onServerError = hooks.onServerError
+  const hooks = await import(path.join(process.env.src_path, "server/index.js"));
+  onServerError = hooks.onServerError;
 } catch {
-    // No hooks file — onServerError remains undefined
+  // No hooks file — onServerError remains undefined
 }
 
 // ─── Process-level error handlers ─────────────────────────────────────────────
 
 function safeStringify(err) {
-    try {
-        return JSON.stringify(err)
-    } catch (e) {
-        console.log("error in safeStringify", e)
-        return err
-    }
+  try {
+    return JSON.stringify(err);
+  } catch (e) {
+    console.log("error in safeStringify", e);
+    return err;
+  }
 }
-
 process.on("uncaughtException", (err, origin) => {
-    console.log(process.stderr.fd)
-    console.log(`Caught exception: ${err}\n` + `Exception origin: ${origin}`)
-})
-
+  console.log(process.stderr.fd);
+  console.log(`Caught exception: ${err}\n` + `Exception origin: ${origin}`);
+});
 process.on("uncaughtExceptionMonitor", (err, origin) => {
-    console.log(err, origin)
-})
-
-process.on("unhandledRejection", (err) => console.log("unhandledRejection in Catalyst", safeStringify(err)))
-
+  console.log(err, origin);
+});
+process.on("unhandledRejection", err => console.log("unhandledRejection in Catalyst", err?.stack || safeStringify(err)));
 process.on("SIGINT", function () {
-    console.log("SIGINT")
-    process.exit(0)
-})
-
+  console.log("SIGINT");
+  process.exit(0);
+});
 process.on("message", function (msg) {
-    if (msg == "shutdown") {
-        console.log("Closing all connections...")
-        setTimeout(function () {
-            console.log("Finished closing connections")
-            process.exit(0)
-        }, 1500)
-    }
-})
-
-import { fileURLToPath } from "url"
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-const isProduction = process.env.NODE_ENV === "production"
-
+  if (msg == "shutdown") {
+    console.log("Closing all connections...");
+    setTimeout(function () {
+      console.log("Finished closing connections");
+      process.exit(0);
+    }, 1500);
+  }
+});
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const isProduction = process.env.NODE_ENV === "production";
 function serveBuildFile(app, buildPath, urlPath, fileName, headers = {}) {
-    app.get(urlPath, (_req, res, next) => {
-        // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - fileName is always a hardcoded literal passed at each serveBuildFile call site, never derived from the request.
-        const filePath = path.join(buildPath, fileName)
-        if (!fs.existsSync(filePath)) return next()
-        res.set(headers)
-        res.sendFile(filePath)
-    })
+  app.get(urlPath, (_req, res, next) => {
+    // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal - fileName is always a hardcoded literal passed at each serveBuildFile call site, never derived from the request.
+    const filePath = path.join(buildPath, fileName);
+    if (!fs.existsSync(filePath)) return next();
+    res.set(headers);
+    res.sendFile(filePath);
+  });
 }
-
 async function createServer() {
-    const port = process.env.NODE_SERVER_PORT ?? 3005
-    const host = process.env.NODE_SERVER_HOSTNAME ?? "localhost"
-    const app = express()
-
-    // This middleware is being used to extract the body of the request
-    app.use(bodyParser.json())
-
-    // // This middleware has been added to accommodate "byetstream array"
-    app.use(bodyParser.raw({ type: "application/*" }))
-
-    // This middleware is being used to parse cookies!
-    app.use(cookieParser())
-
-    // All the middlewares defined by the user will run here.
-    if (validateMiddleware(addMiddlewares)) addMiddlewares(app)
-
-    mountAIRouter(app)
-
-    // response.compress + response.flush spans straddle compression — they
-    // attribute the time past the `handler` span (gzip/brotli, then egress).
-    // MUST be mounted immediately before compression() so its outer res.end
-    // hook reliably wraps compression's patch (no-op when OTEL off).
-    app.use(responseFlushMiddleware(SSR_SERVICE, "response.flush", "response.compress"))
-
-    // The middleware will attempt to compress response bodies for all request that traverse through the middleware
-    app.use(compression())
-
-    let vite
-
-    if (isProduction) {
-        // In production, serve built assets. Build manifests themselves are
-        // loaded once at startup by ./manifestCache.js — handler reads from
-        // that singleton instead of attaching them to every `req`.
-        const buildPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build")
-        const publicPath = path.join(buildPath, "client", "assets")
-        const publicAssetBase = `/${(process.env.PUBLIC_STATIC_ASSET_PATH || "/assets/")
-            .replace(/^\/+|\/+$/g, "")
-            .replace(/\/+/g, "/")}/client/assets`
-
-        serveBuildFile(app, buildPath, "/catalyst-offline-manifest.json", "catalyst-offline-manifest.json", {
-            "cache-control": "no-store",
-        })
-        serveBuildFile(app, buildPath, "/catalyst-sw.js", "catalyst-sw.js", {
-            "cache-control": "no-cache",
-            "service-worker-allowed": "/",
-        })
-        serveBuildFile(app, buildPath, "/offline.html", "offline.html", {
-            "cache-control": "no-cache",
-        })
-
-        // Serve static assets — prefers pre-compressed .br / .gz files generated at build time
-        app.use(
-            publicAssetBase,
-            expressStaticGzip(publicPath, {
-                enableBrotli: true,
-                orderPreference: ["br", "gz"],
-                serveStatic: {
-                    maxAge: "1y",
-                    etag: true,
-                    lastModified: true,
-                },
-            })
-        )
+  const port = process.env.NODE_SERVER_PORT ?? 3005;
+  const host = process.env.NODE_SERVER_HOSTNAME ?? "localhost";
+  const app = express();
+
+  // This middleware is being used to extract the body of the request
+  app.use(bodyParser.json());
+
+  // // This middleware has been added to accommodate "byetstream array"
+  app.use(bodyParser.raw({
+    type: "application/*"
+  }));
+
+  // This middleware is being used to parse cookies!
+  app.use(cookieParser());
+
+  // All the middlewares defined by the user will run here.
+  {
+    const middlewareErr = validateMiddleware(addMiddlewares);
+    if (middlewareErr) handleError(middlewareErr);else addMiddlewares(app);
+  }
+  mountAIRouter(app);
+
+  // response.compress + response.flush spans straddle compression — they
+  // attribute the time past the `handler` span (gzip/brotli, then egress).
+  // MUST be mounted immediately before compression() so its outer res.end
+  // hook reliably wraps compression's patch (no-op when OTEL off).
+  app.use(responseFlushMiddleware(SSR_SERVICE, "response.flush", "response.compress"));
+
+  // The middleware will attempt to compress response bodies for all request that traverse through the middleware
+  app.use(compression());
+  let vite;
+  if (isProduction) {
+    // In production, serve built assets. Build manifests themselves are
+    // loaded once at startup by ./manifestCache.js — handler reads from
+    // that singleton instead of attaching them to every `req`.
+    const buildPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build");
+    const publicPath = path.join(buildPath, "client", "assets");
+    const publicAssetBase = `/${(process.env.PUBLIC_STATIC_ASSET_PATH || "/assets/").replace(/^\/+|\/+$/g, "").replace(/\/+/g, "/")}/client/assets`;
+    serveBuildFile(app, buildPath, "/catalyst-offline-manifest.json", "catalyst-offline-manifest.json", {
+      "cache-control": "no-store"
+    });
+    serveBuildFile(app, buildPath, "/catalyst-sw.js", "catalyst-sw.js", {
+      "cache-control": "no-cache",
+      "service-worker-allowed": "/"
+    });
+    serveBuildFile(app, buildPath, "/offline.html", "offline.html", {
+      "cache-control": "no-cache"
+    });
+
+    // Serve static assets — prefers pre-compressed .br / .gz files generated at build time
+    app.use(publicAssetBase, expressStaticGzip(publicPath, {
+      enableBrotli: true,
+      orderPreference: ["br", "gz"],
+      serveStatic: {
+        maxAge: "1y",
+        etag: true,
+        lastModified: true
+      }
+    }));
+  } else {
+    // In development, use Vite middleware
+    vite = await createViteServer({
+      configFile: "./dist/vite/vite.config.js",
+      server: {
+        middlewareMode: true
+      },
+      appType: "custom",
+      root: process.env.src_path
+    });
+
+    // Expose Vite's resolved base to the SSR renderer so the URLs it injects
+    // (client entry, react-refresh preamble) match the path Vite serves under.
+    // Vite normalizes base with a trailing slash; trim it for clean URL joins.
+    process.env.APP_MOUNT_PATH = toMountPathPrefix(vite.config.base);
+    app.use(vite.middlewares);
+  }
+
+  // In production, resolve the render module once at startup so the ESM
+  // loader and lazy-chunk cache are not re-entered on every request.
+  let productionRender;
+  if (isProduction) {
+    const serverPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build", "server", "server.js");
+    if (fs.existsSync(serverPath)) {
+      productionRender = await import(serverPath);
     } else {
-        // In development, use Vite middleware
-        vite = await createViteServer({
-            configFile: "./dist/vite/vite.config.js",
-            server: {
-                middlewareMode: true,
-            },
-            appType: "custom",
-            root: process.env.src_path,
-        })
-
-        // Expose Vite's resolved base to the SSR renderer so the URLs it injects
-        // (client entry, react-refresh preamble) match the path Vite serves under.
-        // Vite normalizes base with a trailing slash; trim it for clean URL joins.
-        process.env.APP_MOUNT_PATH = toMountPathPrefix(vite.config.base)
-
-        app.use(vite.middlewares)
+      const rendererPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build", "server", "index.js");
+      productionRender = await import(rendererPath);
     }
-
-    // In production, resolve the render module once at startup so the ESM
-    // loader and lazy-chunk cache are not re-entered on every request.
-    let productionRender
-    if (isProduction) {
-        const serverPath = path.join(
-            process.env.src_path,
-            process.env.BUILD_OUTPUT_PATH || "build",
-            "server",
-            "server.js"
-        )
-        if (fs.existsSync(serverPath)) {
-            productionRender = await import(serverPath)
-        } else {
-            const rendererPath = path.join(
-                process.env.src_path,
-                process.env.BUILD_OUTPUT_PATH || "build",
-                "server",
-                "index.js"
-            )
-            productionRender = await import(rendererPath)
-        }
+  }
+  app.use(botDetectionMiddleware);
+  app.use("*", async (req, res, next) => {
+    try {
+      let render;
+      if (isProduction) {
+        render = productionRender;
+      } else {
+        // In development, load through Vite SSR per-request to support HMR
+        const rendererPath = path.join(__dirname, "./renderer/index.js");
+        render = await vite.ssrLoadModule(rendererPath);
+      }
+
+      // Render your app
+      if (render && render.default) {
+        await render.default(req, res, next);
+      } else {
+        console.error("Renderer not found or invalid");
+        res.status(500).send("Error loading renderer");
+      }
+    } catch (err) {
+      console.error("SSR Error:", err);
+      if (vite) {
+        vite.ssrFixStacktrace(err);
+      }
+      res.status(500).send("Internal Server Error");
     }
-
-    app.use(botDetectionMiddleware)
-
-    app.use("*", async (req, res, next) => {
-        try {
-            let render
-
-            if (isProduction) {
-                render = productionRender
-            } else {
-                // In development, load through Vite SSR per-request to support HMR
-                const rendererPath = path.join(__dirname, "./renderer/index.js")
-                render = await vite.ssrLoadModule(rendererPath)
-            }
-
-            // Render your app
-            if (render && render.default) {
-                await render.default(req, res, next)
-            } else {
-                console.error("Renderer not found or invalid")
-                res.status(500).send("Error loading renderer")
-            }
-        } catch (err) {
-            console.error("SSR Error:", err)
-            if (vite) {
-                vite.ssrFixStacktrace(err)
-            }
-            res.status(500).send("Internal Server Error")
-        }
-    })
-
-    app.listen({ port, host }, (error) => {
-        const { APPLICATION, NODE_SERVER_HOSTNAME, NODE_SERVER_PORT } = process.env
-
-        if (error) {
-            console.log("An error occured while starting the Application server : ", error)
-            safeCall(onServerError)
-            return
-        }
-
-        if (process.env.NODE_ENV === "development") console.log(green("Compiled successfully!"))
-
-        console.log(`\nYou can now view ${APPLICATION} in the browser.\n`)
-        console.log(
-            util.format("\tLocal:".padEnd(8), cyan(`http://${NODE_SERVER_HOSTNAME}:${NODE_SERVER_PORT}`))
-        )
-
-        if (process.env.NODE_ENV === "development") {
-            console.log("\nNote that the development build is not optimized.")
-            console.log("To create a production build, use " + cyan("npm run build"))
-        } else {
-            console.log(
-                green(`\nProduction server running in ${isProduction ? "production" : "development"} mode`)
-            )
-        }
-
-        console.log("\nFind out more about deployment here:")
-        console.log(yellow("\n https://catalyst.1mg.com/public_docs/content/deployment\n"))
-    })
+  });
+  app.listen({
+    port,
+    host
+  }, error => {
+    const {
+      APPLICATION,
+      NODE_SERVER_HOSTNAME,
+      NODE_SERVER_PORT
+    } = process.env;
+    if (error) {
+      console.log("An error occured while starting the Application server : ", error);
+      safeCall(onServerError);
+      return;
+    }
+    if (process.env.NODE_ENV === "development") console.log(green("Compiled successfully!"));
+    console.log(`\nYou can now view ${APPLICATION} in the browser.\n`);
+    console.log(util.format("\tLocal:".padEnd(8), cyan(`http://${NODE_SERVER_HOSTNAME}:${NODE_SERVER_PORT}`)));
+    if (process.env.NODE_ENV === "development") {
+      console.log("\nNote that the development build is not optimized.");
+      console.log("To create a production build, use " + cyan("npm run build"));
+    } else {
+      console.log(green(`\nProduction server running in ${isProduction ? "production" : "development"} mode`));
+    }
+    console.log("\nFind out more about deployment here:");
+    console.log(yellow("\n https://catalyst.1mg.com/public_docs/content/deployment\n"));
+  });
 }
-
-createServer()
+createServer().catch(err => {
+  console.error(err?.stack || err);
+  process.exit(1);
+});

package/dist/server/manifestCache.d.ts

@@ -0,0 +1,2 @@
+export declare const getManifest: () => any;
+export declare const getAssetManifest: () => any;

package/dist/server/manifestCache.js

@@ -1,36 +1,28 @@
-import fs from "fs"
-import path from "path"
-
-let manifest = null
-let assetManifest = null
-let loaded = false
-
-const isProduction = process.env.NODE_ENV === "production"
-
+import fs from "fs";
+import path from "path";
+let manifest = null;
+let assetManifest = null;
+let loaded = false;
+const isProduction = process.env.NODE_ENV === "production";
 function loadManifests() {
-    if (loaded) return
-
-    if (!isProduction) return
-
-    const buildPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build")
-    try {
-        const manifestPath = path.join(buildPath, ".vite", "manifest.json")
-        const assetManifestPath = path.join(buildPath, ".vite", "asset-categories.json")
-
-        if (fs.existsSync(manifestPath)) {
-            manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"))
-        }
-        if (fs.existsSync(assetManifestPath)) {
-            assetManifest = JSON.parse(fs.readFileSync(assetManifestPath, "utf-8"))
-        }
-        loaded = true
-    } catch (error) {
-        loaded = false
-        console.warn("Could not load build manifests:", error.message)
+  if (loaded) return;
+  if (!isProduction) return;
+  const buildPath = path.join(process.env.src_path, process.env.BUILD_OUTPUT_PATH || "build");
+  try {
+    const manifestPath = path.join(buildPath, ".vite", "manifest.json");
+    const assetManifestPath = path.join(buildPath, ".vite", "asset-categories.json");
+    if (fs.existsSync(manifestPath)) {
+      manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
     }
+    if (fs.existsSync(assetManifestPath)) {
+      assetManifest = JSON.parse(fs.readFileSync(assetManifestPath, "utf-8"));
+    }
+    loaded = true;
+  } catch (error) {
+    loaded = false;
+    console.warn("Could not load build manifests:", error.message);
+  }
 }
-
-loadManifests()
-
-export const getManifest = () => manifest
-export const getAssetManifest = () => assetManifest
+loadManifests();
+export const getManifest = () => manifest;
+export const getAssetManifest = () => assetManifest;