@yoooclaw/phone-notifications 1.11.8 → 1.11.9

package/README.md

@@ -441,6 +441,9 @@ openclaw ntf search --sender "张三" --from 2026-03-01T00:00:00+08:00
 
 # 仅看飞书群聊消息
 openclaw ntf search --app Feishu --conversation-type group
+
+# 生成轻量通知摘要输入，适合 Agent 总结大量通知
+openclaw ntf summary --limit 700
 ```
 
 ### 通知统计

package/dist/index.cjs

@@ -5574,7 +5574,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.11.8".trim();
+  const version = "1.11.9".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -7985,13 +7985,13 @@ init_env();
 
 // src/update/channel.ts
 function resolveUpdateChannel(params) {
+  if (params.envName === "production") {
+    return "latest";
+  }
   if (params.configuredChannel) {
     return params.configuredChannel;
   }
-  if (params.currentVersion.includes("-")) {
-    return "beta";
-  }
-  return params.envName === "production" ? "latest" : "beta";
+  return "beta";
 }
 
 // src/update/index.ts
@@ -8100,7 +8100,7 @@ var UpdateChecker = class {
     const latest = await this.fetchLatestVersion();
     if (!latest || latest === PLUGIN_VERSION) return;
     if (latest === this.notifiedVersion) return;
-    if (PLUGIN_VERSION.includes("-") && this.channel !== "beta") return;
+    if (this.channel !== "beta" && latest.includes("-")) return;
     if (!isNewerVersion(latest, PLUGIN_VERSION)) return;
     this.notifiedVersion = latest;
     this.logger.info(`\u53D1\u73B0\u65B0\u7248\u672C: ${PLUGIN_VERSION} \u2192 ${latest}`);
@@ -8436,7 +8436,6 @@ function registerAutoUpdateLifecycle(deps) {
     ...config.autoUpdate,
     channel: resolveUpdateChannel({
       configuredChannel: config.autoUpdate?.channel,
-      currentVersion: PLUGIN_VERSION,
       envName: loadEnvName()
     })
   };
@@ -8518,8 +8517,53 @@ function registerAuthCli(program) {
   });
 }
 
-// src/cli/ntf-search.ts
-function filterItem(item, opts) {
+// src/cli/ntf-query.ts
+function parsePositiveIntegerOption(rawValue, defaultValue, optionName, errorCode) {
+  const value = rawValue && rawValue.length > 0 ? rawValue : String(defaultValue);
+  if (!/^\d+$/.test(value)) {
+    exitError(errorCode, `${optionName} \u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6574\u6570`);
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (parsed <= 0) {
+    exitError(errorCode, `${optionName} \u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6574\u6570`);
+  }
+  return parsed;
+}
+function parseNotificationQueryOptions(opts, defaultLimit = 100) {
+  const limit = parsePositiveIntegerOption(
+    opts.limit,
+    defaultLimit,
+    "--limit",
+    "INVALID_LIMIT"
+  );
+  if (opts.conversationType && opts.conversationType !== "group" && opts.conversationType !== "private") {
+    exitError(
+      "INVALID_CONVERSATION_TYPE",
+      "--conversation-type \u53EA\u80FD\u662F group \u6216 private"
+    );
+  }
+  const hasFrom = typeof opts.from === "string" && opts.from.length > 0;
+  const hasTo = typeof opts.to === "string" && opts.to.length > 0;
+  const fromTs = hasFrom ? parseIsoTime(opts.from, "--from") : null;
+  const toTs = hasTo ? parseIsoTime(opts.to, "--to") : null;
+  if (fromTs !== null && toTs !== null && fromTs > toTs) {
+    exitError("INVALID_TIME_RANGE", "--from \u4E0D\u80FD\u665A\u4E8E --to");
+  }
+  return {
+    from: opts.from,
+    to: opts.to,
+    app: opts.app,
+    sender: opts.sender,
+    conversationType: opts.conversationType,
+    keyword: opts.keyword,
+    limit,
+    fromTs,
+    toTs,
+    fromDateKey: hasFrom ? opts.from.slice(0, 10) : null,
+    toDateKey: hasTo ? opts.to.slice(0, 10) : null
+  };
+}
+function matchesNotificationQuery(item, opts) {
   if (opts.app && !matchesNotificationAppFilter(item, opts.app)) return false;
   if (opts.conversationType && item.conversationType !== opts.conversationType) {
     return false;
@@ -8533,8 +8577,34 @@ function filterItem(item, opts) {
     item.conversationName
   ].filter((value) => typeof value === "string" && value.length > 0).join("\n");
   if (opts.keyword && !keywordHaystack.includes(opts.keyword)) return false;
+  const itemTs = Date.parse(item.timestamp);
+  if (Number.isNaN(itemTs)) return false;
+  if (opts.fromTs !== null && itemTs < opts.fromTs) return false;
+  if (opts.toTs !== null && itemTs > opts.toTs) return false;
   return true;
 }
+async function collectMatchingNotifications(dir, opts) {
+  const keys = await listDateKeysAsync(dir);
+  const results = [];
+  const canStopAfterLimit = opts.fromTs === null && opts.toTs === null;
+  for (const dateKey of keys) {
+    if (opts.fromDateKey && dateKey < opts.fromDateKey) continue;
+    if (opts.toDateKey && dateKey > opts.toDateKey) continue;
+    const items = sortNotificationsByTimestampDesc([
+      ...await readDateFileAsync(dir, dateKey)
+    ]);
+    for (const item of items) {
+      if (!matchesNotificationQuery(item, opts)) continue;
+      results.push(item);
+      if (canStopAfterLimit && results.length >= opts.limit) {
+        return results;
+      }
+    }
+  }
+  return sortNotificationsByTimestampDesc(results).slice(0, opts.limit);
+}
+
+// src/cli/ntf-search.ts
 function registerNtfSearch(ntf, ctx) {
   ntf.command("search").description("\u67E5\u8BE2\u901A\u77E5\uFF08\u6309\u65F6\u95F4/\u5E94\u7528/\u53D1\u9001\u4EBA/\u5173\u952E\u8BCD\u7B5B\u9009\uFF09").option("--from <time>", "\u5F00\u59CB\u65F6\u95F4 ISO 8601\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00").option("--to <time>", "\u7ED3\u675F\u65F6\u95F4 ISO 8601\uFF0C\u4F8B\u5982 2026-03-01T18:00:00+08:00").option("--app <name>", "\u6309\u5E94\u7528\u540D\u8FC7\u6EE4").option("--sender <name>", "\u6309\u53D1\u9001\u4EBA\u8FC7\u6EE4").option(
     "--conversation-type <type>",
@@ -8544,55 +8614,8 @@ function registerNtfSearch(ntf, ctx) {
       const dir = resolveNotificationsDir(ctx);
       if (!dir) exitError("STORAGE_UNAVAILABLE", "\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528");
       progress("\u6B63\u5728\u641C\u7D22\u901A\u77E5...");
-      const limit = parseInt(opts.limit, 10) || 100;
-      if (limit <= 0) {
-        exitError("INVALID_LIMIT", "--limit \u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6574\u6570");
-      }
-      if (opts.conversationType && opts.conversationType !== "group" && opts.conversationType !== "private") {
-        exitError(
-          "INVALID_CONVERSATION_TYPE",
-          "--conversation-type \u53EA\u80FD\u662F group \u6216 private"
-        );
-      }
-      const hasFrom = typeof opts.from === "string" && opts.from.length > 0;
-      const hasTo = typeof opts.to === "string" && opts.to.length > 0;
-      const fromTs = hasFrom ? parseIsoTime(opts.from, "--from") : null;
-      const toTs = hasTo ? parseIsoTime(opts.to, "--to") : null;
-      if (fromTs !== null && toTs !== null && fromTs > toTs) {
-        exitError("INVALID_TIME_RANGE", "--from \u4E0D\u80FD\u665A\u4E8E --to");
-      }
-      const keys = await listDateKeysAsync(dir);
-      const results = [];
-      if (fromTs !== null || toTs !== null) {
-        const fromDateKey = hasFrom ? opts.from.slice(0, 10) : null;
-        const toDateKey = hasTo ? opts.to.slice(0, 10) : null;
-        for (const dateKey of keys) {
-          if (fromDateKey && dateKey < fromDateKey) continue;
-          if (toDateKey && dateKey > toDateKey) continue;
-          const items = await readDateFileAsync(dir, dateKey);
-          for (const item of items) {
-            if (!filterItem(item, opts)) continue;
-            const itemTs = Date.parse(item.timestamp);
-            if (Number.isNaN(itemTs)) continue;
-            if (fromTs !== null && itemTs < fromTs) continue;
-            if (toTs !== null && itemTs > toTs) continue;
-            results.push(item);
-          }
-        }
-      } else {
-        for (const dateKey of keys) {
-          const items = await readDateFileAsync(dir, dateKey);
-          for (const item of items) {
-            if (!filterItem(item, opts)) continue;
-            if (Number.isNaN(Date.parse(item.timestamp))) continue;
-            results.push(item);
-          }
-        }
-      }
-      const notifications = sortNotificationsByTimestampDesc(results).slice(
-        0,
-        limit
-      );
+      const query = parseNotificationQueryOptions(opts);
+      const notifications = await collectMatchingNotifications(dir, query);
       output({
         ok: true,
         total: notifications.length,
@@ -8602,6 +8625,117 @@ function registerNtfSearch(ntf, ctx) {
   );
 }
 
+// src/cli/ntf-summary.ts
+function compactNotification(item) {
+  const result = {
+    appName: item.appName,
+    title: item.title,
+    content: item.content,
+    timestamp: item.timestamp
+  };
+  if (item.appDisplayName) result.appDisplayName = item.appDisplayName;
+  if (item.senderName) result.senderName = item.senderName;
+  if (item.conversationType) result.conversationType = item.conversationType;
+  if (item.conversationName) result.conversationName = item.conversationName;
+  return result;
+}
+function truncate(value, maxLength = 120) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function increment(map, key, seed) {
+  const existing = map.get(key);
+  if (existing) {
+    existing.count += 1;
+    return;
+  }
+  map.set(key, { ...seed, count: 1 });
+}
+function topRows(map, limit) {
+  return [...map.values()].sort((a, b) => b.count - a.count).slice(0, limit);
+}
+function hourBucket(timestamp) {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):/.exec(timestamp);
+  if (!match) return null;
+  return `${match[1]} ${match[2]}:00`;
+}
+function buildSamplesBySender(notifications, senderRows) {
+  return senderRows.map((row) => {
+    const samples = [];
+    for (const item of notifications) {
+      const sender = item.senderName?.trim() || item.title?.trim() || "(unknown)";
+      if (sender !== row.sender) continue;
+      const content = truncate(item.content.trim());
+      if (content && !samples.includes(content)) samples.push(content);
+      if (samples.length >= 5) break;
+    }
+    return { sender: row.sender, count: row.count, samples };
+  });
+}
+function registerNtfSummary(ntf, ctx) {
+  ntf.command("summary").description("\u751F\u6210\u901A\u77E5\u6458\u8981\u8F93\u5165\uFF08\u805A\u5408\u7EDF\u8BA1 + \u6837\u4F8B\uFF0C\u4F9B Agent \u5FEB\u901F\u603B\u7ED3\uFF09").option("--from <time>", "\u5F00\u59CB\u65F6\u95F4 ISO 8601\uFF0C\u4F8B\u5982 2026-03-01T09:00:00+08:00").option("--to <time>", "\u7ED3\u675F\u65F6\u95F4 ISO 8601\uFF0C\u4F8B\u5982 2026-03-01T18:00:00+08:00").option("--app <name>", "\u6309\u5E94\u7528\u540D\u8FC7\u6EE4").option("--sender <name>", "\u6309\u53D1\u9001\u4EBA\u8FC7\u6EE4").option(
+    "--conversation-type <type>",
+    "\u6309\u4F1A\u8BDD\u7C7B\u578B\u8FC7\u6EE4\uFF08group/private\uFF09"
+  ).option("--keyword <text>", "\u5728\u6807\u9898\u548C\u5185\u5BB9\u4E2D\u641C\u7D22\u5173\u952E\u8BCD").option("--limit <n>", "\u7EB3\u5165\u6458\u8981\u7684\u6700\u5927\u901A\u77E5\u6761\u6570", "100").option("--sample <n>", "\u8FD4\u56DE\u6700\u8FD1\u6837\u4F8B\u6761\u6570", "30").option("--top <n>", "\u8FD4\u56DE\u805A\u5408\u699C\u5355\u6761\u6570", "10").action(
+    async (opts) => {
+      const dir = resolveNotificationsDir(ctx);
+      if (!dir) exitError("STORAGE_UNAVAILABLE", "\u901A\u77E5\u5B58\u50A8\u76EE\u5F55\u4E0D\u53EF\u7528");
+      progress("\u6B63\u5728\u751F\u6210\u901A\u77E5\u6458\u8981\u8F93\u5165...");
+      const query = parseNotificationQueryOptions(opts);
+      const sampleLimit = parsePositiveIntegerOption(
+        opts.sample,
+        30,
+        "--sample",
+        "INVALID_SAMPLE"
+      );
+      const topLimit = parsePositiveIntegerOption(
+        opts.top,
+        10,
+        "--top",
+        "INVALID_TOP"
+      );
+      const notifications = await collectMatchingNotifications(dir, query);
+      const byApp = /* @__PURE__ */ new Map();
+      const bySender = /* @__PURE__ */ new Map();
+      const byConversation = /* @__PURE__ */ new Map();
+      const byHour = /* @__PURE__ */ new Map();
+      for (const item of notifications) {
+        const appKey = `${item.appName}\0${item.appDisplayName ?? ""}`;
+        increment(byApp, appKey, {
+          appName: item.appName,
+          ...item.appDisplayName ? { appDisplayName: item.appDisplayName } : {}
+        });
+        const sender = item.senderName?.trim() || item.title?.trim() || "(unknown)";
+        increment(bySender, sender, { sender });
+        const conversationName = item.conversationName?.trim() || item.title?.trim() || "(unknown)";
+        const conversationKey = `${conversationName}\0${item.conversationType ?? ""}`;
+        increment(byConversation, conversationKey, {
+          conversationName,
+          ...item.conversationType ? { conversationType: item.conversationType } : {}
+        });
+        const hour = hourBucket(item.timestamp);
+        if (hour) increment(byHour, hour, { hour });
+      }
+      const senderRows = topRows(bySender, topLimit);
+      output({
+        ok: true,
+        limit: query.limit,
+        total: notifications.length,
+        range: {
+          newest: notifications[0]?.timestamp ?? null,
+          oldest: notifications[notifications.length - 1]?.timestamp ?? null
+        },
+        byApp: topRows(byApp, topLimit),
+        bySender: senderRows,
+        byConversation: topRows(byConversation, topLimit),
+        byHour: topRows(byHour, topLimit),
+        latest: notifications.slice(0, sampleLimit).map(compactNotification),
+        samplesBySender: buildSamplesBySender(notifications, senderRows)
+      });
+    }
+  );
+}
+
 // src/cli/ntf-stats.ts
 function registerNtfStats(ntf, ctx) {
   ntf.command("stats").description("\u901A\u77E5\u7EDF\u8BA1\u5206\u6790\uFF08\u6309\u65E5\u671F/\u5E94\u7528/\u53D1\u9001\u4EBA/\u65F6\u6BB5\u805A\u5408\uFF09").option("--from <date>", "\u5F00\u59CB\u65E5\u671F YYYY-MM-DD", daysAgo(7)).option("--to <date>", "\u7ED3\u675F\u65E5\u671F YYYY-MM-DD", today()).option("--app <name>", "\u53EA\u7EDF\u8BA1\u6307\u5B9A\u5E94\u7528").option("--dim <dimension>", "\u7EDF\u8BA1\u7EF4\u5EA6\uFF1Adate/app/sender/hour/all", "all").action(
@@ -9788,7 +9922,6 @@ var checkNodeVersion = () => {
 init_env();
 var checkPluginVersion = async () => {
   const channel = resolveUpdateChannel({
-    currentVersion: PLUGIN_VERSION,
     envName: loadEnvName()
   });
   let latest;
@@ -10275,6 +10408,7 @@ function registerAllCli(program, ctx, rootCommandName = "ntf") {
   const ntf = program.command(rootCommandName).description("\u624B\u673A\u901A\u77E5\u6570\u636E\u7BA1\u7406").version(PLUGIN_VERSION, "-v, --version", "\u663E\u793A\u63D2\u4EF6\u7248\u672C");
   registerAuthCli(ntf);
   registerNtfSearch(ntf, ctx);
+  registerNtfSummary(ntf, ctx);
   registerNtfStats(ntf, ctx);
   registerNtfSync(ntf, ctx);
   registerNtfMonitor(ntf, ctx);
@@ -12851,14 +12985,20 @@ async function handleHttpRequest(opts, frame) {
   const mappedPath = mapPath(frame.path);
   const url = new URL(mappedPath, opts.gatewayBaseUrl);
   const startedAtMs = Date.now();
+  const trustedProxyHeader = opts.gatewayTrustedProxyHeader?.trim();
+  const trustedProxyUser = opts.gatewayTrustedProxyUser?.trim();
+  const trustedProxyHeaderLower = trustedProxyHeader?.toLowerCase();
   const localHeaders = {};
   for (const [k, v] of Object.entries(frame.headers ?? {})) {
     const lower = k.toLowerCase();
-    if (lower !== "authorization" && lower !== "x-openclaw-password") {
-      localHeaders[k] = v;
-    }
+    if (lower === "authorization" || lower === "x-openclaw-password") continue;
+    if (trustedProxyHeaderLower && lower === trustedProxyHeaderLower) continue;
+    localHeaders[k] = v;
   }
   localHeaders[RELAY_INTERNAL_HTTP_HEADER] = "1";
+  if (trustedProxyHeader && trustedProxyUser) {
+    localHeaders[trustedProxyHeader] = trustedProxyUser;
+  }
   const authAttempts = buildLocalGatewayAuthAttempts(opts, localHeaders);
   opts.logger.info(
     `TunnelProxy: HTTP id=${frame.id} ${frame.method} ${frame.path} \u2192 ${url.toString()}${summarizeRequestHeaders(frame.headers)}, authAttempts=${authAttempts.map((a) => a.label).join(" -> ")}, body=${previewText2(frame.body)}`
@@ -13303,6 +13443,16 @@ var TunnelProxy = class {
       `TunnelProxy: cleared stale stored device token after gateway mismatch (deviceId=${this.deviceIdentity.deviceId})`
     );
   }
+  /**
+   * 当 Gateway 处于 trusted-proxy 模式时，构造注入到本地连接的 user header。
+   * 其他模式或参数未配齐时返回 undefined，本地用户保持原握手路径不受影响。
+   */
+  buildTrustedProxyHeaders() {
+    const headerName = this.opts.gatewayTrustedProxyHeader?.trim();
+    const headerValue = this.opts.gatewayTrustedProxyUser?.trim();
+    if (!headerName || !headerValue) return void 0;
+    return { [headerName]: headerValue };
+  }
   async maybeAutoApproveGatewayPairing(frame) {
     const errorCode = typeof frame?.error?.code === "string" ? frame.error.code : void 0;
     const detailsCode = typeof frame?.error?.details?.code === "string" ? frame.error.details.code : void 0;
@@ -13473,10 +13623,12 @@ var TunnelProxy = class {
     this.gatewayWsConnecting = true;
     this.gatewayWsReady = false;
     const wsUrl = this.opts.gatewayBaseUrl.replace(/^http/, "ws");
+    const trustedProxyHeaders = this.buildTrustedProxyHeaders();
+    const trustedProxyHint = trustedProxyHeaders ? `, trustedProxyHeader=${Object.keys(trustedProxyHeaders)[0]}` : "";
     this.opts.logger.info(
-      `TunnelProxy: RPC WS connecting to gateway ${wsUrl} (pending=${this.gatewayWsPending.length})`
+      `TunnelProxy: RPC WS connecting to gateway ${wsUrl} (pending=${this.gatewayWsPending.length}${trustedProxyHint})`
     );
-    const ws = new wrapper_default(wsUrl);
+    const ws = trustedProxyHeaders ? new wrapper_default(wsUrl, { headers: trustedProxyHeaders }) : new wrapper_default(wsUrl);
     ws.on("open", () => {
       this.gatewayWs = ws;
       this.opts.logger.info(
@@ -13809,6 +13961,8 @@ function createTunnelService(opts) {
           gatewayAuthMode: opts.gatewayAuthMode,
           gatewayToken: opts.gatewayToken,
           gatewayPassword: opts.gatewayPassword,
+          gatewayTrustedProxyHeader: opts.gatewayTrustedProxyHeader,
+          gatewayTrustedProxyUser: opts.gatewayTrustedProxyUser,
           client,
           logger
         });
@@ -13921,9 +14075,14 @@ function readHostGatewayConfig(params) {
   }
   return configData;
 }
+var DEFAULT_TRUSTED_PROXY_HEADER = "x-forwarded-user";
+var DEFAULT_TRUSTED_PROXY_USER = "openclaw";
 function resolveLocalGatewayAuth(params) {
   const envGatewayToken = trimToUndefined2(process.env.OPENCLAW_GATEWAY_TOKEN) ?? trimToUndefined2(process.env.QCLAW_GATEWAY_TOKEN);
   const envGatewayPassword = trimToUndefined2(process.env.OPENCLAW_GATEWAY_PASSWORD) ?? trimToUndefined2(process.env.QCLAW_GATEWAY_PASSWORD);
+  const envTrustedProxyUser = trimToUndefined2(
+    process.env.OPENCLAW_GATEWAY_TRUSTED_PROXY_USER
+  );
   const configData = readHostGatewayConfig(params);
   let configGatewayAuthMode;
   const rawGatewayAuthMode = trimToUndefined2(configData?.gateway?.auth?.mode);
@@ -13932,10 +14091,18 @@ function resolveLocalGatewayAuth(params) {
   }
   const configGatewayToken = trimToUndefined2(configData?.gateway?.auth?.token);
   const configGatewayPassword = trimToUndefined2(configData?.gateway?.auth?.password);
+  let gatewayTrustedProxyHeader;
+  let gatewayTrustedProxyUser;
+  if (rawGatewayAuthMode === "trusted-proxy") {
+    gatewayTrustedProxyHeader = trimToUndefined2(configData?.gateway?.auth?.trustedProxy?.userHeader) ?? DEFAULT_TRUSTED_PROXY_HEADER;
+    gatewayTrustedProxyUser = envTrustedProxyUser ?? DEFAULT_TRUSTED_PROXY_USER;
+  }
   return {
     gatewayAuthMode: configGatewayAuthMode,
     gatewayToken: envGatewayToken ?? configGatewayToken,
-    gatewayPassword: envGatewayPassword ?? configGatewayPassword
+    gatewayPassword: envGatewayPassword ?? configGatewayPassword,
+    gatewayTrustedProxyHeader,
+    gatewayTrustedProxyUser
   };
 }
 function resolveExclusiveTunnelHint(params) {
@@ -13984,10 +14151,21 @@ function registerRelayTunnelLifecycle(deps) {
     return null;
   }
   const gatewayPort = process.env.OPENCLAW_GATEWAY_PORT ?? process.env.QCLAW_GATEWAY_PORT ?? "18789";
-  const { gatewayAuthMode, gatewayToken, gatewayPassword } = resolveLocalGatewayAuth({
+  const {
+    gatewayAuthMode,
+    gatewayToken,
+    gatewayPassword,
+    gatewayTrustedProxyHeader,
+    gatewayTrustedProxyUser
+  } = resolveLocalGatewayAuth({
     stateDir: openclawDir,
     logger
   });
+  if (gatewayTrustedProxyHeader && gatewayTrustedProxyUser) {
+    logger.info(
+      `Relay tunnel: gateway in trusted-proxy mode, will inject ${gatewayTrustedProxyHeader} header on local connections`
+    );
+  }
   const tunnelService = createTunnelService({
     tunnelUrl,
     heartbeatSec: config.relay?.heartbeatSec,
@@ -13996,6 +14174,8 @@ function registerRelayTunnelLifecycle(deps) {
     gatewayAuthMode,
     gatewayToken,
     gatewayPassword,
+    gatewayTrustedProxyHeader,
+    gatewayTrustedProxyUser,
     logger
   });
   api.registerService(tunnelService);