@zhin.js/adapter-onebot11 7.0.0 → 7.0.1

package/src/wss-endpoint.ts

@@ -1,20 +1,19 @@
 /**
  * OneBot11 reverse WSS endpoint — accepts inbound WebSocket from OneBot implementation.
  */
-import { clearInterval } from 'node:timers';
 import {
+  ClientEndpoint,
+  createEndpointLifecycle,
   createRecallEndpointControl,
+  type EndpointLifecycle,
   type EndpointControl,
-  type EndpointInstance,
   type EndpointManagement,
   type EndpointSendRequest,
 } from 'zhin.js/adapter';
-import type { MessageGateway, SideEventGateway } from '@zhin.js/core/runtime';
 import type { HttpHost, WsConnection } from '@zhin.js/host-http';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import type { CapabilityId } from 'zhin.js';
 import { createOneBot11EndpointManagement } from './endpoint-management.js';
-import { registerOnebot11AgentEndpoint } from './onebot11-agent-deps.js';
 import {
   buildSendAction,
   formatInboundContent,
@@ -34,46 +33,57 @@ import {
   callOneBot11WsAction,
   handleOneBot11WsMessage,
   rejectAllPending,
-  startOneBot11Heartbeat,
 } from './ws-transport.js';
 import { OneBot11WsEndpoint } from './ws-endpoint.js';
 import {
   type OneBot11PendingAction,
   type OneBot11WsSocket,
 } from './ws-types.js';
+import { callOnebot11Client, createOnebot11EndpointClient, forwardOnebot11ClientEvents, type Onebot11Client } from './client.js';
 
 export interface OneBot11WssEndpointOptions {
   readonly id: CapabilityId;
-  readonly gateway: MessageGateway;
-  readonly sideEvents?: SideEventGateway;
   readonly http: HttpHost;
   readonly config: OneBot11WssConfig;
 }
 
-export class OneBot11WssEndpoint implements EndpointInstance {
+export class OneBot11WssEndpoint extends ClientEndpoint<Onebot11Client> {
+  readonly client: Onebot11Client;
   readonly #logger!: ReturnType<typeof getAdapterLogger>;
 
   readonly #options: OneBot11WssEndpointOptions;
-  readonly management: EndpointManagement = createOneBot11EndpointManagement(this);
+  readonly management: EndpointManagement;
   readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
-  readonly content = createOneBot11ContentPort((action, params) => this.callApi(action, params));
+  readonly content;
   #ws?: OneBot11WsSocket;
   #wsRelease?: () => void;
-  #heartbeatTimer?: NodeJS.Timeout;
+  readonly #lifecycle: EndpointLifecycle;
   #requestId = { value: 0 };
   #pending = new Map<string, OneBot11PendingAction>();
-  #open = false;
-  #started = false;
-  #unregisterAgent?: () => void;
 
   constructor(options: OneBot11WssEndpointOptions) {
+    super();
     this.#logger = getAdapterLogger('onebot11', options.config.id);
     this.#options = options;
+    this.#lifecycle = createEndpointLifecycle({
+      name: options.config.id,
+      reconnect: false,
+      heartbeat: { intervalMs: options.config.heartbeat_interval },
+    });
+    this.client = createOnebot11EndpointClient(options.config, (action, params) => this.#callApi(action, params));
+    const callApi = (action: string, params?: Record<string, unknown>) => callOnebot11Client(this.client, action, params);
+    this.management = createOneBot11EndpointManagement({ callApi });
+    this.content = createOneBot11ContentPort(callApi);
+    this.bindClientEvents(
+      (receive) => forwardOnebot11ClientEvents(this.client, receive),
+      (name, payload) => {
+        if (name === 'event') this.#admitRaw(payload as OneBot11Event);
+      },
+      (_name, error) => this.#warnPlatformEvent(error),
+    );
   }
 
   async start(): Promise<void> {
-    if (this.#started) return;
-    this.#started = true;
     if (!this.#options.config.access_token) {
       // wss 模式未配 access_token 时任何连接都会被放行（verifyOneBotAccessToken 直接 return true）
       this.#logger.warn(formatCompact({
@@ -83,13 +93,21 @@ export class OneBot11WssEndpoint implements EndpointInstance {
         error: 'missing access_token',
       }));
     }
-    this.#unregisterAgent = registerOnebot11AgentEndpoint(
-      this.#options.config.id,
-      this as unknown as OneBot11WsEndpoint,
-    );
-    const handle = this.#options.http.ws(this.#options.config.path);
-    this.#wsRelease = handle.onConnection((connection) => {
-      this.#acceptConnection(connection);
+    await this.#lifecycle.start(async (lifecycleHandle) => {
+      const handle = this.#options.http.ws(this.#options.config.path);
+      this.#wsRelease = handle.onConnection((connection) => {
+        this.#acceptConnection(connection);
+      });
+      lifecycleHandle.onForceClose(() => {
+        this.#wsRelease?.();
+        this.#wsRelease = undefined;
+        try {
+          this.#ws?.close();
+        } catch {
+          /* ignore */
+        }
+        this.#ws = undefined;
+      });
     });
     this.#logger.info(formatCompact({
       op: 'listen',
@@ -99,69 +117,37 @@ export class OneBot11WssEndpoint implements EndpointInstance {
     }));
   }
 
-  open(): void {
-    this.#open = true;
-  }
-
-  close(): void {
-    this.#open = false;
-  }
-
   async stop(): Promise<void> {
-    this.#open = false;
-    this.#unregisterAgent?.();
-    this.#unregisterAgent = undefined;
-    this.#wsRelease?.();
-    this.#wsRelease = undefined;
-    if (this.#heartbeatTimer) {
-      clearInterval(this.#heartbeatTimer);
-      this.#heartbeatTimer = undefined;
-    }
+    this.close();
+    await this.#lifecycle.stop();
     rejectAllPending(this.#pending);
-    if (this.#ws) {
-      try {
-        this.#ws.close();
-      } catch {
-        /* ignore */
-      }
-      this.#ws = undefined;
-    }
-    this.#started = false;
   }
 
   async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
     const message = formatOutboundSegments(payload);
     const { action, params } = buildSendAction(conversation, message);
-    const data = await this.callApi(action, params) as { message_id?: number | string } | undefined;
+    const data = await callOnebot11Client<{ message_id?: number | string }>(this.client, action, params);
     return data?.message_id != null ? String(data.message_id) : '';
   }
 
   async recallMessage(messageId: string): Promise<void> {
     if (!messageId) return;
-    await this.callApi('delete_msg', { message_id: Number(messageId) });
+    await callOnebot11Client(this.client, 'delete_msg', { message_id: Number(messageId) });
   }
 
-  callApi(action: string, params: Record<string, unknown> = {}): Promise<unknown> {
+  #callApi(
+    action: string,
+    params: Record<string, unknown> = {},
+  ): ReturnType<typeof callOneBot11WsAction> {
     return callOneBot11WsAction(this.#ws, this.#pending, this.#requestId, action, params);
   }
 
-  async setTitle(groupId: number, userId: number, title: string, duration = -1): Promise<boolean> {
-    await this.callApi('set_group_special_title', {
-      group_id: groupId,
-      user_id: userId,
-      special_title: title,
-      duration,
-    });
-    return true;
-  }
-
-  admit(ev: OneBot11Event): void {
-    if (!this.#open) return;
+  #admitRaw(ev: OneBot11Event): void {
     if (!isMessageEvent(ev)) {
       receiveOneBot11SideEvent(
-        this.#options.sideEvents,
+        (name, payload) => this.emit(name, payload),
         this.#options.config.id,
-        this,
+        { callApi: (action, params) => callOnebot11Client(this.client, action, params) },
         ev,
         this.#logger,
       );
@@ -169,7 +155,7 @@ export class OneBot11WssEndpoint implements EndpointInstance {
     }
     const conversation = onebot11InboundConversation(String(this.#options.id), ev);
     const inbound = formatInboundMetadata(ev, this.#options.config.id);
-    void this.#options.gateway.receive({
+    void this.emit('message.receive', {
       conversation,
       message: { conversation, id: String(ev.message_id) },
       content: formatInboundContent(ev),
@@ -191,6 +177,13 @@ export class OneBot11WssEndpoint implements EndpointInstance {
     });
   }
 
+  #warnPlatformEvent(error: unknown): void {
+    this.#logger.warn(formatCompact({
+      op: 'onebot11_platform_event_failed',
+      error: error instanceof Error ? error.message : String(error),
+    }));
+  }
+
   #acceptConnection(connection: WsConnection): void {
     if (!verifyOneBotAccessToken(this.#options.config.access_token, connection.request)) {
       connection.socket.close(4003, 'Unauthorized');
@@ -205,25 +198,25 @@ export class OneBot11WssEndpoint implements EndpointInstance {
       }
     }
     this.#ws = socket;
-    this.#heartbeatTimer = startOneBot11Heartbeat(
-      this.#ws,
-      this.#options.config.heartbeat_interval,
-      this.#heartbeatTimer,
-    );
+    this.#lifecycle.startHeartbeat(() => {
+      try {
+        this.#ws?.ping?.();
+      } catch {
+        /* ignore */
+      }
+    });
     socket.on('message', (data) => {
+      this.#lifecycle.notifyHeartbeatAck();
       handleOneBot11WsMessage(data, {
         endpointId: this.#options.config.id,
         pending: this.#pending,
-        admit: (ev) => this.admit(ev),
+        ingest: (ev) => this.client.ingest(ev as Parameters<Onebot11Client['ingest']>[0]),
       });
     });
     socket.on('close', () => {
       if (this.#ws === socket) {
         this.#ws = undefined;
-        if (this.#heartbeatTimer) {
-          clearInterval(this.#heartbeatTimer);
-          this.#heartbeatTimer = undefined;
-        }
+        this.#lifecycle.stopHeartbeat();
       }
     });
     this.#logger.debug(formatCompact({

package/lib/onebot11-agent-deps.d.ts

@@ -1,15 +0,0 @@
-/**
- * Agent tool deps for onebot11 (set_title etc.).
- * Endpoints register themselves on start; tools look up by config name / endpoint id.
- */
-export interface Onebot11AgentEndpoint {
-    setTitle(groupId: number, userId: number, title: string, duration?: number): Promise<boolean>;
-    callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
-}
-export interface Onebot11AgentDeps {
-    getEndpoint: (endpointKey: string) => Onebot11AgentEndpoint;
-}
-export declare function registerOnebot11AgentEndpoint(endpointKey: string, endpoint: Onebot11AgentEndpoint): () => void;
-/** Optional override used by tests / transitional callers. */
-export declare function setOnebot11AgentDeps(deps: Onebot11AgentDeps): void;
-export declare function getOnebot11AgentDeps(): Onebot11AgentDeps;

package/lib/onebot11-agent-deps.js

@@ -1,30 +0,0 @@
-/**
- * Agent tool deps for onebot11 (set_title etc.).
- * Endpoints register themselves on start; tools look up by config name / endpoint id.
- */
-const endpoints = new Map();
-let override = null;
-export function registerOnebot11AgentEndpoint(endpointKey, endpoint) {
-    endpoints.set(endpointKey, endpoint);
-    return () => {
-        if (endpoints.get(endpointKey) === endpoint) {
-            endpoints.delete(endpointKey);
-        }
-    };
-}
-/** Optional override used by tests / transitional callers. */
-export function setOnebot11AgentDeps(deps) {
-    override = deps;
-}
-export function getOnebot11AgentDeps() {
-    if (override)
-        return override;
-    return {
-        getEndpoint(endpointKey) {
-            const registered = endpoints.get(endpointKey);
-            if (!registered)
-                throw new Error(`Endpoint ${endpointKey} 不存在`);
-            return registered;
-        },
-    };
-}

package/src/onebot11-agent-deps.ts

@@ -1,49 +0,0 @@
-/**
- * Agent tool deps for onebot11 (set_title etc.).
- * Endpoints register themselves on start; tools look up by config name / endpoint id.
- */
-
-export interface Onebot11AgentEndpoint {
-  setTitle(
-    groupId: number,
-    userId: number,
-    title: string,
-    duration?: number,
-  ): Promise<boolean>;
-  callApi(action: string, params?: Record<string, unknown>): Promise<unknown>;
-}
-
-export interface Onebot11AgentDeps {
-  getEndpoint: (endpointKey: string) => Onebot11AgentEndpoint;
-}
-
-const endpoints = new Map<string, Onebot11AgentEndpoint>();
-let override: Onebot11AgentDeps | null = null;
-
-export function registerOnebot11AgentEndpoint(
-  endpointKey: string,
-  endpoint: Onebot11AgentEndpoint,
-): () => void {
-  endpoints.set(endpointKey, endpoint);
-  return () => {
-    if (endpoints.get(endpointKey) === endpoint) {
-      endpoints.delete(endpointKey);
-    }
-  };
-}
-
-/** Optional override used by tests / transitional callers. */
-export function setOnebot11AgentDeps(deps: Onebot11AgentDeps): void {
-  override = deps;
-}
-
-export function getOnebot11AgentDeps(): Onebot11AgentDeps {
-  if (override) return override;
-  return {
-    getEndpoint(endpointKey: string): Onebot11AgentEndpoint {
-      const registered = endpoints.get(endpointKey);
-      if (!registered) throw new Error(`Endpoint ${endpointKey} 不存在`);
-      return registered;
-    },
-  };
-}