@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/xpod.single.cjs

@@ -0,0 +1,826 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/global-logger-factory/dist/Logger.js
+var require_Logger = __commonJS({
+  "node_modules/global-logger-factory/dist/Logger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WrappingLogger = exports2.BaseLogger = void 0;
+    var BaseLogger = class {
+      error(message, meta) {
+        return this.log("error", message, meta);
+      }
+      warn(message, meta) {
+        return this.log("warn", message, meta);
+      }
+      info(message, meta) {
+        return this.log("info", message, meta);
+      }
+      verbose(message, meta) {
+        return this.log("verbose", message, meta);
+      }
+      debug(message, meta) {
+        return this.log("debug", message, meta);
+      }
+      silly(message, meta) {
+        return this.log("silly", message, meta);
+      }
+    };
+    exports2.BaseLogger = BaseLogger;
+    var WrappingLogger = class extends BaseLogger {
+      logger;
+      constructor(logger2) {
+        super();
+        this.logger = logger2;
+      }
+      log(level, message, meta) {
+        this.logger.log(level, message, meta);
+        return this;
+      }
+    };
+    exports2.WrappingLogger = WrappingLogger;
+  }
+});
+
+// node_modules/global-logger-factory/dist/VoidLogger.js
+var require_VoidLogger = __commonJS({
+  "node_modules/global-logger-factory/dist/VoidLogger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VoidLogger = void 0;
+    var Logger_1 = require_Logger();
+    var VoidLogger = class extends Logger_1.BaseLogger {
+      log() {
+        return this;
+      }
+    };
+    exports2.VoidLogger = VoidLogger;
+  }
+});
+
+// node_modules/global-logger-factory/dist/VoidLoggerFactory.js
+var require_VoidLoggerFactory = __commonJS({
+  "node_modules/global-logger-factory/dist/VoidLoggerFactory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.VoidLoggerFactory = void 0;
+    var VoidLogger_1 = require_VoidLogger();
+    var VoidLoggerFactory = class {
+      logger = new VoidLogger_1.VoidLogger();
+      // eslint-disable-next-line unused-imports/no-unused-vars
+      createLogger(label) {
+        return this.logger;
+      }
+    };
+    exports2.VoidLoggerFactory = VoidLoggerFactory;
+  }
+});
+
+// node_modules/global-logger-factory/dist/LazyLoggerFactory.js
+var require_LazyLoggerFactory = __commonJS({
+  "node_modules/global-logger-factory/dist/LazyLoggerFactory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LazyLoggerFactory = void 0;
+    var Logger_1 = require_Logger();
+    var VoidLoggerFactory_1 = require_VoidLoggerFactory();
+    var TemporaryLoggerFactory = class {
+      bufferSpaces;
+      wrappers = [];
+      buffer = [];
+      constructor(bufferSize = 1024) {
+        this.bufferSpaces = bufferSize;
+      }
+      createLogger(label) {
+        const wrapper = new Logger_1.WrappingLogger({
+          log: (level, message, meta) => this.bufferLogEntry(wrapper, level, message, meta)
+        });
+        this.wrappers.push({ wrapper, label });
+        return wrapper;
+      }
+      bufferLogEntry(logger2, level, message, meta) {
+        if (this.bufferSpaces > 0) {
+          this.bufferSpaces -= 1;
+          if (this.bufferSpaces === 0) {
+            this.buffer.length = 0;
+            this.switch(new VoidLoggerFactory_1.VoidLoggerFactory());
+            return logger2;
+          }
+          this.buffer.push({ logger: logger2, level, message, meta });
+        }
+        return logger2;
+      }
+      /**
+       * Swaps all lazy loggers to new loggers from the given factory,
+       * and emits any buffered messages through those actual loggers.
+       */
+      switch(loggerFactory) {
+        for (const { wrapper, label } of this.wrappers.splice(0, this.wrappers.length)) {
+          wrapper.logger = loggerFactory.createLogger(label);
+        }
+        for (const { logger: logger2, level, message } of this.buffer.splice(0, this.buffer.length)) {
+          logger2.log(level, message);
+        }
+      }
+    };
+    var LazyLoggerFactory = class {
+      factory;
+      constructor(options = {}) {
+        this.factory = new TemporaryLoggerFactory(options.bufferSize);
+      }
+      get loggerFactory() {
+        if (this.factory instanceof TemporaryLoggerFactory) {
+          throw new TypeError("Logger factory not yet set.");
+        }
+        return this.factory;
+      }
+      set loggerFactory(loggerFactory) {
+        if (this.factory instanceof TemporaryLoggerFactory) {
+          this.factory.switch(loggerFactory);
+        }
+        this.factory = loggerFactory;
+      }
+      createLogger(label) {
+        return this.factory.createLogger(label);
+      }
+    };
+    exports2.LazyLoggerFactory = LazyLoggerFactory;
+  }
+});
+
+// node_modules/global-logger-factory/dist/LoggerFactory.js
+var require_LoggerFactory = __commonJS({
+  "node_modules/global-logger-factory/dist/LoggerFactory.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// node_modules/global-logger-factory/dist/LogLevel.js
+var require_LogLevel = __commonJS({
+  "node_modules/global-logger-factory/dist/LogLevel.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.LOG_LEVELS = void 0;
+    exports2.LOG_LEVELS = ["error", "warn", "info", "verbose", "debug", "silly"];
+  }
+});
+
+// node_modules/global-logger-factory/dist/LogUtil.js
+var require_LogUtil = __commonJS({
+  "node_modules/global-logger-factory/dist/LogUtil.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getLoggerFor = getLoggerFor3;
+    exports2.setGlobalLoggerFactory = setGlobalLoggerFactory2;
+    exports2.resetInternalLoggerFactory = resetInternalLoggerFactory;
+    var LazyLoggerFactory_1 = require_LazyLoggerFactory();
+    var loggerFactoryWrapper = new LazyLoggerFactory_1.LazyLoggerFactory();
+    var classLoggers = /* @__PURE__ */ new WeakMap();
+    function getLoggerFor3(loggable) {
+      let logger2;
+      if (typeof loggable === "string") {
+        logger2 = loggerFactoryWrapper.createLogger(loggable);
+      } else {
+        const { constructor } = loggable;
+        if (classLoggers.has(constructor)) {
+          logger2 = classLoggers.get(constructor);
+        } else {
+          logger2 = loggerFactoryWrapper.createLogger(constructor.name);
+          classLoggers.set(constructor, logger2);
+        }
+      }
+      return logger2;
+    }
+    function setGlobalLoggerFactory2(loggerFactory) {
+      loggerFactoryWrapper.loggerFactory = loggerFactory;
+    }
+    function resetInternalLoggerFactory(factory = new LazyLoggerFactory_1.LazyLoggerFactory()) {
+      loggerFactoryWrapper = factory;
+      classLoggers = /* @__PURE__ */ new WeakMap();
+    }
+  }
+});
+
+// node_modules/global-logger-factory/dist/WinstonLogger.js
+var require_WinstonLogger = __commonJS({
+  "node_modules/global-logger-factory/dist/WinstonLogger.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WinstonLogger = void 0;
+    var Logger_1 = require_Logger();
+    var WinstonLogger2 = class extends Logger_1.BaseLogger {
+      logger;
+      constructor(logger2) {
+        super();
+        this.logger = logger2;
+      }
+      log(level, message, meta) {
+        this.logger.log(level, message, meta);
+        return this;
+      }
+    };
+    exports2.WinstonLogger = WinstonLogger2;
+  }
+});
+
+// node_modules/global-logger-factory/dist/WinstonLoggerFactory.js
+var require_WinstonLoggerFactory = __commonJS({
+  "node_modules/global-logger-factory/dist/WinstonLoggerFactory.js"(exports2) {
+    "use strict";
+    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WinstonLoggerFactory = void 0;
+    var node_cluster_1 = __importDefault(require("node:cluster"));
+    var winston_1 = require("winston");
+    var WinstonLogger_1 = require_WinstonLogger();
+    var WinstonLoggerFactory = class {
+      level;
+      constructor(level) {
+        this.level = level;
+      }
+      clusterInfo() {
+        if (node_cluster_1.default.isPrimary) {
+          return "Primary";
+        }
+        return `W-${process.pid}`;
+      }
+      createLogger(label) {
+        return new WinstonLogger_1.WinstonLogger((0, winston_1.createLogger)({
+          level: this.level,
+          format: winston_1.format.combine(winston_1.format.label({ label }), winston_1.format.colorize(), winston_1.format.timestamp(), winston_1.format.metadata({ fillExcept: ["level", "timestamp", "label", "message"] }), winston_1.format.printf(({ level: levelInner, message, label: labelInner, timestamp }) => `${timestamp} [${labelInner}] {${this.clusterInfo()}} ${levelInner}: ${message}`)),
+          transports: this.createTransports()
+        }));
+      }
+      createTransports() {
+        return [new winston_1.transports.Console()];
+      }
+    };
+    exports2.WinstonLoggerFactory = WinstonLoggerFactory;
+  }
+});
+
+// node_modules/global-logger-factory/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/global-logger-factory/dist/index.js"(exports2) {
+    "use strict";
+    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports2 && exports2.__exportStar || function(m, exports3) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
+    };
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    __exportStar(require_LazyLoggerFactory(), exports2);
+    __exportStar(require_Logger(), exports2);
+    __exportStar(require_LoggerFactory(), exports2);
+    __exportStar(require_LogLevel(), exports2);
+    __exportStar(require_LogUtil(), exports2);
+    __exportStar(require_VoidLogger(), exports2);
+    __exportStar(require_VoidLoggerFactory(), exports2);
+    __exportStar(require_WinstonLogger(), exports2);
+    __exportStar(require_WinstonLoggerFactory(), exports2);
+  }
+});
+
+// src/supervisor/Supervisor.ts
+var import_node_child_process = require("node:child_process");
+var import_tree_kill = __toESM(require("tree-kill"));
+var MAX_RESTARTS = 5;
+var Supervisor = class {
+  constructor() {
+    this.processes = /* @__PURE__ */ new Map();
+    this.states = /* @__PURE__ */ new Map();
+    this.configs = /* @__PURE__ */ new Map();
+    this.isShuttingDown = false;
+    process.on("exit", () => this.killAll());
+    process.on("SIGINT", () => this.shutdown("SIGINT"));
+    process.on("SIGTERM", () => this.shutdown("SIGTERM"));
+  }
+  async shutdown(signal) {
+    if (this.isShuttingDown) return;
+    this.isShuttingDown = true;
+    console.log(`[Supervisor] Received ${signal}, stopping all services...`);
+    await this.stopAll();
+    process.exit(0);
+  }
+  killAll() {
+    for (const [name, child] of this.processes) {
+      if (child.pid) {
+        try {
+          process.kill(child.pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+  }
+  setStatusChangeHandler(handler) {
+    this.onStatusChange = handler;
+  }
+  register(config) {
+    this.configs.set(config.name, config);
+    this.states.set(config.name, {
+      name: config.name,
+      status: "stopped",
+      restartCount: 0
+    });
+  }
+  async startAll() {
+    for (const name of this.configs.keys()) {
+      this.start(name);
+    }
+  }
+  async stopAll() {
+    this.isShuttingDown = true;
+    const promises = [];
+    for (const name of this.processes.keys()) {
+      promises.push(this.stop(name));
+    }
+    await Promise.all(promises);
+  }
+  start(name) {
+    const config = this.configs.get(name);
+    const state = this.states.get(name);
+    if (!config || !state) return;
+    if (state.status === "running" || state.status === "starting") return;
+    console.log(`[Supervisor] Starting ${name}...`);
+    this.updateState(name, { status: "starting", startTime: Date.now() });
+    const env = { ...process.env, ...config.env };
+    const child = (0, import_node_child_process.spawn)(config.command, config.args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      cwd: config.cwd || process.cwd(),
+      detached: false
+      // 确保子进程不脱离父进程
+    });
+    this.processes.set(name, child);
+    this.updateState(name, { status: "running", pid: child.pid });
+    const prefixLog = (name2, data, isError = false) => {
+      const output = data.toString();
+      const lines = output.split("\n");
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed) {
+          if (isError) {
+            console.error(`[${name2}] ${trimmed}`);
+          } else {
+            console.log(`[${name2}] ${trimmed}`);
+          }
+        }
+      }
+    };
+    child.stdout?.on("data", (data) => {
+      prefixLog(name, data, false);
+    });
+    child.stderr?.on("data", (data) => {
+      prefixLog(name, data, true);
+    });
+    child.on("error", (err) => {
+      console.error(`[Supervisor] Error spawning ${name}:`, err);
+      this.updateState(name, { status: "crashed" });
+    });
+    child.on("exit", (code, signal) => {
+      console.log(`[Supervisor] ${name} exited with code ${code} signal ${signal}`);
+      const currentState = this.states.get(name);
+      const wasManualStop = currentState?.status === "stopped";
+      this.updateState(name, {
+        status: "stopped",
+        lastExitCode: code ?? void 0,
+        pid: void 0
+      });
+      this.processes.delete(name);
+      if (code !== 0 && !wasManualStop && !this.isShuttingDown) {
+        const newState = this.states.get(name);
+        const restartCount = (newState?.restartCount || 0) + 1;
+        if (restartCount <= MAX_RESTARTS) {
+          this.updateState(name, { restartCount });
+          console.log(`[Supervisor] Restarting ${name} in 2s... (attempt ${restartCount}/${MAX_RESTARTS})`);
+          setTimeout(() => this.start(name), 2e3);
+        } else {
+          console.error(`[Supervisor] ${name} exceeded max restarts (${MAX_RESTARTS}), giving up`);
+        }
+      }
+    });
+  }
+  stop(name) {
+    return new Promise((resolve) => {
+      const child = this.processes.get(name);
+      if (!child || !child.pid) {
+        resolve();
+        return;
+      }
+      this.updateState(name, { status: "stopped" });
+      (0, import_tree_kill.default)(child.pid, "SIGTERM", (err) => {
+        if (err) console.error(`[Supervisor] Failed to kill ${name}:`, err);
+        resolve();
+      });
+    });
+  }
+  getStatus(name) {
+    const state = this.states.get(name);
+    if (state && state.status === "running" && state.startTime) {
+      return { ...state, uptime: Date.now() - state.startTime };
+    }
+    return state;
+  }
+  getAllStatus() {
+    return Array.from(this.states.values()).map((s) => {
+      if (s.status === "running" && s.startTime) {
+        return { ...s, uptime: Date.now() - s.startTime };
+      }
+      return s;
+    });
+  }
+  updateState(name, update) {
+    const state = this.states.get(name);
+    if (state) {
+      Object.assign(state, update);
+      this.onStatusChange?.(name, { ...state });
+    }
+  }
+};
+
+// src/gateway/proxy.ts
+var import_http_proxy = __toESM(require("http-proxy"));
+var import_http = __toESM(require("http"));
+var import_global_logger_factory = __toESM(require_dist());
+var CORS_CONFIG = {
+  methods: ["GET", "HEAD", "OPTIONS", "POST", "PUT", "PATCH", "DELETE"],
+  credentials: true,
+  allowedHeaders: [
+    "Authorization",
+    "Content-Type",
+    "Accept",
+    "DPoP",
+    "Origin",
+    "X-Requested-With",
+    "If-Match",
+    "If-None-Match",
+    "Slug",
+    "Link"
+  ],
+  exposedHeaders: [
+    "Accept-Patch",
+    "Accept-Post",
+    "Accept-Put",
+    "Allow",
+    "Content-Range",
+    "ETag",
+    "Last-Modified",
+    "Link",
+    "Location",
+    "Updates-Via",
+    "WAC-Allow",
+    "Www-Authenticate",
+    "X-Request-Id"
+  ]
+};
+var GatewayProxy = class {
+  constructor(port, supervisor) {
+    this.port = port;
+    this.supervisor = supervisor;
+    this.logger = (0, import_global_logger_factory.getLoggerFor)(this);
+    this.targets = {};
+    this.proxy = import_http_proxy.default.createProxyServer({
+      xfwd: true
+    });
+    this.proxy.on("error", (err, _req, res) => {
+      this.logger.error("Proxy error:", err);
+      if (res && "writeHead" in res && !res.headersSent) {
+        res.writeHead(502, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Service Unavailable", details: err.message }));
+      }
+    });
+    this.server = import_http.default.createServer(this.handleRequest.bind(this));
+    this.server.on("upgrade", (req, socket, head) => {
+      const url = req.url ?? "/";
+      if (url.startsWith("/ws/") && this.targets.api) {
+        this.proxy.ws(req, socket, head, { target: this.targets.api });
+      } else if (this.targets.css) {
+        this.proxy.ws(req, socket, head, { target: this.targets.css });
+      } else {
+        socket.destroy();
+      }
+    });
+  }
+  setTargets(targets) {
+    this.targets = targets;
+  }
+  start() {
+    this.server.listen(this.port, "0.0.0.0", () => {
+      this.logger.info(`Listening on http://0.0.0.0:${this.port}`);
+    });
+  }
+  handleRequest(req, res) {
+    const url = req.url ?? "/";
+    const origin = req.headers.origin;
+    const originalHost = req.headers.host;
+    const baseUrl = process.env.CSS_BASE_URL || "";
+    if (baseUrl.startsWith("https")) {
+      req.headers["x-forwarded-proto"] = "https";
+    }
+    if (baseUrl) {
+      try {
+        const parsedBaseUrl = new URL(baseUrl);
+        req.headers.host = parsedBaseUrl.host;
+        req.headers["x-forwarded-host"] = parsedBaseUrl.host;
+      } catch {
+        if (!req.headers["x-forwarded-host"]) {
+          req.headers["x-forwarded-host"] = originalHost;
+        }
+      }
+    } else if (!req.headers["x-forwarded-host"]) {
+      req.headers["x-forwarded-host"] = originalHost;
+    }
+    this.logger.debug(`${req.method} ${url} x-forwarded-proto=${req.headers["x-forwarded-proto"]} x-forwarded-host=${req.headers["x-forwarded-host"]} host=${req.headers.host}`);
+    if (url.startsWith("/_gateway/")) {
+      if (req.method === "OPTIONS") {
+        this.handleCorsPreflightRequest(res, origin);
+        return;
+      }
+      if (origin) {
+        this.addCorsHeaders(res, origin);
+      }
+      this.handleInternalApi(req, res);
+      return;
+    }
+    if ((url.startsWith("/v1/") || url.startsWith("/api/")) && this.targets.api) {
+      this.proxy.web(req, res, { target: this.targets.api });
+      return;
+    }
+    if (this.targets.css) {
+      this.proxy.web(req, res, { target: this.targets.css });
+    } else {
+      res.writeHead(503);
+      res.end("CSS Service Not Available");
+    }
+  }
+  handleCorsPreflightRequest(res, origin) {
+    this.addCorsHeaders(res, origin);
+    res.writeHead(204);
+    res.end();
+  }
+  /**
+   * Add CORS headers matching CSS CorsHandler configuration
+   */
+  addCorsHeaders(res, origin) {
+    res.setHeader("Access-Control-Allow-Origin", origin || "*");
+    res.setHeader("Access-Control-Allow-Credentials", String(CORS_CONFIG.credentials));
+    res.setHeader("Access-Control-Allow-Methods", CORS_CONFIG.methods.join(", "));
+    res.setHeader("Access-Control-Allow-Headers", CORS_CONFIG.allowedHeaders.join(", "));
+    res.setHeader("Access-Control-Expose-Headers", CORS_CONFIG.exposedHeaders.join(", "));
+  }
+  handleInternalApi(req, res) {
+    if (req.url === "/_gateway/status") {
+      const status = this.supervisor.getAllStatus();
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(status));
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not Found");
+  }
+};
+
+// src/gateway/port-finder.ts
+var import_portfinder = __toESM(require("portfinder"));
+async function getFreePort(basePort) {
+  import_portfinder.default.basePort = basePort;
+  return import_portfinder.default.getPortPromise();
+}
+
+// src/main.ts
+var import_global_logger_factory3 = __toESM(require_dist());
+
+// src/logging/ConfigurableLoggerFactory.ts
+var import_winston = require("winston");
+var import_winston_daily_rotate_file = __toESM(require("winston-daily-rotate-file"));
+var import_global_logger_factory2 = __toESM(require_dist());
+
+// src/logging/LogContext.ts
+var import_node_async_hooks = require("node:async_hooks");
+var logContext = new import_node_async_hooks.AsyncLocalStorage();
+
+// src/logging/ConfigurableLoggerFactory.ts
+var ConfigurableLoggerFactory = class {
+  constructor(level, options = {}) {
+    this.clusterInfo = (meta) => {
+      if (meta.isPrimary) {
+        return "Primary";
+      }
+      return `W-${process.pid}`;
+    };
+    this.level = level;
+    this.fileName = options.fileName || "./logs/application-%DATE%.log";
+    this.maxSize = options.maxSize || "10m";
+    this.maxFiles = options.maxFiles || "14d";
+    this.showLocation = options.showLocation ?? false;
+    this.fileTransport = new import_winston_daily_rotate_file.default({
+      filename: this.fileName,
+      datePattern: "YYYY-MM-DD",
+      maxSize: this.maxSize,
+      maxFiles: this.maxFiles
+    });
+    this.fileTransport.setMaxListeners(Infinity);
+  }
+  createLogger(label) {
+    return new import_global_logger_factory2.WinstonLogger((0, import_winston.createLogger)({
+      level: this.level,
+      format: this.getFormat(label),
+      transports: this.createTransports(label)
+    }));
+  }
+  createTransports(label) {
+    return [
+      new import_winston.transports.Console({
+        format: import_winston.format.combine(
+          import_winston.format.colorize(),
+          this.getFormat(label)
+        )
+      }),
+      this.fileTransport
+    ];
+  }
+  getFormat(label) {
+    return import_winston.format.combine(
+      import_winston.format.label({ label }),
+      import_winston.format.timestamp({
+        format: () => {
+          return (/* @__PURE__ */ new Date()).toLocaleString("sv-SE", { timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone });
+        }
+      }),
+      (0, import_winston.format)((info) => {
+        const store = logContext.getStore();
+        if (store?.requestId) {
+          info.requestId = store.requestId;
+        }
+        return info;
+      })(),
+      import_winston.format.metadata({ fillExcept: ["level", "timestamp", "label", "message", "requestId"] }),
+      import_winston.format.printf(
+        ({ level: levelInner, message, label: labelInner, timestamp, requestId, metadata: meta }) => {
+          const clusterInfo = this.clusterInfo(meta);
+          const requestInfo = requestId ? ` [Req:${requestId}]` : "";
+          let displayLabel = labelInner;
+          if (this.showLocation && labelInner) {
+            const className = labelInner.split("/").pop();
+            if (className && className !== "Object") {
+              displayLabel = className;
+            }
+          }
+          return `${timestamp}${requestInfo} [${displayLabel}] ${levelInner}: ${message}`;
+        }
+      )
+    );
+  }
+};
+
+// src/main.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var logger = (0, import_global_logger_factory3.getLoggerFor)("Main");
+function loadEnvFile(envPath) {
+  if (!import_fs.default.existsSync(envPath)) {
+    logger.warn(`Env file not found: ${envPath}`);
+    return;
+  }
+  const content = import_fs.default.readFileSync(envPath, "utf-8");
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    if (!process.env[key]) {
+      process.env[key] = value;
+    }
+  }
+}
+async function main() {
+  const argv = await (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).option("mode", { alias: "m", type: "string", choices: ["local", "cloud"], description: "Run mode" }).option("config", { alias: "c", type: "string", description: "Path to config file (overrides --mode)" }).option("env", { alias: "e", type: "string", description: "Path to .env file" }).option("port", { alias: "p", type: "number", description: "Gateway port", default: 3e3 }).option("host", { type: "string", description: "Gateway host", default: "localhost" }).help().parse();
+  if (argv.env) {
+    loadEnvFile(argv.env);
+  }
+  const loggerFactory = new ConfigurableLoggerFactory(process.env.CSS_LOGGING_LEVEL || "info", {
+    fileName: "./logs/xpod-%DATE%.log",
+    showLocation: true
+  });
+  (0, import_global_logger_factory3.setGlobalLoggerFactory)(loggerFactory);
+  logger = (0, import_global_logger_factory3.getLoggerFor)("Main");
+  const mainPort = argv.port !== 3e3 ? argv.port : parseInt(process.env.XPOD_PORT ?? process.env.PORT ?? "3000", 10);
+  let configPath;
+  if (argv.config) {
+    configPath = argv.config;
+  } else if (argv.mode) {
+    configPath = `config/${argv.mode}.json`;
+  } else {
+    configPath = "config/local.json";
+  }
+  const cssStartPort = mainPort === 3e3 ? 3002 : 3e3;
+  const cssPort = await getFreePort(cssStartPort);
+  const apiStartPort = cssPort + 1;
+  const apiPort = await getFreePort(apiStartPort);
+  const baseUrl = process.env.CSS_BASE_URL || `http://${argv.host}:${mainPort}/`;
+  logger.info("Orchestration Plan:");
+  logger.info(`  - Main Entry: ${baseUrl} (${argv.host}:${mainPort})`);
+  logger.info(`  - CSS (internal): http://localhost:${cssPort}`);
+  logger.info(`  - API (internal): http://localhost:${apiPort}`);
+  const supervisor = new Supervisor();
+  const cssBinary = import_path.default.resolve("node_modules/@solid/community-server/bin/server.js");
+  supervisor.register({
+    name: "css",
+    command: "node",
+    // Direct node execution
+    args: [
+      cssBinary,
+      // Path to bin/server.js
+      "-c",
+      configPath,
+      "-m",
+      ".",
+      "-p",
+      cssPort.toString(),
+      "-b",
+      baseUrl
+    ],
+    env: {
+      ...process.env,
+      CSS_PORT: cssPort.toString(),
+      CSS_BASE_URL: baseUrl
+    }
+  });
+  supervisor.register({
+    name: "api",
+    command: "node",
+    args: ["dist/api/main.js"],
+    env: {
+      ...process.env,
+      API_PORT: apiPort.toString(),
+      XPOD_MAIN_PORT: mainPort.toString(),
+      CSS_INTERNAL_URL: `http://localhost:${cssPort}`
+    }
+  });
+  const proxy = new GatewayProxy(mainPort, supervisor);
+  proxy.setTargets({
+    css: `http://localhost:${cssPort}`,
+    api: `http://localhost:${apiPort}`
+  });
+  await supervisor.startAll();
+  proxy.start();
+  const shutdown = async (signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    await supervisor.stopAll();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+}
+main().catch((error) => {
+  logger.error(`Failed to start: ${error}`);
+  process.exit(1);
+});
+//# sourceMappingURL=xpod.single.cjs.map