@kevisual/router 0.1.1 → 0.1.3

package/dist/commander.d.ts

@@ -147,14 +147,6 @@ type RouteOpts<U = {}, T = SimpleObject> = {
     metadata?: T;
     middleware?: RouteMiddleware[];
     type?: 'route' | 'middleware' | 'compound';
-    /**
-     * $#$ will be used to split path and key
-     */
-    idUsePath?: boolean;
-    /**
-     * id 合并的分隔符，默认为 $#$
-     */
-    delimiter?: string;
     isDebug?: boolean;
 };
 type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'nextRoute'>;
@@ -805,14 +797,21 @@ declare const groupByPath: (routes: App["routes"]) => Record<string, Route<Simpl
 declare const parseArgs: (args: string) => any;
 declare const parseDescription: (route: App["routes"][number]) => string;
 declare const createCommand: (opts: {
-    app: App;
+    app: any;
     program: Command;
 }) => void;
 declare const parse: (opts: {
-    app: QueryRouterServer;
+    app: any;
     description?: string;
     parse?: boolean;
+    version?: string;
     program?: Command;
-}) => void;
+    remote?: {
+        token?: string;
+        username?: string;
+        id?: string;
+    };
+    exitOnEnd?: boolean;
+}) => Promise<void>;
 
 export { createCommand, groupByPath, parse, parseArgs, parseDescription };

package/dist/commander.js

@@ -4,21 +4,35 @@ var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
 var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
   target = mod != null ? __create(__getProtoOf(mod)) : {};
   const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
   for (let key of __getOwnPropNames(mod))
     if (!__hasOwnProp.call(to, key))
       __defProp(to, key, {
-        get: () => mod[key],
+        get: __accessProp.bind(mod, key),
         enumerable: true
       });
+  if (canCache)
+    cache.set(mod, to);
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/error.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/error.js
 var require_error = __commonJS((exports) => {
   class CommanderError extends Error {
     constructor(exitCode, code, message) {
@@ -42,7 +56,7 @@ var require_error = __commonJS((exports) => {
   exports.InvalidArgumentError = InvalidArgumentError;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/argument.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/argument.js
 var require_argument = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -122,7 +136,7 @@ var require_argument = __commonJS((exports) => {
   exports.humanReadableArgName = humanReadableArgName;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/help.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/help.js
 var require_help = __commonJS((exports) => {
   var { humanReadableArgName } = require_argument();
 
@@ -479,7 +493,7 @@ ${itemIndentStr}`);
   exports.stripColor = stripColor;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/option.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/option.js
 var require_option = __commonJS((exports) => {
   var { InvalidArgumentError } = require_error();
 
@@ -663,7 +677,7 @@ var require_option = __commonJS((exports) => {
   exports.DualOptions = DualOptions;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/suggestSimilar.js
 var require_suggestSimilar = __commonJS((exports) => {
   var maxDistance = 3;
   function editDistance(a, b) {
@@ -736,7 +750,7 @@ var require_suggestSimilar = __commonJS((exports) => {
   exports.suggestSimilar = suggestSimilar;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
   var EventEmitter = __require("node:events").EventEmitter;
   var childProcess = __require("node:child_process");
@@ -2091,7 +2105,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
   exports.useColor = useColor;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/index.js
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/index.js
 var require_commander = __commonJS((exports) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
@@ -2111,7 +2125,7 @@ var require_commander = __commonJS((exports) => {
   exports.InvalidOptionArgumentError = InvalidArgumentError;
 });
 
-// node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
+// ../../node_modules/.pnpm/commander@14.0.3/node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
   program,
@@ -2127,6 +2141,490 @@ var {
   Help
 } = import__.default;
 
+// ../../node_modules/.pnpm/@kevisual+remote-app@0.0.7/node_modules/@kevisual/remote-app/dist/app.js
+var __create2 = Object.create;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __toESM2 = (mod, isNodeMode, target) => {
+  target = mod != null ? __create2(__getProtoOf2(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames2(mod))
+    if (!__hasOwnProp2.call(to, key))
+      __defProp2(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS2 = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_eventemitter3 = __commonJS2((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+var import__2 = __toESM2(require_eventemitter3(), 1);
+
+class RemoteApp {
+  mainApp;
+  url;
+  id;
+  username;
+  emitter;
+  isConnected;
+  isVerified;
+  ws;
+  remoteIsConnected;
+  isError = false;
+  autoReconnect;
+  maxReconnectAttempts;
+  reconnectDelay;
+  maxReconnectDelay;
+  enableBackoff;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  isManuallyClosed = false;
+  isInitializing = false;
+  initId = 0;
+  constructor(opts) {
+    this.mainApp = opts?.app;
+    const token = opts.token;
+    const url = opts.url || "https://kevisual.cn/ws/proxy";
+    const id = opts.id;
+    const username = opts.username;
+    this.username = username;
+    this.emitter = opts?.emitter || new import__2.default;
+    const _url = new URL(url);
+    if (token) {
+      _url.searchParams.set("token", token);
+    }
+    _url.searchParams.set("id", id);
+    if (!token && !username) {
+      console.error(`[remote-app] 不存在用户名和token ${id}. 权限认证会失败。`);
+    }
+    this.url = _url.toString();
+    this.id = id;
+    this.autoReconnect = opts?.autoReconnect ?? true;
+    this.maxReconnectAttempts = opts?.maxReconnectAttempts ?? Infinity;
+    this.reconnectDelay = opts?.reconnectDelay ?? 1000;
+    this.maxReconnectDelay = opts?.maxReconnectDelay ?? 30000;
+    this.enableBackoff = opts?.enableBackoff ?? true;
+    this.init();
+  }
+  async isConnect() {
+    const that = this;
+    if (this.isConnected) {
+      return true;
+    }
+    if (this.reconnectTimer !== null) {
+      console.log(`远程应用 ${this.id} 正在重连中...`);
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve(false);
+        that.emitter.off("open", listenOnce);
+      }, 5000);
+      const listenOnce = () => {
+        clearTimeout(timeout);
+        that.isConnected = true;
+        that.remoteIsConnected = true;
+        resolve(true);
+      };
+      that.emitter.once("open", listenOnce);
+    });
+  }
+  async waitVerify() {
+    if (this.isVerified) {
+      return true;
+    }
+    return new Promise((resolve) => {
+      const listenOnce = () => {
+        this.isVerified = true;
+        resolve(true);
+      };
+      this.emitter.once("verified", listenOnce);
+    });
+  }
+  getWsURL(url) {
+    const { protocol } = new URL(url);
+    if (protocol.startsWith("ws")) {
+      return url.toString();
+    }
+    const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+    const wsURL = url.toString().replace(protocol, wsProtocol);
+    return wsURL;
+  }
+  async init() {
+    if (this.isInitializing) {
+      return;
+    }
+    this.isInitializing = true;
+    const currentInitId = ++this.initId;
+    if (!this.url) {
+      this.isInitializing = false;
+      throw new Error("No url provided for remote app");
+    }
+    if (!this.id) {
+      this.isInitializing = false;
+      throw new Error("No id provided for remote app");
+    }
+    this.isError = false;
+    if (this.ws) {
+      this.ws.close();
+    }
+    const ws = new WebSocket(this.getWsURL(this.url));
+    const that = this;
+    ws.onopen = function() {
+      if (currentInitId !== that.initId) {
+        ws.close();
+        return;
+      }
+      that.isConnected = true;
+      that.isInitializing = false;
+      that.onOpen();
+      console.log("[remote-app] WebSocket connection opened");
+    };
+    ws.onclose = function() {
+      if (currentInitId !== that.initId) {
+        return;
+      }
+      that.isInitializing = false;
+      that.isConnected = false;
+      that.onClose();
+    };
+    ws.onmessage = function(event) {
+      that.onMessage(event.data);
+    };
+    ws.onerror = function(error) {
+      if (currentInitId !== that.initId) {
+        return;
+      }
+      that.isInitializing = false;
+      that.onError(error);
+    };
+    this.ws = ws;
+  }
+  onOpen() {
+    this.isError = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.emitter.emit("open", this.id);
+  }
+  onClose() {
+    console.log("远程应用关闭:", this.id);
+    this.isConnected = false;
+    this.emitter.emit("close", this.id);
+    if (this.autoReconnect && !this.isManuallyClosed) {
+      this.scheduleReconnect();
+    }
+  }
+  calculateReconnectDelay() {
+    if (!this.enableBackoff) {
+      return this.reconnectDelay;
+    }
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+    return Math.min(delay, this.maxReconnectDelay);
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error(`远程应用 ${this.id} 已达到最大重连次数 ${this.maxReconnectAttempts}，停止重连`);
+      this.emitter.emit("maxReconnectAttemptsReached", this.id);
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    const delay = this.calculateReconnectDelay();
+    this.reconnectAttempts++;
+    console.log(`远程应用 ${this.id} 将在 ${delay}ms 后尝试第 ${this.reconnectAttempts} 次重连`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      try {
+        this.init();
+      } catch (error) {
+        console.error(`远程应用 ${this.id} 重连失败:`, error);
+        this.emitter.emit("reconnectFailed", { id: this.id, attempt: this.reconnectAttempts, error });
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  disconnect() {
+    this.isManuallyClosed = true;
+    this.autoReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+  reconnect() {
+    this.isManuallyClosed = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.init();
+  }
+  onMessage(data) {
+    this.emitter.emit("message", data);
+  }
+  onError(error) {
+    console.error(`[remote-app] 远程应用错误: ${this.id}`, error);
+    this.isError = true;
+    this.emitter.emit("error", error);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => {
+      this.emitter.off(event, listener);
+    };
+  }
+  json(data) {
+    this.ws.send(JSON.stringify(data));
+  }
+  listenProxy() {
+    const remoteApp = this;
+    const app = this.mainApp;
+    const username = this.username;
+    const listenFn = async (event) => {
+      try {
+        const data = event.toString();
+        const body = JSON.parse(data);
+        const bodyData = body?.data;
+        const message = bodyData?.message || {};
+        const context = bodyData?.context || {};
+        console.log("[remote-app] 远程应用收到消息:", body);
+        if (body?.code === 401) {
+          console.error("[remote-app] 远程应用认证失败，请检查 token 是否正确");
+          this.isError = true;
+          return;
+        }
+        if (body?.type === "verified") {
+          remoteApp.emitter.emit("verified");
+          return;
+        }
+        if (body?.type !== "proxy")
+          return;
+        if (!body.id) {
+          remoteApp.json({
+            id: body.id,
+            data: {
+              code: 400,
+              message: "id is required"
+            }
+          });
+          return;
+        }
+        const res = await app.run(message, context);
+        remoteApp.json({
+          id: body.id,
+          data: {
+            code: res.code,
+            data: res.data,
+            message: res.message
+          }
+        });
+      } catch (error) {
+        console.error("[remote-app] 处理远程代理请求出错:", error);
+      }
+    };
+    remoteApp.json({
+      id: this.id,
+      type: "registryClient",
+      username
+    });
+    console.log(`[remote-app] 远程应用 ${this.id} (${username}) 已注册到主应用，等待消息...`);
+    remoteApp.emitter.on("message", listenFn);
+    const closeMessage = () => {
+      remoteApp.emitter.off("message", listenFn);
+    };
+    remoteApp.emitter.once("close", () => {
+      closeMessage();
+    });
+    return () => {
+      closeMessage();
+    };
+  }
+}
+
 // src/commander.ts
 var groupByPath = (routes) => {
   return routes.reduce((acc, route) => {
@@ -2196,7 +2694,8 @@ var parseDescription = (route) => {
   return desc;
 };
 var createCommand2 = (opts) => {
-  const { app, program: program2 } = opts;
+  const { program: program2 } = opts;
+  const app = opts.app;
   const routes = app.routes;
   const groupRoutes = groupByPath(routes);
   for (const path in groupRoutes) {
@@ -2237,13 +2736,52 @@ var createCommand2 = (opts) => {
     });
   }
 };
-var parse = (opts) => {
-  const { app, description, parse: parse2 = true } = opts;
+var parse = async (opts) => {
+  const { description, parse: parse2 = true, version, exitOnEnd = true } = opts;
+  const app = opts.app;
   const _program = opts.program || program;
   _program.description(description || "Router 命令行工具");
+  if (version) {
+    _program.version(version);
+  }
+  app.createRouteList();
+  app.route({
+    path: "cli",
+    key: "list"
+  }).define(async () => {
+    const routes = app.routes.map((route) => {
+      return {
+        path: route.path,
+        key: route.key,
+        description: route?.metadata?.summary || route.description || ""
+      };
+    });
+    const table = routes.map((route) => {
+      return `${route.path} ${route.key} - ${route.description}`;
+    }).join(`
+`);
+    console.log(table);
+  }).addTo(app, { overwrite: false });
   createCommand2({ app, program: _program });
+  if (opts.remote) {
+    const { token, username, id } = opts.remote;
+    const remoteApp = new RemoteApp({
+      token,
+      username,
+      id
+    });
+    const isConnect = await remoteApp.isConnect();
+    if (isConnect) {
+      remoteApp.listenProxy();
+      console.log("已连接到远程应用，正在监听命令...");
+    }
+    return;
+  }
   if (parse2) {
-    _program.parse(process.argv);
+    await _program.parseAsync(process.argv);
+    if (exitOnEnd) {
+      process.exit(0);
+    }
   }
 };
 export {

package/dist/opencode.d.ts

@@ -147,14 +147,6 @@ type RouteOpts<U = {}, T = SimpleObject> = {
     metadata?: T;
     middleware?: RouteMiddleware[];
     type?: 'route' | 'middleware' | 'compound';
-    /**
-     * $#$ will be used to split path and key
-     */
-    idUsePath?: boolean;
-    /**
-     * id 合并的分隔符，默认为 $#$
-     */
-    delimiter?: string;
     isDebug?: boolean;
 };
 type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'nextRoute'>;