nikou-cli 0.1.6 → 0.1.8

package/README.md

@@ -162,6 +162,8 @@ Hook 支持三种启动模式：
 
 主节点负责连接聊天平台、接收消息、维护 Worker 列表并分发任务。从节点负责连接主节点，收到任务后调用 Codex、Claude 或 Gemini 执行。
 
+群聊发送 `@机器人 绑定: <目录>` 时，主节点会先检查当前用户是否已经绑定该目录；已有绑定会直接返回结果，未绑定则只把路径校验任务发给该用户自己的在线 Worker。一个群可以保留多个用户、多个目录的 Agent 绑定，绑定指令不会广播给其他 Worker 抢占。
+
 ### 初始化配置
 
 ```bash
@@ -177,6 +179,8 @@ ai-hook local
 
 初始化时会提示部署方式和主节点地址。没有远端主节点配置时默认选择本机一体，并使用 `127.0.0.1`；如果旧配置里已有非本机主节点地址，默认选择从节点并沿用该地址。
 
+单独从节点连接已有主节点时，不要求配置主节点专用的 `hook.bind_allowed_user_ids`。本机一体或单独启动主节点时，仍必须至少配置一个允许绑定的飞书 `user_id`。
+
 `ai-hook` 裸命令为兼容旧习惯，仍默认等价于 `nikou-cli hook worker codex`；如需只启动 Claude Worker：
 
 ```bash

package/dist/index.js

@@ -912,7 +912,7 @@ function pad3(str, width) {
 
 // src/hook/master/master-command.ts
 import * as lark2 from "@larksuiteoapi/node-sdk";
-import fs8 from "fs";
+import fs7 from "fs";
 import path8 from "path";
 import process4 from "process";
 
@@ -975,7 +975,7 @@ var CARD_STREAM_STDOUT_MAX_LENGTH = 12e3;
 var BIND_WHITELIST_REFRESH_MS = 5e3;
 
 // src/hook/utils.ts
-import fs2 from "fs";
+import fs from "fs";
 import os2 from "os";
 import path2 from "path";
 import process2 from "process";
@@ -1029,9 +1029,9 @@ function resolveAiHookGuestPath() {
 }
 function resolveOpsUserName() {
   const propsPath = path2.join(os2.homedir(), "ops", "ops_global.properties");
-  if (!fs2.existsSync(propsPath)) return "\u672A\u77E5";
+  if (!fs.existsSync(propsPath)) return "\u672A\u77E5";
   try {
-    const lines = fs2.readFileSync(propsPath, "utf-8").split(/\r?\n/);
+    const lines = fs.readFileSync(propsPath, "utf-8").split(/\r?\n/);
     for (const line of lines) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1056,8 +1056,8 @@ function resolveCardPathDisplay(dirPath) {
   return `${segments[segments.length - 2]}\\${segments[segments.length - 1]}`;
 }
 function ensureDirExists(dirPath) {
-  if (!fs2.existsSync(dirPath)) {
-    fs2.mkdirSync(dirPath, { recursive: true });
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
   }
 }
 function normalizeHost(value) {
@@ -1369,7 +1369,7 @@ function formatCompactTokenCount(value) {
 }
 
 // src/hook/config-loader.ts
-import fs3 from "fs";
+import fs2 from "fs";
 
 // src/hook/json-config.ts
 function stripJsonLineComments(content) {
@@ -1413,7 +1413,7 @@ function parseJsonWithLineComments(content, filePath = "JSON \u914D\u7F6E") {
 // src/hook/config-loader.ts
 function resolveConfigPath(role = "worker") {
   const configPath = role === "master" ? MASTER_CONFIG_PATH : WORKER_CONFIG_PATH;
-  return fs3.existsSync(configPath) ? configPath : null;
+  return fs2.existsSync(configPath) ? configPath : null;
 }
 function loadRoleConfig(role) {
   const configPath = resolveConfigPath(role);
@@ -1427,7 +1427,7 @@ function loadRoleConfig(role) {
 ` + sampleBody + "}"
     );
   }
-  const raw = fs3.readFileSync(configPath, "utf-8");
+  const raw = fs2.readFileSync(configPath, "utf-8");
   const config = parseJsonWithLineComments(raw, configPath);
   return { config, configPath };
 }
@@ -1597,7 +1597,7 @@ function resolveAuthConfig(config) {
 }
 
 // src/hook/state-manager.ts
-import fs4 from "fs";
+import fs3 from "fs";
 import path3 from "path";
 import process3 from "process";
 var StateManager = class {
@@ -1609,13 +1609,13 @@ var StateManager = class {
     this.logger = logger3;
   }
   read() {
-    if (!fs4.existsSync(this.statePath)) {
+    if (!fs3.existsSync(this.statePath)) {
       this.state = null;
       return null;
     }
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const raw = fs4.readFileSync(this.statePath, "utf-8");
+        const raw = fs3.readFileSync(this.statePath, "utf-8");
         this.state = JSON.parse(raw);
         return this.state;
       } catch (error) {
@@ -1634,13 +1634,13 @@ var StateManager = class {
     const tempPath = `${this.statePath}.tmp.${process3.pid}`;
     try {
       ensureDirExists(path3.dirname(this.statePath));
-      fs4.writeFileSync(tempPath, JSON.stringify(nextState, null, 4));
-      fs4.renameSync(tempPath, this.statePath);
+      fs3.writeFileSync(tempPath, JSON.stringify(nextState, null, 4));
+      fs3.renameSync(tempPath, this.statePath);
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
       this.logger.warn(`\u5199\u5165\u72B6\u6001\u6587\u4EF6\u5931\u8D25: ${msg}`);
       try {
-        if (fs4.existsSync(tempPath)) fs4.unlinkSync(tempPath);
+        if (fs3.existsSync(tempPath)) fs3.unlinkSync(tempPath);
       } catch (cleanupError) {
         const cmsg = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
         this.logger.warn(`\u6E05\u7406\u4E34\u65F6\u72B6\u6001\u6587\u4EF6\u5931\u8D25: ${cmsg}`);
@@ -3041,7 +3041,10 @@ var TaskManager = class {
     }
     if (task.status !== "pending") {
       this.logger.info(
-        formatTraceLog(task.traceId, `\u8BA4\u9886\u88AB\u62D2\u7EDD\uFF1A\u4EFB\u52A1\u5DF2\u88AB\u8BA4\u9886 worker=${workerMeta.workerId}`)
+        formatTraceLog(
+          task.traceId,
+          `\u8BA4\u9886\u88AB\u62D2\u7EDD\uFF1A\u4EFB\u52A1\u5DF2\u88AB\u8BA4\u9886 claimed_worker=${task.claimedWorkerId || "-"}, rejected_worker=${workerMeta.workerId}`
+        )
       );
       return false;
     }
@@ -3909,7 +3912,7 @@ var DirectWorkerRegistry = class {
 };
 
 // src/hook/master/routing/chat-binding-registry.ts
-import fs5 from "fs";
+import fs4 from "fs";
 import path4 from "path";
 function normalize2(value) {
   return String(value || "").trim();
@@ -3970,12 +3973,12 @@ var ChatBindingRegistry = class {
   }
   load() {
     this.bindings.clear();
-    if (!fs5.existsSync(this.filePath)) {
+    if (!fs4.existsSync(this.filePath)) {
       this.save();
       return;
     }
     try {
-      const parsed = JSON.parse(fs5.readFileSync(this.filePath, "utf-8") || "{}");
+      const parsed = JSON.parse(fs4.readFileSync(this.filePath, "utf-8") || "{}");
       for (const [chatId, value] of Object.entries(parsed.bindings || {})) {
         const normalizedChatId = normalize2(chatId);
         if (!normalizedChatId || !value || typeof value !== "object") {
@@ -4003,7 +4006,7 @@ var ChatBindingRegistry = class {
     }
   }
   save() {
-    fs5.mkdirSync(path4.dirname(this.filePath), { recursive: true });
+    fs4.mkdirSync(path4.dirname(this.filePath), { recursive: true });
     const bindings = {};
     for (const [chatId, chatMap] of this.bindings.entries()) {
       const serialized = {};
@@ -4012,7 +4015,7 @@ var ChatBindingRegistry = class {
       }
       bindings[chatId] = serialized;
     }
-    fs5.writeFileSync(
+    fs4.writeFileSync(
       this.filePath,
       `${JSON.stringify({ version: 2, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), bindings }, null, 2)}
 `,
@@ -4028,6 +4031,15 @@ var ChatBindingRegistry = class {
   getByKey(chatId, bindingKey) {
     return this.bindings.get(normalize2(chatId))?.get(normalize2(bindingKey)) || null;
   }
+  /** 按群、绑定用户和目录查找普通绑定，供绑定指令做幂等校验。 */
+  getNormalBinding(chatId, ownerUserId, dirPath) {
+    const owner = normalize2(ownerUserId);
+    const dir = normalize2(dirPath);
+    if (!owner || !dir) {
+      return null;
+    }
+    return this.listByChat(chatId).find((binding) => binding.kind === "normal" && binding.ownerUserId === owner && binding.dirPath === dir) || null;
+  }
   /** 返回全部绑定记录（扁平） */
   list() {
     const all = [];
@@ -4136,7 +4148,7 @@ var ChatBindingRegistry = class {
 };
 
 // src/hook/master/routing/worker-diagnostics-registry.ts
-import fs6 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 function normalize3(value) {
   return String(value || "").trim();
@@ -4161,12 +4173,12 @@ var WorkerDiagnosticsRegistry = class {
   }
   load() {
     this.workers.clear();
-    if (!fs6.existsSync(this.filePath)) {
+    if (!fs5.existsSync(this.filePath)) {
       this.save();
       return;
     }
     try {
-      const parsed = JSON.parse(fs6.readFileSync(this.filePath, "utf-8") || "{}");
+      const parsed = JSON.parse(fs5.readFileSync(this.filePath, "utf-8") || "{}");
       for (const [workerId, diagnostics] of Object.entries(safeObject(parsed.workers))) {
         const normalizedWorkerId = normalize3(diagnostics.workerId || workerId);
         const registryKey = buildRegistryKey({
@@ -4198,12 +4210,12 @@ var WorkerDiagnosticsRegistry = class {
     }
   }
   save() {
-    fs6.mkdirSync(path5.dirname(this.filePath), { recursive: true });
+    fs5.mkdirSync(path5.dirname(this.filePath), { recursive: true });
     const workers = {};
     for (const [key, diagnostics] of this.workers.entries()) {
       workers[key] = diagnostics;
     }
-    fs6.writeFileSync(
+    fs5.writeFileSync(
       this.filePath,
       `${JSON.stringify({ version: 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), workers }, null, 2)}
 `,
@@ -4252,7 +4264,7 @@ var WorkerDiagnosticsRegistry = class {
 };
 
 // src/hook/master/master-event-utils.ts
-import fs7 from "fs";
+import fs6 from "fs";
 import os3 from "os";
 import path6 from "path";
 var VOPS_USER_CACHE_PATH = path6.join(os3.homedir(), "ops", "vops_user.json");
@@ -4339,11 +4351,11 @@ function isTaskOperatorMatched(task, operatorUserId, operatorOpenId) {
 function resolveSenderNameFromCache(senderUserId, senderOpenId = "") {
   const targetUserId = String(senderUserId || "").trim();
   const targetOpenId = String(senderOpenId || "").trim();
-  if (!targetUserId && !targetOpenId || !fs7.existsSync(VOPS_USER_CACHE_PATH)) {
+  if (!targetUserId && !targetOpenId || !fs6.existsSync(VOPS_USER_CACHE_PATH)) {
     return "";
   }
   try {
-    const parsed = JSON.parse(fs7.readFileSync(VOPS_USER_CACHE_PATH, "utf-8"));
+    const parsed = JSON.parse(fs6.readFileSync(VOPS_USER_CACHE_PATH, "utf-8"));
     const entries = Array.isArray(parsed) ? parsed : [];
     const matched = entries.find((item) => {
       if (!item || typeof item !== "object" || item.__cacheType) {
@@ -5231,7 +5243,7 @@ var HookMasterCommand = class {
     if (masterConfig.botName) {
       this.botName = masterConfig.botName;
     }
-    const configStat = fs8.statSync(configPath);
+    const configStat = fs7.statSync(configPath);
     this.bindWhitelistConfigMtimeMs = Number(configStat.mtimeMs || 0);
     this.chatBindingRegistry.load();
     this.workerDiagnosticsRegistry.load();
@@ -5356,9 +5368,17 @@ var HookMasterCommand = class {
     const bindCmd = parseBindingCommand(text);
     if (bindCmd.matched) {
       this.logger.info(formatMasterTraceLog(messageId, `\u4E3B\u8282\u70B9\u547D\u4E2D\u7ED1\u5B9A\u6307\u4EE4: chat_id=${chatId}, target=${bindCmd.target}`));
-      if (!this.handleBindCommand(chatId, messageId, senderId, bindCmd.target)) {
-        return;
-      }
+      await this.handleBindCommand({
+        data,
+        message,
+        chatId,
+        chatType,
+        messageId,
+        senderId,
+        senderOpenId,
+        target: bindCmd.target
+      });
+      return;
     }
     const stopCmd = parseStopCommand(text);
     if (stopCmd.matched) {
@@ -5378,8 +5398,7 @@ var HookMasterCommand = class {
       chatType,
       senderId,
       senderOpenId,
-      text,
-      isBindingCommand: bindCmd.matched
+      text
     });
   }
   async dispatchFeishuTask(input) {
@@ -5409,10 +5428,6 @@ var HookMasterCommand = class {
       } else {
         this.logger.warn(formatMasterTraceLog(input.messageId, `\u5355\u804A\u4EFB\u52A1\u672A\u5339\u914D\u5230\u4ECE\u8282\u70B9: task_id=${task.taskId}, requester=${input.senderId || "-"}, chat_id=${input.chatId || "-"}`));
       }
-    } else if (input.isBindingCommand) {
-      this.wsServer.broadcast(buildTaskOffer(task, eventKey, input.data));
-      delivered = this.wsServer.getWorkerCount();
-      this.logger.info(formatMasterTraceLog(input.messageId, `\u7ED1\u5B9A\u6307\u4EE4\u5DF2\u5E7F\u64AD\u7ED9\u4ECE\u8282\u70B9\u5339\u914D\u76EE\u5F55: task_id=${task.taskId}, chat_id=${input.chatId || "-"}, delivered=${delivered}, message_id=${input.messageId}`));
     } else {
       await this.groupRouteDispatcher?.dispatch(task, input.text);
       return;
@@ -5433,16 +5448,54 @@ var HookMasterCommand = class {
       () => this.messageResponder?.replyNoWorker(task)
     );
   }
-  handleBindCommand(chatId, messageId, senderId, target) {
+  async handleBindCommand(input) {
+    const { chatId, messageId, senderId, target } = input;
+    const replyInThread = resolveReplyInThread(input.message);
     if (this.bindAllowedUserIds.length > 0 && !this.bindAllowedUserIds.includes(senderId)) {
-      void this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u5F53\u524D\u7528\u6237\u4E0D\u5728\u7ED1\u5B9A\u767D\u540D\u5355", messageId, resolveReplyInThread({
-        chat_id: chatId,
-        message_id: messageId
-      }));
-      return false;
+      await this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u5F53\u524D\u7528\u6237\u4E0D\u5728\u7ED1\u5B9A\u767D\u540D\u5355", messageId, replyInThread);
+      return;
     }
-    this.logger.info(formatMasterTraceLog(messageId, `\u7ED1\u5B9A\u6307\u4EE4\u6821\u9A8C\u901A\u8FC7\uFF0C\u7EE7\u7EED\u4E0B\u53D1\u5230\u4ECE\u8282\u70B9: chat_id=${chatId}, target=${target}`));
-    return true;
+    if (!target) {
+      await this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u8BF7\u6307\u5B9A\u7ED1\u5B9A\u8DEF\u5F84", messageId, replyInThread);
+      return;
+    }
+    const existing = this.chatBindingRegistry.getNormalBinding(chatId, senderId, target);
+    if (existing) {
+      this.logger.info(formatMasterTraceLog(messageId, `\u4E3B\u8282\u70B9\u547D\u4E2D\u5DF2\u6709\u7FA4\u804A\u7ED1\u5B9A: chat_id=${chatId}, worker=${existing.workerId}, owner_user_id=${senderId}, dir=${target}`));
+      await this.messageResponder?.replyText(chatId, `\u5DF2\u7ED1\u5B9A\u5230: ${target}`, messageId, replyInThread);
+      return;
+    }
+    if (!this.taskManager || !this.wsServer) {
+      return;
+    }
+    const workerId = this.workerRegistry.getWorkerIdByOwner(senderId);
+    if (!workerId) {
+      this.logger.warn(formatMasterTraceLog(messageId, `\u7ED1\u5B9A\u5931\u8D25\uFF0C\u672A\u627E\u5230\u53D1\u8D77\u4EBA\u7684\u5728\u7EBF\u4ECE\u8282\u70B9: chat_id=${chatId}, owner_user_id=${senderId}, dir=${target}`));
+      await this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u672A\u627E\u5230\u4F60\u7684\u5728\u7EBF\u4ECE\u8282\u70B9\uFF0C\u8BF7\u5148\u542F\u52A8 ai-hook", messageId, replyInThread);
+      return;
+    }
+    const eventKey = "im.message.receive_v1";
+    const task = this.taskManager.createTaskRecord(input.data, messageId, eventKey, {
+      chatId,
+      chatType: input.chatType,
+      requesterUserId: senderId,
+      requesterOpenId: input.senderOpenId,
+      responseMode: "card",
+      routeMode: "direct_group",
+      replyInThread
+    });
+    task.targetWorkerId = workerId;
+    const delivered = this.wsServer.sendTo(workerId, buildTaskOffer(task, eventKey, input.data));
+    if (!delivered) {
+      this.taskManager.cleanupTask(task.taskId);
+      await this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u4F60\u7684\u4ECE\u8282\u70B9\u5F53\u524D\u4E0D\u53EF\u7528\uFF0C\u8BF7\u91CD\u65B0\u542F\u52A8 ai-hook", messageId, replyInThread);
+      return;
+    }
+    this.logger.info(formatMasterTraceLog(messageId, `\u7ED1\u5B9A\u6307\u4EE4\u5DF2\u5B9A\u5411\u4E0B\u53D1: task_id=${task.taskId}, chat_id=${chatId}, owner_user_id=${senderId}, worker=${workerId}, dir=${target}`));
+    this.taskManager.scheduleClaimTimeout(
+      task.taskId,
+      () => this.messageResponder?.replyText(chatId, "\u7ED1\u5B9A\u5931\u8D25\uFF1A\u4ECE\u8282\u70B9\u54CD\u5E94\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5", messageId, replyInThread)
+    );
   }
   async handleBotMenuEvent(data) {
     const event = data?.event || data;
@@ -5753,8 +5806,8 @@ var HookMasterCommand = class {
   }
   refreshBindWhitelistIfNeeded() {
     try {
-      if (!this.configPath || !fs8.existsSync(this.configPath)) return;
-      const stat = fs8.statSync(this.configPath);
+      if (!this.configPath || !fs7.existsSync(this.configPath)) return;
+      const stat = fs7.statSync(this.configPath);
       const mtimeMs = Number(stat.mtimeMs || 0);
       if (!mtimeMs || mtimeMs <= this.bindWhitelistConfigMtimeMs) return;
       const { config } = loadMasterHstMcpConfig();
@@ -5836,11 +5889,11 @@ var HookMasterCommand = class {
 };
 
 // src/hook/logger.ts
-import fs9 from "fs";
+import fs8 from "fs";
 import path9 from "path";
 function ensureLogsDir() {
-  if (!fs9.existsSync(LOGS_DIR)) {
-    fs9.mkdirSync(LOGS_DIR, { recursive: true });
+  if (!fs8.existsSync(LOGS_DIR)) {
+    fs8.mkdirSync(LOGS_DIR, { recursive: true });
   }
 }
 function todaySuffix() {
@@ -5851,8 +5904,8 @@ function timestamp() {
 }
 function appendLine(filePath, line) {
   try {
-    fs9.mkdirSync(path9.dirname(filePath), { recursive: true });
-    fs9.appendFileSync(filePath, line + "\n", "utf-8");
+    fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
+    fs8.appendFileSync(filePath, line + "\n", "utf-8");
   } catch {
   }
 }
@@ -5877,22 +5930,22 @@ function resolveServiceLogName(role) {
 }
 function ensureCurrentLogLink(currentPath, dailyPath) {
   try {
-    fs9.mkdirSync(path9.dirname(currentPath), { recursive: true });
-    fs9.mkdirSync(path9.dirname(dailyPath), { recursive: true });
-    fs9.writeFileSync(dailyPath, "", { flag: "a" });
-    if (fs9.existsSync(currentPath)) {
-      const stat = fs9.lstatSync(currentPath);
+    fs8.mkdirSync(path9.dirname(currentPath), { recursive: true });
+    fs8.mkdirSync(path9.dirname(dailyPath), { recursive: true });
+    fs8.writeFileSync(dailyPath, "", { flag: "a" });
+    if (fs8.existsSync(currentPath)) {
+      const stat = fs8.lstatSync(currentPath);
       if (!stat.isSymbolicLink()) {
         const legacyDir = path9.join(path9.dirname(currentPath), "logs", "legacy");
-        fs9.mkdirSync(legacyDir, { recursive: true });
+        fs8.mkdirSync(legacyDir, { recursive: true });
         const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-        fs9.renameSync(currentPath, path9.join(legacyDir, `${path9.basename(currentPath)}.${stamp}`));
+        fs8.renameSync(currentPath, path9.join(legacyDir, `${path9.basename(currentPath)}.${stamp}`));
       }
     }
-    fs9.rmSync(currentPath, { force: true });
-    fs9.symlinkSync(dailyPath, currentPath);
+    fs8.rmSync(currentPath, { force: true });
+    fs8.symlinkSync(dailyPath, currentPath);
   } catch {
-    fs9.writeFileSync(currentPath, "", { flag: "a" });
+    fs8.writeFileSync(currentPath, "", { flag: "a" });
   }
 }
 function createLogger(name, verbose = false) {
@@ -5957,12 +6010,15 @@ import os17 from "os";
 import path27 from "path";
 import * as lark3 from "@larksuiteoapi/node-sdk";
 
+// src/hook/worker/message-strategy.ts
+import fs14 from "fs";
+
 // src/hook/worker/runners/codex-runner.ts
 import process7 from "process";
 import { spawn, spawnSync as spawnSync4 } from "child_process";
 
 // src/hook/runtime-env.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import process5 from "process";
 import { spawnSync as spawnSync2 } from "child_process";
 var HST_MCP_DISABLED_MODULES_ENV_KEY = "HST_MCP_DISABLED_MODULES";
@@ -6007,11 +6063,11 @@ function parseEnvFileContent(content = "") {
   return env;
 }
 function loadRuntimeEnvFile(filePath = RUNTIME_ENV_PATH) {
-  if (!filePath || !fs10.existsSync(filePath)) {
+  if (!filePath || !fs9.existsSync(filePath)) {
     return {};
   }
   try {
-    return parseEnvFileContent(fs10.readFileSync(filePath, "utf-8"));
+    return parseEnvFileContent(fs9.readFileSync(filePath, "utf-8"));
   } catch {
     return {};
   }
@@ -6023,7 +6079,7 @@ function resolveUnixShell(baseEnv = process5.env) {
     "/bin/bash",
     "/bin/sh"
   ].filter(Boolean);
-  return candidates.find((item) => fs10.existsSync(item)) || "/bin/sh";
+  return candidates.find((item) => fs9.existsSync(item)) || "/bin/sh";
 }
 function parseNullSeparatedEnv(output = "") {
   const env = {};
@@ -6144,23 +6200,23 @@ function buildHookRuntimeEnv(baseEnv = process5.env, {
 }
 
 // src/hook/worker/runners/command-resolver.ts
-import fs11 from "fs";
+import fs10 from "fs";
 import path10 from "path";
 import process6 from "process";
 import { spawnSync as spawnSync3 } from "child_process";
 function isExecutableFile(filePath) {
-  if (!filePath || !fs11.existsSync(filePath)) {
+  if (!filePath || !fs10.existsSync(filePath)) {
     return false;
   }
   try {
-    const stat = fs11.statSync(filePath);
+    const stat = fs10.statSync(filePath);
     if (!stat.isFile()) {
       return false;
     }
     if (process6.platform === "win32") {
       return true;
     }
-    fs11.accessSync(filePath, fs11.constants.X_OK);
+    fs10.accessSync(filePath, fs10.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -6705,7 +6761,7 @@ command=${execConfig.displayCommand}`));
 };
 
 // src/hook/context/identity-resolver.ts
-import fs12 from "fs";
+import fs11 from "fs";
 import os5 from "os";
 import path11 from "path";
 
@@ -6910,12 +6966,12 @@ var IdentityResolver = class {
     if (Array.isArray(this.cache)) {
       return this.cache;
     }
-    if (!fs12.existsSync(this.cachePath)) {
+    if (!fs11.existsSync(this.cachePath)) {
       this.cache = [];
       return this.cache;
     }
     try {
-      const parsed = JSON.parse(fs12.readFileSync(this.cachePath, "utf-8"));
+      const parsed = JSON.parse(fs11.readFileSync(this.cachePath, "utf-8"));
       const input = Array.isArray(parsed) ? parsed : [];
       this.cache = this.dedupeCacheEntries(input);
       if (this.cache.length !== input.length) {
@@ -6932,7 +6988,7 @@ var IdentityResolver = class {
   saveCache() {
     try {
       this.cache = this.dedupeCacheEntries(this.cache || []);
-      fs12.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
+      fs11.writeFileSync(this.cachePath, JSON.stringify(this.cache, null, 2));
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.warn(`\u5199\u5165 vops_user.json \u5931\u8D25: ${message}`);
@@ -7265,7 +7321,7 @@ var IdentityResolver = class {
 };
 
 // src/hook/prompt/nikou-prompt-store.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import os6 from "os";
 import path12 from "path";
 
@@ -7320,7 +7376,7 @@ function normalizeText2(value) {
   return String(value || "").trim();
 }
 function ensureDir(dirPath) {
-  fs13.mkdirSync(dirPath, { recursive: true });
+  fs12.mkdirSync(dirPath, { recursive: true });
 }
 function parseFrontmatter(content) {
   const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
@@ -7367,18 +7423,18 @@ ${body}
 ` : "\n"}`;
 }
 function readTextFile(filePath) {
-  if (!fs13.existsSync(filePath)) {
+  if (!fs12.existsSync(filePath)) {
     return "";
   }
   try {
-    return fs13.readFileSync(filePath, "utf-8").trim();
+    return fs12.readFileSync(filePath, "utf-8").trim();
   } catch {
     return "";
   }
 }
 function writeTextFile(filePath, content) {
   ensureDir(path12.dirname(filePath));
-  fs13.writeFileSync(filePath, content, "utf-8");
+  fs12.writeFileSync(filePath, content, "utf-8");
 }
 function buildPromptDefinitions() {
   const roleDefinitions = Object.entries(REQUESTER_PERSONA_RULES.roles).map(([roleKey, roleConfig]) => ({
@@ -7439,7 +7495,7 @@ var NikouPromptStore = class {
     return definition.defaultContent.trim();
   }
   readPromptFile(definition) {
-    if (!fs13.existsSync(definition.path)) {
+    if (!fs12.existsSync(definition.path)) {
       const content = this.resolveBootstrapContent(definition);
       const file = {
         title: definition.title,
@@ -7450,7 +7506,7 @@ var NikouPromptStore = class {
       this.syncLegacyFiles(definition, file);
       return file;
     }
-    return parseFrontmatter(fs13.readFileSync(definition.path, "utf-8"));
+    return parseFrontmatter(fs12.readFileSync(definition.path, "utf-8"));
   }
   syncLegacyFiles(definition, file) {
     if (!definition.legacyPaths.length) {
@@ -7463,7 +7519,7 @@ var NikouPromptStore = class {
     }
   }
   toSummary(definition, file) {
-    const stat = fs13.existsSync(definition.path) ? fs13.statSync(definition.path) : null;
+    const stat = fs12.existsSync(definition.path) ? fs12.statSync(definition.path) : null;
     return {
       id: definition.id,
       kind: definition.kind,
@@ -7544,7 +7600,7 @@ var NikouPromptStore = class {
 };
 
 // src/hook/worker/task-route-binding.ts
-import fs14 from "fs";
+import fs13 from "fs";
 import path13 from "path";
 function resolveTaskRouteDir(routeBinding, fallbackDir) {
   if (routeBinding) {
@@ -7553,7 +7609,7 @@ function resolveTaskRouteDir(routeBinding, fallbackDir) {
       return { dirPath: "", reason: "invalid_route_dir" };
     }
     try {
-      if (!fs14.statSync(dirPath2).isDirectory()) {
+      if (!fs13.statSync(dirPath2).isDirectory()) {
         return { dirPath: "", reason: "invalid_route_dir" };
       }
     } catch {
@@ -8323,10 +8379,9 @@ ${question}` : question;
     if (!bindTarget) {
       return { ...baseTask, canHandle: true, type: "quick_result", quickResult: "\u8BF7\u6307\u5B9A\u7ED1\u5B9A\u8DEF\u5F84\uFF0C\u683C\u5F0F: \u7ED1\u5B9A:/path/to/project" };
     }
-    if (!fs.existsSync(bindTarget)) {
+    if (!fs14.existsSync(bindTarget)) {
       return { ...baseTask, canHandle: true, type: "quick_result", quickResult: `\u8DEF\u5F84\u4E0D\u5B58\u5728: ${bindTarget}` };
     }
-    this.stateManager.rebindChatToDir(message.chatId, bindTarget);
     const bindAt = (/* @__PURE__ */ new Date()).toISOString();
     const pathDisplay = resolveCardPathDisplay(bindTarget);
     this.logger.info(formatTraceLog(baseTask.traceId, `\u7ED1\u5B9A\u6210\u529F: chatId=${message.chatId} -> ${bindTarget}`));
@@ -9759,7 +9814,15 @@ var SlaveRelayClient = class {
         this.resolvePendingClaim(packet.task_id, false);
         break;
       case "task_offer":
-        this.handleTaskOffer(packet);
+        void this.handleTaskOffer(packet).catch((error) => {
+          const taskId = String(packet.task_id || "").trim();
+          const traceId = resolveTraceId(taskId);
+          const message = error instanceof Error ? error.message : String(error);
+          this.logger.error(formatTraceLog(
+            traceId,
+            `\u5904\u7406\u4EFB\u52A1 offer \u5931\u8D25: task_id=${taskId || "-"}, error=${message}`
+          ));
+        });
         break;
       case "task_cancel": {
         const cancelResult = this.taskExecutor.cancelTask(packet.task_id);
@@ -9945,6 +10008,7 @@ var SlaveRelayClient = class {
     if (!chatId || !dirPath) {
       return;
     }
+    this.stateManager.rebindChatToDir(chatId, dirPath);
     this.send({
       type: "binding_update",
       worker_id: this.workerId,
@@ -14000,6 +14064,7 @@ import { execFile, spawn as spawn4 } from "child_process";
 import { createRequire } from "module";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
+var MISSING_CLI_AUTH_SECRET_ERROR = "\u672A\u914D\u7F6E CLI_AUTH_SECRET\uFF0C\u65E0\u6CD5\u62C9\u53D6 Nacos \u540C\u6B65\u8BA1\u5212";
 var NacosSubscriptionSyncCoordinator = class {
   logger;
   workerId;
@@ -14008,12 +14073,15 @@ var NacosSubscriptionSyncCoordinator = class {
   daemon = null;
   running = false;
   stopped = false;
+  missingCliAuthSecretWarned = false;
   status;
+  resolveAuthRuntimeConfig;
   statePath = path26.join(os16.homedir(), ".nikou-block", "worker", "nacos-subscriptions.json");
   constructor(options) {
     this.logger = options.logger;
     this.workerId = options.workerId;
     this.config = options.config;
+    this.resolveAuthRuntimeConfig = options.resolveAuthRuntimeConfig || resolveCliAuthRuntimeConfig;
     this.status = {
       enabled: this.config.enabled,
       configured: false,
@@ -14081,15 +14149,20 @@ var NacosSubscriptionSyncCoordinator = class {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.status.lastError = message;
-      this.logger.warn(`Nacos Skill \u8BA2\u9605\u540C\u6B65\u5931\u8D25: ${message}`);
+      if (message !== MISSING_CLI_AUTH_SECRET_ERROR || !this.missingCliAuthSecretWarned) {
+        this.logger.warn(`Nacos Skill \u8BA2\u9605\u540C\u6B65\u5931\u8D25: ${message}`);
+      }
+      if (message === MISSING_CLI_AUTH_SECRET_ERROR) {
+        this.missingCliAuthSecretWarned = true;
+      }
     } finally {
       this.running = false;
     }
   }
   async fetchPlan() {
-    const runtime = resolveCliAuthRuntimeConfig();
+    const runtime = this.resolveAuthRuntimeConfig();
     if (!runtime.cliAuthSecret) {
-      throw new Error("\u672A\u914D\u7F6E CLI_AUTH_SECRET\uFF0C\u65E0\u6CD5\u62C9\u53D6 Nacos \u540C\u6B65\u8BA1\u5212");
+      throw new Error(MISSING_CLI_AUTH_SECRET_ERROR);
     }
     const response = await fetch(`${runtime.apiUrl}/worker-skills/nacos-sync/plan`, {
       method: "POST",
@@ -14104,7 +14177,7 @@ var NacosSubscriptionSyncCoordinator = class {
   }
   async report(results) {
     if (!results.length) return;
-    const runtime = resolveCliAuthRuntimeConfig();
+    const runtime = this.resolveAuthRuntimeConfig();
     const response = await fetch(`${runtime.apiUrl}/worker-skills/nacos-sync/report`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -14839,7 +14912,9 @@ function normalizeHookInitConfig(config, defaults = {}) {
   if (!appSecret) missing.push("feishu.app_secret");
   if (!masterHost) missing.push(`hook.master_host \u6216 ${DEFAULT_MASTER_HOST_ENV}`);
   if (!sharedSecret) missing.push("hook.shared_secret");
-  if (bindAllowedUserIds.length === 0) missing.push("hook.bind_allowed_user_ids");
+  if (defaults.deploymentMode !== "slave" && bindAllowedUserIds.length === 0) {
+    missing.push("hook.bind_allowed_user_ids");
+  }
   if (missing.length > 0) {
     throw new Error(`\u521D\u59CB\u5316\u6240\u9700\u914D\u7F6E\u7F3A\u5931: ${missing.join(", ")}`);
   }
@@ -14897,7 +14972,8 @@ var HookInitCommand = class {
       const defaultMasterHost = deploymentMode === "local" ? LOCAL_MASTER_HOST : deploymentDefaults.masterHost;
       const masterHost = await this.askMasterHost(rl, source.config, defaultMasterHost);
       const normalized = this.normalizeSourceConfig(
-        mergeHookInitMasterHost(source.config, masterHost)
+        mergeHookInitMasterHost(source.config, masterHost),
+        deploymentMode
       );
       const nextMasterConfig = this.buildMasterConfigPayload(normalized, botName);
       const nextWorkerConfig = this.buildWorkerConfigPayload(normalized, botName);
@@ -14969,9 +15045,10 @@ var HookInitCommand = class {
     }
     throw new Error(`\u672A\u627E\u5230\u53EF\u521D\u59CB\u5316\u7684\u914D\u7F6E\u6E90\uFF0C\u8BF7\u5148\u51C6\u5907 ${LEGACY_CONFIG_PATH}\u3001${DEFAULT_CONFIG_PATH} \u6216\u89D2\u8272\u914D\u7F6E\u6587\u4EF6`);
   }
-  normalizeSourceConfig(config) {
+  normalizeSourceConfig(config, deploymentMode) {
     return normalizeHookInitConfig(config, {
-      defaultMasterHost: resolveDefaultMasterHost()
+      defaultMasterHost: resolveDefaultMasterHost(),
+      deploymentMode
     });
   }
   printEnvironmentSummary(sourcePath, existingConfig, migrationSummary) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "nikou-cli",
-    "version": "0.1.6",
+    "version": "0.1.8",
     "description": "Install Agent Skills and MCP servers, and run distributed AI hook workers.",
     "type": "module",
     "bin": {