@yoooclaw/phone-notifications 1.6.0 → 1.6.2

package/dist/index.js

@@ -2233,7 +2233,7 @@ var require_websocket = __commonJS({
     var http = __require("http");
     var net = __require("net");
     var tls = __require("tls");
-    var { randomBytes, createHash } = __require("crypto");
+    var { randomBytes, createHash: createHash2 } = __require("crypto");
     var { Duplex, Readable } = __require("stream");
     var { URL: URL2 } = __require("url");
     var PerMessageDeflate = require_permessage_deflate();
@@ -2893,7 +2893,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -3260,7 +3260,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = __require("events");
     var http = __require("http");
     var { Duplex } = __require("stream");
-    var { createHash } = __require("crypto");
+    var { createHash: createHash2 } = __require("crypto");
     var extension = require_extension();
     var PerMessageDeflate = require_permessage_deflate();
     var subprotocol = require_subprotocol();
@@ -3561,7 +3561,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest = createHash("sha1").update(key + GUID).digest("base64");
+        const digest = createHash2("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -3798,11 +3798,13 @@ 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"
+    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"
+    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));
@@ -3812,13 +3814,13 @@ function envFilePath() {
 }
 function loadEnvName() {
   const filePath = envFilePath();
-  if (!existsSync(filePath)) return "development";
+  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 "development";
+  return "production";
 }
 function saveEnvName(env) {
   if (!VALID_ENVS.has(env)) {
@@ -3839,12 +3841,12 @@ function getAvailableEnvs() {
 }
 
 // src/light/sender.ts
-async function sendLightEffect(token, segments, logger, repeat) {
+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 {
@@ -3869,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)
   });
@@ -3918,17 +3920,18 @@ function writeCredentials(creds) {
     mode: 384
   });
 }
-function loadToken() {
-  return readCredentials().token;
+function loadApiKey() {
+  const creds = readCredentials();
+  return creds.apiKey ?? creds.token;
 }
-function requireToken() {
-  const token = loadToken();
-  if (!token) {
+function requireApiKey() {
+  const apiKey = loadApiKey();
+  if (!apiKey) {
     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"
+      "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 token;
+  return apiKey;
 }
 function watchCredentials(onChange) {
   const path2 = credentialsPath();
@@ -3958,8 +3961,8 @@ function watchCredentials(onChange) {
 // 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 = "https://openclaw-service-dev.yoootek.com/api/application-config/app-package/config-all";
-var APP_NAME_MAP_URL = BUILTIN_APP_NAME_MAP_URL;
+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;
@@ -3992,36 +3995,54 @@ function createAppNameMapProvider(opts) {
       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 token = loadToken();
-    if (!token || !url) return;
-    const auth = token.startsWith("Bearer ") ? token : `Bearer ${token}`;
+    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", Authorization: auth },
+        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 });
-      writeFileSync3(getCachePath(stateDir), JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      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() {
@@ -4072,9 +4093,11 @@ import {
   rmSync,
   constants
 } from "fs";
+import { createHash } from "crypto";
 import { join as join4 } from "path";
 var NOTIFICATION_DIR_NAME = "notifications";
 var ID_INDEX_DIR_NAME = ".ids";
+var CONTENT_KEY_INDEX_DIR_NAME = ".keys";
 function getStateFallbackNotificationDir(stateDir) {
   return join4(stateDir, "plugins", "phone-notifications", NOTIFICATION_DIR_NAME);
 }
@@ -4110,56 +4133,75 @@ var NotificationStorage = class {
     this.logger = logger;
     this.dir = dir;
     this.idIndexDir = join4(dir, ID_INDEX_DIR_NAME);
+    this.contentKeyIndexDir = join4(dir, CONTENT_KEY_INDEX_DIR_NAME);
     this.resolveDisplayName = resolveDisplayName;
   }
   dir;
   idIndexDir;
+  contentKeyIndexDir;
   idCache = /* @__PURE__ */ new Map();
+  contentKeyCache = /* @__PURE__ */ new Map();
+  dateWriteChains = /* @__PURE__ */ new Map();
   resolveDisplayName;
   async init() {
     mkdirSync4(this.dir, { recursive: true });
     mkdirSync4(this.idIndexDir, { recursive: true });
+    mkdirSync4(this.contentKeyIndexDir, { recursive: true });
   }
   async ingest(items) {
+    const result = {
+      received: items.length,
+      ingested: 0,
+      dedupedById: 0,
+      dedupedByContent: 0,
+      invalid: 0
+    };
     for (const n of items) {
-      await this.writeNotification(n);
+      const outcome = await this.writeNotification(n);
+      result[outcome] += 1;
     }
     this.prune();
+    return result;
   }
   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;
+      return "invalid";
     }
     const dateKey = this.formatDate(ts);
     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,
-      appDisplayName,
+    const entry = this.buildStoredNotification(n);
+    return this.withDateWriteLock(dateKey, async () => {
+      if (normalizedId && this.hasNotificationId(dateKey, normalizedId)) {
+        return "dedupedById";
+      }
+      if (this.hasNotificationContentKey(dateKey, filePath, entry)) {
+        return "dedupedByContent";
+      }
+      const appDisplayName = this.resolveDisplayName ? await this.resolveDisplayName(entry.appName) : entry.appName;
+      const storedEntry = {
+        ...entry,
+        appDisplayName
+      };
+      const arr = this.readStoredNotifications(filePath);
+      arr.push(storedEntry);
+      writeFileSync4(filePath, JSON.stringify(arr, null, 2), "utf-8");
+      if (normalizedId) {
+        this.recordNotificationId(dateKey, normalizedId);
+      }
+      this.recordNotificationContentKey(dateKey, filePath, storedEntry);
+      return "ingested";
+    });
+  }
+  buildStoredNotification(n) {
+    return {
+      appName: typeof n.app === "string" && n.app ? n.app : "Unknown",
       title: typeof n.title === "string" ? n.title : "",
       content: this.buildContent(n),
       timestamp: n.timestamp
     };
-    let arr = [];
-    if (existsSync4(filePath)) {
-      try {
-        arr = JSON.parse(readFileSync4(filePath, "utf-8"));
-      } catch {
-        arr = [];
-      }
-    }
-    arr.push(entry);
-    writeFileSync4(filePath, JSON.stringify(arr, null, 2), "utf-8");
-    if (normalizedId) {
-      this.recordNotificationId(dateKey, normalizedId);
-    }
   }
   buildContent(n) {
     const body = n.body?.trim();
@@ -4203,9 +4245,44 @@ var NotificationStorage = class {
     this.idCache.set(dateKey, ids);
     return ids;
   }
+  getContentKeyIndexPath(dateKey) {
+    return join4(this.contentKeyIndexDir, `${dateKey}.keys`);
+  }
+  getContentKeySet(dateKey, filePath) {
+    const cached = this.contentKeyCache.get(dateKey);
+    if (cached) {
+      return cached;
+    }
+    const keyPath = this.getContentKeyIndexPath(dateKey);
+    const keys = /* @__PURE__ */ new Set();
+    if (existsSync4(keyPath)) {
+      const lines = readFileSync4(keyPath, "utf-8").split(/\r?\n/);
+      for (const line of lines) {
+        const key = line.trim();
+        if (key) {
+          keys.add(key);
+        }
+      }
+    } else if (existsSync4(filePath)) {
+      for (const item of this.readStoredNotifications(filePath)) {
+        keys.add(this.buildNotificationContentKey(item));
+      }
+      if (keys.size > 0) {
+        writeFileSync4(keyPath, `${Array.from(keys).join("\n")}
+`, "utf-8");
+      }
+    }
+    this.contentKeyCache.set(dateKey, keys);
+    return keys;
+  }
   hasNotificationId(dateKey, id) {
     return this.getIdSet(dateKey).has(id);
   }
+  hasNotificationContentKey(dateKey, filePath, entry) {
+    return this.getContentKeySet(dateKey, filePath).has(
+      this.buildNotificationContentKey(entry)
+    );
+  }
   recordNotificationId(dateKey, id) {
     const ids = this.getIdSet(dateKey);
     if (ids.has(id)) {
@@ -4215,12 +4292,55 @@ var NotificationStorage = class {
 `, "utf-8");
     ids.add(id);
   }
+  recordNotificationContentKey(dateKey, filePath, entry) {
+    const keys = this.getContentKeySet(dateKey, filePath);
+    const key = this.buildNotificationContentKey(entry);
+    if (keys.has(key)) {
+      return;
+    }
+    appendFileSync(this.getContentKeyIndexPath(dateKey), `${key}
+`, "utf-8");
+    keys.add(key);
+  }
+  buildNotificationContentKey(entry) {
+    return createHash("sha256").update(entry.appName).update("").update(entry.title).update("").update(entry.content).digest("hex");
+  }
+  readStoredNotifications(filePath) {
+    if (!existsSync4(filePath)) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(readFileSync4(filePath, "utf-8"));
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  async withDateWriteLock(dateKey, task) {
+    const previous = this.dateWriteChains.get(dateKey) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    const chain = previous.then(() => current);
+    this.dateWriteChains.set(dateKey, chain);
+    await previous;
+    try {
+      return await task();
+    } finally {
+      release();
+      if (this.dateWriteChains.get(dateKey) === chain) {
+        this.dateWriteChains.delete(dateKey);
+      }
+    }
+  }
   prune() {
     const retentionDays = this.config.retentionDays ?? 30;
     const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1e3;
     const cutoffDate = this.formatDate(new Date(cutoffMs));
     this.pruneDataFiles(cutoffDate);
     this.pruneIdIndex(cutoffDate);
+    this.pruneContentKeyIndex(cutoffDate);
   }
   /** Remove expired .json, legacy .md files, and legacy date directories */
   pruneDataFiles(cutoffDate) {
@@ -4254,8 +4374,24 @@ var NotificationStorage = class {
     } catch {
     }
   }
+  /** Remove expired .keys index files */
+  pruneContentKeyIndex(cutoffDate) {
+    try {
+      for (const entry of readdirSync(this.contentKeyIndexDir, { withFileTypes: true })) {
+        if (!entry.isFile()) continue;
+        const match = /^(\d{4}-\d{2}-\d{2})\.keys$/.exec(entry.name);
+        if (match && match[1] < cutoffDate) {
+          rmSync(join4(this.contentKeyIndexDir, entry.name), { force: true });
+          this.contentKeyCache.delete(match[1]);
+        }
+      }
+    } catch {
+    }
+  }
   async close() {
     this.idCache.clear();
+    this.contentKeyCache.clear();
+    this.dateWriteChains.clear();
   }
 };
 
@@ -4328,31 +4464,41 @@ function exitError(code, message) {
 // 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 (existsSync6(path2)) {
       const creds = readCredentials();
+      delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
         rmSync2(path2, { force: true });
@@ -5012,14 +5158,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}`);
     }
@@ -5058,17 +5204,17 @@ 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 = getEnvUrls().relayTunnelUrl;
-    const token = loadToken();
+    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);
@@ -5343,9 +5489,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;
@@ -6197,10 +6348,10 @@ 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;
       }
@@ -6217,7 +6368,7 @@ function createTunnelService(opts) {
       try {
         client = new RelayClient({
           tunnelUrl: opts.tunnelUrl,
-          token,
+          apiKey,
           heartbeatSec: opts.heartbeatSec ?? DEFAULT_HEARTBEAT_SEC,
           reconnectBackoffMs: opts.reconnectBackoffMs ?? DEFAULT_RECONNECT_BACKOFF_MS,
           statusFilePath,
@@ -6314,6 +6465,15 @@ function trimToUndefined(value) {
   const trimmed = value.trim();
   return trimmed || void 0;
 }
+function createEmptyIngestResult() {
+  return {
+    received: 0,
+    ingested: 0,
+    dedupedById: 0,
+    dedupedByContent: 0,
+    invalid: 0
+  };
+}
 function resolveLocalGatewayAuth(params) {
   const envGatewayToken = trimToUndefined(process.env.OPENCLAW_GATEWAY_TOKEN) ?? trimToUndefined(process.env.CLAWDBOT_GATEWAY_TOKEN);
   const envGatewayPassword = trimToUndefined(process.env.OPENCLAW_GATEWAY_PASSWORD) ?? trimToUndefined(process.env.CLAWDBOT_GATEWAY_PASSWORD);
@@ -6412,10 +6572,8 @@ var index_default = {
         const { items } = params;
         if (Array.isArray(items)) {
           const filtered = filterNotifications(items);
-          if (filtered.length) {
-            await storage.ingest(filtered);
-          }
-          respond(true, { ingested: filtered.length });
+          const result = filtered.length ? await storage.ingest(filtered) : createEmptyIngestResult();
+          respond(true, result);
         } else {
           respond(false, null, {
             code: "INVALID_PARAMS",
@@ -6538,9 +6696,9 @@ var index_default = {
         }
       },
       async execute(_toolCallId, params) {
-        let token;
+        let apiKey;
         try {
-          token = requireToken();
+          apiKey = requireApiKey();
         } catch (e) {
           return {
             ok: false,
@@ -6548,7 +6706,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}`
@@ -6593,11 +6751,9 @@ var index_default = {
           return;
         }
         const filtered = filterNotifications(body.notifications);
-        if (filtered.length) {
-          await storage.ingest(filtered);
-        }
+        const result = filtered.length ? await storage.ingest(filtered) : createEmptyIngestResult();
         res.writeHead(200, { "Content-Type": "application/json" });
-        res.end(JSON.stringify({ ok: true, ingested: filtered.length }));
+        res.end(JSON.stringify({ ok: true, ...result }));
       }
     });
     logger.info("HTTP \u901A\u77E5\u7AEF\u70B9\u5DF2\u6CE8\u518C: POST /notifications");