@tego/core 1.3.44

package/lib/gateway/gateway.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'node:events';
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import { SystemLogger } from '@tachybase/logger';
+import { Registry, Toposort, ToposortOptions } from '@tachybase/utils';
+import { IPCSocketClient } from './ipc-socket-client';
+import { IPCSocketServer } from './ipc-socket-server';
+import { AppSelectorMiddleware, Handler, IncomingRequest, RunOptions, StartHttpServerOptions } from './types';
+export declare class Gateway extends EventEmitter {
+    #private;
+    private static instance;
+    /**
+     * use main app as default app to handle request
+     */
+    selectorMiddlewares: Toposort<AppSelectorMiddleware>;
+    server: http.Server | null;
+    ipcSocketServer: IPCSocketServer | null;
+    private wsServer;
+    private socketPath;
+    private handlers;
+    loggers: Registry<SystemLogger>;
+    private constructor();
+    static getInstance(options?: any): Gateway;
+    destroy(): void;
+    reset(): void;
+    addAppSelectorMiddleware(middleware: AppSelectorMiddleware, options?: ToposortOptions): void;
+    getLogger(appName: string, res: ServerResponse): import("winston").Logger;
+    responseError(res: ServerResponse, error: {
+        status: number;
+        maintaining: boolean;
+        message: string;
+        code: string;
+    }): void;
+    responseErrorWithCode(code: any, res: any, options: any): void;
+    requestHandler(req: IncomingMessage, res: ServerResponse): Promise<void>;
+    getAppSelectorMiddlewares(): Toposort<AppSelectorMiddleware>;
+    getRequestHandleAppName(req: IncomingRequest): Promise<string>;
+    getCallback(): any;
+    watch(): Promise<void>;
+    run(options: RunOptions): Promise<void>;
+    isStart(): boolean;
+    get runAt(): string;
+    get runAtLoop(): string;
+    get port(): number;
+    get host(): string;
+    isHelp(): boolean;
+    getStartOptions(): import("commander").OptionValues;
+    start(options: StartHttpServerOptions): void;
+    startIPCSocketServer(): void;
+    startHttpServer(options: StartHttpServerOptions): void;
+    registerHandler(handler: Handler): void;
+    unregisterHandler(name: string): void;
+    tryConnectToIPCServer(): Promise<false | IPCSocketClient>;
+    getIPCSocketClient(): Promise<IPCSocketClient>;
+    close(): void;
+    static getIPCSocketClient(): Promise<false | IPCSocketClient>;
+}

package/lib/gateway/gateway.js

@@ -0,0 +1,408 @@
+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 __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var gateway_exports = {};
+__export(gateway_exports, {
+  Gateway: () => Gateway
+});
+module.exports = __toCommonJS(gateway_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_events = require("node:events");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_http = __toESM(require("node:http"));
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+var import_node_util = require("node:util");
+var import_logger = require("@tachybase/logger");
+var import_utils = require("@tachybase/utils");
+var import_commander = require("commander");
+var import_compression = __toESM(require("compression"));
+var import_koa_compose = __toESM(require("koa-compose"));
+var import_qs = __toESM(require("qs"));
+var import_serve_handler = __toESM(require("serve-handler"));
+var import_app_supervisor = require("../app-supervisor");
+var import_plugin_manager = require("../plugin-manager");
+var import_errors = require("./errors");
+var import_ipc_socket_client = require("./ipc-socket-client");
+var import_ipc_socket_server = require("./ipc-socket-server");
+var import_ws_server = require("./ws-server");
+var _port, _host;
+const compress = (0, import_node_util.promisify)((0, import_compression.default)());
+const _Gateway = class _Gateway extends import_node_events.EventEmitter {
+  constructor() {
+    super();
+    /**
+     * use main app as default app to handle request
+     */
+    this.selectorMiddlewares = new import_utils.Toposort();
+    this.server = null;
+    this.ipcSocketServer = null;
+    __privateAdd(this, _port, process.env.APP_PORT ? parseInt(process.env.APP_PORT) : null);
+    __privateAdd(this, _host, "0.0.0.0");
+    this.socketPath = (0, import_node_path.resolve)(process.cwd(), "storage", "gateway.sock");
+    this.handlers = /* @__PURE__ */ new Map();
+    this.loggers = new import_utils.Registry();
+    this.reset();
+    if (process.env.SOCKET_PATH) {
+      this.socketPath = (0, import_node_path.resolve)(process.cwd(), process.env.SOCKET_PATH);
+    }
+  }
+  static getInstance(options = {}) {
+    if (!_Gateway.instance) {
+      _Gateway.instance = new _Gateway();
+    }
+    return _Gateway.instance;
+  }
+  destroy() {
+    this.reset();
+    _Gateway.instance = null;
+  }
+  reset() {
+    this.selectorMiddlewares = new import_utils.Toposort();
+    this.addAppSelectorMiddleware(
+      async (ctx, next) => {
+        var _a;
+        const { req } = ctx;
+        const appName = (_a = import_qs.default.parse((0, import_node_url.parse)(req.url).query)) == null ? void 0 : _a.__appName;
+        if (appName) {
+          ctx.resolvedAppName = appName;
+        }
+        if (req.headers["x-app"]) {
+          ctx.resolvedAppName = req.headers["x-app"];
+        }
+        await next();
+      },
+      {
+        tag: "core",
+        group: "core"
+      }
+    );
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+    }
+    if (this.ipcSocketServer) {
+      this.ipcSocketServer.close();
+      this.ipcSocketServer = null;
+    }
+  }
+  addAppSelectorMiddleware(middleware, options) {
+    if (this.selectorMiddlewares.nodes.some((existingFunc) => existingFunc.toString() === middleware.toString())) {
+      return;
+    }
+    this.selectorMiddlewares.add(middleware, options);
+    this.emit("appSelectorChanged");
+  }
+  getLogger(appName, res) {
+    const reqId = (0, import_node_crypto.randomUUID)();
+    res.setHeader("X-Request-Id", reqId);
+    let logger = this.loggers.get(appName);
+    if (logger) {
+      return logger.child({ reqId });
+    }
+    logger = (0, import_logger.createSystemLogger)({
+      dirname: (0, import_logger.getLoggerFilePath)(appName),
+      filename: "system",
+      defaultMeta: {
+        app: appName,
+        module: "gateway"
+      }
+    });
+    this.loggers.register(appName, logger);
+    return logger.child({ reqId });
+  }
+  responseError(res, error) {
+    res.setHeader("Content-Type", "application/json");
+    res.statusCode = error.status;
+    res.end(JSON.stringify({ error }));
+  }
+  responseErrorWithCode(code, res, options) {
+    const log = this.getLogger(options.appName, res);
+    const error = (0, import_errors.applyErrorWithArgs)((0, import_errors.getErrorWithCode)(code), options);
+    log.error(error.message, { method: "responseErrorWithCode", error });
+    this.responseError(res, error);
+  }
+  async requestHandler(req, res) {
+    var _a;
+    for (const handler2 of this.handlers.values()) {
+      if ((_a = req.url) == null ? void 0 : _a.startsWith(handler2.prefix)) {
+        return handler2.callback(req, res);
+      }
+    }
+    const { pathname } = (0, import_node_url.parse)(req.url);
+    const { PLUGIN_STATICS_PATH, APP_PUBLIC_PATH } = process.env;
+    if (pathname.endsWith("/__umi/api/bundle-status")) {
+      res.statusCode = 200;
+      res.end("ok");
+      return;
+    }
+    if (pathname.startsWith(APP_PUBLIC_PATH + "storage/uploads/")) {
+      req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
+      await compress(req, res);
+      return (0, import_serve_handler.default)(req, res, {
+        public: (0, import_node_path.resolve)(process.cwd()),
+        directoryListing: false
+      });
+    }
+    if (pathname.startsWith(PLUGIN_STATICS_PATH) && !pathname.includes("/server/")) {
+      await compress(req, res);
+      const packageName = (0, import_plugin_manager.getPackageNameByExposeUrl)(pathname);
+      const publicDir = (0, import_plugin_manager.getPackageDirByExposeUrl)(pathname);
+      const destination = pathname.replace(PLUGIN_STATICS_PATH, "").replace(packageName, "");
+      return (0, import_serve_handler.default)(req, res, {
+        public: publicDir,
+        rewrites: [
+          {
+            source: pathname,
+            destination
+          }
+        ]
+      });
+    }
+    if (!pathname.startsWith(process.env.API_BASE_PATH) && !pathname.startsWith(process.env.EXTENSION_UI_BASE_PATH)) {
+      req.url = req.url.substring(APP_PUBLIC_PATH.length - 1);
+      await compress(req, res);
+      return (0, import_serve_handler.default)(req, res, {
+        public: process.env.SERVE_PATH ? process.env.SERVE_PATH : `${process.env.APP_CLIENT_ROOT}/dist`,
+        rewrites: [{ source: "/**", destination: "/index.html" }]
+      });
+    }
+    const handleApp = await this.getRequestHandleAppName(req);
+    const log = this.getLogger(handleApp, res);
+    await import_app_supervisor.AppSupervisor.getInstance().getApp(handleApp);
+    let appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp, "initializing");
+    if (appStatus === "not_found") {
+      log.warn(`app not found`, { method: "requestHandler" });
+      this.responseErrorWithCode("APP_NOT_FOUND", res, { appName: handleApp });
+      return;
+    }
+    if (appStatus === "initializing") {
+      this.responseErrorWithCode("APP_INITIALIZING", res, { appName: handleApp });
+      return;
+    }
+    if (appStatus === "initialized") {
+      const appInstance = await import_app_supervisor.AppSupervisor.getInstance().getApp(handleApp);
+      appInstance.runCommand("start", "--quickstart");
+      appStatus = import_app_supervisor.AppSupervisor.getInstance().getAppStatus(handleApp);
+    }
+    const app = await import_app_supervisor.AppSupervisor.getInstance().getApp(handleApp);
+    if (appStatus !== "running") {
+      log.warn(`app is not running`, { method: "requestHandler", status: appStatus });
+      this.responseErrorWithCode(`${appStatus}`, res, { app, appName: handleApp });
+      return;
+    }
+    if (req.url.endsWith("/__health_check")) {
+      res.statusCode = 200;
+      res.end("ok");
+      return;
+    }
+    if (handleApp !== "main") {
+      import_app_supervisor.AppSupervisor.getInstance().touchApp(handleApp);
+    }
+    app.callback()(req, res);
+  }
+  getAppSelectorMiddlewares() {
+    return this.selectorMiddlewares;
+  }
+  async getRequestHandleAppName(req) {
+    const appSelectorMiddlewares = this.selectorMiddlewares.sort();
+    const ctx = {
+      req,
+      resolvedAppName: null
+    };
+    await (0, import_koa_compose.default)(appSelectorMiddlewares)(ctx);
+    if (!ctx.resolvedAppName) {
+      ctx.resolvedAppName = "main";
+    }
+    return ctx.resolvedAppName;
+  }
+  getCallback() {
+    return this.requestHandler.bind(this);
+  }
+  async watch() {
+    if (!process.env.IS_DEV_CMD) {
+      return;
+    }
+    const file = (0, import_node_path.resolve)(process.cwd(), "storage/app.watch.ts");
+    if (!import_node_fs.default.existsSync(file)) {
+      await import_node_fs.default.promises.writeFile(file, `export const watchId = '${(0, import_utils.uid)()}';`, "utf-8");
+    }
+    require(file);
+  }
+  async run(options) {
+    const isStart = this.isStart();
+    let ipcClient;
+    if (isStart) {
+      await this.watch();
+      const startOptions = this.getStartOptions();
+      const port = startOptions.port || process.env.APP_PORT || 3e3;
+      const host = startOptions.host || process.env.APP_HOST || "0.0.0.0";
+      this.start({
+        port,
+        host
+      });
+    } else if (!this.isHelp()) {
+      ipcClient = await this.tryConnectToIPCServer();
+      if (ipcClient) {
+        const response = await ipcClient.write({ type: "passCliArgv", payload: { argv: process.argv } });
+        ipcClient.close();
+        if (!["error", "not_found"].includes(response.type)) {
+          return;
+        }
+      }
+    }
+    if (isStart || !ipcClient) {
+      await (0, import_utils.createStoragePluginsSymlink)();
+    }
+    const mainApp = import_app_supervisor.AppSupervisor.getInstance().bootMainApp(options.mainAppOptions);
+    mainApp.runAsCLI(process.argv, {
+      throwError: true,
+      from: "node"
+    }).then(async () => {
+      if (!isStart && !await mainApp.isStarted()) {
+        await mainApp.stop({ logging: false });
+      }
+    }).catch(async (e) => {
+      if (e.code !== "commander.helpDisplayed") {
+        mainApp.logger.error(e);
+      }
+      if (!isStart && !await mainApp.isStarted()) {
+        await mainApp.stop({ logging: false });
+      }
+    });
+  }
+  isStart() {
+    const argv = process.argv;
+    return argv[2] === "start";
+  }
+  get runAt() {
+    return `http://${__privateGet(this, _host)}:${__privateGet(this, _port)}`;
+  }
+  get runAtLoop() {
+    return `http://127.0.0.1:${__privateGet(this, _port)}`;
+  }
+  get port() {
+    return __privateGet(this, _port);
+  }
+  get host() {
+    return __privateGet(this, _host);
+  }
+  isHelp() {
+    const argv = process.argv;
+    return argv[2] === "help";
+  }
+  getStartOptions() {
+    const argv = process.argv;
+    const program = new import_commander.Command();
+    program.allowUnknownOption().option("-s, --silent").option("-p, --port [post]").option("-h, --host [host]").option("--db-sync").parse(process.argv);
+    const options = program.opts();
+    return options;
+  }
+  start(options) {
+    this.startHttpServer(options);
+    this.startIPCSocketServer();
+  }
+  startIPCSocketServer() {
+    this.ipcSocketServer = import_ipc_socket_server.IPCSocketServer.buildServer(this.socketPath);
+  }
+  startHttpServer(options) {
+    if ((options == null ? void 0 : options.port) !== null) {
+      __privateSet(this, _port, options.port);
+    }
+    if (options == null ? void 0 : options.host) {
+      __privateSet(this, _host, options.host);
+    }
+    if (__privateGet(this, _port) === null) {
+      console.log("gateway port is not set, http server will not start");
+      return;
+    }
+    this.server = import_node_http.default.createServer(this.getCallback());
+    this.wsServer = new import_ws_server.WSServer();
+    this.server.on("upgrade", (request, socket, head) => {
+      const { pathname } = (0, import_node_url.parse)(request.url);
+      if (pathname === process.env.WS_PATH) {
+        this.wsServer.wss.handleUpgrade(request, socket, head, (ws) => {
+          this.wsServer.wss.emit("connection", ws, request);
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+    this.server.listen(__privateGet(this, _port), __privateGet(this, _host), () => {
+      console.log(`Gateway HTTP Server running at http://${__privateGet(this, _host)}:${__privateGet(this, _port)}/`);
+      if (options == null ? void 0 : options.callback) {
+        options.callback(this.server);
+      }
+    });
+  }
+  registerHandler(handler2) {
+    this.handlers.set(handler2.name, handler2);
+  }
+  unregisterHandler(name) {
+    this.handlers.delete(name);
+  }
+  async tryConnectToIPCServer() {
+    try {
+      const ipcClient = await this.getIPCSocketClient();
+      return ipcClient;
+    } catch (e) {
+      return false;
+    }
+  }
+  async getIPCSocketClient() {
+    return await import_ipc_socket_client.IPCSocketClient.getConnection(this.socketPath);
+  }
+  close() {
+    var _a, _b;
+    (_a = this.server) == null ? void 0 : _a.close();
+    (_b = this.wsServer) == null ? void 0 : _b.close();
+  }
+  static async getIPCSocketClient() {
+    const socketPath = (0, import_node_path.resolve)(process.cwd(), process.env.SOCKET_PATH || "storage/gateway.sock");
+    try {
+      return await import_ipc_socket_client.IPCSocketClient.getConnection(socketPath);
+    } catch (error) {
+      return false;
+    }
+  }
+};
+_port = new WeakMap();
+_host = new WeakMap();
+__name(_Gateway, "Gateway");
+let Gateway = _Gateway;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Gateway
+});

package/lib/gateway/index.d.ts

@@ -0,0 +1,2 @@
+export { Gateway } from './gateway';
+export { WSServer } from './ws-server';

package/lib/gateway/index.js

@@ -0,0 +1,30 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var gateway_exports = {};
+__export(gateway_exports, {
+  Gateway: () => import_gateway.Gateway,
+  WSServer: () => import_ws_server.WSServer
+});
+module.exports = __toCommonJS(gateway_exports);
+var import_gateway = require("./gateway");
+var import_ws_server = require("./ws-server");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Gateway,
+  WSServer
+});

package/lib/gateway/ipc-socket-client.d.ts

@@ -0,0 +1,17 @@
+import * as events from 'node:events';
+import net from 'node:net';
+import { Logger } from '@tachybase/logger';
+export declare const writeJSON: (socket: net.Socket, data: object) => void;
+export declare class IPCSocketClient extends events.EventEmitter {
+    client: net.Socket;
+    logger: Logger;
+    constructor(client: net.Socket);
+    static getConnection(serverPath: string): Promise<IPCSocketClient>;
+    handleServerMessage({ reqId, type, payload }: {
+        reqId: any;
+        type: any;
+        payload: any;
+    }): Promise<void>;
+    close(): void;
+    write(data: any): Promise<unknown>;
+}

package/lib/gateway/ipc-socket-client.js

@@ -0,0 +1,99 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ipc_socket_client_exports = {};
+__export(ipc_socket_client_exports, {
+  IPCSocketClient: () => IPCSocketClient,
+  writeJSON: () => writeJSON
+});
+module.exports = __toCommonJS(ipc_socket_client_exports);
+var events = __toESM(require("node:events"));
+var import_node_net = __toESM(require("node:net"));
+var import_logger = require("@tachybase/logger");
+var import_xpipe = __toESM(require("xpipe"));
+const writeJSON = /* @__PURE__ */ __name((socket, data) => {
+  socket.write(JSON.stringify(data) + "\n", "utf8");
+}, "writeJSON");
+const _IPCSocketClient = class _IPCSocketClient extends events.EventEmitter {
+  constructor(client) {
+    super();
+    this.logger = (0, import_logger.createConsoleLogger)();
+    this.client = client;
+    this.client.on("data", (data) => {
+      const dataAsString = data.toString();
+      const messages = dataAsString.split("\n");
+      for (const message of messages) {
+        if (message.length === 0) {
+          continue;
+        }
+        const dataObj = JSON.parse(message);
+        this.handleServerMessage(dataObj);
+      }
+    });
+  }
+  static async getConnection(serverPath) {
+    return new Promise((resolve, reject) => {
+      const client = import_node_net.default.createConnection({ path: import_xpipe.default.eq(serverPath) }, () => {
+        resolve(new _IPCSocketClient(client));
+      });
+      client.on("error", (err) => {
+        reject(err);
+      });
+    });
+  }
+  async handleServerMessage({ reqId, type, payload }) {
+    switch (type) {
+      case "not_found":
+        break;
+      case "error":
+        this.logger.error({ reqId, message: `${payload.message}|${payload.stack}` });
+        break;
+      case "success":
+        this.logger.info({ reqId, message: "success" });
+        break;
+      default:
+        this.logger.info({ reqId, message: JSON.stringify({ type, payload }) });
+        break;
+    }
+    this.emit("response", { reqId, type, payload });
+  }
+  close() {
+    this.client.end();
+  }
+  write(data) {
+    writeJSON(this.client, data);
+    return new Promise((resolve) => this.once("response", resolve));
+  }
+};
+__name(_IPCSocketClient, "IPCSocketClient");
+let IPCSocketClient = _IPCSocketClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IPCSocketClient,
+  writeJSON
+});

package/lib/gateway/ipc-socket-server.d.ts

@@ -0,0 +1,12 @@
+import net from 'node:net';
+export declare class IPCSocketServer {
+    socketServer: net.Server;
+    constructor(server: net.Server);
+    static buildServer(socketPath: string): IPCSocketServer;
+    static handleClientMessage({ reqId, type, payload }: {
+        reqId: any;
+        type: any;
+        payload: any;
+    }): Promise<string | false | import("../app-command").AppCommand>;
+    close(): void;
+}