@zhin.js/adapter-milky 1.1.25 → 1.1.27

package/src/webhook-endpoint.ts

@@ -2,7 +2,6 @@ import { createMilkySelfProfile } from './self-profile.js';
 /**
  * Milky webhook endpoint — httpHostToken POST inbound + baseUrl HTTP API outbound.
  */
-import type { IncomingMessage, ServerResponse } from 'node:http';
 import { acceptHttpIngress } from 'imhelper';
 import {
   createEndpointSpecification, endpointSpec, type Endpoint, type EndpointSpecification,
@@ -28,6 +27,7 @@ import {
   formatOutboundSegments,
   isMentioned,
   milkyInboundConversation,
+  milkySenderStanding,
   parseMessageReceiveData,
   parseMilkyMessageId,
   senderNickname,
@@ -150,6 +150,7 @@ export class MilkyWebhookEndpoint extends MilkyClient implements Endpoint {
     const segments = formatInboundSegments(data);
     const audioUrl = extractInboundAudioUrl(data);
     const nickname = senderNickname(data);
+    const platform = milkySenderStanding(data);
     const mentioned = isMentioned(data, event.self_id);
     void this[endpointSpec].events.message({
       event,
@@ -158,7 +159,7 @@ export class MilkyWebhookEndpoint extends MilkyClient implements Endpoint {
       message: { conversation, id: formatInboundMessageId(data) },
       content,
       segments,
-      sender: { id: String(data.sender_id), name: nickname },
+      sender: { id: String(data.sender_id), name: nickname, ...(platform ? { platform } : {}) },
       endpointId: this.#options.config.id,
       ...(mentioned ? { mentioned: true } : {}),
       metadata: Object.freeze({
@@ -182,34 +183,26 @@ export class MilkyWebhookEndpoint extends MilkyClient implements Endpoint {
   #setupRoutes(): void {
     const path = this.#options.config.path;
     this.#routeReleases.push(
-      this.#options.http.route('POST', path, async (request, response) => {
-        await this.#handleWebhook(request, response);
-      }, { summary: 'Milky webhook callback', tags: ['milky'] }),
+      this.#options.http.route('POST', path, (request) => this.#handleWebhook(request), { summary: 'Milky webhook callback', tags: ['milky'] }),
     );
   }
 
-  async #handleWebhook(request: IncomingMessage, response: ServerResponse): Promise<void> {
+  async #handleWebhook(request: Request): Promise<Response> {
     try {
       if (!verifyMilkyAccessToken(this.#options.config.access_token, request)) {
-        response.writeHead(403, { 'Content-Type': 'application/json' });
-        response.end(JSON.stringify({ message: 'Unauthorized' }));
-        return;
+        return new Response(JSON.stringify({ message: 'Unauthorized' }), { status: 403, headers: { 'Content-Type': 'application/json' } });
       }
       if (!this.#open) {
-        response.writeHead(200, { 'Content-Type': 'application/json' });
-        response.end(JSON.stringify({ status: 'ok' }));
-        return;
+        return new Response(JSON.stringify({ status: 'ok' }), { status: 200, headers: { 'Content-Type': 'application/json' } });
       }
-      await acceptHttpIngress<MilkyEvent>(request, response, event => {
+      const result = await acceptHttpIngress<MilkyEvent>(request, undefined, event => {
         void this[endpointSpec].events.run(() => this.ingest(event as Parameters<MilkyClient['ingest']>[0]))
           .catch(error => this.#warnPlatformEvent(error));
       });
+      return new Response(JSON.stringify(result.body), { status: result.status, headers: result.headers });
     } catch (error) {
       this.#logger.error('Milky webhook error:', error);
-      if (!response.headersSent) {
-        response.writeHead(500, { 'Content-Type': 'application/json' });
-        response.end(JSON.stringify({ message: 'Internal Server Error' }));
-      }
+      return new Response(JSON.stringify({ message: 'Internal Server Error' }), { status: 500, headers: { 'Content-Type': 'application/json' } });
     }
   }
 }

package/src/ws-endpoint.ts

@@ -34,6 +34,7 @@ import {
   formatOutboundSegments,
   isMentioned,
   milkyInboundConversation,
+  milkySenderStanding,
   parseMessageReceiveData,
   parseMilkyMessageId,
   senderNickname,
@@ -183,6 +184,7 @@ export class MilkyWsEndpoint extends MilkyClient implements Endpoint {
     const segments = formatInboundSegments(data);
     const audioUrl = extractInboundAudioUrl(data);
     const nickname = senderNickname(data);
+    const platform = milkySenderStanding(data);
     const mentioned = isMentioned(data, event.self_id);
     void this[endpointSpec].events.message({
       event,
@@ -191,7 +193,7 @@ export class MilkyWsEndpoint extends MilkyClient implements Endpoint {
       message: { conversation, id: formatInboundMessageId(data) },
       content,
       segments,
-      sender: { id: String(data.sender_id), name: nickname },
+      sender: { id: String(data.sender_id), name: nickname, ...(platform ? { platform } : {}) },
       endpointId: this.#options.config.id,
       ...(mentioned ? { mentioned: true } : {}),
       metadata: Object.freeze({

package/src/ws-types.ts

@@ -1,3 +1,5 @@
+import type { WsConnection } from '@zhin.js/host-http';
+
 /** Minimal WS surface used by the endpoint (real `ws` or test mock). */
 export interface MilkyWsSocket {
   readonly readyState: number;
@@ -10,3 +12,34 @@ export interface MilkyWsSocket {
 export interface MilkyWsCreateOptions {
   readonly headers?: Record<string, string>;
 }
+
+/**
+ * A Host reverse-WebSocket connection seen through the MilkyWsSocket surface. Protocol
+ * keepalive (ping / pong) belongs to the Host transport, so `ping` is absent.
+ */
+export function socketOfConnection(connection: WsConnection): MilkyWsSocket {
+  let readyState = 1;
+  connection.onClose(() => { readyState = 3; });
+  const subscriptions = new Map<(...args: unknown[]) => void, () => void>();
+  const off = (_event: string, listener: (...args: unknown[]) => void): void => {
+    subscriptions.get(listener)?.();
+    subscriptions.delete(listener);
+  };
+  return {
+    get readyState() { return readyState; },
+    send: (data: string) => connection.send(data),
+    close: (code?: number, reason?: string) => connection.close(code, reason),
+    on(event: string, listener: (...args: unknown[]) => void) {
+      if (event === 'message') {
+        subscriptions.set(listener, connection.onMessage((data) => {
+          listener(typeof data === 'string' ? data : Buffer.from(data));
+        }));
+      } else if (event === 'close') {
+        subscriptions.set(listener, connection.onClose((code, reason) => listener(code, reason)));
+      }
+      // 'error' surfaces as a close on a WsConnection; 'open' already happened.
+    },
+    off,
+    removeListener: off,
+  } as MilkyWsSocket;
+}

package/src/wss-endpoint.ts

@@ -11,10 +11,9 @@ import {
   type EndpointManagement,
   type EndpointSendRequest,
 } from 'zhin.js/adapter';
-import type { HttpHost, WsConnection } from '@zhin.js/host-http';
+import { verifyProtocolAccessToken, type HttpHost, type WsConnection } from '@zhin.js/host-http';
 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 { createMilkyActionCaller, readMilkyResponse, type MilkyActionCaller, milkyClientOptions, forwardMilkyClientEvents, MilkyClient } from './client.js';
 import {
@@ -28,6 +27,7 @@ import {
   formatOutboundSegments,
   isMentioned,
   milkyInboundConversation,
+  milkySenderStanding,
   parseMessageReceiveData,
   parseMilkyMessageId,
   senderNickname,
@@ -35,7 +35,7 @@ import {
   type MilkyIncomingMessage,
   type MilkyWssConfig,
 } from './protocol.js';
-import type { MilkyWsSocket } from './ws-types.js';
+import { socketOfConnection, type MilkyWsSocket } from './ws-types.js';
 
 const WS_OPEN = 1;
 
@@ -99,7 +99,17 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
   async #start(): Promise<void> {
     if (this.#started) return;
     this.#started = true;
-    const handle = this.#options.http.ws(this.#options.config.path);
+    if (!this.#options.config.access_token) {
+      // 未配 access_token 时只接受本机回环连接（verifyProtocolAccessToken）。
+      this.#logger.warn(formatCompact({
+        endpoint: this.#options.config.id,
+        mode: 'wss',
+        ok: false,
+        error: 'missing access_token: only loopback peers are accepted',
+      }));
+    }
+    // The peer authenticates with this endpoint's own access_token, not a Console credential.
+    const handle = this.#options.http.ws(this.#options.config.path, { auth: 'protocol' });
     this.#wsRelease = handle.onConnection((connection) => {
       this.#connectionTask = this.#connectionTask
         .then(() => this.#acceptConnection(connection))
@@ -177,6 +187,7 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
     const segments = formatInboundSegments(data);
     const audioUrl = extractInboundAudioUrl(data);
     const nickname = senderNickname(data);
+    const platform = milkySenderStanding(data);
     const mentioned = isMentioned(data, event.self_id);
     void this[endpointSpec].events.message({
       event,
@@ -185,7 +196,7 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
       message: { conversation, id: formatInboundMessageId(data) },
       content,
       segments,
-      sender: { id: String(data.sender_id) },
+      sender: { id: String(data.sender_id), ...(platform ? { platform } : {}) },
       endpointId: this.#options.config.id,
       ...(mentioned ? { mentioned: true } : {}),
       metadata: Object.freeze({
@@ -207,11 +218,11 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
   }
 
   async #acceptConnection(connection: WsConnection): Promise<void> {
-    if (!verifyMilkyAccessToken(this.#options.config.access_token, connection.request)) {
-      connection.socket.close(4003, 'Unauthorized');
+    if (!verifyProtocolAccessToken(this.#options.config.access_token, connection)) {
+      connection.close(4003, 'Unauthorized');
       return;
     }
-    const socket = connection.socket as unknown as MilkyWsSocket;
+    const socket = socketOfConnection(connection);
     await this.#connectionLifecycle.stop();
     await this.#connectionLifecycle.start(async (lifecycleHandle) => {
       this.#ws = socket;
@@ -229,13 +240,7 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
         }
         if (this.#ws === socket) this.#ws = undefined;
       });
-      this.#connectionLifecycle.startHeartbeat(() => {
-        try {
-          if (socket.readyState === WS_OPEN) socket.ping?.();
-        } catch {
-          /* ignore */
-        }
-      }, this.#options.config.heartbeat_interval);
+      // Dead-peer detection is the Host transport's keepalive (protocol ping / pong).
       socket.on('message', () => {
         this.#connectionLifecycle.notifyHeartbeatAck();
       });
@@ -251,7 +256,7 @@ export class MilkyWssEndpoint extends MilkyClient implements Endpoint {
     this.#logger.debug(formatCompact({
       endpoint: this.#options.config.id,
       mode: 'wss',
-      peer: connection.request.socket.remoteAddress,
+      peer: connection.remoteAddress,
     }));
   }