@yoooclaw/phone-notifications 1.7.2 → 1.7.5

package/README.md

@@ -50,13 +50,13 @@ OpenClaw / QClaw 手机通知同步插件：接收手机通知并写入本地 JS
 ### 通过 OpenClaw CLI 安装（OpenClaw）
 
 ```bash
-openclaw plugin install @yoooclaw/phone-notifications
+openclaw plugins install @yoooclaw/phone-notifications
 ```
 
 ### 更新
 
 ```bash
-openclaw plugin update @yoooclaw/phone-notifications
+openclaw plugins update @yoooclaw/phone-notifications
 ```
 
 ### 通过一键脚本安装（推荐给 QClaw，备选给 OpenClaw）
@@ -321,6 +321,10 @@ openclaw ntf monitor delete boss-alert --yes
 ### 灯效控制
 
 ```bash
+
+# 启用灯效控制工具
+openclaw ntf light setup
+
 # 直接发送灯效指令到硬件设备（需要先 set-api-key）
 openclaw ntf light send \
   --segments '[{"mode":"wave","duration_s":4,"brightness":192,"color":{"r":255,"g":0,"b":0}}]'

package/dist/index.js

@@ -3647,8 +3647,8 @@ var require_websocket_server = __commonJS({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync14 } from "fs";
-import { basename as basename2, dirname as dirname6 } from "path";
+import { readFileSync as readFileSync15 } from "fs";
+import { basename as basename2, dirname as dirname7 } from "path";
 
 // src/light/protocol.ts
 var MAX_LIGHT_SEGMENTS = 12;
@@ -5271,16 +5271,93 @@ function registerLightSend(light) {
   });
 }
 
+// src/cli/light-setup-tools.ts
+import { existsSync as existsSync11, mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
+import { homedir } from "os";
+import { dirname as dirname4, join as join8 } from "path";
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function ensureArray(obj, key) {
+  const current = obj[key];
+  if (Array.isArray(current)) return current;
+  const next = [];
+  obj[key] = next;
+  return next;
+}
+function resolveConfigPath2() {
+  const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
+  if (fromEnv) return fromEnv;
+  return join8(homedir(), ".openclaw", "openclaw.json");
+}
+function upsertLightControlAlsoAllow(cfg) {
+  if (!isObject(cfg.tools)) cfg.tools = {};
+  const toolsAlsoAllow = ensureArray(cfg.tools, "alsoAllow");
+  const hasGlobal = toolsAlsoAllow.includes("light_control");
+  if (!hasGlobal) toolsAlsoAllow.push("light_control");
+  if (!isObject(cfg.agents)) cfg.agents = {};
+  const agents = cfg.agents;
+  const list = ensureArray(agents, "list");
+  let mainAgent = list.find(
+    (item) => isObject(item) && item.id === "main"
+  );
+  if (!mainAgent) {
+    mainAgent = { id: "main" };
+    list.push(mainAgent);
+  }
+  if (!isObject(mainAgent.tools)) mainAgent.tools = {};
+  const mainAlsoAllow = ensureArray(mainAgent.tools, "alsoAllow");
+  const hasMain = mainAlsoAllow.includes("light_control");
+  if (!hasMain) mainAlsoAllow.push("light_control");
+  return {
+    globalChanged: !hasGlobal,
+    mainAgentChanged: !hasMain
+  };
+}
+function registerLightSetupTools(light) {
+  light.command("setup").description("\u81EA\u52A8\u653E\u884C light_control\uFF08\u5199\u5165 tools.alsoAllow \u4E0E agents.main.tools.alsoAllow\uFF09").action(() => {
+    const configPath = resolveConfigPath2();
+    if (!existsSync11(configPath)) {
+      exitError("CONFIG_NOT_FOUND", `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
+    }
+    let cfg = {};
+    try {
+      const raw = readFileSync10(configPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (isObject(parsed)) cfg = parsed;
+    } catch (err) {
+      exitError("CONFIG_INVALID", `\u8BFB\u53D6/\u89E3\u6790\u914D\u7F6E\u5931\u8D25: ${err?.message ?? String(err)}`);
+    }
+    const result = upsertLightControlAlsoAllow(cfg);
+    try {
+      mkdirSync6(dirname4(configPath), { recursive: true });
+      writeFileSync8(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+    } catch (err) {
+      exitError("WRITE_FAILED", `\u5199\u5165\u914D\u7F6E\u5931\u8D25: ${err?.message ?? String(err)}`);
+    }
+    output({
+      ok: true,
+      configPath,
+      changed: result.globalChanged || result.mainAgentChanged,
+      updates: {
+        toolsAlsoAllow: result.globalChanged ? "added" : "already_exists",
+        mainAgentAlsoAllow: result.mainAgentChanged ? "added" : "already_exists"
+      },
+      next: "\u8BF7\u6267\u884C: openclaw gateway restart"
+    });
+  });
+}
+
 // src/cli/tunnel-status.ts
-import { existsSync as existsSync11, readFileSync as readFileSync10 } from "fs";
-import { join as join8 } from "path";
-var STATUS_REL_PATH = join8("plugins", "phone-notifications", "tunnel-status.json");
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
+import { join as join9 } from "path";
+var STATUS_REL_PATH = join9("plugins", "phone-notifications", "tunnel-status.json");
 function readTunnelStatus(ctx) {
   if (!ctx.stateDir) return null;
-  const filePath = join8(ctx.stateDir, STATUS_REL_PATH);
-  if (!existsSync11(filePath)) return null;
+  const filePath = join9(ctx.stateDir, STATUS_REL_PATH);
+  if (!existsSync12(filePath)) return null;
   try {
-    return JSON.parse(readFileSync10(filePath, "utf-8"));
+    return JSON.parse(readFileSync11(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -5348,17 +5425,17 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-import { existsSync as existsSync12, readFileSync as readFileSync11, readdirSync as readdirSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync12, readdirSync as readdirSync4 } from "fs";
+import { join as join10 } from "path";
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = join9(
+    const dir = join10(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if (existsSync12(dir)) return dir;
+    if (existsSync13(dir)) return dir;
   }
   return null;
 }
@@ -5373,9 +5450,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = join9(dir, `${dateKey}.log`);
-  if (!existsSync12(filePath)) return;
-  const content = readFileSync11(filePath, "utf-8");
+  const filePath = join10(dir, `${dateKey}.log`);
+  if (!existsSync13(filePath)) return;
+  const content = readFileSync12(filePath, "utf-8");
   const lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -5441,12 +5518,12 @@ function registerEnvCli(ntf) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 function readPluginVersion() {
   try {
     const packageJsonUrl = new URL("../package.json", import.meta.url);
     const packageJson = JSON.parse(
-      readFileSync12(packageJsonUrl, "utf-8")
+      readFileSync13(packageJsonUrl, "utf-8")
     );
     return packageJson.version ?? "unknown";
   } catch {
@@ -5465,6 +5542,7 @@ function registerAllCli(program, ctx, rootCommandName = "ntf") {
   registerNtfMonitor(ntf, ctx);
   const light = registerLightRules(ntf, ctx);
   registerLightSend(light);
+  registerLightSetupTools(light);
   registerNtfStoragePath(ntf, ctx);
   registerLogSearch(ntf, ctx);
   registerTunnelStatus(ntf, ctx);
@@ -5474,17 +5552,17 @@ function registerAllCli(program, ctx, rootCommandName = "ntf") {
 // src/tunnel/service.ts
 import {
   closeSync,
-  mkdirSync as mkdirSync7,
+  mkdirSync as mkdirSync8,
   openSync,
-  readFileSync as readFileSync13,
+  readFileSync as readFileSync14,
   unlinkSync,
-  writeFileSync as writeFileSync9
+  writeFileSync as writeFileSync10
 } from "fs";
-import { dirname as dirname5, join as join10 } from "path";
+import { dirname as dirname6, join as join11 } from "path";
 
 // src/tunnel/relay-client.ts
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
-import { dirname as dirname4 } from "path";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync7 } from "fs";
+import { dirname as dirname5 } from "path";
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -5526,8 +5604,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      mkdirSync6(dirname4(this.opts.statusFilePath), { recursive: true });
-      writeFileSync8(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      mkdirSync7(dirname5(this.opts.statusFilePath), { recursive: true });
+      writeFileSync9(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {
     }
   }
@@ -5856,11 +5934,96 @@ function buildDeviceAuthPayload(params) {
     params.nonce
   ].join("|");
 }
-function resolveStateDir2() {
-  return resolveStateDir();
+function resolveClientStateDir(stateDir) {
+  return stateDir ?? resolveStateDir();
+}
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+function resolveIdentityPath(stateDir) {
+  return path.join(stateDir, "identity", "device.json");
 }
-function loadOrCreateDeviceIdentity() {
-  const filePath = path.join(resolveStateDir2(), "identity", "device.json");
+function normalizeDeviceAuthRole(role) {
+  return role.trim();
+}
+function normalizeDeviceAuthScopes(scopes) {
+  const out = /* @__PURE__ */ new Set();
+  for (const scope of scopes) {
+    const trimmed = scope.trim();
+    if (trimmed) {
+      out.add(trimmed);
+    }
+  }
+  return [...out].sort();
+}
+function resolveDeviceAuthPath(stateDir) {
+  return path.join(stateDir, "identity", "device-auth.json");
+}
+function readDeviceAuthStore(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1 || typeof parsed.deviceId !== "string") return null;
+    if (!parsed.tokens || typeof parsed.tokens !== "object") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeDeviceAuthStore(filePath, store) {
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+`, {
+    mode: 384
+  });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+}
+function loadDeviceAuthToken(params) {
+  const store = readDeviceAuthStore(resolveDeviceAuthPath(params.stateDir));
+  if (!store || store.deviceId !== params.deviceId) return null;
+  const entry = store.tokens[normalizeDeviceAuthRole(params.role)];
+  if (!entry || typeof entry.token !== "string") return null;
+  return entry;
+}
+function storeDeviceAuthToken(params) {
+  const filePath = resolveDeviceAuthPath(params.stateDir);
+  const existing = readDeviceAuthStore(filePath);
+  const role = normalizeDeviceAuthRole(params.role);
+  const next = {
+    version: 1,
+    deviceId: params.deviceId,
+    tokens: existing && existing.deviceId === params.deviceId && existing.tokens ? { ...existing.tokens } : {}
+  };
+  const entry = {
+    token: params.token,
+    role,
+    scopes: normalizeDeviceAuthScopes(params.scopes),
+    updatedAtMs: Date.now()
+  };
+  next.tokens[role] = entry;
+  writeDeviceAuthStore(filePath, next);
+  return entry;
+}
+function clearDeviceAuthToken(params) {
+  const filePath = resolveDeviceAuthPath(params.stateDir);
+  const store = readDeviceAuthStore(filePath);
+  if (!store || store.deviceId !== params.deviceId) return;
+  const role = normalizeDeviceAuthRole(params.role);
+  if (!store.tokens[role]) return;
+  const next = {
+    version: 1,
+    deviceId: store.deviceId,
+    tokens: { ...store.tokens }
+  };
+  delete next.tokens[role];
+  writeDeviceAuthStore(filePath, next);
+}
+function loadOrCreateDeviceIdentity(stateDir) {
+  const filePath = resolveIdentityPath(stateDir);
   try {
     if (fs.existsSync(filePath)) {
       const raw = fs.readFileSync(filePath, "utf8");
@@ -5890,6 +6053,7 @@ function loadOrCreateDeviceIdentity() {
     ...identity,
     createdAtMs: Date.now()
   };
+  ensureDir(filePath);
   fs.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
@@ -5899,7 +6063,8 @@ function loadOrCreateDeviceIdentity() {
 var TunnelProxy = class _TunnelProxy {
   constructor(opts) {
     this.opts = opts;
-    this.deviceIdentity = loadOrCreateDeviceIdentity();
+    this.stateDir = resolveClientStateDir(opts.stateDir);
+    this.deviceIdentity = loadOrCreateDeviceIdentity(this.stateDir);
     opts.logger.info(
       `TunnelProxy: loaded device identity (deviceId=${this.deviceIdentity.deviceId})`
     );
@@ -5915,6 +6080,7 @@ var TunnelProxy = class _TunnelProxy {
   gatewayWsPending = [];
   /** 设备身份，用于 Gateway connect 握手 */
   deviceIdentity;
+  stateDir;
   pushGatewayPending(payload, reason) {
     this.gatewayWsPending.push(payload);
     this.opts.logger.info(
@@ -5932,6 +6098,65 @@ var TunnelProxy = class _TunnelProxy {
       password
     };
   }
+  loadStoredDeviceToken(role) {
+    return loadDeviceAuthToken({
+      stateDir: this.stateDir,
+      deviceId: this.deviceIdentity.deviceId,
+      role
+    })?.token ?? void 0;
+  }
+  buildGatewayConnectAuth(role) {
+    const explicitAuth = this.resolveGatewayConnectAuth();
+    const authPassword = explicitAuth?.password?.trim() || void 0;
+    const explicitGatewayToken = explicitAuth?.token?.trim() || void 0;
+    const deviceToken = explicitGatewayToken ? void 0 : this.loadStoredDeviceToken(role);
+    const authToken = explicitGatewayToken ?? deviceToken;
+    const auth = authToken || authPassword || deviceToken ? {
+      token: authToken,
+      deviceToken,
+      password: authPassword
+    } : void 0;
+    return {
+      auth,
+      authToken,
+      authPassword,
+      deviceToken
+    };
+  }
+  storeIssuedDeviceToken(params) {
+    const token = params.authInfo?.deviceToken;
+    if (typeof token !== "string" || !token.trim()) {
+      return;
+    }
+    const role = typeof params.authInfo?.role === "string" && params.authInfo.role.trim() ? params.authInfo.role.trim() : params.fallbackRole;
+    const scopes = Array.isArray(params.authInfo?.scopes) ? params.authInfo.scopes.filter(
+      (scope) => typeof scope === "string" && !!scope.trim()
+    ) : params.fallbackScopes;
+    storeDeviceAuthToken({
+      stateDir: this.stateDir,
+      deviceId: this.deviceIdentity.deviceId,
+      role,
+      token: token.trim(),
+      scopes
+    });
+  }
+  maybeClearStoredDeviceTokenOnMismatch(code, reason) {
+    const explicitAuth = this.resolveGatewayConnectAuth();
+    if (explicitAuth?.token || explicitAuth?.password) {
+      return;
+    }
+    if (code !== 1008 || !reason.toLowerCase().includes("device token mismatch")) {
+      return;
+    }
+    clearDeviceAuthToken({
+      stateDir: this.stateDir,
+      deviceId: this.deviceIdentity.deviceId,
+      role: "operator"
+    });
+    this.opts.logger.warn(
+      `TunnelProxy: cleared stale stored device token after gateway mismatch (deviceId=${this.deviceIdentity.deviceId})`
+    );
+  }
   buildLocalGatewayAuthAttempts(baseHeaders) {
     const auth = this.resolveGatewayConnectAuth();
     const attempts = [];
@@ -6101,12 +6326,12 @@ var TunnelProxy = class _TunnelProxy {
       if (frame.type === "event" && frame.event === "connect.challenge") {
         const challengeNonce = frame.payload?.nonce ?? "";
         const connectRequestId = `tunnel-connect-${randomUUID2()}`;
-        const gatewayAuth = this.resolveGatewayConnectAuth();
-        this.opts.logger.info(
-          `TunnelProxy: received connect.challenge (nonce=${challengeNonce}, connectReqId=${connectRequestId}, hasToken=${!!gatewayAuth?.token}, hasPassword=${!!gatewayAuth?.password}), sending connect request with device identity`
-        );
         const role = "operator";
         const scopes = ["operator.admin"];
+        const gatewayConnectAuth = this.buildGatewayConnectAuth(role);
+        this.opts.logger.info(
+          `TunnelProxy: received connect.challenge (nonce=${challengeNonce}, connectReqId=${connectRequestId}, hasToken=${!!gatewayConnectAuth.authToken}, hasPassword=${!!gatewayConnectAuth.authPassword}, hasDeviceToken=${!!gatewayConnectAuth.deviceToken}), sending connect request with device identity`
+        );
         const signedAtMs = Date.now();
         const clientId = "gateway-client";
         const clientMode = "backend";
@@ -6117,7 +6342,7 @@ var TunnelProxy = class _TunnelProxy {
           role,
           scopes,
           signedAtMs,
-          token: gatewayAuth?.token ?? null,
+          token: gatewayConnectAuth.authToken ?? null,
           nonce: challengeNonce
         });
         const signature = signDevicePayload(
@@ -6139,7 +6364,7 @@ var TunnelProxy = class _TunnelProxy {
             },
             role,
             scopes,
-            ...gatewayAuth ? { auth: gatewayAuth } : {},
+            ...gatewayConnectAuth.auth ? { auth: gatewayConnectAuth.auth } : {},
             device: {
               id: this.deviceIdentity.deviceId,
               publicKey: publicKeyRawBase64UrlFromPem(
@@ -6155,6 +6380,11 @@ var TunnelProxy = class _TunnelProxy {
         return;
       }
       if (frame.type === "res" && frame.ok === true && frame.payload?.type === "hello-ok") {
+        this.storeIssuedDeviceToken({
+          fallbackRole: "operator",
+          fallbackScopes: ["operator.admin"],
+          authInfo: frame.payload?.auth
+        });
         this.gatewayWsReady = true;
         this.gatewayWsConnecting = false;
         this.opts.logger.info(
@@ -6178,14 +6408,16 @@ var TunnelProxy = class _TunnelProxy {
     ws.on("close", (code, reason) => {
       const wasReady = this.gatewayWsReady;
       const pendingCount = this.gatewayWsPending.length;
+      const reasonText = reason.toString();
       this.opts.logger.info(
-        `TunnelProxy: RPC WS closed by gateway (code=${code}, reason=${reason.toString()}, ready=${wasReady}, pending=${pendingCount}, activeWs=${this.wsConnections.size})`
+        `TunnelProxy: RPC WS closed by gateway (code=${code}, reason=${reasonText}, ready=${wasReady}, pending=${pendingCount}, activeWs=${this.wsConnections.size})`
       );
       if (this.gatewayWs === ws) {
         this.gatewayWs = null;
         this.gatewayWsReady = false;
       }
       this.gatewayWsConnecting = false;
+      this.maybeClearStoredDeviceTokenOnMismatch(code, reasonText);
     });
     ws.on("error", (err) => {
       this.opts.logger.warn(
@@ -6444,7 +6676,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse(readFileSync13(filePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync14(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -6469,11 +6701,11 @@ function createTunnelService(opts) {
     }
   }
   function acquireLock(filePath) {
-    mkdirSync7(dirname5(filePath), { recursive: true });
+    mkdirSync8(dirname6(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
         const fd = openSync(filePath, "wx", 384);
-        writeFileSync9(
+        writeFileSync10(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -6530,12 +6762,12 @@ function createTunnelService(opts) {
         return;
       }
       const { logger } = opts;
-      const baseStateDir = join10(ctx.stateDir, "plugins", "phone-notifications");
+      const baseStateDir = join11(ctx.stateDir, "plugins", "phone-notifications");
       logger.info(
         `Relay tunnel: starting (pid=${process.pid}, url=${opts.tunnelUrl}, heartbeat=${opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC}s, backoff=${opts.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS}ms, gateway=${opts.gatewayBaseUrl}, hasGatewayToken=${!!opts.gatewayToken}, hasGatewayPwd=${!!opts.gatewayPassword})`
       );
-      const statusFilePath = join10(baseStateDir, "tunnel-status.json");
-      const lockPath = join10(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = join11(baseStateDir, "tunnel-status.json");
+      const lockPath = join11(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
@@ -6549,6 +6781,7 @@ function createTunnelService(opts) {
           logger
         });
         proxy = new TunnelProxy({
+          stateDir: baseStateDir,
           gatewayBaseUrl: opts.gatewayBaseUrl,
           gatewayAuthMode: opts.gatewayAuthMode,
           gatewayToken: opts.gatewayToken,
@@ -6583,13 +6816,13 @@ function createTunnelService(opts) {
 }
 
 // src/logger.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "fs";
-import { join as join11 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync9 } from "fs";
+import { join as join12 } from "path";
 var PluginFileLogger = class {
   constructor(upstream, stateDir) {
     this.upstream = upstream;
-    this.logsDir = join11(stateDir, "plugins", "phone-notifications", "logs");
-    mkdirSync8(this.logsDir, { recursive: true });
+    this.logsDir = join12(stateDir, "plugins", "phone-notifications", "logs");
+    mkdirSync9(this.logsDir, { recursive: true });
   }
   logsDir;
   info(msg) {
@@ -6611,7 +6844,7 @@ var PluginFileLogger = class {
     const line = `${time} [${level}] ${msg}
 `;
     try {
-      appendFileSync2(join11(this.logsDir, `${dateKey}.log`), line);
+      appendFileSync2(join12(this.logsDir, `${dateKey}.log`), line);
     } catch {
     }
   }
@@ -6657,7 +6890,7 @@ function resolveLocalGatewayAuth(params) {
   const configPath = params.stateDir ? resolveConfigPath(params.stateDir) : void 0;
   if (configPath) {
     try {
-      const configData = JSON.parse(readFileSync14(configPath, "utf-8"));
+      const configData = JSON.parse(readFileSync15(configPath, "utf-8"));
       const rawGatewayAuthMode = trimToUndefined2(configData?.gateway?.auth?.mode);
       if (rawGatewayAuthMode === "token" || rawGatewayAuthMode === "password") {
         configGatewayAuthMode = rawGatewayAuthMode;
@@ -6935,7 +7168,7 @@ var index_default = {
       if (openclawDir) return openclawDir;
       if (!workspaceDir) return void 0;
       if (basename2(workspaceDir) !== "workspace") return void 0;
-      return dirname6(workspaceDir);
+      return dirname7(workspaceDir);
     };
     api.registerCli(
       (ctx) => {