@yoooclaw/phone-notifications 1.5.2 → 1.6.1

package/dist/index.js

@@ -3647,8 +3647,8 @@ var require_websocket_server = __commonJS({
 });
 
 // src/index.ts
-import { readFileSync as readFileSync11 } from "fs";
-import { basename, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync13 } from "fs";
+import { basename as basename2, dirname as dirname5 } from "path";
 
 // src/light/protocol.ts
 var MAX_LIGHT_SEGMENTS = 12;
@@ -3791,12 +3791,62 @@ function quantizeWindow(value) {
 
 // src/light/sender.ts
 import { randomUUID } from "crypto";
-async function sendLightEffect(token, segments, logger, repeat) {
-  const apiUrl = "https://openclaw-service-dev.yoootek.com/api/message/tob/sendMessage";
+
+// src/env.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, dirname } from "path";
+var ENV_CONFIG = {
+  development: {
+    lightApiUrl: "https://openclaw-service-dev.yoootek.com/api/message/tob/sendMessage",
+    relayTunnelUrl: "wss://openclaw-service-dev.yoootek.com/message/messages/ws/plugin",
+    appNameMapUrl: "https://openclaw-service-dev.yoootek.com/api/application-config/app-package/config-all"
+  },
+  production: {
+    lightApiUrl: "https://openclaw-service.yoootek.com/api/message/tob/sendMessage",
+    relayTunnelUrl: "wss://openclaw-service.yoootek.com/message/messages/ws/plugin",
+    appNameMapUrl: "https://openclaw-service.yoootek.com/api/application-config/app-package/config-all"
+  }
+};
+var VALID_ENVS = new Set(Object.keys(ENV_CONFIG));
+function envFilePath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join(home, ".openclaw", "env.json");
+}
+function loadEnvName() {
+  const filePath = envFilePath();
+  if (!existsSync(filePath)) return "production";
+  try {
+    const data = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (data.env && VALID_ENVS.has(data.env)) return data.env;
+  } catch {
+  }
+  return "production";
+}
+function saveEnvName(env) {
+  if (!VALID_ENVS.has(env)) {
+    throw new Error(`\u65E0\u6548\u7684\u73AF\u5883\u540D\u79F0: ${env}\uFF0C\u53EF\u9009\u503C: ${[...VALID_ENVS].join(", ")}`);
+  }
+  const filePath = envFilePath();
+  mkdirSync(dirname(filePath), { recursive: true, mode: 448 });
+  writeFileSync(filePath, JSON.stringify({ env }, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function getEnvUrls(env) {
+  return ENV_CONFIG[env ?? loadEnvName()];
+}
+function getAvailableEnvs() {
+  return Object.keys(ENV_CONFIG);
+}
+
+// src/light/sender.ts
+async function sendLightEffect(apiKey, segments, logger, repeat) {
+  const apiUrl = getEnvUrls().lightApiUrl;
   const appKey = "7Q617S1G5WD274JI";
   const templateId = "1990771146010017788";
   logger?.info(
-    `Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "\u2026" : "UNSET"}, templateId=${templateId ?? "UNSET"}, token=${token ? token.substring(0, 20) + "\u2026" : "EMPTY"}, segments=${JSON.stringify(segments)}`
+    `Light sender: apiUrl=${apiUrl ?? "UNSET"}, appKey=${appKey ? appKey.substring(0, 8) + "\u2026" : "UNSET"}, templateId=${templateId ?? "UNSET"}, apiKey=${apiKey ? apiKey.substring(0, 20) + "\u2026" : "EMPTY"}, segments=${JSON.stringify(segments)}`
   );
   if (!apiUrl || !appKey || !templateId) {
     return {
@@ -3821,7 +3871,7 @@ async function sendLightEffect(token, segments, logger, repeat) {
     method: "POST",
     headers: {
       "Content-Type": "application/json",
-      Authorization: token.startsWith("Bearer ") ? token : `Bearer ${token}`
+      "X-Api-Key-Id": apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey
     },
     body: JSON.stringify(requestBody)
   });
@@ -3836,27 +3886,222 @@ async function sendLightEffect(token, segments, logger, repeat) {
   return { ok: true, bizUniqueId, response: JSON.parse(resBody) };
 }
 
+// src/notification/app-name-map.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/auth/credentials.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  writeFileSync as writeFileSync2,
+  watch
+} from "fs";
+import { join as join2, dirname as dirname2, basename } from "path";
+function credentialsPath() {
+  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
+  return join2(home, ".openclaw", "credentials.json");
+}
+function readCredentials() {
+  const path2 = credentialsPath();
+  if (!existsSync2(path2)) return {};
+  try {
+    return JSON.parse(readFileSync2(path2, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeCredentials(creds) {
+  const path2 = credentialsPath();
+  mkdirSync2(dirname2(path2), { recursive: true, mode: 448 });
+  writeFileSync2(path2, JSON.stringify(creds, null, 2), {
+    encoding: "utf-8",
+    mode: 384
+  });
+}
+function loadApiKey() {
+  const creds = readCredentials();
+  return creds.apiKey ?? creds.token;
+}
+function requireApiKey() {
+  const apiKey = loadApiKey();
+  if (!apiKey) {
+    throw new Error(
+      "API Key \u672A\u8BBE\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C openclaw ntf auth set-api-key <apiKey>\uFF08\u82E5 ntf \u547D\u4EE4\u51B2\u7A81\uFF0C\u53EF\u4F7F\u7528 openclaw phone-notifications auth set-api-key <apiKey>\uFF09"
+    );
+  }
+  return apiKey;
+}
+function watchCredentials(onChange) {
+  const path2 = credentialsPath();
+  const dir = dirname2(path2);
+  const filename = basename(path2);
+  let debounceTimer = null;
+  const delayMs = 200;
+  const listener = (_event, changedName) => {
+    if (!changedName || changedName !== filename && !changedName.endsWith(filename)) return;
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      debounceTimer = null;
+      onChange();
+    }, delayMs);
+  };
+  let watcher = null;
+  try {
+    watcher = watch(dir, { persistent: false }, listener);
+  } catch {
+  }
+  return () => {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    watcher?.close();
+  };
+}
+
+// src/notification/app-name-map.ts
+var PLUGIN_STATE_DIR = "phone-notifications";
+var CACHE_FILE = "app-name-map.json";
+var BUILTIN_APP_NAME_MAP_URL = getEnvUrls().appNameMapUrl;
+var APP_NAME_MAP_URL = ("".trim() ? "".trim() : void 0) ?? BUILTIN_APP_NAME_MAP_URL;
+var APP_NAME_MAP_REFRESH_HOURS = 12;
+function isRecordOfStrings(v) {
+  if (v === null || typeof v !== "object") return false;
+  for (const val of Object.values(v)) if (typeof val !== "string") return false;
+  return true;
+}
+function isAppNameMapApiResponse(v) {
+  if (v === null || typeof v !== "object") return false;
+  const o = v;
+  return Array.isArray(o.data) && o.data.every(
+    (item) => item !== null && typeof item === "object" && typeof item.packageName === "string" && typeof item.appName === "string"
+  );
+}
+function getCachePath(stateDir) {
+  return join3(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+}
+function createAppNameMapProvider(opts) {
+  const { stateDir, logger } = opts;
+  const url = APP_NAME_MAP_URL;
+  const refreshHours = APP_NAME_MAP_REFRESH_HOURS;
+  const map = /* @__PURE__ */ new Map();
+  let refreshTimer = null;
+  let stopWatching = null;
+  let inFlightFetch = null;
+  function loadFromDisk() {
+    const path2 = getCachePath(stateDir);
+    if (!existsSync3(path2)) return;
+    try {
+      const raw = JSON.parse(readFileSync3(path2, "utf-8"));
+      if (!isRecordOfStrings(raw)) return;
+      map.clear();
+      for (const [k, v] of Object.entries(raw)) map.set(k, v);
+      logger.info(`[app-name-map] loaded ${map.size} entries from cache: ${path2}`);
+    } catch {
+    }
+  }
+  async function fetchFromServer() {
+    const apiKey = loadApiKey();
+    if (!url) {
+      logger.warn("[app-name-map] APP_NAME_MAP_URL is empty, skip refresh");
+      return;
+    }
+    if (!apiKey) {
+      logger.info("[app-name-map] api key missing, skip refresh");
+      return;
+    }
+    const rawApiKey = apiKey.startsWith("Bearer ") ? apiKey.slice("Bearer ".length) : apiKey;
+    try {
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "X-Api-Key-Id": rawApiKey },
+        body: JSON.stringify({
+          platform: ""
+        })
+      });
+      if (!res.ok) {
+        logger.warn(`[app-name-map] refresh failed: HTTP ${res.status} ${res.statusText}`);
+        return;
+      }
+      const body = await res.json();
+      if (!isAppNameMapApiResponse(body) || !body.success || !body.data?.length) {
+        logger.warn("[app-name-map] refresh failed: unexpected response shape or empty data");
+        return;
+      }
+      map.clear();
+      for (const item of body.data) {
+        if (item.packageName && item.appName) map.set(item.packageName, item.appName);
+      }
+      if (map.size === 0) {
+        logger.warn("[app-name-map] refresh succeeded but got 0 entries");
+        return;
+      }
+      const dir = join3(stateDir, "plugins", PLUGIN_STATE_DIR);
+      mkdirSync3(dir, { recursive: true });
+      const cachePath = getCachePath(stateDir);
+      writeFileSync3(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      logger.info(`[app-name-map] refreshed ${map.size} entries from server and saved: ${cachePath}`);
+    } catch (e) {
+      const message = e instanceof Error ? e.message : String(e);
+      logger.warn(`[app-name-map] refresh error: ${message}`);
+    }
+  }
+  async function ensureOneFetch() {
+    if (inFlightFetch) return inFlightFetch;
+    inFlightFetch = fetchFromServer().finally(() => {
+      inFlightFetch = null;
+    });
+    return inFlightFetch;
+  }
+  return {
+    async resolveDisplayName(packageName) {
+      if (map.has(packageName)) return map.get(packageName);
+      return packageName;
+    },
+    async start() {
+      loadFromDisk();
+      await fetchFromServer();
+      if (!url) return;
+      if (refreshHours > 0) {
+        const ms = refreshHours * 60 * 60 * 1e3;
+        refreshTimer = setInterval(() => fetchFromServer().catch(() => {
+        }), ms);
+      }
+      stopWatching = watchCredentials(() => fetchFromServer().catch(() => {
+      }));
+    },
+    stop() {
+      stopWatching?.();
+      stopWatching = null;
+      if (refreshTimer) {
+        clearInterval(refreshTimer);
+        refreshTimer = null;
+      }
+      map.clear();
+    }
+  };
+}
+
 // src/notification/storage.ts
 import {
   accessSync,
-  mkdirSync,
+  mkdirSync as mkdirSync4,
   appendFileSync,
   readdirSync,
-  readFileSync,
-  writeFileSync,
-  existsSync,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync4,
+  existsSync as existsSync4,
   rmSync,
   constants
 } from "fs";
-import { join } from "path";
+import { join as join4 } from "path";
 var NOTIFICATION_DIR_NAME = "notifications";
 var ID_INDEX_DIR_NAME = ".ids";
 function getStateFallbackNotificationDir(stateDir) {
-  return join(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
+  return join4(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
 }
 function ensureWritableDirectory(dir) {
   try {
-    mkdirSync(dir, { recursive: true });
+    mkdirSync4(dir, { recursive: true });
     accessSync(dir, constants.R_OK | constants.W_OK);
     return true;
   } catch {
@@ -3870,7 +4115,7 @@ function resolveNotificationStorageDir(ctx, logger) {
     return stateNotifDir;
   }
   if (ctx.workspaceDir) {
-    const workspaceDir = join(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
+    const workspaceDir = join4(ctx.workspaceDir, NOTIFICATION_DIR_NAME);
     if (ensureWritableDirectory(workspaceDir)) {
       logger.warn(
         `stateDir \u4E0D\u53EF\u7528\uFF0C\u901A\u77E5\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${workspaceDir}`
@@ -3881,53 +4126,58 @@ function resolveNotificationStorageDir(ctx, logger) {
   throw new Error(`\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528: ${stateNotifDir}`);
 }
 var NotificationStorage = class {
-  constructor(dir, config, logger) {
+  constructor(dir, config, logger, resolveDisplayName) {
     this.config = config;
     this.logger = logger;
     this.dir = dir;
-    this.idIndexDir = join(dir, ID_INDEX_DIR_NAME);
+    this.idIndexDir = join4(dir, ID_INDEX_DIR_NAME);
+    this.resolveDisplayName = resolveDisplayName;
   }
   dir;
   idIndexDir;
   idCache = /* @__PURE__ */ new Map();
+  resolveDisplayName;
   async init() {
-    mkdirSync(this.dir, { recursive: true });
-    mkdirSync(this.idIndexDir, { recursive: true });
+    mkdirSync4(this.dir, { recursive: true });
+    mkdirSync4(this.idIndexDir, { recursive: true });
   }
   async ingest(items) {
     for (const n of items) {
-      this.writeNotification(n);
+      await this.writeNotification(n);
     }
     this.prune();
   }
-  writeNotification(n) {
+  async writeNotification(n) {
     const ts = new Date(n.timestamp);
     if (Number.isNaN(ts.getTime())) {
       this.logger.warn(`\u5FFD\u7565\u975E\u6CD5 timestamp \u7684\u901A\u77E5: ${n.id}`);
       return;
     }
     const dateKey = this.formatDate(ts);
-    const filePath = join(this.dir, `${dateKey}.json`);
+    const filePath = join4(this.dir, `${dateKey}.json`);
     const normalizedId = typeof n.id === "string" ? n.id.trim() : "";
     if (normalizedId && this.hasNotificationId(dateKey, normalizedId)) {
       return;
     }
+    const appName = typeof n.app === "string" && n.app ? n.app : "Unknown";
+    const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(appName) : appName;
     const entry = {
-      appName: typeof n.app === "string" && n.app ? n.app : "Unknown",
+      appName,
+      appDisplayName,
       title: typeof n.title === "string" ? n.title : "",
       content: this.buildContent(n),
       timestamp: n.timestamp
     };
     let arr = [];
-    if (existsSync(filePath)) {
+    if (existsSync4(filePath)) {
       try {
-        arr = JSON.parse(readFileSync(filePath, "utf-8"));
+        arr = JSON.parse(readFileSync4(filePath, "utf-8"));
       } catch {
         arr = [];
       }
     }
     arr.push(entry);
-    writeFileSync(filePath, JSON.stringify(arr, null, 2), "utf-8");
+    writeFileSync4(filePath, JSON.stringify(arr, null, 2), "utf-8");
     if (normalizedId) {
       this.recordNotificationId(dateKey, normalizedId);
     }
@@ -3953,7 +4203,7 @@ var NotificationStorage = class {
     return `${year}-${month}-${day}`;
   }
   getIdIndexPath(dateKey) {
-    return join(this.idIndexDir, `${dateKey}.ids`);
+    return join4(this.idIndexDir, `${dateKey}.ids`);
   }
   getIdSet(dateKey) {
     const cached = this.idCache.get(dateKey);
@@ -3962,8 +4212,8 @@ var NotificationStorage = class {
     }
     const idPath = this.getIdIndexPath(dateKey);
     const ids = /* @__PURE__ */ new Set();
-    if (existsSync(idPath)) {
-      const lines = readFileSync(idPath, "utf-8").split(/\r?\n/);
+    if (existsSync4(idPath)) {
+      const lines = readFileSync4(idPath, "utf-8").split(/\r?\n/);
       for (const line of lines) {
         const id = line.trim();
         if (id) {
@@ -4002,10 +4252,10 @@ var NotificationStorage = class {
         if (entry.isFile()) {
           const match = dateFilePattern.exec(entry.name);
           if (match && match[1] < cutoffDate) {
-            rmSync(join(this.dir, entry.name), { force: true });
+            rmSync(join4(this.dir, entry.name), { force: true });
           }
         } else if (entry.isDirectory() && dateDirPattern.test(entry.name) && entry.name < cutoffDate) {
-          rmSync(join(this.dir, entry.name), { recursive: true, force: true });
+          rmSync(join4(this.dir, entry.name), { recursive: true, force: true });
         }
       }
     } catch {
@@ -4018,7 +4268,7 @@ var NotificationStorage = class {
         if (!entry.isFile()) continue;
         const match = /^(\d{4}-\d{2}-\d{2})\.ids$/.exec(entry.name);
         if (match && match[1] < cutoffDate) {
-          rmSync(join(this.idIndexDir, entry.name), { force: true });
+          rmSync(join4(this.idIndexDir, entry.name), { force: true });
           this.idCache.delete(match[1]);
         }
       }
@@ -4031,24 +4281,24 @@ var NotificationStorage = class {
 };
 
 // src/cli/auth.ts
-import { existsSync as existsSync4, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync6, rmSync as rmSync2 } from "fs";
 
 // src/cli/helpers.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync5, readdirSync as readdirSync2 } from "fs";
+import { join as join5 } from "path";
 function resolveNotificationsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = join2(
+    const dir = join5(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "notifications"
     );
-    if (existsSync2(dir)) return dir;
+    if (existsSync5(dir)) return dir;
   }
   if (ctx.workspaceDir) {
-    const dir = join2(ctx.workspaceDir, "notifications");
-    if (existsSync2(dir)) return dir;
+    const dir = join5(ctx.workspaceDir, "notifications");
+    if (existsSync5(dir)) return dir;
   }
   return null;
 }
@@ -4063,10 +4313,10 @@ function listDateKeys(dir) {
   return keys.sort().reverse();
 }
 function readDateFile(dir, dateKey) {
-  const filePath = join2(dir, `${dateKey}.json`);
-  if (!existsSync2(filePath)) return [];
+  const filePath = join5(dir, `${dateKey}.json`);
+  if (!existsSync5(filePath)) return [];
   try {
-    return JSON.parse(readFileSync2(filePath, "utf-8"));
+    return JSON.parse(readFileSync5(filePath, "utf-8"));
   } catch {
     return [];
   }
@@ -4096,76 +4346,44 @@ function exitError(code, message) {
   process.exit(1);
 }
 
-// src/auth/credentials.ts
-import {
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readFileSync as readFileSync3,
-  writeFileSync as writeFileSync2
-} from "fs";
-import { join as join3, dirname } from "path";
-function credentialsPath() {
-  const home = process.env.HOME || process.env.USERPROFILE || "/tmp";
-  return join3(home, ".openclaw", "credentials.json");
-}
-function readCredentials() {
-  const path2 = credentialsPath();
-  if (!existsSync3(path2)) return {};
-  try {
-    return JSON.parse(readFileSync3(path2, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeCredentials(creds) {
-  const path2 = credentialsPath();
-  mkdirSync2(dirname(path2), { recursive: true, mode: 448 });
-  writeFileSync2(path2, JSON.stringify(creds, null, 2), {
-    encoding: "utf-8",
-    mode: 384
-  });
-}
-function loadToken() {
-  return readCredentials().token;
-}
-function requireToken() {
-  const token = loadToken();
-  if (!token) {
-    throw new Error(
-      "Token \u672A\u8BBE\u7F6E\uFF0C\u8BF7\u5148\u6267\u884C openclaw ntf auth set-token <token>\uFF08\u82E5 ntf \u547D\u4EE4\u51B2\u7A81\uFF0C\u53EF\u4F7F\u7528 openclaw phone-notifications auth set-token <token>\uFF09"
-    );
-  }
-  return token;
-}
-
 // src/cli/auth.ts
 function registerAuthCli(program) {
   const auth = program.command("auth").description("\u7528\u6237\u8BA4\u8BC1\u7BA1\u7406");
-  auth.command("set-token <token>").description("\u8BBE\u7F6E\u7528\u6237 Token\uFF08\u6301\u4E45\u5316\u5230\u672C\u5730\u914D\u7F6E\uFF09").action((token) => {
-    writeCredentials({ ...readCredentials(), token });
+  auth.command("set-api-key <apiKey>").description("\u8BBE\u7F6E\u7528\u6237 API Key\uFF08\u6301\u4E45\u5316\u5230\u672C\u5730\u914D\u7F6E\uFF09").action((apiKey) => {
+    writeCredentials({ ...readCredentials(), apiKey, token: void 0 });
+    output({
+      ok: true,
+      apiKey: apiKey.slice(0, 8) + "\u2026",
+      storedAt: credentialsPath()
+    });
+  });
+  auth.command("set-token <token>").description("\uFF08\u517C\u5BB9\uFF09\u8BBE\u7F6E\u7528\u6237 API Key\uFF08\u65E7\u547D\u4EE4\u540D\uFF09").action((token) => {
+    writeCredentials({ ...readCredentials(), apiKey: token, token: void 0 });
     output({
       ok: true,
-      token: token.slice(0, 8) + "\u2026",
+      apiKey: token.slice(0, 8) + "\u2026",
       storedAt: credentialsPath()
     });
   });
   auth.command("show").description("\u67E5\u770B\u5F53\u524D\u8BA4\u8BC1\u72B6\u6001").action(() => {
     const creds = readCredentials();
-    if (creds.token) {
+    const apiKey = creds.apiKey ?? creds.token;
+    if (apiKey) {
       output({
         ok: true,
-        hasToken: true,
-        token: creds.token.slice(0, 8) + "\u2026",
+        hasApiKey: true,
+        apiKey: apiKey.slice(0, 8) + "\u2026",
         storedAt: credentialsPath()
       });
     } else {
-      output({ ok: true, hasToken: false });
+      output({ ok: true, hasApiKey: false });
     }
   });
   auth.command("clear").description("\u6E05\u9664\u5DF2\u4FDD\u5B58\u7684\u8BA4\u8BC1\u4FE1\u606F").action(() => {
     const path2 = credentialsPath();
-    if (existsSync4(path2)) {
+    if (existsSync6(path2)) {
       const creds = readCredentials();
+      delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
         rmSync2(path2, { force: true });
@@ -4263,22 +4481,22 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
-import { join as join4 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { join as join6 } from "path";
 function checkpointPath(dir) {
-  return join4(dir, ".checkpoint.json");
+  return join6(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!existsSync5(p)) return {};
+  if (!existsSync7(p)) return {};
   try {
-    return JSON.parse(readFileSync4(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  writeFileSync3(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  writeFileSync5(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
 }
 function registerNtfSync(ntf, ctx) {
   const sync = ntf.command("sync").description("\u540C\u6B65\u901A\u77E5\u5230\u8BB0\u5FC6\u7CFB\u7EDF");
@@ -4352,30 +4570,30 @@ function registerNtfSync(ntf, ctx) {
 
 // src/cli/ntf-monitor.ts
 import {
-  existsSync as existsSync6,
-  mkdirSync as mkdirSync3,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync7,
+  writeFileSync as writeFileSync6,
   rmSync as rmSync3,
   readdirSync as readdirSync3
 } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 function tasksDir(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base) throw new Error("workspaceDir and stateDir both unavailable");
-  return join5(base, "tasks");
+  return join7(base, "tasks");
 }
 function readMeta(taskDir) {
-  const metaPath = join5(taskDir, "meta.json");
-  if (!existsSync6(metaPath)) return null;
+  const metaPath = join7(taskDir, "meta.json");
+  if (!existsSync8(metaPath)) return null;
   try {
-    return JSON.parse(readFileSync5(metaPath, "utf-8"));
+    return JSON.parse(readFileSync7(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta(taskDir, meta) {
-  writeFileSync4(join5(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  writeFileSync6(join7(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateFetchPy(name, matchRules) {
   const appName = matchRules.appName || "";
@@ -4452,27 +4670,27 @@ function registerNtfMonitor(ntf, ctx) {
   const monitor = ntf.command("monitor").description("\u901A\u77E5\u76D1\u63A7\u4EFB\u52A1\u7BA1\u7406");
   monitor.command("list").description("\u5217\u51FA\u6240\u6709\u76D1\u63A7\u4EFB\u52A1").action(() => {
     const dir = tasksDir(ctx);
-    if (!existsSync6(dir)) {
+    if (!existsSync8(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
     for (const entry of readdirSync3(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const meta = readMeta(join5(dir, entry.name));
+      const meta = readMeta(join7(dir, entry.name));
       if (meta) tasks.push(meta);
     }
     output({ ok: true, tasks });
   });
   monitor.command("show <name>").description("\u67E5\u770B\u76D1\u63A7\u4EFB\u52A1\u8BE6\u60C5").action((name) => {
-    const taskDir = join5(tasksDir(ctx), name);
+    const taskDir = join7(tasksDir(ctx), name);
     const meta = readMeta(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
-    const checkpointPath2 = join5(taskDir, "checkpoint.json");
+    const checkpointPath2 = join7(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if (existsSync6(checkpointPath2)) {
+    if (existsSync8(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse(readFileSync5(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse(readFileSync7(checkpointPath2, "utf-8"));
       } catch {
       }
     }
@@ -4487,8 +4705,8 @@ function registerNtfMonitor(ntf, ctx) {
   monitor.command("create <name>").description("\u521B\u5EFA\u76D1\u63A7\u4EFB\u52A1").requiredOption("--description <text>", "\u4EFB\u52A1\u63CF\u8FF0").requiredOption("--match-rules <json>", "\u5339\u914D\u89C4\u5219 JSON").requiredOption("--schedule <cron>", "cron \u8868\u8FBE\u5F0F").action(
     (name, opts) => {
       const dir = tasksDir(ctx);
-      const taskDir = join5(dir, name);
-      if (existsSync6(taskDir)) {
+      const taskDir = join7(dir, name);
+      if (existsSync8(taskDir)) {
         exitError("ALREADY_EXISTS", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u5DF2\u5B58\u5728`);
       }
       let matchRules;
@@ -4500,7 +4718,7 @@ function registerNtfMonitor(ntf, ctx) {
           "match-rules \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON"
         );
       }
-      mkdirSync3(taskDir, { recursive: true });
+      mkdirSync5(taskDir, { recursive: true });
       const meta = {
         name,
         description: opts.description,
@@ -4510,13 +4728,13 @@ function registerNtfMonitor(ntf, ctx) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeMeta(taskDir, meta);
-      writeFileSync4(
-        join5(taskDir, "fetch.py"),
+      writeFileSync6(
+        join7(taskDir, "fetch.py"),
         generateFetchPy(name, matchRules),
         "utf-8"
       );
-      writeFileSync4(
-        join5(taskDir, "README.md"),
+      writeFileSync6(
+        join7(taskDir, "README.md"),
         generateReadme(name, opts.description),
         "utf-8"
       );
@@ -4544,8 +4762,8 @@ function registerNtfMonitor(ntf, ctx) {
     }
   );
   monitor.command("delete <name>").description("\u5220\u9664\u76D1\u63A7\u4EFB\u52A1").option("--yes", "\u8DF3\u8FC7\u786E\u8BA4").action((name, opts) => {
-    const taskDir = join5(tasksDir(ctx), name);
-    if (!existsSync6(taskDir)) {
+    const taskDir = join7(tasksDir(ctx), name);
+    if (!existsSync8(taskDir)) {
       exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     }
     if (!opts.yes) {
@@ -4570,7 +4788,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("\u542F\u7528\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = join5(tasksDir(ctx), name);
+    const taskDir = join7(tasksDir(ctx), name);
     const meta = readMeta(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = true;
@@ -4578,7 +4796,7 @@ function registerNtfMonitor(ntf, ctx) {
     output({ ok: true, name, enabled: true });
   });
   monitor.command("disable <name>").description("\u6682\u505C\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = join5(tasksDir(ctx), name);
+    const taskDir = join7(tasksDir(ctx), name);
     const meta = readMeta(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = false;
@@ -4588,8 +4806,8 @@ function registerNtfMonitor(ntf, ctx) {
 }
 
 // src/cli/light-rules.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join8 } from "path";
 
 // src/light/validators.ts
 var VALID_MODES = ["wave", "breath", "strobe", "steady", "wave_rainbow"];
@@ -4654,15 +4872,15 @@ var LIGHT_RULES_SECTION = "## \u706F\u6548\u89C4\u5219";
 function memoryPath(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base) throw new Error("workspaceDir and stateDir both unavailable");
-  return join6(base, "MEMORY.md");
+  return join8(base, "MEMORY.md");
 }
 function readMemory(ctx) {
   const p = memoryPath(ctx);
-  if (!existsSync7(p)) return "";
-  return readFileSync6(p, "utf-8");
+  if (!existsSync9(p)) return "";
+  return readFileSync8(p, "utf-8");
 }
 function writeMemory(ctx, content) {
-  writeFileSync5(memoryPath(ctx), content, "utf-8");
+  writeFileSync7(memoryPath(ctx), content, "utf-8");
 }
 function parseLightRules(content) {
   const rules = [];
@@ -4825,14 +5043,14 @@ function registerLightRules(program, ctx) {
 // src/cli/light-send.ts
 function registerLightSend(light) {
   light.command("send").description("\u53D1\u9001\u706F\u6548\u6307\u4EE4\u5230\u786C\u4EF6\u8BBE\u5907").requiredOption("--segments <json>", "\u706F\u6548\u53C2\u6570 JSON").option("--repeat", "\u65E0\u9650\u5FAA\u73AF\u64AD\u653E\uFF08\u9ED8\u8BA4\u4EC5\u64AD\u653E\u4E00\u8F6E\uFF09").action(async (opts) => {
-    let token;
+    let apiKey;
     try {
-      token = requireToken();
+      apiKey = requireApiKey();
     } catch (e) {
       exitError("AUTH_REQUIRED", e.message);
     }
     const segments = parseAndValidateSegments(opts.segments);
-    const result = await sendLightEffect(token, segments, void 0, opts.repeat);
+    const result = await sendLightEffect(apiKey, segments, void 0, opts.repeat);
     if (!result.ok) {
       exitError("HTTP_ERROR", `\u8BF7\u6C42\u5931\u8D25: ${result.status} ${result.error}`);
     }
@@ -4841,15 +5059,15 @@ function registerLightSend(light) {
 }
 
 // src/cli/tunnel-status.ts
-import { existsSync as existsSync8, readFileSync as readFileSync7 } from "fs";
-import { join as join7 } from "path";
-var STATUS_REL_PATH = join7("plugins", "phone-notifications", "tunnel-status.json");
+import { existsSync as existsSync10, readFileSync as readFileSync9 } 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 = join7(ctx.stateDir, STATUS_REL_PATH);
-  if (!existsSync8(filePath)) return null;
+  const filePath = join9(ctx.stateDir, STATUS_REL_PATH);
+  if (!existsSync10(filePath)) return null;
   try {
-    return JSON.parse(readFileSync7(filePath, "utf-8"));
+    return JSON.parse(readFileSync9(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -4870,18 +5088,18 @@ function formatMessage(status) {
 }
 function registerTunnelStatus(ntf, ctx) {
   ntf.command("tunnel-status").description("\u68C0\u67E5 Relay Tunnel \u96A7\u9053\u8FDE\u63A5\u72B6\u6001\uFF08\u8BFB\u53D6\u8FD0\u884C\u4E2D\u670D\u52A1\u7684\u72B6\u6001\u6587\u4EF6\uFF0C\u4E0D\u5F71\u54CD\u5DF2\u6709\u8FDE\u63A5\uFF09").action(async () => {
-    const tunnelUrl = "wss://openclaw-service-dev.yoootek.com/message/messages/ws/plugin";
-    const token = loadToken();
+    const tunnelUrl = getEnvUrls().relayTunnelUrl;
+    const apiKey = loadApiKey();
     if (!tunnelUrl) {
       exitError(
         "TUNNEL_NOT_CONFIGURED",
         "RELAY_TUNNEL_URL \u672A\u914D\u7F6E\uFF0C\u96A7\u9053\u529F\u80FD\u672A\u542F\u7528\u3002\u8BF7\u5728\u6784\u5EFA\u65F6\u8BBE\u7F6E RELAY_TUNNEL_URL \u73AF\u5883\u53D8\u91CF\u3002"
       );
     }
-    if (!token) {
+    if (!apiKey) {
       exitError(
         "TOKEN_MISSING",
-        "Token \u672A\u8BBE\u7F6E\uFF0C\u96A7\u9053\u65E0\u6CD5\u8FDE\u63A5\u3002\u8BF7\u6267\u884C openclaw ntf auth set-token <token>"
+        "API Key \u672A\u8BBE\u7F6E\uFF0C\u96A7\u9053\u65E0\u6CD5\u8FDE\u63A5\u3002\u8BF7\u6267\u884C openclaw ntf auth set-api-key <apiKey>"
       );
     }
     const status = readTunnelStatus(ctx);
@@ -4917,17 +5135,17 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-import { existsSync as existsSync9, readFileSync as readFileSync8, readdirSync as readdirSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync10, readdirSync as readdirSync4 } from "fs";
+import { join as join10 } from "path";
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = join8(
+    const dir = join10(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if (existsSync9(dir)) return dir;
+    if (existsSync11(dir)) return dir;
   }
   return null;
 }
@@ -4942,9 +5160,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = join8(dir, `${dateKey}.log`);
-  if (!existsSync9(filePath)) return;
-  const content = readFileSync8(filePath, "utf-8");
+  const filePath = join10(dir, `${dateKey}.log`);
+  if (!existsSync11(filePath)) return;
+  const content = readFileSync10(filePath, "utf-8");
   const lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -4975,13 +5193,47 @@ function registerLogSearch(ntf, ctx) {
   );
 }
 
+// src/cli/env.ts
+function registerEnvCli(ntf) {
+  const env = ntf.command("env").description("\u73AF\u5883\u7BA1\u7406\uFF08\u5207\u6362 development / production\uFF09");
+  env.command("show").description("\u663E\u793A\u5F53\u524D\u73AF\u5883\u53CA\u5BF9\u5E94\u7684\u63A5\u53E3\u5730\u5740").action(() => {
+    const current = loadEnvName();
+    const urls = getEnvUrls(current);
+    output({
+      ok: true,
+      env: current,
+      lightApiUrl: urls.lightApiUrl,
+      relayTunnelUrl: urls.relayTunnelUrl,
+      availableEnvs: getAvailableEnvs()
+    });
+  });
+  env.command("switch <env>").description("\u5207\u6362\u73AF\u5883\uFF08development / production\uFF09").action((envName) => {
+    const available = getAvailableEnvs();
+    if (!available.includes(envName)) {
+      exitError(
+        "INVALID_ENV",
+        `\u65E0\u6548\u7684\u73AF\u5883\u540D\u79F0: ${envName}\uFF0C\u53EF\u9009\u503C: ${available.join(", ")}`
+      );
+    }
+    saveEnvName(envName);
+    const urls = getEnvUrls(envName);
+    output({
+      ok: true,
+      message: `\u5DF2\u5207\u6362\u5230 ${envName} \u73AF\u5883`,
+      env: envName,
+      lightApiUrl: urls.lightApiUrl,
+      relayTunnelUrl: urls.relayTunnelUrl
+    });
+  });
+}
+
 // src/version.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync11 } from "fs";
 function readPluginVersion() {
   try {
     const packageJsonUrl = new URL("../package.json", import.meta.url);
     const packageJson = JSON.parse(
-      readFileSync9(packageJsonUrl, "utf-8")
+      readFileSync11(packageJsonUrl, "utf-8")
     );
     return packageJson.version ?? "unknown";
   } catch {
@@ -5003,22 +5255,23 @@ function registerAllCli(program, ctx, rootCommandName = "ntf") {
   registerNtfStoragePath(ntf, ctx);
   registerLogSearch(ntf, ctx);
   registerTunnelStatus(ntf, ctx);
+  registerEnvCli(ntf);
 }
 
 // src/tunnel/service.ts
 import {
   closeSync,
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync7,
   openSync,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync12,
   unlinkSync,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname4, join as join11 } from "path";
 
 // src/tunnel/relay-client.ts
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync4 } from "fs";
-import { dirname as dirname2 } from "path";
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
+import { dirname as dirname3 } from "path";
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -5050,8 +5303,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      mkdirSync4(dirname2(this.opts.statusFilePath), { recursive: true });
-      writeFileSync6(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      mkdirSync6(dirname3(this.opts.statusFilePath), { recursive: true });
+      writeFileSync8(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {
     }
   }
@@ -5121,9 +5374,14 @@ var RelayClient = class {
           resolve();
         }
       };
-      const ws = new wrapper_default(this.opts.tunnelUrl, {
+      const rawApiKey = this.opts.apiKey.startsWith("Bearer ") ? this.opts.apiKey.slice("Bearer ".length) : this.opts.apiKey;
+      const wsUrl = new URL(this.opts.tunnelUrl);
+      if (!wsUrl.searchParams.get("apiKey")) {
+        wsUrl.searchParams.set("apiKey", rawApiKey);
+      }
+      const ws = new wrapper_default(wsUrl.toString(), {
         headers: {
-          Authorization: this.opts.token.startsWith("Bearer ") ? this.opts.token : `Bearer ${this.opts.token}`
+          "X-Api-Key-Id": rawApiKey
         }
       });
       this.ws = ws;
@@ -5897,7 +6155,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse(readFileSync10(filePath, "utf-8"));
+      const parsed = JSON.parse(readFileSync12(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -5922,11 +6180,11 @@ function createTunnelService(opts) {
     }
   }
   function acquireLock(filePath) {
-    mkdirSync5(dirname3(filePath), { recursive: true });
+    mkdirSync7(dirname4(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
         const fd = openSync(filePath, "wx", 384);
-        writeFileSync7(
+        writeFileSync9(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -5975,27 +6233,27 @@ function createTunnelService(opts) {
       proxy?.cleanup();
       proxy = null;
       client = null;
-      const token = loadToken();
-      if (!token) {
+      const apiKey = loadApiKey();
+      if (!apiKey) {
         opts.logger.warn(
-          "Relay tunnel: token \u672A\u8BBE\u7F6E\uFF0C\u8DF3\u8FC7\u96A7\u9053\u8FDE\u63A5\u3002\u8BF7\u6267\u884C openclaw ntf auth set-token <token>"
+          "Relay tunnel: apiKey \u672A\u8BBE\u7F6E\uFF0C\u8DF3\u8FC7\u96A7\u9053\u8FDE\u63A5\u3002\u8BF7\u6267\u884C openclaw ntf auth set-api-key <apiKey>"
         );
         return;
       }
       const { logger } = opts;
-      const baseStateDir = join9(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 = join9(baseStateDir, "tunnel-status.json");
-      const lockPath = join9(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = join11(baseStateDir, "tunnel-status.json");
+      const lockPath = join11(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
       try {
         client = new RelayClient({
           tunnelUrl: opts.tunnelUrl,
-          token,
+          apiKey,
           heartbeatSec: opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC,
           reconnectBackoffMs: opts.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS,
           statusFilePath,
@@ -6036,13 +6294,13 @@ function createTunnelService(opts) {
 }
 
 // src/logger.ts
-import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync6 } from "fs";
-import { join as join10 } from "path";
+import { appendFileSync as appendFileSync2, mkdirSync as mkdirSync8 } from "fs";
+import { join as join12 } from "path";
 var PluginFileLogger = class {
   constructor(upstream, stateDir) {
     this.upstream = upstream;
-    this.logsDir = join10(stateDir, "plugins", "phone-notifications", "logs");
-    mkdirSync6(this.logsDir, { recursive: true });
+    this.logsDir = join12(stateDir, "plugins", "phone-notifications", "logs");
+    mkdirSync8(this.logsDir, { recursive: true });
   }
   logsDir;
   info(msg) {
@@ -6064,7 +6322,7 @@ var PluginFileLogger = class {
     const line = `${time} [${level}] ${msg}
 `;
     try {
-      appendFileSync2(join10(this.logsDir, `${dateKey}.log`), line);
+      appendFileSync2(join12(this.logsDir, `${dateKey}.log`), line);
     } catch {
     }
   }
@@ -6101,7 +6359,7 @@ function resolveLocalGatewayAuth(params) {
   const configPath = params.stateDir ? `${params.stateDir}/openclaw.json` : void 0;
   if (configPath) {
     try {
-      const configData = JSON.parse(readFileSync11(configPath, "utf-8"));
+      const configData = JSON.parse(readFileSync13(configPath, "utf-8"));
       const rawGatewayAuthMode = trimToUndefined(configData?.gateway?.auth?.mode);
       if (rawGatewayAuthMode === "token" || rawGatewayAuthMode === "password") {
         configGatewayAuthMode = rawGatewayAuthMode;
@@ -6128,6 +6386,7 @@ var index_default = {
   register(api) {
     const config = api.pluginConfig ?? {};
     let storage = null;
+    let appNameMapProvider = null;
     const ignoredApps = new Set(config.ignoredApps ?? []);
     const openclawDir = api.runtime.state.resolveStateDir();
     const logger = openclawDir ? new PluginFileLogger(api.logger, openclawDir) : api.logger;
@@ -6138,17 +6397,25 @@ var index_default = {
       id: "notification-storage",
       async start(ctx) {
         const storageDir = resolveNotificationStorageDir(ctx, logger);
-        storage = new NotificationStorage(storageDir, config, logger);
+        appNameMapProvider = createAppNameMapProvider({
+          stateDir: ctx.stateDir,
+          logger
+        });
+        await appNameMapProvider.start();
+        const resolveDisplayName = appNameMapProvider.resolveDisplayName.bind(appNameMapProvider);
+        storage = new NotificationStorage(storageDir, config, logger, resolveDisplayName);
         await storage.init();
         logger.info(`\u901A\u77E5\u5B58\u50A8\u670D\u52A1\u5DF2\u542F\u52A8: ${storageDir}`);
       },
       async stop() {
         await storage?.close();
         storage = null;
+        appNameMapProvider?.stop();
+        appNameMapProvider = null;
         logger.info("\u901A\u77E5\u5B58\u50A8\u670D\u52A1\u5DF2\u505C\u6B62");
       }
     });
-    const tunnelUrl = "wss://openclaw-service-dev.yoootek.com/message/messages/ws/plugin";
+    const tunnelUrl = getEnvUrls().relayTunnelUrl;
     if (tunnelUrl) {
       const gatewayPort = process.env.OPENCLAW_GATEWAY_PORT || "18789";
       const { gatewayAuthMode, gatewayToken, gatewayPassword } = resolveLocalGatewayAuth({
@@ -6307,9 +6574,9 @@ var index_default = {
         }
       },
       async execute(_toolCallId, params) {
-        let token;
+        let apiKey;
         try {
-          token = requireToken();
+          apiKey = requireApiKey();
         } catch (e) {
           return {
             ok: false,
@@ -6317,7 +6584,7 @@ var index_default = {
           };
         }
         const { segments, repeat } = params;
-        const result = await sendLightEffect(token, segments, logger, repeat);
+        const result = await sendLightEffect(apiKey, segments, logger, repeat);
         if (!result.ok) {
           logger.warn(
             `Light control HTTP request failed: ${result.status} ${result.error}`
@@ -6373,8 +6640,8 @@ var index_default = {
     const inferOpenClawRootDir = (workspaceDir) => {
       if (openclawDir) return openclawDir;
       if (!workspaceDir) return void 0;
-      if (basename(workspaceDir) !== "workspace") return void 0;
-      return dirname4(workspaceDir);
+      if (basename2(workspaceDir) !== "workspace") return void 0;
+      return dirname5(workspaceDir);
     };
     api.registerCli(
       (ctx) => {