@simplysm/service-server 13.0.100 → 14.0.4

package/src/transport/socket/service-socket.ts

@@ -15,10 +15,10 @@ import type {
 const logger = consola.withTag("service-server:ServiceSocket");
 
 /**
- * Service socket interface
+ * 서비스 소켓 인터페이스
  *
- * Manages a single WebSocket connection with protocol encoding/decoding,
- * ping/pong keep-alive, and event listener tracking.
+ * 프로토콜 인코딩/디코딩, ping/pong 연결 유지,
+ * 이벤트 리스너 추적이 포함된 단일 WebSocket 연결을 관리한다.
  */
 export interface ServiceSocket {
   readonly connectedAtDateTime: DateTime;
@@ -27,37 +27,37 @@ export interface ServiceSocket {
   authTokenPayload?: AuthTokenPayload;
 
   /**
-   * Close the WebSocket connection
+   * WebSocket 연결을 닫는다
    */
   close(): void;
 
   /**
-   * Send a message to the client
+   * 클라이언트에 메시지를 전송한다
    */
   send(uuid: string, msg: ServiceServerMessage): Promise<number>;
 
   /**
-   * Register an event listener with key/name/info
+   * key/name/info로 이벤트 리스너를 등록한다
    */
   addListener(key: string, eventName: string, info: unknown): void;
 
   /**
-   * Remove an event listener by key
+   * key로 이벤트 리스너를 제거한다
    */
   removeListener(key: string): void;
 
   /**
-   * Get all event listeners for a specific event name
+   * 특정 이벤트 이름에 해당하는 모든 이벤트 리스너를 조회한다
    */
   getEventListeners(eventName: string): Array<{ key: string; info: unknown }>;
 
   /**
-   * Filter target keys that exist in this socket's listeners
+   * 이 소켓의 리스너에 존재하는 대상 키를 필터링한다
    */
   filterEventTargetKeys(targetKeys: string[]): string[];
 
   /**
-   * Register event handlers
+   * 이벤트 핸들러를 등록한다
    */
   on(event: "error", handler: (err: Error) => void): void;
   on(event: "close", handler: (code: number) => void): void;
@@ -65,10 +65,10 @@ export interface ServiceSocket {
 }
 
 /**
- * Create a service socket instance
+ * 서비스 소켓 인스턴스를 생성한다
  *
- * Manages a single WebSocket connection with protocol encoding/decoding,
- * ping/pong keep-alive, and event listener tracking.
+ * 프로토콜 인코딩/디코딩, ping/pong 연결 유지,
+ * 이벤트 리스너 추적이 포함된 단일 WebSocket 연결을 관리한다.
  */
 export function createServiceSocket(
   socket: WebSocket,
@@ -77,10 +77,10 @@ export function createServiceSocket(
   connReq: FastifyRequest,
 ): ServiceSocket {
   // -------------------------------------------------------------------
-  // State
+  // 상태
   // -------------------------------------------------------------------
 
-  const PING_INTERVAL = 5000; // Send ping every 5s
+  const PING_INTERVAL = 5000; // 5초마다 ping 전송
   const PONG_PACKET = new Uint8Array([0x02]);
 
   const protocol = createServerProtocolWrapper();
@@ -97,7 +97,7 @@ export function createServiceSocket(
   const connectedAtDateTime = new DateTime();
 
   // -------------------------------------------------------------------
-  // Helpers
+  // 헬퍼
   // -------------------------------------------------------------------
 
   async function sendInternal(uuid: string, msg: ServiceServerRawMessage): Promise<number> {
@@ -121,11 +121,11 @@ export function createServiceSocket(
   }
 
   // -------------------------------------------------------------------
-  // Event Handlers
+  // 이벤트 핸들러
   // -------------------------------------------------------------------
 
   function onError(err: Error): void {
-    logger.error("WebSocket client error", err);
+    logger.error("WebSocket 클라이언트 에러", err);
     emitEvent("error", err);
   }
 
@@ -137,7 +137,7 @@ export function createServiceSocket(
 
   async function onMessage(msgBuffer: Bytes): Promise<void> {
     try {
-      // Handle pong response to ping
+      // ping에 대한 pong 응답 처리
       if (msgBuffer.length === 1 && msgBuffer[0] === 0x01) {
         if (socket.readyState === WebSocket.OPEN) {
           socket.send(PONG_PACKET);
@@ -159,12 +159,12 @@ export function createServiceSocket(
         emitEvent("message", { uuid: decodeResult.uuid, msg });
       }
     } catch (err) {
-      logger.error("Error processing WebSocket message", err);
+      logger.error("WebSocket 메시지 처리 중 에러 발생", err);
     }
   }
 
   // -------------------------------------------------------------------
-  // Setup
+  // 설정
   // -------------------------------------------------------------------
 
   socket.on("close", onClose);
@@ -186,7 +186,7 @@ export function createServiceSocket(
   }, PING_INTERVAL);
 
   // -------------------------------------------------------------------
-  // Public API
+  // 공개 API
   // -------------------------------------------------------------------
 
   return {

package/src/transport/socket/websocket-handler.ts

@@ -1,5 +1,5 @@
 import type { WebSocket } from "ws";
-import { Uuid } from "@simplysm/core-common";
+import { Uuid, env } from "@simplysm/core-common";
 import type { ServiceEventDef, ServiceClientMessage } from "@simplysm/service-common";
 import { createServiceSocket, type ServiceSocket } from "./service-socket";
 import { verifyJwt } from "../../auth/jwt-manager";
@@ -9,29 +9,24 @@ import consola from "consola";
 const logger = consola.withTag("service-server:WebSocketHandler");
 
 /**
- * WebSocket handler interface
+ * WebSocket 핸들러 인터페이스
  *
- * Manages multiple WebSocket connections, routes messages to services,
- * and handles event broadcasting.
+ * 여러 WebSocket 연결을 관리하고, 메시지를 서비스로 라우팅하며,
+ * 이벤트 브로드캐스팅을 처리한다.
  */
 export interface WebSocketHandler {
   /**
-   * Add a new WebSocket connection
+   * 새 WebSocket 연결을 추가한다
    */
   addSocket(socket: WebSocket, clientId: string, clientName: string, connReq: FastifyRequest): void;
 
   /**
-   * Close all active connections
+   * 모든 활성 연결을 닫는다
    */
   closeAll(): void;
 
   /**
-   * Broadcast reload message to all clients
-   */
-  broadcastReload(clientName: string | undefined, changedFileSet: Set<string>): Promise<void>;
-
-  /**
-   * Emit event to matching clients
+   * 매칭되는 클라이언트에 이벤트를 발생시킨다
    */
   emit<TInfo, TData>(
     eventDef: ServiceEventDef<TInfo, TData>,
@@ -41,10 +36,10 @@ export interface WebSocketHandler {
 }
 
 /**
- * Create a WebSocket handler instance
+ * WebSocket 핸들러 인스턴스를 생성한다
  *
- * Manages multiple WebSocket connections, routes messages to services,
- * and handles event broadcasting.
+ * 여러 WebSocket 연결을 관리하고, 메시지를 서비스로 라우팅하며,
+ * 이벤트 브로드캐스팅을 처리한다.
  */
 export function createWebSocketHandler(
   runMethod: (def: {
@@ -56,13 +51,13 @@ export function createWebSocketHandler(
   jwtSecret: string | undefined,
 ): WebSocketHandler {
   // -------------------------------------------------------------------
-  // State
+  // 상태
   // -------------------------------------------------------------------
 
   const socketMap = new Map<string, ServiceSocket>();
 
   // -------------------------------------------------------------------
-  // Helpers
+  // 헬퍼
   // -------------------------------------------------------------------
 
   async function processRequest(
@@ -72,7 +67,9 @@ export function createWebSocketHandler(
   ): Promise<number> {
     try {
       if (message.name.includes(".") && Array.isArray(message.body)) {
-        const [serviceName, methodName] = message.name.split(".");
+        const dotIndex = message.name.indexOf(".");
+        const serviceName = message.name.substring(0, dotIndex);
+        const methodName = message.name.substring(dotIndex + 1);
 
         const result = await runMethod({
           serviceName,
@@ -99,35 +96,34 @@ export function createWebSocketHandler(
       } else if (message.name === "evt:emit") {
         const { keys, data } = message.body as { keys: string[]; data: unknown };
 
-        for (const subSock of socketMap.values()) {
-          const targetKeys = subSock.filterEventTargetKeys(keys);
-          if (targetKeys.length > 0) {
-            await subSock.send(uuid, {
-              name: "evt:on",
-              body: {
-                keys: targetKeys,
-                data,
-              },
-            });
-          }
-        }
+        await Promise.allSettled(
+          Array.from(socketMap.values()).map(async (subSock) => {
+            const targetKeys = subSock.filterEventTargetKeys(keys);
+            if (targetKeys.length > 0) {
+              await subSock.send(uuid, {
+                name: "evt:on",
+                body: { keys: targetKeys, data },
+              });
+            }
+          }),
+        );
 
         return await serviceSocket.send(uuid, { name: "response" });
       } else if (message.name === "auth") {
-        if (jwtSecret == null) throw new Error("JWT Secret is not defined.");
+        if (jwtSecret == null) throw new Error("JWT Secret이 정의되지 않았습니다.");
 
         const token = message.body;
         serviceSocket.authTokenPayload = await verifyJwt(jwtSecret, token);
         return await serviceSocket.send(uuid, { name: "response" });
       } else {
-        const err = new Error("Invalid request.");
+        const err = new Error("유효하지 않은 요청입니다.");
 
         return await serviceSocket.send(uuid, {
           name: "error",
           body: {
             name: err.name,
             message: err.message,
-            stack: err.stack,
+            ...(env.DEV ? { stack: err.stack } : {}),
             code: "BAD_MESSAGE",
           },
         });
@@ -136,7 +132,7 @@ export function createWebSocketHandler(
       const error =
         err instanceof Error
           ? err
-          : new Error(typeof err === "string" ? err : "An unknown error has occurred.");
+          : new Error(typeof err === "string" ? err : "알 수 없는 에러가 발생했습니다.");
 
       return serviceSocket.send(uuid, {
         name: "error",
@@ -144,14 +140,14 @@ export function createWebSocketHandler(
           name: error.name,
           message: error.message,
           code: "INTERNAL_ERROR",
-          stack: error.stack,
+          ...(env.DEV ? { stack: error.stack } : {}),
         },
       });
     }
   }
 
   // -------------------------------------------------------------------
-  // Public API
+  // 공개 API
   // -------------------------------------------------------------------
 
   return {
@@ -164,7 +160,7 @@ export function createWebSocketHandler(
       try {
         const serviceSocket = createServiceSocket(socket, clientId, clientName, connReq);
 
-        // Disconnect existing connection
+        // 기존 연결 해제
         const prevServiceSocket = socketMap.get(clientId);
         if (prevServiceSocket != null) {
           prevServiceSocket.close();
@@ -172,32 +168,32 @@ export function createWebSocketHandler(
           const connectionDateTimeText =
             prevServiceSocket.connectedAtDateTime.toFormatString("yyyy:MM:dd HH:mm:ss.fff");
           logger.debug(
-            `Disconnected previous client connection: ${clientId}: ${connectionDateTimeText}`,
+            `이전 클라이언트 연결 해제됨: ${clientId}: ${connectionDateTimeText}`,
           );
         }
 
         socketMap.set(clientId, serviceSocket);
 
         serviceSocket.on("close", (code) => {
-          logger.debug(`Client disconnected: (code: ${code})`);
+          logger.debug(`클라이언트 연결 해제됨: (code: ${code})`);
 
           if (socketMap.get(clientId) !== serviceSocket) return;
           socketMap.delete(clientId);
         });
 
         serviceSocket.on("message", async ({ uuid, msg }) => {
-          logger.debug("Request received", msg);
+          logger.debug("요청 수신됨", msg);
           const sentSize = await processRequest(serviceSocket, uuid, msg);
-          logger.debug(`Response sent (size: ${sentSize})`);
+          logger.debug(`응답 전송됨 (크기: ${sentSize})`);
         });
 
-        logger.debug("Client connected", {
+        logger.debug("클라이언트 연결됨", {
           clientId,
           remoteAddress: connReq.socket.remoteAddress,
           socketSize: socketMap.size,
         });
       } catch (err) {
-        logger.error("Error handling connection", err);
+        logger.error("연결 처리 중 에러 발생", err);
         socket.terminate();
       }
     },
@@ -208,21 +204,6 @@ export function createWebSocketHandler(
       }
     },
 
-    async broadcastReload(
-      clientName: string | undefined,
-      changedFileSet: Set<string>,
-    ): Promise<void> {
-      for (const serviceSocket of socketMap.values()) {
-        await serviceSocket.send(Uuid.generate().toString(), {
-          name: "reload",
-          body: {
-            clientName,
-            changedFileSet,
-          },
-        });
-      }
-    },
-
     async emit<TInfo, TData>(
       eventDef: ServiceEventDef<TInfo, TData>,
       infoSelector: (item: TInfo) => boolean,
@@ -234,18 +215,17 @@ export function createWebSocketHandler(
         .filter((item) => infoSelector(item.info as TInfo))
         .map((item) => item.key);
 
-      for (const subSock of socketMap.values()) {
-        const subTargetKeys = subSock.filterEventTargetKeys(targetKeys);
-        if (subTargetKeys.length > 0) {
-          await subSock.send(Uuid.generate().toString(), {
-            name: "evt:on",
-            body: {
-              keys: subTargetKeys,
-              data,
-            },
-          });
-        }
-      }
+      await Promise.allSettled(
+        Array.from(socketMap.values()).map(async (subSock) => {
+          const subTargetKeys = subSock.filterEventTargetKeys(targetKeys);
+          if (subTargetKeys.length > 0) {
+            await subSock.send(Uuid.generate().toString(), {
+              name: "evt:on",
+              body: { keys: subTargetKeys, data },
+            });
+          }
+        }),
+      );
     },
   };
 }

package/src/types/server-options.ts

@@ -9,6 +9,6 @@ export interface ServiceServerOptions {
   };
   auth?: {
     jwtSecret: string;
-  };
+  } | false;
   services: ServiceDefinition[];
 }

package/src/utils/config-manager.ts

@@ -5,12 +5,12 @@ import consola from "consola";
 
 const logger = consola.withTag("service-server:ConfigManager");
 
-// Value: Config object, Key: file path
+// 값: 설정 객체, 키: 파일 경로
 const _cache = new LazyGcMap<string, unknown>({
-  gcInterval: 10 * 60 * 1000, // Every 10 minutes
-  expireTime: 60 * 60 * 1000, // Expire after 1 hour
+  gcInterval: 10 * 60 * 1000, // 10분마다
+  expireTime: 60 * 60 * 1000, // 1시간 후 만료
   onExpire: async (filePath) => {
-    logger.debug(`Config cache expired and watcher released: ${path.basename(filePath)}`);
+    logger.debug(`설정 캐시 만료 및 워처 해제됨: ${path.basename(filePath)}`);
     await closeWatcher(filePath);
   },
 });
@@ -18,18 +18,18 @@ const _cache = new LazyGcMap<string, unknown>({
 const _watchers = new Map<string, FsWatcher>();
 
 export async function getConfig<TConfig>(filePath: string): Promise<TConfig | undefined> {
-  // 1. Cache hit (time auto-renewed)
+  // 1. 캐시 히트 (시간 자동 갱신)
   if (_cache.has(filePath)) {
     return _cache.get(filePath) as TConfig;
   }
 
   if (!(await fsx.exists(filePath))) return undefined;
 
-  // 2. Load and cache
+  // 2. 로드 및 캐시
   const config = await fsx.readJson(filePath);
   _cache.set(filePath, config);
 
-  // 3. Register watcher
+  // 3. 워처 등록
   if (!_watchers.has(filePath)) {
     try {
       const watcher = await FsWatcher.watch([filePath]);
@@ -39,20 +39,20 @@ export async function getConfig<TConfig>(filePath: string): Promise<TConfig | un
         if (!(await fsx.exists(filePath))) {
           _cache.delete(filePath);
           await closeWatcher(filePath);
-          logger.debug(`Config file deleted: ${path.basename(filePath)}`);
+          logger.debug(`설정 파일 삭제됨: ${path.basename(filePath)}`);
           return;
         }
 
         try {
           const newConfig = await fsx.readJson(filePath);
           _cache.set(filePath, newConfig);
-          logger.debug(`Config file live-reloaded: ${path.basename(filePath)}`);
+          logger.debug(`설정 파일 실시간 리로드됨: ${path.basename(filePath)}`);
         } catch (err) {
-          logger.warn(`Config file reload failed: ${filePath}`, err);
+          logger.warn(`설정 파일 리로드 실패: ${filePath}`, err);
         }
       });
     } catch (err) {
-      logger.error(`Watch failed: ${filePath}`, err);
+      logger.error(`워치 실패: ${filePath}`, err);
     }
   }
 

package/dist/services/smtp-client-service.d.ts

@@ -1,8 +0,0 @@
-import { type ServiceMethods } from "../core/define-service";
-import type { SmtpClientSendByDefaultOption, SmtpClientSendOption } from "@simplysm/service-common";
-export declare const SmtpClientService: import("..").ServiceDefinition<{
-    send(options: SmtpClientSendOption): Promise<string>;
-    sendByConfig(configName: string, options: SmtpClientSendByDefaultOption): Promise<string>;
-}>;
-export type SmtpClientServiceType = ServiceMethods<typeof SmtpClientService>;
-//# sourceMappingURL=smtp-client-service.d.ts.map

package/dist/services/smtp-client-service.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"smtp-client-service.d.ts","sourceRoot":"","sources":["..\\..\\src\\services\\smtp-client-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC5E,OAAO,KAAK,EAEV,6BAA6B,EAC7B,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC,eAAO,MAAM,iBAAiB;kBACR,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;6BA6B3B,MAAM,WAAW,6BAA6B,GAAG,OAAO,CAAC,MAAM,CAAC;EAkB9F,CAAC;AAEJ,MAAM,MAAM,qBAAqB,GAAG,cAAc,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/services/smtp-client-service.js

@@ -1,46 +0,0 @@
-import nodemailer from "nodemailer";
-import { defineService } from "../core/define-service.js";
-const SmtpClientService = defineService("SmtpClient", (ctx) => ({
-  async send(options) {
-    return new Promise((resolve, reject) => {
-      const transport = nodemailer.createTransport({
-        host: options.host,
-        port: options.port,
-        secure: options.secure,
-        auth: options.user != null ? {
-          user: options.user,
-          pass: options.pass
-        } : void 0,
-        tls: {
-          rejectUnauthorized: false
-        }
-      });
-      transport.sendMail(options, (err, info) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        resolve(info.messageId);
-      });
-    });
-  },
-  async sendByConfig(configName, options) {
-    const config = (await ctx.getConfig("smtp"))[configName];
-    if (config == null) {
-      throw new Error(`SMTP config not found: ${configName}`);
-    }
-    return this.send({
-      user: config.user,
-      pass: config.pass,
-      host: config.host,
-      port: config.port,
-      secure: config.secure,
-      from: `"${config.senderName}" <${config.senderEmail ?? config.user}>`,
-      ...options
-    });
-  }
-}));
-export {
-  SmtpClientService
-};
-//# sourceMappingURL=smtp-client-service.js.map

package/dist/services/smtp-client-service.js.map

@@ -1,6 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/services/smtp-client-service.ts"],
-  "mappings": "AAAA,OAAO,gBAAgB;AACvB,SAAS,qBAA0C;AAO5C,MAAM,oBAAoB,cAAc,cAAc,CAAC,SAAS;AAAA,EACrE,MAAM,KAAK,SAAgD;AACzD,WAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,YAAM,YAAY,WAAW,gBAAgB;AAAA,QAC3C,MAAM,QAAQ;AAAA,QACd,MAAM,QAAQ;AAAA,QACd,QAAQ,QAAQ;AAAA,QAChB,MACE,QAAQ,QAAQ,OACZ;AAAA,UACE,MAAM,QAAQ;AAAA,UACd,MAAM,QAAQ;AAAA,QAChB,IACA;AAAA,QACN,KAAK;AAAA,UACH,oBAAoB;AAAA,QACtB;AAAA,MACF,CAAC;AAED,gBAAU,SAAS,SAAuC,CAAC,KAAK,SAAS;AACvE,YAAI,KAAK;AACP,iBAAO,GAAG;AACV;AAAA,QACF;AAEA,gBAAQ,KAAK,SAAS;AAAA,MACxB,CAAC;AAAA,IACH,CAAC;AAAA,EACH;AAAA,EAEA,MAAM,aAAa,YAAoB,SAAyD;AAC9F,UAAM,UACJ,MAAM,IAAI,UAAgE,MAAM,GAChF,UAAU;AACZ,QAAI,UAAU,MAAM;AAClB,YAAM,IAAI,MAAM,0BAA0B,UAAU,EAAE;AAAA,IACxD;AAEA,WAAO,KAAK,KAAK;AAAA,MACf,MAAM,OAAO;AAAA,MACb,MAAM,OAAO;AAAA,MACb,MAAM,OAAO;AAAA,MACb,MAAM,OAAO;AAAA,MACb,QAAQ,OAAO;AAAA,MACf,MAAM,IAAI,OAAO,UAAU,MAAM,OAAO,eAAe,OAAO,IAAI;AAAA,MAClE,GAAG;AAAA,IACL,CAAC;AAAA,EACH;AACF,EAAE;",
-  "names": []
-}

package/docs/server.md

@@ -1,126 +0,0 @@
-# Server
-
-## `ServiceServerOptions`
-
-Configuration options for `ServiceServer`.
-
-```typescript
-interface ServiceServerOptions {
-  rootPath: string;
-  port: number;
-  ssl?: {
-    pfxBytes: Uint8Array;
-    passphrase: string;
-  };
-  auth?: {
-    jwtSecret: string;
-  };
-  services: ServiceDefinition[];
-}
-```
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `rootPath` | `string` | Root path for static files, uploads, and config |
-| `port` | `number` | Server port |
-| `ssl` | `object` | SSL/TLS config (PFX certificate) |
-| `ssl.pfxBytes` | `Uint8Array` | PFX certificate bytes |
-| `ssl.passphrase` | `string` | Certificate passphrase |
-| `auth` | `object` | Authentication config |
-| `auth.jwtSecret` | `string` | JWT signing secret |
-| `services` | `ServiceDefinition[]` | Service definitions to register |
-
-## `ServiceServer`
-
-Fastify-based service server with WebSocket support, JWT authentication, and built-in services. Extends `EventEmitter`.
-
-```typescript
-class ServiceServer<TAuthInfo = unknown> extends EventEmitter<{
-  ready: void;
-  close: void;
-}> {
-  isOpen: boolean;
-  readonly fastify: FastifyInstance;
-  readonly options: ServiceServerOptions;
-
-  constructor(options: ServiceServerOptions);
-
-  listen(): Promise<void>;
-  close(): Promise<void>;
-  broadcastReload(clientName: string | undefined, changedFileSet: Set<string>): Promise<void>;
-  emitEvent<TInfo, TData>(
-    eventDef: ServiceEventDef<TInfo, TData>,
-    infoSelector: (item: TInfo) => boolean,
-    data: TData,
-  ): Promise<void>;
-  signAuthToken(payload: AuthTokenPayload<TAuthInfo>): Promise<string>;
-  verifyAuthToken(token: string): Promise<AuthTokenPayload<TAuthInfo>>;
-}
-```
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `isOpen` | `boolean` | Whether server is listening |
-| `fastify` | `FastifyInstance` | Underlying Fastify instance |
-| `options` | `ServiceServerOptions` | Server options |
-
-| Method | Description |
-|--------|-------------|
-| `listen()` | Start the server (registers plugins, routes, WebSocket, graceful shutdown) |
-| `close()` | Stop the server (close all connections) |
-| `broadcastReload()` | Broadcast reload to all connected clients |
-| `emitEvent()` | Emit event to matching clients |
-| `signAuthToken()` | Sign a JWT token |
-| `verifyAuthToken()` | Verify and decode a JWT token |
-
-### Registered Routes
-
-| Route | Method | Description |
-|-------|--------|-------------|
-| `/api/:service/:method` | GET/POST | HTTP service method endpoint |
-| `/upload` | POST | File upload endpoint (multipart) |
-| `/ws` | WebSocket | WebSocket service endpoint (Protocol V2) |
-| `/` | WebSocket | WebSocket endpoint (V1 legacy + V2) |
-| `/*` | GET | Static file serving from `www/` |
-
-### Registered Plugins
-
-- `@fastify/websocket` - WebSocket support
-- `@fastify/helmet` - Security headers (CSP, HSTS)
-- `@fastify/multipart` - File upload
-- `@fastify/static` - Static file serving
-- `@fastify/cors` - CORS support
-
-## `createServiceServer`
-
-Factory function to create a `ServiceServer` instance.
-
-```typescript
-function createServiceServer<TAuthInfo = unknown>(
-  options: ServiceServerOptions,
-): ServiceServer<TAuthInfo>;
-```
-
-## Utils
-
-### `getConfig`
-
-Read JSON configuration from file with caching and live-reload via file watcher. Cache expires after 1 hour.
-
-```typescript
-async function getConfig<TConfig>(filePath: string): Promise<TConfig | undefined>;
-```
-
-## Legacy
-
-### `handleV1Connection`
-
-V1 legacy client handler. Only auto-update is supported; all other requests return an upgrade-required error.
-
-```typescript
-function handleV1Connection(
-  socket: WebSocket,
-  autoUpdateMethods: { getLastVersion: (platform: string) => Promise<any> },
-  clientNameSetter?: (clientName: string | undefined) => void,
-): void;
-```