@kevisual/router 0.0.66 → 0.0.68

package/dist/ws.js

@@ -0,0 +1,186 @@
+import WebSocket from 'ws';
+
+/**
+ * 一个支持自动重连的 WebSocket 客户端。
+ * 在连接断开时会根据配置进行重连尝试，支持指数退避。
+ */
+class ReconnectingWebSocket {
+    ws = null;
+    url;
+    config;
+    retryCount = 0;
+    reconnectTimer = null;
+    isManualClose = false;
+    messageHandlers = [];
+    openHandlers = [];
+    closeHandlers = [];
+    errorHandlers = [];
+    constructor(url, config = {}) {
+        this.url = url;
+        this.config = {
+            maxRetries: config.maxRetries ?? Infinity,
+            retryDelay: config.retryDelay ?? 1000,
+            maxDelay: config.maxDelay ?? 30000,
+            backoffMultiplier: config.backoffMultiplier ?? 2,
+        };
+    }
+    log(...args) {
+        console.log('[ReconnectingWebSocket]', ...args);
+    }
+    error(...args) {
+        console.error('[ReconnectingWebSocket]', ...args);
+    }
+    connect() {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            return;
+        }
+        this.log(`正在连接到 ${this.url}...`);
+        this.ws = new WebSocket(this.url);
+        this.ws.on('open', () => {
+            this.log('WebSocket 连接已打开');
+            this.retryCount = 0;
+            this.openHandlers.forEach(handler => handler());
+            this.send({ type: 'heartbeat', timestamp: new Date().toISOString() });
+        });
+        this.ws.on('message', (data) => {
+            this.messageHandlers.forEach(handler => {
+                try {
+                    const message = JSON.parse(data.toString());
+                    handler(message);
+                }
+                catch {
+                    handler(data.toString());
+                }
+            });
+        });
+        this.ws.on('close', (code, reason) => {
+            this.log(`WebSocket 连接已关闭: code=${code}, reason=${reason.toString()}`);
+            this.closeHandlers.forEach(handler => handler(code, reason));
+            if (!this.isManualClose) {
+                this.scheduleReconnect();
+            }
+        });
+        this.ws.on('error', (error) => {
+            this.error('WebSocket 错误:', error.message);
+            this.errorHandlers.forEach(handler => handler(error));
+        });
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer) {
+            return;
+        }
+        if (this.retryCount >= this.config.maxRetries) {
+            this.error(`已达到最大重试次数 (${this.config.maxRetries})，停止重连`);
+            return;
+        }
+        // 计算延迟（指数退避）
+        const delay = Math.min(this.config.retryDelay * Math.pow(this.config.backoffMultiplier, this.retryCount), this.config.maxDelay);
+        this.retryCount++;
+        this.log(`将在 ${delay}ms 后进行第 ${this.retryCount} 次重连尝试...`);
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connect();
+        }, delay);
+    }
+    send(data) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(data));
+            return true;
+        }
+        this.log('WebSocket 未连接，无法发送消息');
+        return false;
+    }
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    onOpen(handler) {
+        this.openHandlers.push(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.push(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    close() {
+        this.isManualClose = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    getReadyState() {
+        return this.ws?.readyState ?? WebSocket.CLOSED;
+    }
+    getRetryCount() {
+        return this.retryCount;
+    }
+}
+// const ws = new ReconnectingWebSocket('ws://localhost:51516/livecode/ws?id=test-live-app', {
+//   maxRetries: Infinity,    // 无限重试
+//   retryDelay: 1000,        // 初始重试延迟 1 秒
+//   maxDelay: 30000,         // 最大延迟 30 秒
+//   backoffMultiplier: 2,    // 指数退避倍数
+// });
+
+const handleCallWsApp = async (ws, app, message) => {
+    return handleCallApp((data) => {
+        ws.send(data);
+    }, app, message);
+};
+const handleCallApp = async (send, app, message) => {
+    if (message.type === 'router' && message.id) {
+        const data = message?.data;
+        if (!message.id) {
+            console.error('Message id is required for router type');
+            return;
+        }
+        if (!data) {
+            send({
+                type: 'router',
+                id: message.id,
+                data: { code: 500, message: 'No data received' }
+            });
+            return;
+        }
+        const { tokenUser, ...rest } = data || {};
+        const res = await app.run(rest, {
+            state: { tokenUser },
+            appId: app.appId,
+        });
+        send({
+            type: 'router',
+            id: message.id,
+            data: res
+        });
+    }
+};
+class Ws {
+    wsClient;
+    app;
+    showLog = true;
+    constructor(opts) {
+        const { url, app, showLog = true, handleMessage = handleCallWsApp, ...rest } = opts;
+        this.wsClient = new ReconnectingWebSocket(url, rest);
+        this.app = app;
+        this.showLog = showLog;
+        this.wsClient.connect();
+        const onMessage = async (data) => {
+            return handleMessage(this.wsClient, this.app, data);
+        };
+        this.wsClient.onMessage(onMessage);
+    }
+    send(data) {
+        return this.wsClient.send(data);
+    }
+    log(...args) {
+        if (this.showLog)
+            console.log('[Ws]', ...args);
+    }
+}
+
+export { ReconnectingWebSocket, Ws, handleCallApp, handleCallWsApp };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.66",
+  "version": "0.0.68",
   "description": "",
   "type": "module",
   "main": "./dist/router.js",
@@ -24,17 +24,18 @@
   "packageManager": "pnpm@10.28.2",
   "devDependencies": {
     "@kevisual/context": "^0.0.4",
+    "@kevisual/dts": "^0.0.3",
     "@kevisual/js-filter": "^0.0.5",
     "@kevisual/local-proxy": "^0.0.8",
-    "@kevisual/query": "^0.0.38",
-    "@kevisual/use-config": "^1.0.28",
-    "@opencode-ai/plugin": "^1.1.47",
+    "@kevisual/query": "^0.0.39",
+    "@kevisual/use-config": "^1.0.30",
+    "@opencode-ai/plugin": "^1.1.48",
     "@rollup/plugin-alias": "^6.0.0",
     "@rollup/plugin-commonjs": "29.0.0",
     "@rollup/plugin-node-resolve": "^16.0.3",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/bun": "^1.3.8",
-    "@types/node": "^25.1.0",
+    "@types/node": "^25.2.0",
     "@types/send": "^1.2.1",
     "@types/ws": "^8.18.1",
     "@types/xml2js": "^0.4.14",
@@ -52,16 +53,14 @@
     "typescript": "^5.9.3",
     "ws": "npm:@kevisual/ws",
     "xml2js": "^0.6.2",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "hono": "^4.11.7"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/abearxiong/kevisual-router.git"
   },
-  "dependencies": {
-    "@kevisual/dts": "^0.0.3",
-    "hono": "^4.11.7"
-  },
+  "dependencies": {},
   "publishConfig": {
     "access": "public"
   },
@@ -88,6 +87,7 @@
       "require": "./dist/router-define.js",
       "types": "./dist/router-define.d.ts"
     },
+    "./ws": "./dist/ws.js",
     "./mod.ts": {
       "import": "./mod.ts",
       "require": "./mod.ts",
@@ -102,4 +102,4 @@
       "require": "./src/modules/*"
     }
   }
-}
+}

package/src/browser.ts

@@ -8,7 +8,7 @@ export type { RouteContext, RouteOpts, RouteMiddleware } from './route.ts';
 
 export type { Run, Skill } from './route.ts';
 
-export { createSkill, tool } from './route.ts';
+export { createSkill, tool, fromJSONSchema, toJSONSchema } from './route.ts';
 
 export { CustomError } from './result/error.ts';
 

package/src/index.ts

@@ -8,7 +8,7 @@ export type { RouteContext, RouteOpts, RouteMiddleware } from './route.ts';
 
 export type { Run, Skill } from './route.ts';
 
-export { createSkill, tool } from './route.ts';
+export { createSkill, tool, fromJSONSchema, toJSONSchema } from './route.ts';
 
 export { CustomError } from './result/error.ts';
 

package/src/route.ts

@@ -1,7 +1,7 @@
 import { nanoid } from 'nanoid';
 import { CustomError } from './result/error.ts';
 import { pick } from './utils/pick.ts';
-import { listenProcess } from './utils/listen-process.ts';
+import { listenProcess, MockProcess } from './utils/listen-process.ts';
 import { z } from 'zod';
 import { filter } from '@kevisual/js-filter'
 
@@ -243,11 +243,42 @@ export class Route<U = { [key: string]: any }, T extends SimpleObject = SimpleOb
     throw new CustomError(...args);
   }
 }
+export const toJSONSchema = (route: RouteInfo) => {
+  const pickValues = pick(route, pickValue as any);
+  if (pickValues?.metadata?.args) {
+    const args = pickValues.metadata.args;
+    const keys = Object.keys(args);
+    const newArgs: { [key: string]: any } = {};
+    for (let key of keys) {
+      const item = args[key] as z.ZodAny;
+      if (item && typeof item === 'object' && typeof item.toJSONSchema === 'function') {
+        newArgs[key] = item.toJSONSchema();
+      } else {
+        newArgs[key] = args[key]; // 可能不是schema
+      }
+    }
+    pickValues.metadata.args = newArgs;
+  }
+  return pickValues;
+}
+
+export const fromJSONSchema = (route: RouteInfo): {
+  [key: string]: z.ZodTypeAny
+} => {
+  const args = route?.metadata?.args || {};
+  const keys = Object.keys(args);
+  const newArgs: { [key: string]: any } = {};
+  for (let key of keys) {
+    const item = args[key];
+    newArgs[key] = z.fromJSONSchema(item);
+  }
+  return newArgs;
+}
 
 /**
- * @parmas override 是否覆盖已存在的route，默认true
+ * @parmas overwrite 是否覆盖已存在的route，默认true
  */
-export type AddOpts = { override?: boolean };
+export type AddOpts = { overwrite?: boolean };
 export class QueryRouter {
   appId: string = '';
   routes: Route[];
@@ -262,14 +293,14 @@ export class QueryRouter {
    * @param opts
    */
   add(route: Route, opts?: AddOpts) {
-    const override = opts?.override ?? true;
+    const overwrite = opts?.overwrite ?? true;
     const has = this.routes.findIndex((r) => r.path === route.path && r.key === route.key);
 
     if (has !== -1) {
-      if (!override) {
+      if (!overwrite) {
         return;
       }
-      // 如果存在，且override为true，则覆盖
+      // 如果存在，且overwrite为true，则覆盖
       this.routes.splice(has, 1);
     }
     this.routes.push(route);
@@ -555,7 +586,23 @@ export class QueryRouter {
   }
   getList(filter?: (route: Route) => boolean): RouteInfo[] {
     return this.routes.filter(filter || (() => true)).map((r) => {
-      return pick(r, pickValue as any);
+      const pickValues = pick(r, pickValue as any);
+      if (pickValues?.metadata?.args) {
+        // const demoArgs = { k: tool.schema.string().describe('示例参数') };
+        const args = pickValues.metadata.args;
+        const keys = Object.keys(args);
+        const newArgs: { [key: string]: any } = {};
+        for (let key of keys) {
+          const item = args[key] as z.ZodAny;
+          if (item && typeof item === 'object' && typeof item.toJSONSchema === 'function') {
+            newArgs[key] = item.toJSONSchema();
+          } else {
+            newArgs[key] = args[key]; // 可能不是schema
+          }
+        }
+        pickValues.metadata.args = newArgs;
+      }
+      return pickValues;
     });
   }
   /**
@@ -634,7 +681,7 @@ export class QueryRouter {
    * -- .send
    */
   wait(params?: { path?: string; key?: string; payload?: any }, opts?: {
-    emitter?: any,
+    mockProcess?: MockProcess,
     timeout?: number,
     getList?: boolean
     force?: boolean
@@ -646,6 +693,8 @@ export class QueryRouter {
     }
     return listenProcess({ app: this as any, params, ...opts });
   }
+  static toJSONSchema = toJSONSchema;
+  static fromJSONSchema = fromJSONSchema;
 }
 
 type QueryRouterServerOpts = {
@@ -729,4 +778,5 @@ export class QueryRouterServer extends QueryRouter {
 }
 
 
-export class Mini extends QueryRouterServer { }
+export class Mini extends QueryRouterServer { }
+

package/src/server/reconnect-ws.ts

@@ -0,0 +1,170 @@
+import WebSocket from 'ws';
+
+export type ReconnectConfig = {
+  /**
+   * 重连配置选项, 最大重试次数，默认无限
+   */
+  maxRetries?: number;
+  /**
+   * 重连配置选项, 重试延迟(ms)，默认1000
+   */
+  retryDelay?: number;
+  /**
+   * 重连配置选项, 最大延迟(ms)，默认30000
+   */
+  maxDelay?: number;
+  /**
+   * 重连配置选项, 退避倍数，默认2
+   */
+  backoffMultiplier?: number;
+};
+
+/**
+ * 一个支持自动重连的 WebSocket 客户端。
+ * 在连接断开时会根据配置进行重连尝试，支持指数退避。
+ */
+export class ReconnectingWebSocket {
+  private ws: WebSocket | null = null;
+  private url: string;
+  private config: Required<ReconnectConfig>;
+  private retryCount: number = 0;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private isManualClose: boolean = false;
+  private messageHandlers: Array<(data: any) => void> = [];
+  private openHandlers: Array<() => void> = [];
+  private closeHandlers: Array<(code: number, reason: Buffer) => void> = [];
+  private errorHandlers: Array<(error: Error) => void> = [];
+
+  constructor(url: string, config: ReconnectConfig = {}) {
+    this.url = url;
+    this.config = {
+      maxRetries: config.maxRetries ?? Infinity,
+      retryDelay: config.retryDelay ?? 1000,
+      maxDelay: config.maxDelay ?? 30000,
+      backoffMultiplier: config.backoffMultiplier ?? 2,
+    };
+  }
+  log(...args: any[]): void {
+    console.log('[ReconnectingWebSocket]', ...args);
+  }
+  error(...args: any[]): void {
+    console.error('[ReconnectingWebSocket]', ...args);
+  }
+  connect(): void {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      return;
+    }
+
+    this.log(`正在连接到 ${this.url}...`);
+    this.ws = new WebSocket(this.url);
+
+    this.ws.on('open', () => {
+      this.log('WebSocket 连接已打开');
+      this.retryCount = 0;
+      this.openHandlers.forEach(handler => handler());
+      this.send({ type: 'heartbeat', timestamp: new Date().toISOString() });
+    });
+
+    this.ws.on('message', (data: any) => {
+      this.messageHandlers.forEach(handler => {
+        try {
+          const message = JSON.parse(data.toString());
+          handler(message);
+        } catch {
+          handler(data.toString());
+        }
+      });
+    });
+
+    this.ws.on('close', (code: number, reason: Buffer) => {
+      this.log(`WebSocket 连接已关闭: code=${code}, reason=${reason.toString()}`);
+      this.closeHandlers.forEach(handler => handler(code, reason));
+
+      if (!this.isManualClose) {
+        this.scheduleReconnect();
+      }
+    });
+
+    this.ws.on('error', (error: Error) => {
+      this.error('WebSocket 错误:', error.message);
+      this.errorHandlers.forEach(handler => handler(error));
+    });
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectTimer) {
+      return;
+    }
+
+    if (this.retryCount >= this.config.maxRetries) {
+      this.error(`已达到最大重试次数 (${this.config.maxRetries})，停止重连`);
+      return;
+    }
+
+    // 计算延迟（指数退避）
+    const delay = Math.min(
+      this.config.retryDelay * Math.pow(this.config.backoffMultiplier, this.retryCount),
+      this.config.maxDelay
+    );
+
+    this.retryCount++;
+    this.log(`将在 ${delay}ms 后进行第 ${this.retryCount} 次重连尝试...`);
+
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+
+  send(data: any): boolean {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(data));
+      return true;
+    }
+    this.log('WebSocket 未连接，无法发送消息');
+    return false;
+  }
+
+  onMessage(handler: (data: any) => void): void {
+    this.messageHandlers.push(handler);
+  }
+
+  onOpen(handler: () => void): void {
+    this.openHandlers.push(handler);
+  }
+
+  onClose(handler: (code: number, reason: Buffer) => void): void {
+    this.closeHandlers.push(handler);
+  }
+
+  onError(handler: (error: Error) => void): void {
+    this.errorHandlers.push(handler);
+  }
+
+  close(): void {
+    this.isManualClose = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  getReadyState(): number {
+    return this.ws?.readyState ?? WebSocket.CLOSED;
+  }
+
+  getRetryCount(): number {
+    return this.retryCount;
+  }
+}
+
+// const ws = new ReconnectingWebSocket('ws://localhost:51516/livecode/ws?id=test-live-app', {
+//   maxRetries: Infinity,    // 无限重试
+//   retryDelay: 1000,        // 初始重试延迟 1 秒
+//   maxDelay: 30000,         // 最大延迟 30 秒
+//   backoffMultiplier: 2,    // 指数退避倍数
+// });

package/src/ws.ts

@@ -0,0 +1,65 @@
+import { ReconnectingWebSocket, ReconnectConfig } from "./server/reconnect-ws.ts";
+
+export * from "./server/reconnect-ws.ts";
+import type { App } from "./app.ts";
+
+export const handleCallWsApp = async (ws: ReconnectingWebSocket, app: App, message: any) => {
+  return handleCallApp((data: any) => {
+    ws.send(data);
+  }, app, message);
+}
+export const handleCallApp = async (send: (data: any) => void, app: App, message: any) => {
+  if (message.type === 'router' && message.id) {
+    const data = message?.data;
+    if (!message.id) {
+      console.error('Message id is required for router type');
+      return;
+    }
+    if (!data) {
+      send({
+        type: 'router',
+        id: message.id,
+        data: { code: 500, message: 'No data received' }
+      });
+      return;
+    }
+    const { tokenUser, ...rest } = data || {};
+    const res = await app.run(rest, {
+      state: { tokenUser },
+      appId: app.appId,
+    });
+    send({
+      type: 'router',
+      id: message.id,
+      data: res
+    });
+  }
+}
+export class Ws {
+  wsClient: ReconnectingWebSocket;
+  app: App;
+  showLog: boolean = true;
+  constructor(opts?: ReconnectConfig & {
+    url: string;
+    app: App;
+    showLog?: boolean;
+    handleMessage?: (ws: ReconnectingWebSocket, app: App, message: any) => void;
+  }) {
+    const { url, app, showLog = true, handleMessage = handleCallWsApp, ...rest } = opts;
+    this.wsClient = new ReconnectingWebSocket(url, rest);
+    this.app = app;
+    this.showLog = showLog;
+    this.wsClient.connect();
+    const onMessage = async (data: any) => {
+      return handleMessage(this.wsClient, this.app, data);
+    }
+    this.wsClient.onMessage(onMessage);
+  }
+  send(data: any): boolean {
+    return this.wsClient.send(data);
+  }
+  log(...args: any[]): void {
+    if (this.showLog)
+      console.log('[Ws]', ...args);
+  }
+}