@dangao/bun-server 2.3.0 → 3.0.0

package/docs/zh/platform.md

@@ -0,0 +1,299 @@
+# 平台适配指南
+
+[English](../platform.md) | **中文**
+
+---
+
+Bun Server 通过内部的 Platform Adapter Layer，原生支持在 **Bun** 和 **Node.js 22+** 上运行。所有运行时相关的 API（HTTP 服务器、文件 I/O、加密、解析器、进程管理、WebSocket）均被抽象到统一的 TypeScript 接口后。你编写一套代码，框架在启动时自动选择正确的实现——无需额外配置。
+
+## 目录
+
+- [架构](#架构)
+- [运行时检测](#运行时检测)
+- [平台配置](#平台配置)
+- [支持矩阵](#支持矩阵)
+- [数据库自动适配](#数据库自动适配)
+- [公开 API 变更](#公开-api-变更)
+- [Bun 独有特性](#bun-独有特性)
+- [Node.js 启动指南](#nodejs-启动指南)
+- [多运行时测试](#多运行时测试)
+- [已知限制](#已知限制)
+
+---
+
+## 架构
+
+```
+┌──────────────────────────────────────────────────────┐
+│                   应用层                              │
+│   Controllers / Services / Modules / Middleware       │
+└──────────────────────────┬───────────────────────────┘
+                           │ getRuntime()
+┌──────────────────────────▼───────────────────────────┐
+│              Platform Adapter Layer                   │
+│  IFsAdapter · ICryptoAdapter · IParserAdapter         │
+│  IProcessAdapter · IHttpDriver · IWebSocket           │
+└──────┬───────────────────────────────┬───────────────┘
+       │                               │
+┌──────▼──────┐                 ┌──────▼──────┐
+│ BunPlatform │                 │ NodePlatform│
+│ Bun.serve   │                 │ node:http   │
+│ Bun.file    │                 │ node:fs     │
+│ Bun.Crypto  │                 │ node:crypto │
+│ spawn(bun)  │                 │ ws package  │
+└─────────────┘                 └─────────────┘
+```
+
+每个适配器接口及其对应实现：
+
+| 接口 | Bun 实现 | Node.js 实现 |
+|---|---|---|
+| `IFsAdapter` | `Bun.file`、`Bun.write`、`Bun.Glob` | `node:fs/promises`、`node:fs` glob |
+| `ICryptoAdapter` | `Bun.CryptoHasher` | `node:crypto` HMAC/hash |
+| `IParserAdapter` | `Bun.JSONC`、`Bun.JSON5`、`Bun.JSONL`、`Bun.markdown` | `jsonc-parser`、`json5`、自定义 JSONL、`marked` |
+| `IProcessAdapter` | `spawn`（bun）、`Bun.sleep` | `node:child_process`、`setTimeout` |
+| `IHttpDriver` | `Bun.serve` | `node:http.createServer` |
+| `IWebSocket<T>` | `Bun.ServerWebSocket<T>` | `ws` 包 |
+
+---
+
+## 运行时检测
+
+平台在 `Application` 构造时按以下优先级链解析：
+
+```
+1. Bootstrap 配置  →  new Application({ platform: 'node' })
+2. CLI 参数        →  --platform=node
+3. 环境变量        →  BUN_SERVER_PLATFORM=node
+4. 自动检测        →  typeof Bun !== 'undefined' ? 'bun' : 'node'
+```
+
+一旦解析完成，单例在进程生命周期内保持不变。后续调用 `getRuntime()` 始终返回同一实例。
+
+---
+
+## 平台配置
+
+### 方式一 — 代码配置（最高优先级）
+
+```typescript
+import { Application } from '@dangao/bun-server';
+
+const app = new Application({ platform: 'node' }); // 'bun' | 'node'
+app.registerModule(AppModule);
+await app.listen(3000);
+```
+
+### 方式二 — CLI 参数
+
+```bash
+# Bun 运行时，但强制使用 Node.js 适配器
+bun run src/main.ts --platform=node
+
+# Node.js 运行时（无需参数，自动检测）
+node dist/main.js
+```
+
+### 方式三 — 环境变量
+
+```bash
+BUN_SERVER_PLATFORM=node node dist/main.js
+```
+
+### 方式四 — 自动检测（默认，无需配置）
+
+无需任何配置。如果 `typeof Bun !== 'undefined'`，选择 `BunPlatform`；否则自动选择 `NodePlatform`。
+
+---
+
+## 支持矩阵
+
+| 特性 | Bun | Node.js 22+ |
+|---|---|---|
+| HTTP 服务器 | `Bun.serve`（原生） | `node:http` |
+| WebSocket | `Bun.ServerWebSocket`（原生） | `ws` 包 |
+| 文件 I/O | `Bun.file / Bun.write` | `node:fs/promises` |
+| Crypto / JWT | `Bun.CryptoHasher` | `node:crypto` |
+| JSONC 解析 | `Bun.JSONC` | `jsonc-parser` 包 |
+| JSON5 解析 | `Bun.JSON5` | `json5` 包 |
+| JSONL 解析 | `Bun.JSONL` | 自定义流式解析器 |
+| Markdown 渲染 | `Bun.markdown` | `marked` 包 |
+| Cluster spawn | Bun `spawn` | `node:child_process` |
+| SQLite | `bun:sqlite` | `better-sqlite3` |
+| PostgreSQL | `Bun.SQL` | `postgres` 包 |
+| MySQL | `Bun.SQL` | `mysql2` 包 |
+| `idleTimeout` | 支持 | 静默忽略 |
+| `reusePort` | 支持 | 静默忽略 |
+| SSE TCP keepalive | 支持（via `server.timeout`） | 不可用 |
+| 整体性能 | 最优 | 良好 |
+
+---
+
+## 数据库自动适配
+
+`DatabaseModule` 根据检测到的平台自动选择数据库驱动，**无需用户额外配置**。
+
+```
+Bun 平台                          Node.js 平台
+─────────────────────────────    ─────────────────────────────
+SQLite  →  bun:sqlite            SQLite  →  better-sqlite3
+PostgreSQL  →  Bun.SQL           PostgreSQL  →  postgres 包
+MySQL  →  Bun.SQL                MySQL  →  mysql2 包
+```
+
+你的 `DatabaseModule` 配置在两个平台间完全一致：
+
+```typescript
+DatabaseModule.forRoot({
+  connections: [
+    {
+      name: 'default',
+      type: 'sqlite',
+      database: './data/app.db',
+    },
+    {
+      name: 'pg',
+      type: 'postgres',
+      url: process.env.DATABASE_URL,
+    },
+  ],
+})
+```
+
+---
+
+## 公开 API 变更
+
+### `BunServer.getServer()`
+
+返回 `IServerHandle | undefined`（原来为 `Bun.Server | undefined`）。
+
+```typescript
+const handle: IServerHandle | undefined = app.getServer();
+handle?.port;      // number
+handle?.hostname;  // string
+await handle?.stop();
+
+// 访问底层原生服务器实例（不推荐，类型为 unknown）
+const native: unknown = app.getNativeServer();
+// Bun:     native as Bun.Server<any>
+// Node.js: native as import('node:http').Server
+```
+
+### `WsArgumentsHost.getClient()`
+
+返回 `IWebSocket<T>` 而非 Bun 的 `ServerWebSocket<T>`。这是 WebSocket 公开 API 中的**唯一破坏性变更**。
+
+```typescript
+import type { IWebSocket } from '@dangao/bun-server';
+
+@WebSocketGateway()
+class ChatGateway {
+  @OnMessage('chat')
+  onChat(client: IWebSocket<unknown>, data: unknown) {
+    client.send('pong');
+  }
+}
+```
+
+`IWebSocket<T>` 暴露与 `ServerWebSocket<T>` 相同的核心方法：
+`send`、`close`、`data`、`readyState`、`remoteAddress`。
+
+---
+
+## Bun 独有特性
+
+以下选项在 `ApplicationOptions` 中接受，但仅在 Bun 上生效，在 Node.js 上静默忽略。
+
+| 选项 | Bun 效果 | Node.js |
+|---|---|---|
+| `idleTimeout` | 通过 `Bun.serve` 设置 TCP 空闲超时 | 忽略 |
+| `reusePort` | 通过 `Bun.serve` 启用端口复用 | 忽略 |
+| `sseKeepAlive` | 使用 `server.timeout(req, 0)` | 仅注入心跳 |
+
+如果你的应用依赖这些特性，请在文档中明确说明对 Bun 运行时的要求。
+
+---
+
+## Node.js 启动指南
+
+### 1. 安装
+
+```bash
+npm install @dangao/bun-server
+# Node.js 所需的对等依赖会自动安装
+```
+
+### 2. 构建
+
+```bash
+# 使用 bun build 输出面向 Node.js 的 JS 文件
+bun build src/main.ts --target=node --outdir=dist
+
+# 或使用 tsc
+npx tsc
+```
+
+### 3. 运行
+
+```bash
+node dist/main.js
+# 平台自动检测为 'node'，无需额外参数
+```
+
+### 4. 冒烟测试（验证 bun build 输出能被 Node.js 原生运行）
+
+```bash
+bun run test:node
+# 等价于：vitest run tests/platform/node
+```
+
+---
+
+## 多运行时测试
+
+共享测试用例位于 `tests/platform/shared/*.cases.ts`。Bun 和 Node.js 的测试运行器导入相同的断言，保证测试覆盖完全一致。
+
+```
+tests/platform/
+├── shared/
+│   ├── suite.ts              ← TestSuite 接口（test / expect / beforeEach）
+│   ├── fs.cases.ts
+│   ├── crypto.cases.ts
+│   ├── parser.cases.ts
+│   ├── process.cases.ts
+│   ├── websocket.cases.ts
+│   └── database.cases.ts
+├── bun/                      ← bun:test 运行器
+│   └── *.test.ts
+├── node/                     ← vitest 运行器
+│   ├── *.test.ts
+│   └── build-smoke.test.ts   ← 验证 bun build --target=node 输出
+└── detector.test.ts          ← 优先级链单元测试
+```
+
+### 执行测试
+
+```bash
+# Bun 平台测试
+bun run test:bun
+
+# Node.js 平台测试
+bun run test:node
+
+# 两个平台全部测试
+bun run test:platform
+```
+
+---
+
+## 已知限制
+
+| 限制 | 说明 |
+|---|---|
+| `idleTimeout` / `reusePort` | Bun 独有，Node.js 无对等实现 |
+| SSE TCP keepalive（`server.timeout`） | Bun 独有 API；Node.js 仅支持心跳注入 |
+| `Bun.SQL` 高级特性 | 部分 Bun.SQL 选项（如预处理语句缓存）在 `postgres`/`mysql2` 中不可用 |
+| Node.js 上的 Cluster 模式 | 使用 `node:child_process`，行为可能与 Bun cluster 存在差异 |
+| `bun:sqlite` 扩展 | Bun SQLite 支持扩展加载；`better-sqlite3` 的扩展机制不同 |
+| 整体性能 | Bun 原生 API 在文件 I/O 和加密等方面性能优于 Node.js 适配实现 |

package/docs/zh/testing.md

@@ -61,6 +61,66 @@ const client = await module.createHttpClient();
 
 `options` 支持 `headers`、`body`、`query`。响应对象包含 `status`、`headers`、`body`、`text`、`ok`。
 
+## 多运行时测试
+
+框架内置的共享测试策略，能在 Bun 和 Node.js 上运行完全相同的测试用例。
+
+### 测试目录结构
+
+```
+tests/platform/
+├── shared/          ← 平台无关的断言辅助函数
+│   ├── suite.ts     ← TestSuite 接口（test / expect / beforeEach）
+│   ├── fs.cases.ts
+│   ├── crypto.cases.ts
+│   ├── parser.cases.ts
+│   ├── process.cases.ts
+│   ├── websocket.cases.ts
+│   └── database.cases.ts
+├── bun/             ← bun:test 运行器（initRuntime('bun')）
+│   └── *.test.ts
+└── node/            ← vitest 运行器（initRuntime('node')）
+    ├── *.test.ts
+    └── build-smoke.test.ts
+```
+
+### 执行平台测试
+
+```bash
+# 仅 Bun 平台测试
+bun run test:bun
+
+# 仅 Node.js 平台测试（使用 vitest）
+bun run test:node
+
+# 两个平台全部测试
+bun run test:platform
+```
+
+### 编写跨平台测试
+
+在测试文件开头调用 `initRuntime()`：
+
+```ts
+// tests/platform/bun/fs.test.ts
+import { test, expect, beforeEach } from 'bun:test';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+initRuntime('bun');
+runFsCases({ test, expect, beforeEach });
+```
+
+```ts
+// tests/platform/node/fs.test.ts
+import { test, expect, beforeEach } from 'vitest';
+import { initRuntime, _resetRuntime } from '../../../src/platform/runtime';
+import { runFsCases } from '../shared/fs.cases';
+
+beforeEach(() => { _resetRuntime(); initRuntime('node'); });
+runFsCases({ test, expect, beforeEach });
+```
+
 ## 配合 bun:test 使用
 
 ```ts

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@dangao/bun-server",
-  "version": "2.3.0",
+  "version": "3.0.0",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "node": "./dist/index.node.mjs",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
@@ -38,27 +39,44 @@
     "url": "https://github.com/dangaogit/bun-server/issues"
   },
   "engines": {
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.10",
+    "node": ">=22.0.0"
   },
   "scripts": {
     "dev": "bun --watch src/index.ts",
     "test": "bun test",
+    "test:bun": "bun test tests/platform/bun",
+    "test:node": "vitest run tests/platform/node",
+    "test:platform": "bun run test:bun && bun run test:node",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
     "bundle": "bun build src/index.ts --target=bun --format=esm --outfile=dist/index.js --external reflect-metadata --external @dangao/logsmith --external @dangao/nacos-client",
+    "bundle:node": "bun build src/index.ts --target=node --packages=external --outfile=dist/index.node.mjs",
     "dts": "tsc -p tsconfig.build.json",
-    "build": "bun run clean && bun run bundle && bun run dts",
+    "build": "bun run clean && bun run bundle && bun run bundle:node && bun run dts",
     "prepublishOnly": "bun run build",
     "publish:package": "cp -r ../../README.md ../../LICENSE ../../docs . && bun publish --access public && rm -rf ./README.md ./LICENSE ./docs",
     "publish:package:github": "cp -r ../../README.md ../../LICENSE ../../docs . && bun pm pack --access public && npm publish *.tgz --provenance --access public && rm -rf ./README.md ./LICENSE ./docs"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.3.10",
+    "@types/mime-types": "^3.0.1",
+    "@types/ws": "^8.18.1",
     "typescript": "^5.9.3",
-    "@types/bun": "^1.3.10"
+    "vitest": "^4.1.4"
   },
   "dependencies": {
-    "reflect-metadata": "^0.2.2",
     "@dangao/logsmith": "0.2.0",
-    "@dangao/nacos-client": "0.1.1"
+    "@dangao/nacos-client": "0.1.1",
+    "better-sqlite3": "^12.8.0",
+    "json5": "^2.2.3",
+    "jsonc-parser": "^3.3.1",
+    "marked": "^18.0.0",
+    "mime-types": "^3.0.2",
+    "mysql2": "^3.21.0",
+    "postgres": "^3.4.9",
+    "reflect-metadata": "^0.2.2",
+    "ws": "^8.20.0"
   }
 }

package/src/auth/jwt.ts

@@ -1,4 +1,5 @@
 import type { JWTConfig, JWTPayload } from './types';
+import { getRuntime } from '../platform/runtime';
 
 /**
  * JWT 工具类
@@ -120,7 +121,7 @@ export class JWTUtil {
 
     if (key.length > blockSize) {
       // 如果密钥长度超过块大小，先哈希
-      const hasher = new Bun.CryptoHasher('sha256');
+      const hasher = getRuntime().crypto.createHasher('sha256');
       hasher.update(key);
       keyBuffer = new Uint8Array(hasher.digest());
     } else {
@@ -141,7 +142,7 @@ export class JWTUtil {
     const innerData = new Uint8Array(iKeyPad.length + data.length);
     innerData.set(iKeyPad);
     innerData.set(data, iKeyPad.length);
-    const innerHasher = new Bun.CryptoHasher('sha256');
+    const innerHasher = getRuntime().crypto.createHasher('sha256');
     innerHasher.update(innerData);
     const innerHash = new Uint8Array(innerHasher.digest());
 
@@ -149,7 +150,7 @@ export class JWTUtil {
     const outerData = new Uint8Array(oKeyPad.length + innerHash.length);
     outerData.set(oKeyPad);
     outerData.set(innerHash, oKeyPad.length);
-    const outerHasher = new Bun.CryptoHasher('sha256');
+    const outerHasher = getRuntime().crypto.createHasher('sha256');
     outerHasher.update(outerData);
 
     return new Uint8Array(outerHasher.digest());

package/src/config/service.ts

@@ -1,4 +1,5 @@
 import type { ConfigFileFormat } from './types';
+import { getRuntime } from '../platform/runtime';
 
 /**
  * 配置服务
@@ -7,16 +8,16 @@ import type { ConfigFileFormat } from './types';
 export class ConfigService<TConfig extends Record<string, unknown> = Record<string, unknown>> {
   /**
    * 解析配置内容，按 JSON -> JSONC -> JSON5 顺序自动尝试
-   * 利用 Bun 1.3.6+ 的 Bun.JSONC 和 Bun 1.3.7+ 的 Bun.JSON5
    * @param content - 配置文本内容
    * @param format - 强制指定格式（可选），省略则自动检测
    */
   public static parseConfigContent(content: string, format?: ConfigFileFormat): unknown {
+    const parser = getRuntime().parser;
     if (format === 'jsonc') {
-      return Bun.JSONC.parse(content);
+      return parser.parseJSONC(content);
     }
     if (format === 'json5') {
-      return Bun.JSON5.parse(content);
+      return parser.parseJSON5(content);
     }
     if (format === 'json') {
       return JSON.parse(content);
@@ -26,9 +27,9 @@ export class ConfigService<TConfig extends Record<string, unknown> = Record<stri
       return JSON.parse(content);
     } catch (_error) {
       try {
-        return Bun.JSONC.parse(content);
+        return parser.parseJSONC(content);
       } catch (_innerError) {
-        return Bun.JSON5.parse(content);
+        return parser.parseJSON5(content);
       }
     }
   }
@@ -38,7 +39,7 @@ export class ConfigService<TConfig extends Record<string, unknown> = Record<stri
    * @param filePath - 配置文件路径（.json / .jsonc / .json5）
    */
   public static async loadConfigFile(filePath: string): Promise<Record<string, unknown>> {
-    const file = Bun.file(filePath);
+    const file = getRuntime().fs.file(filePath);
     const content = await file.text();
 
     let format: ConfigFileFormat | undefined;

package/src/core/application.ts

@@ -21,6 +21,8 @@ import { LoggerManager } from '@dangao/logsmith';
 import { EventModule } from '../events/event-module';
 import { AsyncProviderRegistry } from '../di/async-module';
 import { ServiceRegistryModule } from '../microservice/service-registry/service-registry-module';
+import type { PlatformEngine } from '../platform/types';
+import { initRuntime } from '../platform/runtime';
 
 /**
  * 应用配置选项
@@ -79,6 +81,19 @@ export interface ApplicationOptions {
     /** 心跳间隔（毫秒），默认 15000 */
     intervalMs?: number;
   };
+
+  /**
+   * 运行时平台选择
+   *
+   * 优先级（从高到低）：
+   * 1. 此字段（构造函数选项）
+   * 2. CLI 参数 `--platform=node`
+   * 3. 环境变量 `BUN_SERVER_PLATFORM=node`
+   * 4. 自动检测（有 Bun 全局对象则使用 bun，否则使用 node）
+   *
+   * @default 自动检测
+   */
+  platform?: PlatformEngine;
 }
 
 /**
@@ -94,6 +109,9 @@ export class Application {
   private signalHandlersInstalled: boolean = false;
 
   public constructor(options: ApplicationOptions = {}) {
+    // Initialize platform runtime first — must be the very first operation
+    initRuntime(options.platform);
+
     this.options = options;
     this.middlewarePipeline = new MiddlewarePipeline([createErrorHandlingMiddleware()]);
     this.websocketRegistry = WebSocketGatewayRegistry.getInstance();
@@ -175,7 +193,7 @@ export class Application {
     };
 
     this.server = new BunServer(serverOptions);
-    this.server.start();
+    await this.server.start();
 
     // 安装信号处理器（如果启用）
     if (this.options.enableSignalHandlers !== false) {

package/src/core/cluster.ts

@@ -1,8 +1,9 @@
-import { spawn } from 'bun';
 import { LoggerManager } from '@dangao/logsmith';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { mkdirSync, rmSync, existsSync } from 'fs';
+import type { IServerHandle, IChildProcess } from '../platform/types';
+import { getRuntime } from '../platform/runtime';
 
 /**
  * 集群模式
@@ -38,12 +39,12 @@ export interface ClusterOptions {
  */
 export class ClusterManager {
   private readonly workerCount: number;
-  private readonly workers: ReturnType<typeof spawn>[] = [];
+  private readonly workers: IChildProcess[] = [];
   private readonly scriptPath: string;
   private readonly port: number;
   private readonly hostname?: string;
   private readonly mode: 'reusePort' | 'proxy';
-  private proxyServer?: ReturnType<typeof Bun.serve>;
+  private proxyServer?: IServerHandle;
   private socketPaths: string[] = [];
   private roundRobinIndex = 0;
   private socketDir?: string;
@@ -145,8 +146,8 @@ export class ClusterManager {
     this.monitorReusePortWorkers();
   }
 
-  private spawnReusePortWorker(index: number): ReturnType<typeof spawn> {
-    return spawn({
+  private spawnReusePortWorker(index: number): IChildProcess {
+    return getRuntime().process.spawn({
       cmd: ['bun', 'run', this.scriptPath],
       env: {
         ...process.env,
@@ -197,7 +198,7 @@ export class ClusterManager {
     }
 
     await this.waitForWorkerSockets();
-    this.startProxyServer();
+    await this.startProxyServer();
 
     logger.info(
       `[Cluster] ${this.workerCount} workers ready (proxy mode, unix sockets)`,
@@ -206,8 +207,8 @@ export class ClusterManager {
     this.monitorProxyWorkers();
   }
 
-  private spawnProxyWorker(index: number, socketPath: string): ReturnType<typeof spawn> {
-    return spawn({
+  private spawnProxyWorker(index: number, socketPath: string): IChildProcess {
+    return getRuntime().process.spawn({
       cmd: ['bun', 'run', this.scriptPath],
       env: {
         ...process.env,
@@ -239,11 +240,11 @@ export class ClusterManager {
 
       if (allReady) {
         // Give workers a moment to finish bind+listen after file creation
-        await Bun.sleep(200);
+        await getRuntime().process.sleep(200);
         return;
       }
 
-      await Bun.sleep(100);
+      await getRuntime().process.sleep(100);
     }
 
     const ready = this.socketPaths.filter((p) => existsSync(p)).length;
@@ -252,11 +253,11 @@ export class ClusterManager {
     );
   }
 
-  private startProxyServer(): void {
+  private async startProxyServer(): Promise<void> {
     const sockets = this.socketPaths;
     const count = sockets.length;
 
-    this.proxyServer = Bun.serve({
+    this.proxyServer = await getRuntime().http.serve({
       port: this.port,
       hostname: this.hostname,
       fetch: async (req) => {
@@ -269,6 +270,7 @@ export class ClusterManager {
             headers: req.headers,
             body: req.body,
             redirect: 'manual',
+            // @ts-ignore — unix fetch is Bun-specific; Node fallback skips this
             unix: socketPath,
           });
         } catch (_error) {
@@ -296,11 +298,11 @@ export class ClusterManager {
           const deadline = Date.now() + 15_000;
           while (Date.now() < deadline) {
             if (existsSync(socketPath)) {
-              await Bun.sleep(200);
+              await getRuntime().process.sleep(200);
               logger.info(`[Cluster] Worker ${index} restarted (unix socket)`);
               return;
             }
-            await Bun.sleep(100);
+            await getRuntime().process.sleep(100);
           }
 
           logger.error(`[Cluster] Worker ${index} failed to restart within 15s`);