@zhin.js/adapter-milky 1.1.18 → 1.1.19

package/src/wss-endpoint.ts

@@ -2,7 +2,7 @@
  * Milky reverse WSS endpoint — httpHostToken WS upgrade inbound + baseUrl HTTP API outbound.
  */
 import {
-  ClientEndpoint,
+  createEndpointSpecification, endpointSpec, type Endpoint, type EndpointSpecification,
   createEndpointLifecycle,
   createRecallEndpointControl,
   type EndpointLifecycle,
@@ -15,7 +15,7 @@ import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import type { CapabilityId } from 'zhin.js';
 import { verifyMilkyAccessToken } from './milky-auth.js';
 import { createMilkyEndpointManagement } from './endpoint-management.js';
-import { callMilkyClient, createMilkyEndpointClient, forwardMilkyClientEvents, type MilkyClient } from './client.js';
+import { createMilkyActionCaller, readMilkyResponse, type MilkyActionCaller, milkyClientOptions, forwardMilkyClientEvents, MilkyClient } from './client.js';
 import {
   buildSendAction,
   callApi,
@@ -40,19 +40,21 @@ const WS_OPEN = 1;
 
 export interface MilkyWssEndpointOptions {
   readonly id: CapabilityId;
+  readonly signal?: AbortSignal;
   readonly http: HttpHost;
   readonly config: MilkyWssConfig;
   readonly callApi?: typeof callApi;
 }
 
-export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
-  readonly client: MilkyClient;
+export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
+  readonly [endpointSpec]: EndpointSpecification;
+  #open = false;
   readonly #logger!: ReturnType<typeof getAdapterLogger>;
 
   readonly #options: MilkyWssEndpointOptions;
-  readonly #callApi: typeof callApi;
-  readonly management: EndpointManagement;
-  readonly control: EndpointControl = createRecallEndpointControl((id) => this.recallMessage(id));
+  readonly #management: EndpointManagement;
+  readonly #call: MilkyActionCaller;
+  readonly #control: EndpointControl = createRecallEndpointControl((id, signal) => this.#recallMessage({ id, signal }));
   #ws?: MilkyWsSocket;
   #wsRelease?: () => void;
   #clientSocketRelease?: () => void;
@@ -61,28 +63,37 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
   #started = false;
 
   constructor(options: MilkyWssEndpointOptions) {
-    super();
+    const call = createMilkyActionCaller({ config: options.config, request: options.callApi ?? callApi, signal: options.signal });
+    super(milkyClientOptions({ config: options.config, call }));
+    this.#call = call;
     this.#logger = getAdapterLogger('milky', options.config.id);
     this.#options = options;
-    this.#callApi = options.callApi ?? callApi;
     this.#connectionLifecycle = createEndpointLifecycle({
       name: `${options.config.id}:inbound`,
       reconnect: false,
     });
-    this.client = createMilkyEndpointClient(options.config, this.#callApi);
-    this.management = createMilkyEndpointManagement({
-      callApi: (action, params) => callMilkyClient(this.client, action, params),
+    this.#management = createMilkyEndpointManagement({
+      callApi: request => call(request).then(response => readMilkyResponse(response, request.action)),
     });
-    this.bindClientEvents(
-      (receive) => forwardMilkyClientEvents(this.client, receive),
-      (name, payload) => {
+    const readTransportState = () => this.#connectionLifecycle.state;
+    this[endpointSpec] = createEndpointSpecification(this, {
+      name: options.config.id,
+      start: () => this.#start(), open: () => { this.#open = true; },
+      close: () => { this.#open = false; }, stop: () => this.#stop(),
+      send: request => this.#send(request),
+      management: this.#management, control: this.#control,
+      get transportState() { return readTransportState(); },
+    });
+    forwardMilkyClientEvents(this, (name, payload) => {
+      void this[endpointSpec].events.run(() => {
+        if (!this.#open && !this.#started) return;
+        void this[endpointSpec].events.platform(name, payload).catch(error => this.#warnPlatformEvent(error));
         if (name === 'event') this.#admitRaw(payload as MilkyEvent);
-      },
-      (_name, error) => this.#warnPlatformEvent(error),
-    );
+      }).catch(error => this.#warnPlatformEvent(error));
+    });
   }
 
-  async start(): Promise<void> {
+  async #start(): Promise<void> {
     if (this.#started) return;
     this.#started = true;
     const handle = this.#options.http.ws(this.#options.config.path);
@@ -105,8 +116,8 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
     }));
   }
 
-  async stop(): Promise<void> {
-    this.close();
+  async #stop(): Promise<void> {
+    this.#open = false;
     this.#wsRelease?.();
     this.#wsRelease = undefined;
     await this.#connectionTask;
@@ -115,10 +126,10 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
     this.#started = false;
   }
 
-  async send({ conversation, payload }: EndpointSendRequest): Promise<string> {
+  async #send({ conversation, payload, signal }: EndpointSendRequest): Promise<string> {
     const message = formatOutboundSegments(payload);
     const { action, params } = buildSendAction(conversation, message);
-    const data = await callMilkyClient<{ message_seq?: number }>(this.client, action, params);
+    const data = readMilkyResponse<{ message_seq?: number }>(await this.#call({ action, params, signal }), action);
     const messageId = formatOutboundMessageId(conversation, data?.message_seq);
     this.#logger.debug(formatCompact({
       op: 'milky_send',
@@ -129,23 +140,24 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
     return messageId;
   }
 
-  async recallMessage(id: string): Promise<void> {
+  async #recallMessage({ id, signal }: { readonly id: string; readonly signal?: AbortSignal }): Promise<void> {
     const parsed = parseMilkyMessageId(id);
     if (!parsed) throw new Error(`Invalid message id: ${id}`);
     if (parsed.message_scene === 'group') {
-      await callMilkyClient(this.client, 'recall_group_message', {
+      readMilkyResponse(await this.#call({ action: 'recall_group_message', signal, params: {
         group_id: parsed.peer_id,
         message_seq: parsed.message_seq,
-      });
+      } }), 'recall_group_message');
     } else {
-      await callMilkyClient(this.client, 'recall_private_message', {
+      readMilkyResponse(await this.#call({ action: 'recall_private_message', signal, params: {
         user_id: parsed.peer_id,
         message_seq: parsed.message_seq,
-      });
+      } }), 'recall_private_message');
     }
   }
 
   #admitRaw(event: MilkyEvent): void {
+    if (event.self_id != null) this[endpointSpec].reportSelfUserId(String(event.self_id));
     const data = parseMessageReceiveData(event);
     if (!data) return;
     this.#admitMessage(data, event);
@@ -156,14 +168,16 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
   }
 
   #admitMessage(data: MilkyIncomingMessage, event: MilkyEvent): void {
-    const conversation = milkyInboundConversation(String(this.#options.id), data);
+    const conversation = { ...milkyInboundConversation(String(this.#options.id), data), endpoint: this[endpointSpec].identity };
     const target = `${conversation.kind}:${conversation.id}`;
     const content = formatInboundContent(data);
     const segments = formatInboundSegments(data);
     const audioUrl = extractInboundAudioUrl(data);
     const nickname = senderNickname(data);
     const mentioned = isMentioned(data, event.self_id);
-    void this.emit('message.receive', {
+    void this[endpointSpec].events.message({
+      event,
+      ...(typeof event.time === 'number' ? { platformSentAt: event.time * 1000 } : {}),
       conversation,
       message: { conversation, id: formatInboundMessageId(data) },
       content,
@@ -198,7 +212,7 @@ export class MilkyWssEndpoint extends ClientEndpoint<MilkyClient> {
     await this.#connectionLifecycle.stop();
     await this.#connectionLifecycle.start(async (lifecycleHandle) => {
       this.#ws = socket;
-      const releaseClientSocket = this.client.acceptWebSocket(socket);
+      const releaseClientSocket = this.acceptWebSocket(socket);
       this.#clientSocketRelease = releaseClientSocket;
       lifecycleHandle.onForceClose(() => {
         if (this.#clientSocketRelease === releaseClientSocket) {

package/lib/milky-runtime-state.d.ts

@@ -1 +0,0 @@
-export declare const milkyRuntimeStateToken: import("zhin.js").Token<import("@zhin.js/adapter").EndpointRuntimeState>;

package/lib/milky-runtime-state.js

@@ -1,6 +0,0 @@
-/**
- * Milky 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
- * 由 plugin.ts setup() provide，adapter create 与 `milky endpoint` 命令共享（同一 owner generation）。
- */
-import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
-export const milkyRuntimeStateToken = defineEndpointRuntimeStateToken('milky');

package/src/milky-runtime-state.ts

@@ -1,7 +0,0 @@
-/**
- * Milky 插件实例的运行时状态：adapter create() 注册的 endpoint 列表。
- * 由 plugin.ts setup() provide，adapter create 与 `milky endpoint` 命令共享（同一 owner generation）。
- */
-import { defineEndpointRuntimeStateToken } from 'zhin.js/adapter';
-
-export const milkyRuntimeStateToken = defineEndpointRuntimeStateToken('milky');