@zhin.js/adapter-napcat 3.0.1 → 4.0.1

package/src/endpoint-ws-server.ts

@@ -1,136 +0,0 @@
-/**
- * NapCat 反向 WebSocket 连接
- */
-import WebSocket, { WebSocketServer } from 'ws';
-import { formatCompact } from 'zhin.js';
-import type { IncomingMessage } from 'http';
-import { NapCatEndpointBase } from './endpoint-base.js';
-import type { NapCatWsServerConfig, ApiResponse } from './types.js';
-import type { NapCatAdapter } from './adapter.js';
-import type { Router } from '@zhin.js/host-router';
-
-export class NapCatWsServer extends NapCatEndpointBase {
-  #wss?: WebSocketServer;
-  #clientMap = new Map<string, WebSocket>();
-  private heartbeatTimer?: NodeJS.Timeout;
-  private requestId = 0;
-  private pendingRequests = new Map<string, {
-    resolve: (value: any) => void;
-    reject: (error: Error) => void;
-    timeout: NodeJS.Timeout;
-  }>();
-
-  declare $config: NapCatWsServerConfig;
-
-  constructor(adapter: NapCatAdapter, public router: Router, config: NapCatWsServerConfig) {
-    super(adapter, config);
-  }
-
-  async $connect(): Promise<void> {
-    if (!this.$config.access_token) {
-      this.logger.warn(formatCompact({ endpoint: this.$id, ok: false, error: 'missing access_token' }));
-    }
-    this.#wss = this.router.ws(this.$config.path, {
-      verifyClient: (info: { origin: string; secure: boolean; req: IncomingMessage }) => {
-        const authorization = info.req.headers['authorization'] || '';
-        if (this.$config.access_token && authorization !== `Bearer ${this.$config.access_token}`) {
-          this.logger.error(`[${this.$id}] auth failed`);
-          return false;
-        }
-        return true;
-      },
-    });
-    this.logger.info(formatCompact( { op: 'listen', endpoint: this.$id, mode: 'wss', path: this.$config.path }));
-
-    this.#wss.on('connection', (client, req) => {
-      this.startHeartbeat();
-      this.logger.info(formatCompact({ endpoint: this.$id, peer: req.socket.remoteAddress }));
-
-      client.on('error', (err) => this.logger.warn(formatCompact( {
-        op: 'ws_error',
-        endpoint: this.$id,
-        ok: false,
-        error: err instanceof Error ? err.message : String(err),
-      })));
-      client.on('close', (code, reason) => {
-        const reasonStr = reason?.toString?.() || '';
-        this.logger.warn(formatCompact( {
-          op: 'disconnect',
-          endpoint: this.$id,
-          code,
-          error: reasonStr || undefined,
-        }));
-        for (const [key, val] of this.#clientMap) {
-          if (val === client) this.#clientMap.delete(key);
-        }
-        if (this.#clientMap.size === 0) this.$connected = false;
-      });
-      client.on('message', (data) => {
-        try { this.handleWsMessage(client, JSON.parse(data.toString())); } catch (e) { this.emit('error', e); }
-      });
-    });
-  }
-
-  async $disconnect(): Promise<void> {
-    this.#wss?.close();
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = undefined; }
-    for (const [, req] of this.pendingRequests) { clearTimeout(req.timeout); req.reject(new Error('Connection closed')); }
-    this.pendingRequests.clear();
-    this.inboundDeduper.clear();
-    this.$connected = false;
-  }
-
-  async callApi<T = any>(action: string, params: Record<string, any> = {}): Promise<T> {
-    const selfId = this.getFirstSelfId();
-    const client = this.#clientMap.get(selfId);
-    if (!client || client.readyState !== WebSocket.OPEN) throw new Error('WebSocket is not connected');
-    const echo = `req_${++this.requestId}`;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => { this.pendingRequests.delete(echo); reject(new Error(`API call timeout: ${action}`)); }, 30000);
-      this.pendingRequests.set(echo, { resolve, reject, timeout });
-      client.send(JSON.stringify({ action, params, echo }));
-    });
-  }
-
-  private getFirstSelfId(): string {
-    const first = this.#clientMap.keys().next().value;
-    if (!first) throw new Error('No NapCat client connected to reverse WS');
-    return first;
-  }
-
-  private handleWsMessage(client: WebSocket, message: any): void {
-    if (message.self_id != null) {
-      const selfIdStr = String(message.self_id);
-      if (!this.#clientMap.has(selfIdStr) || this.#clientMap.get(selfIdStr) !== client) {
-        this.#clientMap.set(selfIdStr, client);
-        if (!this.$connected) this.$connected = true;
-      }
-    }
-    if (message.echo && this.pendingRequests.has(message.echo)) {
-      const req = this.pendingRequests.get(message.echo)!;
-      this.pendingRequests.delete(message.echo);
-      clearTimeout(req.timeout);
-      const resp = message as ApiResponse;
-      if (resp.status === 'ok') return req.resolve(resp.data);
-      return req.reject(new Error(`API error [${resp.retcode}]: ${resp.message || resp.wording || 'unknown'}`));
-    }
-
-    if (message.post_type === 'meta_event' && message.sub_type === 'connect') {
-      this.#clientMap.set(String(message.self_id), client);
-      this.$connected = true;
-      this.logger.info(formatCompact({ endpoint: this.$id, self_id: message.self_id }));
-      return;
-    }
-    this.dispatchEvent(message);
-  }
-
-  private startHeartbeat(): void {
-    if (this.heartbeatTimer) return;
-    const interval = this.$config.heartbeat_interval || 30000;
-    this.heartbeatTimer = setInterval(() => {
-      for (const client of this.#wss?.clients || []) {
-        if (client.readyState === WebSocket.OPEN) client.ping();
-      }
-    }, interval);
-  }
-}

package/src/routes.ts

@@ -1,61 +0,0 @@
-import type { Router } from '@zhin.js/host-router';
-import type { NapCatAdapter } from './adapter.js';
-
-export function registerRoutes(router: Router, napcat: NapCatAdapter): void {
-  router.get('/api/napcat/endpoints', async (ctx) => {
-    try {
-      const endpoints = Array.from(napcat.endpoints.values());
-      if (endpoints.length === 0) {
-        ctx.body = { success: true, data: [], message: '暂无 NapCat Endpoint 实例' };
-        return;
-      }
-      const result = await Promise.all(
-        endpoints.map(async (endpoint) => {
-          try {
-            const connection = (endpoint.$config as any).connection ?? 'ws';
-            const base: Record<string, unknown> = {
-              name: endpoint.$config.name,
-              connected: endpoint.$connected || false,
-              connection,
-              status: endpoint.$connected ? 'online' : 'offline',
-              lastActivity: new Date().toISOString(),
-            };
-            if (endpoint.$connected) {
-              try {
-                const friends = await endpoint.getFriendList();
-                const groups = await endpoint.getGroupList();
-                base.friendCount = Array.isArray(friends) ? friends.length : 0;
-                base.groupCount = Array.isArray(groups) ? groups.length : 0;
-              } catch {
-                base.friendCount = 0;
-                base.groupCount = 0;
-              }
-            } else {
-              base.friendCount = 0;
-              base.groupCount = 0;
-            }
-            return base;
-          } catch {
-            return {
-              name: endpoint.$config.name,
-              connected: false,
-              connection: 'unknown',
-              status: 'error',
-              friendCount: 0,
-              groupCount: 0,
-            };
-          }
-        }),
-      );
-      ctx.body = { success: true, data: result, timestamp: new Date().toISOString() };
-    } catch (error) {
-      ctx.status = 500;
-      ctx.body = {
-        success: false,
-        error: 'NAPCAT_API_ERROR',
-        message: '获取 Endpoint 数据失败',
-        details: process.env.NODE_ENV === 'development' ? (error as Error).message : undefined,
-      };
-    }
-  });
-}

package/src/segment-mapper.ts

@@ -1 +0,0 @@
-export { toCanonicalSegments, fromCanonicalSegments } from 'zhin.js';