@jacksontian/kite-server 0.1.0 → 0.3.0

package/server.js

@@ -5,7 +5,8 @@
  * 职责：签名鉴权、任务信箱（手机写入 / Worker 领取）、日志与结果收集、
  *       Worker 心跳、托管手机端 Web 控制台。
  *
- * 依赖：ws（WebSocket）、dingbot（钉钉群机器人）、yaml。其余为 Node 内置模块。Node >= 24。
+ * 依赖：ws（WebSocket）、dingbot（钉钉群机器人）、yaml、zod（配置校验，见 config.js）。
+ * 其余为 Node 内置模块。Node >= 24。
  *
  * 鉴权模型：HMAC-SHA256 请求签名。密钥（API_SECRET）只存在两端，
  * 永不在网络上传输；HTTP 明文下抓到请求也无法重放（时间窗 + nonce）。
@@ -18,7 +19,14 @@
  *
  * 配置文件（--config 传入的 YAML 文件，唯一配置来源，不再读取环境变量；
  * 字段说明与模板见包内 config.example.yaml）：
- *   apiSecret          必填，两端共享的签名密钥（强随机 hex，见 README 快速开始）
+ *   apiSecret          必填，控制台签名密钥（强随机 hex，见 README 快速开始）
+ *   workerSecret       可选，Worker 专用密钥；配置后 Worker 侧 API 与 /worker/ws
+ *                      只认该密钥，控制台密钥泄露不再等于 Worker 执行权；
+ *                      留空则两端共用 apiSecret
+ *   workerSecrets      可选，workerId -> 密钥映射（多 Worker 各自专属密钥）；
+ *                      验签命中映射条目即绑定该 Worker 身份（自报 workerId 须一致），
+ *                      Worker 间无法互相冒充；与 workerSecret 可并存（命中共享
+ *                      密钥时身份自报，兼容旧部署）
  *   port               可选，默认 8787
  *   dataDir             可选，持久化目录，默认 ~/.kite/data；
  *                      相对路径相对启动工作目录解析，建议写绝对路径；
@@ -47,6 +55,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const {
   configFile: CONFIG_FILE,
   apiSecret: API_SECRET,
+  workerAuth: WORKER_AUTH,
   port: PORT,
   dataDir: DATA_DIR,
   maxTasks: MAX_TASKS,
@@ -60,6 +69,9 @@ const {
 const WEB_DIR = path.join(__dirname, 'web');
 const DB_FILE = path.join(DATA_DIR, 'tasks.json');
 const MAX_LOG_LINES = 2000;
+// pending 任务数上限：密钥泄露/控制台失守时防无限灌任务撑爆内存与 tasks.json
+// （pruneFinishedTasks 只清终态，堆积的 pending 没有任何自然出口）
+const MAX_PENDING_TASKS = 100;
 
 // ---------------------------------------------------------------------------
 // 持久化：单文件 JSON，异步落盘（脏标记 + 节流 + 串行化，全程无同步 IO）
@@ -112,7 +124,9 @@ async function flushSave() {
   try {
     const data = JSON.stringify(state, null, 2);
     const tmp = DB_FILE + '.tmp';
-    await fs.promises.writeFile(tmp, data);
+    // 0600：tasks.json 含全部命令/日志/结果，不允许同机其他用户读取
+    await fs.promises.writeFile(tmp, data, { mode: 0o600 });
+    await fs.promises.chmod(tmp, 0o600); // writeFile 的 mode 只在创建时生效，历史文件需显式收紧
     await fs.promises.rename(tmp, DB_FILE);
   } catch (err) {
     console.error(`[server] 落盘失败，下次变更时重试: ${err.message}`);
@@ -140,6 +154,15 @@ for (const sig of ['SIGTERM', 'SIGINT']) {
 // pty 交互会话例外：时长不可预期，由 PTY_IDLE_SEC 空闲回收（见 sweepPtyIdle）
 function sweepStaleRunning() {
   const now = Date.now();
+  // 顺带清理离线超过 7 天的 Worker 心跳记录，防止 heartbeats 无限增长
+  let hbPruned = false;
+  for (const [id, hb] of Object.entries(state.heartbeats)) {
+    if (now - hb.at > 7 * 24 * 3600 * 1000) {
+      delete state.heartbeats[id];
+      hbPruned = true;
+    }
+  }
+  if (hbPruned) scheduleSave();
   for (const t of state.tasks) {
     if (t.status !== 'running' || t.type === 'pty') continue;
     const hb = t.workerId ? state.heartbeats[t.workerId] : null;
@@ -180,6 +203,8 @@ function json(res, code, body) {
 // ---------------------------------------------------------------------------
 // 签名鉴权：HMAC-SHA256(密钥, METHOD\nPATH\nTS\nNONCE\nSHA256(BODY))
 // 密钥永不上网；时间窗 + nonce 缓存联合防重放。
+// 密钥按路由角色选择：控制台 API 用 API_SECRET，Worker API 用 WORKER_AUTH
+// 条目列表（workerSecrets 绑定密钥 / 共享 workerSecret / 回落 apiSecret）。
 // ---------------------------------------------------------------------------
 
 const seenNonces = new Map(); // nonce -> 过期时间戳(ms)
@@ -193,7 +218,7 @@ function pruneNonces(now) {
 
 // 校验 ts/nonce/签名三元组；通过即消费掉该 nonce。
 // signingParts 为参与签名的各行（不含密钥），body 为原始字节（可为空 Buffer）。
-function verifySignature(signingParts, tsRaw, nonce, sig) {
+function verifySignature(signingParts, tsRaw, nonce, sig, secret) {
   const now = Date.now();
   if (!tsRaw || !nonce || !sig) {
     return { ok: false, reason: '缺少签名头 X-RW-Ts/X-RW-Nonce/X-RW-Sig' };
@@ -215,7 +240,7 @@ function verifySignature(signingParts, tsRaw, nonce, sig) {
     return { ok: false, reason: 'nonce 重复（疑似重放）' };
   }
   const signingString = signingParts.join('\n');
-  const expected = crypto.createHmac('sha256', API_SECRET).update(signingString).digest('hex');
+  const expected = crypto.createHmac('sha256', secret).update(signingString).digest('hex');
   if (!timingSafeEqualStr(String(sig), expected)) {
     return { ok: false, reason: '签名不匹配（密钥错误或请求被篡改）' };
   }
@@ -231,7 +256,9 @@ function readRawBody(req, limit = 1024 * 1024) {
     req.on('data', (chunk) => {
       size += chunk.length;
       if (size > limit) {
-        reject(new Error('body too large'));
+        const err = new Error('body too large');
+        err.statusCode = 413; // 明确为客户端错误，响应里可安全回显
+        reject(err);
         req.destroy();
         return;
       }
@@ -244,16 +271,54 @@ function readRawBody(req, limit = 1024 * 1024) {
 
 // REST 请求验签：签名覆盖方法、路径、时间戳、nonce 与请求体摘要。
 // 注意：路径用含 query 的完整形式（与客户端签名方式一致，防止改写查询参数）。
-async function verifyRestSignature(req, pathname) {
+// entries 为该路由可接受的密钥条目列表（{ secret, workerId }，按序尝试，
+// 验过任一即通过）；workerId 非 null 表示该密钥绑定了 Worker 身份
+// （workerSecrets 条目），null 表示身份自报（共享密钥兼容路径）。
+// nonce 只在验过之后消费，失败尝试不留副作用。
+async function verifyRestSignature(req, entries) {
   const rawBody = await readRawBody(req);
   const bodySha = crypto.createHash('sha256').update(rawBody).digest('hex');
-  const result = verifySignature(
-    [req.method, req.url, req.headers['x-rw-ts'], req.headers['x-rw-nonce'], bodySha],
-    req.headers['x-rw-ts'],
-    req.headers['x-rw-nonce'],
-    req.headers['x-rw-sig'],
-  );
-  return { ...result, rawBody };
+  const parts = [req.method, req.url, req.headers['x-rw-ts'], req.headers['x-rw-nonce'], bodySha];
+  let result = { ok: false, reason: '缺少签名头 X-RW-Ts/X-RW-Nonce/X-RW-Sig' };
+  let workerId = null;
+  for (const entry of entries) {
+    result = verifySignature(parts, req.headers['x-rw-ts'], req.headers['x-rw-nonce'], req.headers['x-rw-sig'], entry.secret);
+    if (result.ok) {
+      workerId = entry.workerId;
+      break;
+    }
+  }
+  return { ...result, rawBody, workerId };
+}
+
+// 路由 -> 可接受的密钥条目：Worker 侧 API 只认 WORKER_AUTH 条目，控制台只认
+// API_SECRET；worker/status 两端都要读（控制台轮询兜底也用），两边密钥都放行
+const WORKER_PATH = /^\/api\/(worker\/(claim|heartbeat)|tasks\/[0-9a-f-]{36}\/(logs|finish))$/;
+function secretsForPath(pathname) {
+  if (pathname === '/api/worker/status') {
+    return [{ secret: API_SECRET, workerId: null }, ...WORKER_AUTH];
+  }
+  return WORKER_PATH.test(pathname) ? WORKER_AUTH : [{ secret: API_SECRET, workerId: null }];
+}
+
+// 验签失败限流：单 IP 滑动窗口（60s/30 次），防止恶意刷 401 灌日志耗 CPU；
+// 只统计失败，成功请求不计（正常轮询频率不会触限）
+const authFailures = new Map(); // ip -> { count, windowStart }
+function authLimitExceeded(ip) {
+  const rec = authFailures.get(ip);
+  return Boolean(rec && Date.now() - rec.windowStart <= 60_000 && rec.count >= 30);
+}
+function recordAuthFailure(ip) {
+  const now = Date.now();
+  if (authFailures.size > 10_000) {
+    for (const [k, rec] of authFailures) if (now - rec.windowStart > 60_000) authFailures.delete(k);
+  }
+  let rec = authFailures.get(ip);
+  if (!rec || now - rec.windowStart > 60_000) {
+    rec = { count: 0, windowStart: now };
+    authFailures.set(ip, rec);
+  }
+  rec.count++;
 }
 
 function parseBody(rawBody) {
@@ -268,7 +333,8 @@ function parseBody(rawBody) {
 }
 
 function publicTask(task) {
-  // 不外泄内部字段的浅拷贝
+  // 浅拷贝切断与内部状态的引用别名，防止响应侧改动波及 state.tasks；
+  // 任务现有字段（含 logs/result/payload）均为控制台可见，无需裁剪
   return { ...task };
 }
 
@@ -288,6 +354,7 @@ function taskSummary(t) {
     startedAt: t.startedAt,
     finishedAt: t.finishedAt,
     workerId: t.workerId,
+    targetWorker: t.targetWorker || null,
     logCount: t.logs.length,
     ...shellPreview(t),
   };
@@ -334,9 +401,10 @@ function broadcast(msg) {
 // Worker 收到后仍走 HTTP claim 原子领取，断线期间由轮询兜底
 const wsWorkers = new Set();
 
-function notifyWorkers() {
+function notifyWorkers(targetWorker = null) {
   if (!wsWorkers.size) return;
-  const data = JSON.stringify({ type: 'task.available' });
+  // 附带目标 Worker：定向任务无关的 Worker 收到后不领取，省一次空 claim
+  const data = JSON.stringify({ type: 'task.available', targetWorker });
   for (const ws of wsWorkers) ws.send(data);
 }
 
@@ -470,14 +538,33 @@ function sweepPtyIdle() {
 // API 路由
 // ---------------------------------------------------------------------------
 
-async function handleApi(req, res, pathname, rawBody) {
+// 身份绑定：配置 workerSecrets 时验签密钥即决定 Worker 身份；
+// 自报 workerId 与绑定身份不一致返回 null，调用方按 401 拒绝
+function resolveWorkerId(authedWorkerId, bodyWorkerId) {
+  const claimed = String(bodyWorkerId || 'unknown').slice(0, 128);
+  if (authedWorkerId && claimed !== authedWorkerId) return null;
+  return authedWorkerId || claimed;
+}
+
+// 归属校验（仅身份绑定生效时启用）：只允许领取者上报日志/结果，
+// 防止其他 Worker 伪造他人任务（含未领取任务）的日志与终态；
+// 共享密钥模式（authedWorkerId 为 null）维持旧行为
+function canReportTask(task, authedWorkerId) {
+  return !authedWorkerId || task.workerId === authedWorkerId;
+}
+
+async function handleApi(req, res, pathname, rawBody, authedWorkerId) {
   sweepStaleRunning();
   const body = parseBody(rawBody);
 
   // --- Worker：领取最老的 pending 任务（原子置为 running）---
   if (req.method === 'POST' && pathname === '/api/worker/claim') {
-    const workerId = String(body.workerId || 'unknown').slice(0, 128);
-    const task = state.tasks.find((t) => t.status === 'pending');
+    const workerId = resolveWorkerId(authedWorkerId, body.workerId);
+    if (!workerId) return json(res, 401, { error: 'workerId 与密钥绑定的身份不一致' });
+    // 只领取指向本 Worker 或未指定目标（任意）的任务
+    const task = state.tasks.find(
+      (t) => t.status === 'pending' && (!t.targetWorker || t.targetWorker === workerId),
+    );
     if (!task) return json(res, 200, { task: null });
     task.status = 'running';
     task.workerId = workerId;
@@ -489,7 +576,8 @@ async function handleApi(req, res, pathname, rawBody) {
 
   // --- Worker：心跳 ---
   if (req.method === 'POST' && pathname === '/api/worker/heartbeat') {
-    const workerId = String(body.workerId || 'unknown').slice(0, 128);
+    const workerId = resolveWorkerId(authedWorkerId, body.workerId);
+    if (!workerId) return json(res, 401, { error: 'workerId 与密钥绑定的身份不一致' });
     state.heartbeats[workerId] = {
       at: Date.now(),
       hostname: String(body.hostname || '').slice(0, 128),
@@ -509,12 +597,25 @@ async function handleApi(req, res, pathname, rawBody) {
     return json(res, 200, { workers: workersSnapshot() });
   }
 
-  // --- 创建任务 ---
+  // --- 创建任务（pending 超限拒绝，见 MAX_PENDING_TASKS）---
   if (req.method === 'POST' && pathname === '/api/tasks') {
     const type = String(body.type || '');
     if (!['script', 'shell', 'agent', 'chat', 'pty'].includes(type)) {
       return json(res, 400, { error: 'type 必须是 script|shell|agent|chat|pty' });
     }
+    const pendingCount = state.tasks.filter((t) => t.status === 'pending').length;
+    if (pendingCount >= MAX_PENDING_TASKS) {
+      return json(res, 429, { error: `待执行任务已达上限（${MAX_PENDING_TASKS}），请先消化积压` });
+    }
+    // 定向任务：只允许指定 Worker 领取；空/未传 = 任意 Worker 均可领取
+    let targetWorker = null;
+    if (body.targetWorker) {
+      const tw = String(body.targetWorker).trim().slice(0, 128);
+      if (!/^[\w.-]{1,128}$/.test(tw)) {
+        return json(res, 400, { error: 'targetWorker 只能含字母/数字/._-' });
+      }
+      targetWorker = tw;
+    }
     const task = {
       id: crypto.randomUUID(),
       type,
@@ -527,11 +628,12 @@ async function handleApi(req, res, pathname, rawBody) {
       startedAt: null,
       finishedAt: null,
       workerId: null,
+      targetWorker,
     };
     state.tasks.push(task);
     scheduleSave();
     broadcast({ type: 'task.created', task: taskSummary(task) });
-    notifyWorkers(); // 任务到达即推送，Worker 立即领取，不再等轮询周期
+    notifyWorkers(targetWorker); // 任务到达即推送，Worker 立即领取，不再等轮询周期
     return json(res, 201, publicTask(task));
   }
 
@@ -559,6 +661,9 @@ async function handleApi(req, res, pathname, rawBody) {
   if (req.method === 'POST' && logMatch) {
     const task = state.tasks.find((t) => t.id === logMatch[1]);
     if (!task) return json(res, 404, { error: 'task not found' });
+    if (!canReportTask(task, authedWorkerId)) {
+      return json(res, 403, { error: '只能上报自己领取的任务' });
+    }
     const lines = Array.isArray(body.lines) ? body.lines : [];
     for (const line of lines) {
       task.logs.push(String(line).slice(0, 4000));
@@ -576,6 +681,14 @@ async function handleApi(req, res, pathname, rawBody) {
   if (req.method === 'POST' && finishMatch) {
     const task = state.tasks.find((t) => t.id === finishMatch[1]);
     if (!task) return json(res, 404, { error: 'task not found' });
+    if (!canReportTask(task, authedWorkerId)) {
+      return json(res, 403, { error: '只能上报自己领取的任务' });
+    }
+    // 状态守卫：已到终态（被 sweepStaleRunning 判失败回收、控制台取消等）的任务
+    // 拒绝迟到的 finish，防止短暂失联后"复活"的 Worker 把终态翻回
+    if (task.status !== 'running') {
+      return json(res, 409, { error: `任务已处于终态（${task.status}），拒绝 finish 上报` });
+    }
     task.status = body.status === 'done' ? 'done' : 'failed';
     task.result = body.result ?? null;
     task.finishedAt = Date.now();
@@ -615,7 +728,7 @@ async function handleApi(req, res, pathname, rawBody) {
 }
 
 // ---------------------------------------------------------------------------
-// 静态文件（手机端 Web 控制台）
+// 静态文件（Web 控制台：移动端 index.html / PC 端 pc.html，按 UA 分发）
 // ---------------------------------------------------------------------------
 
 const MIME = {
@@ -626,10 +739,18 @@ const MIME = {
   '.png': 'image/png',
 };
 
+// 移动端 UA 特征词；命中走手机版，其余（桌面浏览器）走 PC 版。
+// iPadOS 13+ 默认伪装 Mac UA，会落到 PC 版——需要时可显式访问 /index.html
+const MOBILE_UA = /android|iphone|ipod|ipad|mobile|harmonyos/i;
+
 function serveStatic(req, res, pathname) {
-  const rel = pathname === '/' ? 'index.html' : pathname.replace(/^\/+/, '');
-  const filePath = path.join(WEB_DIR, rel);
-  if (!filePath.startsWith(WEB_DIR)) {
+  let rel = pathname.replace(/^\/+/, '');
+  if (!rel) {
+    rel = MOBILE_UA.test(req.headers['user-agent'] || '') ? 'index.html' : 'pc.html';
+  }
+  // resolve 归一化 ../ 后按「目录 + 分隔符」前缀判断，避免同级前缀目录（web-xxx）绕过
+  const filePath = path.resolve(WEB_DIR, rel);
+  if (filePath !== WEB_DIR && !filePath.startsWith(WEB_DIR + path.sep)) {
     res.writeHead(403);
     return res.end('forbidden');
   }
@@ -641,6 +762,13 @@ function serveStatic(req, res, pathname) {
     res.writeHead(200, {
       'Content-Type': MIME[path.extname(filePath)] || 'application/octet-stream',
       'Cache-Control': 'no-store',
+      // 纵深防御：页面资源一律限同源，阻断潜在注入脚本把密钥外传（connect-src
+      // 的 'self' 按 CSP3 含同源 ws/wss，实时通道不受影响）；页面含内联 <script>
+      // 与行内样式操作，script/style 需放行 'unsafe-inline'
+      'Content-Security-Policy':
+        "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; " +
+        "img-src 'self' data:; connect-src 'self'",
+      'X-Content-Type-Options': 'nosniff',
     });
     res.end(data);
   });
@@ -651,29 +779,46 @@ function serveStatic(req, res, pathname) {
 // ---------------------------------------------------------------------------
 
 const server = http.createServer(async (req, res) => {
+  let pathname = '';
   try {
     const url = new URL(req.url, 'http://localhost');
-    const pathname = url.pathname;
+    pathname = url.pathname;
+
+    // 探活端点：反代/uptime 监控（Caddy health、Uptime Kuma 等）直接 GET 即可，
+    // 不参与签名鉴权，只回固定 { ok: true }，不暴露任何状态与数据
+    if (req.method === 'GET' && pathname === '/health') {
+      return json(res, 200, { ok: true });
+    }
 
     if (pathname.startsWith('/api/')) {
-      // 先验签（读原始 body 计算摘要），通过后才进入业务路由
-      const auth = await verifyRestSignature(req, pathname);
+      // 验签失败限流：超阈值直接拒，不再读 body 做 HMAC，防止刷 401 耗资源
+      if (authLimitExceeded(req.socket.remoteAddress)) {
+        return json(res, 429, { error: 'auth failures rate limited' });
+      }
+      // 先验签（读原始 body 计算摘要），通过后才进入业务路由；
+      // 密钥按路由角色选择（见 secretsForPath）
+      const auth = await verifyRestSignature(req, secretsForPath(pathname));
       if (!auth.ok) {
+        recordAuthFailure(req.socket.remoteAddress);
         console.warn(
           `[server] 拒绝请求 ${req.method} ${pathname}，来源 ${req.socket.remoteAddress}：${auth.reason}`,
         );
         return json(res, 401, { error: 'unauthorized' });
       }
-      return await handleApi(req, res, pathname, auth.rawBody);
+      return await handleApi(req, res, pathname, auth.rawBody, auth.workerId);
     }
 
     if (req.method === 'GET') return serveStatic(req, res, pathname);
 
     return json(res, 405, { error: 'method not allowed' });
   } catch (err) {
-    return json(res, err.statusCode || (err.message === 'invalid json' ? 400 : 500), {
-      error: err.message || 'internal error',
-    });
+    const statusCode = err.statusCode || (err.message === 'invalid json' ? 400 : 500);
+    if (statusCode >= 500) {
+      // 内部异常只记服务端日志，响应不外泄细节（可能含路径等内部信息）
+      console.error(`[server] 请求处理异常 ${req.method} ${pathname}: ${err.stack || err.message}`);
+      return json(res, 500, { error: 'internal error' });
+    }
+    return json(res, statusCode, { error: err.message || 'bad request' });
   }
 });
 
@@ -681,7 +826,9 @@ const server = http.createServer(async (req, res) => {
 // WebSocket 连接管理
 // ---------------------------------------------------------------------------
 
-const wss = new WebSocketServer({ noServer: true });
+// maxPayload：限制单帧 1MiB（pty 单帧输出/输入远小于此），
+// 杜绝默认 100MiB 大帧配合广播造成的内存放大
+const wss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
 
 wss.on('connection', (ws, req) => {
   const remote = req.socket.remoteAddress;
@@ -704,12 +851,14 @@ wss.on('connection', (ws, req) => {
         ws.close(4002, 'bad auth message');
         return;
       }
-      // 签名鉴权：sig = HMAC(密钥, "WS\nTS\nNONCE")，同样走时间窗 + nonce 防重放
+      // 签名鉴权：sig = HMAC(密钥, "WS\nTS\nNONCE")，同样走时间窗 + nonce 防重放；
+      // 控制台通道只认控制台密钥
       const result = verifySignature(
         ['WS', String(msg.ts), String(msg.nonce)],
         msg.ts,
         msg.nonce,
         msg.sig,
+        API_SECRET,
       );
       if (!result.ok) {
         console.warn(`[server] 拒绝 WS 连接，来源 ${remote}：${result.reason}`);
@@ -787,7 +936,7 @@ wss.on('connection', (ws, req) => {
 
 // --- Worker 通道 /worker/ws：鉴权方式同 /ws；鉴权后下发 task.available，
 // 并承载 pty 会话上行消息（session.started/output/exited）---
-const workerWss = new WebSocketServer({ noServer: true });
+const workerWss = new WebSocketServer({ noServer: true, maxPayload: 1024 * 1024 });
 
 workerWss.on('connection', (ws, req) => {
   const remote = req.socket.remoteAddress;
@@ -809,24 +958,45 @@ workerWss.on('connection', (ws, req) => {
         ws.close(4002, 'bad auth message');
         return;
       }
-      const result = verifySignature(
-        ['WS', String(msg.ts), String(msg.nonce)],
-        msg.ts,
-        msg.nonce,
-        msg.sig,
-      );
+      // Worker 通道只认 Worker 侧密钥：控制台密钥泄露不能冒充 Worker 领任务。
+      // 逐一尝试 WORKER_AUTH 条目；命中 workerSecrets 绑定密钥时身份以绑定
+      // 为准（自报 workerId 不一致即拒绝），共享密钥为兼容路径（身份自报）
+      let result = { ok: false, reason: '缺少签名头' };
+      let boundId = null;
+      for (const entry of WORKER_AUTH) {
+        result = verifySignature(
+          ['WS', String(msg.ts), String(msg.nonce)],
+          msg.ts,
+          msg.nonce,
+          msg.sig,
+          entry.secret,
+        );
+        if (result.ok) {
+          boundId = entry.workerId;
+          break;
+        }
+      }
       if (!result.ok) {
         console.warn(`[server] 拒绝 Worker WS 连接，来源 ${remote}：${result.reason}`);
         ws.close(4003, 'auth failed');
         return;
       }
       clearTimeout(authTimer);
+      const claimedId = String(msg.workerId || 'unknown').slice(0, 128);
+      if (boundId && claimedId !== boundId) {
+        console.warn(
+          `[server] 拒绝 Worker WS 连接，来源 ${remote}：workerId "${claimedId}" 与密钥绑定身份 "${boundId}" 不一致`,
+        );
+        ws.close(4003, 'identity mismatch');
+        return;
+      }
       ws.isAuthed = true;
-      ws.workerId = String(msg.workerId || 'unknown').slice(0, 128);
+      ws.workerId = boundId || claimedId;
       wsWorkers.add(ws);
       console.log(`[server] Worker ${ws.workerId} 通道已连接（来源 ${remote}）`);
       // 断线窗口内可能已有积压任务，连接建立即补一次通知
-      if (state.tasks.some((t) => t.status === 'pending')) {
+      // （只推指向本 Worker 或未指定目标的，避免无关 Worker 空领）
+      if (state.tasks.some((t) => t.status === 'pending' && (!t.targetWorker || t.targetWorker === ws.workerId))) {
         ws.send(JSON.stringify({ type: 'task.available' }));
       }
       return;
@@ -918,4 +1088,16 @@ server.listen(PORT, () => {
   console.log(`[server] kite API listening on :${PORT}`);
   console.log(`[server] config file: ${CONFIG_FILE}`);
   console.log(`[server] data dir: ${DATA_DIR}`);
+  const boundEntries = WORKER_AUTH.filter((e) => e.workerId);
+  const sharedEntry = WORKER_AUTH.find((e) => !e.workerId);
+  let authMode;
+  if (boundEntries.length) {
+    authMode = `多 Worker 密钥（${boundEntries.map((e) => e.workerId).join(', ')}` +
+      `${sharedEntry ? '，另有共享 workerSecret' : ''}）`;
+  } else if (sharedEntry && sharedEntry.secret === API_SECRET) {
+    authMode = '单密钥（控制台与 Worker 共用 apiSecret）';
+  } else {
+    authMode = '双密钥（控制台/Worker 已分离）';
+  }
+  console.log(`[server] auth mode: ${authMode}`);
 });