@yoooclaw/phone-notifications 1.10.3 → 1.10.4

package/dist/index.cjs

@@ -206,9 +206,38 @@ var init_credentials = __esm({
 });
 
 // src/env.ts
+function writeDotEnv(key, value) {
+  const path2 = resolveStateFile(".env");
+  (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(path2), { recursive: true });
+  const existing = (0, import_node_fs9.existsSync)(path2) ? (0, import_node_fs9.readFileSync)(path2, "utf-8") : "";
+  const lines = existing.split("\n");
+  const prefix = `${key}=`;
+  const idx = lines.findIndex((l) => l.startsWith(prefix));
+  const newLine = `${prefix}${value}`;
+  if (idx >= 0) {
+    lines[idx] = newLine;
+  } else {
+    if (existing && !existing.endsWith("\n")) lines.push("");
+    lines.push(newLine);
+  }
+  (0, import_node_fs9.writeFileSync)(path2, lines.join("\n"), "utf-8");
+}
+function readDotEnv() {
+  const path2 = resolveStateFile(".env");
+  if (!(0, import_node_fs9.existsSync)(path2)) return {};
+  return Object.fromEntries(
+    (0, import_node_fs9.readFileSync)(path2, "utf-8").split("\n").flatMap((line) => {
+      const eq = line.indexOf("=");
+      if (eq < 1) return [];
+      return [[line.slice(0, eq).trim(), line.slice(eq + 1).trim()]];
+    })
+  );
+}
 function loadEnvName() {
-  const fromEnvVar = process.env.OPENCLAW_ENV?.trim();
+  const fromEnvVar = process.env.PHONE_NOTIFICATIONS_ENV?.trim();
   if (fromEnvVar && VALID_ENVS.has(fromEnvVar)) return fromEnvVar;
+  const fromDotEnv = readDotEnv()["PHONE_NOTIFICATIONS_ENV"]?.trim();
+  if (fromDotEnv && VALID_ENVS.has(fromDotEnv)) return fromDotEnv;
   const { env } = readCredentials();
   if (env && VALID_ENVS.has(env)) return env;
   return "production";
@@ -219,7 +248,7 @@ function saveEnvName(env) {
       `\u65E0\u6548\u7684\u73AF\u5883\u540D\u79F0: ${env}\uFF0C\u53EF\u9009\u503C: ${[...VALID_ENVS].join(", ")}`
     );
   }
-  writeCredentials({ ...readCredentials(), env });
+  writeDotEnv("PHONE_NOTIFICATIONS_ENV", env);
 }
 function getEnvUrls(env) {
   return ENV_CONFIG[env ?? loadEnvName()];
@@ -227,11 +256,14 @@ function getEnvUrls(env) {
 function getAvailableEnvs() {
   return Object.keys(ENV_CONFIG);
 }
-var ENV_CONFIG, VALID_ENVS;
+var import_node_fs9, import_node_path8, ENV_CONFIG, VALID_ENVS;
 var init_env = __esm({
   "src/env.ts"() {
     "use strict";
+    import_node_fs9 = require("fs");
+    import_node_path8 = require("path");
     init_credentials();
+    init_host();
     ENV_CONFIG = {
       development: {
         lightApiUrl: "https://openclaw-service-dev.yoooclaw.com/api/message/tob/sendMessage",
@@ -500,20 +532,20 @@ function selectModelByMemory(availableGB, isAppleSilicon = false) {
   return "tiny";
 }
 function resolveModelsDir(dataDir) {
-  const dir = (0, import_node_path21.join)(dataDir, WHISPER_MODELS_DIR);
-  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path22.join)(dataDir, WHISPER_MODELS_DIR);
+  (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function resolveBinDir(dataDir) {
-  const dir = (0, import_node_path21.join)(dataDir, WHISPER_BIN_DIR);
-  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path22.join)(dataDir, WHISPER_BIN_DIR);
+  (0, import_node_fs26.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function isModelDownloaded(modelsDir, modelSize) {
-  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
-  if (!(0, import_node_fs25.existsSync)(modelPath)) return false;
+  const modelPath = (0, import_node_path22.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  if (!(0, import_node_fs26.existsSync)(modelPath)) return false;
   try {
-    const stat = (0, import_node_fs25.statSync)(modelPath);
+    const stat = (0, import_node_fs26.statSync)(modelPath);
     const expectedSize = MODEL_DISK_SIZES[modelSize];
     return stat.size >= expectedSize * 0.8;
   } catch {
@@ -522,7 +554,7 @@ function isModelDownloaded(modelsDir, modelSize) {
 }
 async function downloadModel(modelsDir, modelSize, logger, modelSource, mirrorUrl) {
   const filename = MODEL_FILENAMES[modelSize];
-  const modelPath = (0, import_node_path21.join)(modelsDir, filename);
+  const modelPath = (0, import_node_path22.join)(modelsDir, filename);
   if (isModelDownloaded(modelsDir, modelSize)) {
     logger.info(`[whisper-local] \u6A21\u578B\u5DF2\u5B58\u5728\uFF0C\u8DF3\u8FC7\u4E0B\u8F7D: ${filename}`);
     return { ok: true, modelPath };
@@ -588,7 +620,7 @@ async function probeUrl(url, logger) {
 async function downloadFromUrl(url, modelPath, logger) {
   const tmpPath = `${modelPath}.downloading`;
   try {
-    (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(modelPath), { recursive: true });
+    (0, import_node_fs26.mkdirSync)((0, import_node_path22.dirname)(modelPath), { recursive: true });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30 * 60 * 1e3);
     try {
@@ -604,7 +636,7 @@ async function downloadFromUrl(url, modelPath, logger) {
         return { ok: false, modelPath, error: "\u6A21\u578B\u4E0B\u8F7D\u5931\u8D25: \u54CD\u5E94\u4F53\u4E3A\u7A7A" };
       }
       const contentLength = Number(res.headers.get("content-length") ?? 0);
-      const writeStream = (0, import_node_fs25.createWriteStream)(tmpPath);
+      const writeStream = (0, import_node_fs26.createWriteStream)(tmpPath);
       const readable = import_node_stream2.Readable.fromWeb(res.body);
       let downloaded = 0;
       let lastLogPercent = 0;
@@ -626,14 +658,14 @@ async function downloadFromUrl(url, modelPath, logger) {
     }
     const { renameSync: renameSync2 } = await import("fs");
     renameSync2(tmpPath, modelPath);
-    const fileSize = (0, import_node_fs25.statSync)(modelPath).size;
+    const fileSize = (0, import_node_fs26.statSync)(modelPath).size;
     logger.info(
-      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path21.basename)(modelPath)} (${formatBytes2(fileSize)})`
+      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path22.basename)(modelPath)} (${formatBytes2(fileSize)})`
     );
     return { ok: true, modelPath };
   } catch (err) {
     try {
-      if ((0, import_node_fs25.existsSync)(tmpPath)) (0, import_node_fs25.unlinkSync)(tmpPath);
+      if ((0, import_node_fs26.existsSync)(tmpPath)) (0, import_node_fs26.unlinkSync)(tmpPath);
     } catch {
     }
     const msg = err?.name === "AbortError" ? "\u6A21\u578B\u4E0B\u8F7D\u8D85\u65F6\uFF0830 \u5206\u949F\uFF09" : err?.message ?? String(err);
@@ -645,8 +677,8 @@ function findWhisperBinary(dataDir, logger) {
   const binDir = resolveBinDir(dataDir);
   const binNames = (0, import_node_os4.platform)() === "win32" ? ["whisper-cli.exe", "whisper.exe", "main.exe"] : ["whisper-cli", "whisper", "main"];
   for (const name of binNames) {
-    const binPath = (0, import_node_path21.join)(binDir, name);
-    if ((0, import_node_fs25.existsSync)(binPath)) {
+    const binPath = (0, import_node_path22.join)(binDir, name);
+    if ((0, import_node_fs26.existsSync)(binPath)) {
       logger.info(`[whisper-local] \u627E\u5230\u672C\u5730\u4E8C\u8FDB\u5236: ${binPath}`);
       return binPath;
     }
@@ -697,7 +729,7 @@ async function transcribeWithWhisperLocal(audioFilePath, localConfig, dataDir, l
       return { ok: false, error: `\u6A21\u578B\u4E0B\u8F7D\u5931\u8D25: ${downloadResult.error}` };
     }
   }
-  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  const modelPath = (0, import_node_path22.join)(modelsDir, MODEL_FILENAMES[modelSize]);
   let inputPath = audioFilePath;
   let tmpWavPath = null;
   const actualFmt = detectAudioFormat(audioFilePath);
@@ -749,10 +781,10 @@ async function transcribeWithWhisperLocal(audioFilePath, localConfig, dataDir, l
     logger.info(`[whisper-local] \u8F6C\u5199\u8017\u65F6: ${Math.round(elapsed / 1e3)}s`);
     const jsonPath = inputPath + ".json";
     let jsonContent;
-    if ((0, import_node_fs25.existsSync)(jsonPath)) {
-      jsonContent = (0, import_node_fs25.readFileSync)(jsonPath, "utf-8");
+    if ((0, import_node_fs26.existsSync)(jsonPath)) {
+      jsonContent = (0, import_node_fs26.readFileSync)(jsonPath, "utf-8");
       try {
-        (0, import_node_fs25.unlinkSync)(jsonPath);
+        (0, import_node_fs26.unlinkSync)(jsonPath);
       } catch {
       }
     } else {
@@ -830,10 +862,10 @@ function getPhysicalCoreCount() {
 }
 function detectAudioFormat(filePath) {
   try {
-    const fd = (0, import_node_fs25.openSync)(filePath, "r");
+    const fd = (0, import_node_fs26.openSync)(filePath, "r");
     const buf = Buffer.alloc(12);
-    (0, import_node_fs25.readSync)(fd, buf, 0, 12, 0);
-    (0, import_node_fs25.closeSync)(fd);
+    (0, import_node_fs26.readSync)(fd, buf, 0, 12, 0);
+    (0, import_node_fs26.closeSync)(fd);
     const header = buf.toString("ascii", 0, 4);
     const header8 = buf.toString("ascii", 0, 8);
     if (header === "RIFF" && buf.toString("ascii", 8, 12) === "WAVE") return ".wav";
@@ -868,7 +900,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
       timeout: 12e4,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (ffmpegResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+    if (ffmpegResult.status === 0 && (0, import_node_fs26.existsSync)(outputPath)) {
       logger.info(`[whisper-local] ffmpeg \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
       return { ok: true };
     }
@@ -881,7 +913,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         ["--rate", "16000", "--mono", inputPath, outputPath],
         { encoding: "utf-8", timeout: 12e4, stdio: ["pipe", "pipe", "pipe"] }
       );
-      if (opusResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+      if (opusResult.status === 0 && (0, import_node_fs26.existsSync)(outputPath)) {
         logger.info(`[whisper-local] opusdec \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
@@ -895,7 +927,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
     if (detectedExt && !inputPath.endsWith(detectedExt)) {
       tmpCopy = inputPath + ".detected" + detectedExt;
       try {
-        (0, import_node_fs25.copyFileSync)(inputPath, tmpCopy);
+        (0, import_node_fs26.copyFileSync)(inputPath, tmpCopy);
         actualInputPath = tmpCopy;
         logger.info(
           `[whisper-local] \u68C0\u6D4B\u5230\u5B9E\u9645\u683C\u5F0F ${detectedExt}\uFF0C\u4E34\u65F6\u91CD\u547D\u540D`
@@ -919,22 +951,22 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         timeout: 12e4,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs26.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs25.unlinkSync)(tmpCopy);
+          (0, import_node_fs26.unlinkSync)(tmpCopy);
         } catch {
         }
       }
-      if (afResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
+      if (afResult.status === 0 && (0, import_node_fs26.existsSync)(outputPath)) {
         logger.info(`[whisper-local] afconvert \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
       const stderr = afResult.stderr?.slice(0, 200) ?? "";
       return { ok: false, error: `afconvert \u8F6C\u6362\u5931\u8D25 (exit ${afResult.status}): ${stderr}` };
     } catch (err) {
-      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs26.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs25.unlinkSync)(tmpCopy);
+          (0, import_node_fs26.unlinkSync)(tmpCopy);
         } catch {
         }
       }
@@ -945,9 +977,9 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
   return { ok: false, error: `\u65E0\u6CD5\u5C06\u97F3\u9891\u8F6C\u6362\u4E3A WAV \u683C\u5F0F\u3002${fmtHint}` };
 }
 function cleanupTmpWav(path2) {
-  if (path2 && (0, import_node_fs25.existsSync)(path2)) {
+  if (path2 && (0, import_node_fs26.existsSync)(path2)) {
     try {
-      (0, import_node_fs25.unlinkSync)(path2);
+      (0, import_node_fs26.unlinkSync)(path2);
     } catch {
     }
   }
@@ -1033,13 +1065,13 @@ function formatBytes2(bytes) {
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
   return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
 }
-var import_node_child_process2, import_node_fs25, import_node_path21, import_promises3, import_node_stream2, import_node_os4, WHISPER_MODELS_DIR, WHISPER_BIN_DIR, HF_MODEL_URL_TEMPLATE, MODELSCOPE_MODEL_URL_TEMPLATE, PROBE_TIMEOUT_MS, MODEL_FILENAMES, MODEL_DISK_SIZES;
+var import_node_child_process2, import_node_fs26, import_node_path22, import_promises3, import_node_stream2, import_node_os4, WHISPER_MODELS_DIR, WHISPER_BIN_DIR, HF_MODEL_URL_TEMPLATE, MODELSCOPE_MODEL_URL_TEMPLATE, PROBE_TIMEOUT_MS, MODEL_FILENAMES, MODEL_DISK_SIZES;
 var init_whisper_local = __esm({
   "src/recording/whisper-local.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_node_fs25 = require("fs");
-    import_node_path21 = require("path");
+    import_node_fs26 = require("fs");
+    import_node_path22 = require("path");
     import_promises3 = require("stream/promises");
     import_node_stream2 = require("stream");
     import_node_os4 = require("os");
@@ -1194,7 +1226,7 @@ async function initializeAsr(config, dataDir, logger) {
   }
 }
 async function transcribeAudio(audioFilePath, config, logger, options = {}) {
-  if (!(0, import_node_fs26.existsSync)(audioFilePath)) {
+  if (!(0, import_node_fs27.existsSync)(audioFilePath)) {
     return { ok: false, error: `\u97F3\u9891\u6587\u4EF6\u4E0D\u5B58\u5728: ${audioFilePath}` };
   }
   logger.info(
@@ -1338,8 +1370,8 @@ async function runTranscriptionWorkflow(params) {
     createdAt
   );
   const transcriptDataFilename = buildTranscriptDataFilename(recordingId);
-  const transcriptDataPath = (0, import_node_path22.join)(transcriptDataDir, transcriptDataFilename);
-  (0, import_node_fs26.writeFileSync)(
+  const transcriptDataPath = (0, import_node_path23.join)(transcriptDataDir, transcriptDataFilename);
+  (0, import_node_fs27.writeFileSync)(
     transcriptDataPath,
     JSON.stringify(transcriptData, null, 2),
     "utf-8"
@@ -1347,14 +1379,14 @@ async function runTranscriptionWorkflow(params) {
   logger.info(`[asr] \u8F6C\u5199 JSON \u5DF2\u5199\u5165: ${transcriptDataPath}`);
   const safeSummary = title.replace(/[/\\:*?"<>|]/g, "").trim().slice(0, 20);
   const filename = safeSummary ? `${recordingId}_${safeSummary}.md` : `${recordingId}.md`;
-  const filePath = (0, import_node_path22.join)(transcriptsDir, filename);
-  (0, import_node_fs26.writeFileSync)(filePath, markdown, "utf-8");
+  const filePath = (0, import_node_path23.join)(transcriptsDir, filename);
+  (0, import_node_fs27.writeFileSync)(filePath, markdown, "utf-8");
   logger.info(`[asr] \u8F6C\u5199\u6587\u672C\u5DF2\u5199\u5165: ${filePath}`);
   let summaryFilename;
   if (summary) {
     summaryFilename = `${recordingId}.md`;
-    const summaryFilePath = (0, import_node_path22.join)(summariesDir, summaryFilename);
-    (0, import_node_fs26.writeFileSync)(summaryFilePath, summary, "utf-8");
+    const summaryFilePath = (0, import_node_path23.join)(summariesDir, summaryFilename);
+    (0, import_node_fs27.writeFileSync)(summaryFilePath, summary, "utf-8");
     logger.info(`[asr] \u6458\u8981\u6587\u672C\u5DF2\u5199\u5165: ${summaryFilePath}`);
   }
   return {
@@ -1439,7 +1471,7 @@ async function transcribeWithModelProxy(audioOssUrl, apiConfig, logger) {
 }
 async function transcribeWithWhisperLocal2(audioFilePath, config, logger) {
   const { transcribeWithWhisperLocal: runLocal } = await Promise.resolve().then(() => (init_whisper_local(), whisper_local_exports));
-  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path22.join)(audioFilePath, "..", "..", "..");
+  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path23.join)(audioFilePath, "..", "..", "..");
   const localConfig = config.local ?? {};
   const result = await runLocal(
     audioFilePath,
@@ -1742,12 +1774,12 @@ function formatTranscriptSegmentText(segment) {
   }
   return text;
 }
-var import_node_fs26, import_node_path22, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
+var import_node_fs27, import_node_path23, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
 var init_asr = __esm({
   "src/recording/asr.ts"() {
     "use strict";
-    import_node_fs26 = require("fs");
-    import_node_path22 = require("path");
+    import_node_fs27 = require("fs");
+    import_node_path23 = require("path");
     init_credentials();
     init_env();
     init_transcript_document();
@@ -5392,7 +5424,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.10.3".trim();
+  const version = "1.10.4".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -7196,7 +7228,7 @@ function resolveUpdateChannel(params) {
 }
 
 // src/update/index.ts
-var import_node_path9 = require("path");
+var import_node_path10 = require("path");
 
 // src/update/checker.ts
 function parseSemver(v) {
@@ -7298,8 +7330,8 @@ var UpdateChecker = class {
 };
 
 // src/update/executor.ts
-var import_node_fs9 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs10 = require("fs");
+var import_node_path9 = require("path");
 var import_node_os = require("os");
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
 var BASE_URL = "https://artifact.yoooclaw.com/plugin";
@@ -7309,9 +7341,9 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
   }
   const tgzUrl = `${BASE_URL}/v${version}/yoooclaw-phone-notifications-${version}.tgz`;
   logger.info(`\u6267\u884C\u66F4\u65B0: ${tgzUrl} \u2192 ${targetDir}`);
-  const workDir = (0, import_node_fs9.mkdtempSync)((0, import_node_path8.join)((0, import_node_os.tmpdir)(), ".openclaw-plugin-update-"));
-  const tgzPath = (0, import_node_path8.join)(workDir, "plugin.tgz");
-  const stagingDir = (0, import_node_path8.join)(workDir, "staged");
+  const workDir = (0, import_node_fs10.mkdtempSync)((0, import_node_path9.join)((0, import_node_os.tmpdir)(), ".openclaw-plugin-update-"));
+  const tgzPath = (0, import_node_path9.join)(workDir, "plugin.tgz");
+  const stagingDir = (0, import_node_path9.join)(workDir, "staged");
   let backupDir = null;
   try {
     logger.info("\u4E0B\u8F7D\u63D2\u4EF6\u5305...");
@@ -7320,9 +7352,9 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
       return { success: false, message: `\u4E0B\u8F7D\u5931\u8D25 (HTTP ${response.status}): ${tgzUrl}` };
     }
     const buffer = Buffer.from(await response.arrayBuffer());
-    (0, import_node_fs9.writeFileSync)(tgzPath, buffer);
+    (0, import_node_fs10.writeFileSync)(tgzPath, buffer);
     logger.info(`\u4E0B\u8F7D\u5B8C\u6210 (${buffer.length} bytes)`);
-    (0, import_node_fs9.mkdirSync)(stagingDir, { recursive: true });
+    (0, import_node_fs10.mkdirSync)(stagingDir, { recursive: true });
     const tarResult = await runCommand(
       ["tar", "-xzf", tgzPath, "-C", stagingDir, "--strip-components=1"],
       { timeoutMs: 3e4 }
@@ -7331,14 +7363,14 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
       const err = tarResult.stderr || tarResult.stdout || "unknown error";
       return { success: false, message: `\u89E3\u538B\u5931\u8D25: ${err}` };
     }
-    (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(targetDir), { recursive: true });
+    (0, import_node_fs10.mkdirSync)((0, import_node_path9.dirname)(targetDir), { recursive: true });
     try {
       backupDir = `${targetDir}.bak.${Date.now()}`;
-      (0, import_node_fs9.renameSync)(targetDir, backupDir);
+      (0, import_node_fs10.renameSync)(targetDir, backupDir);
     } catch {
       backupDir = null;
     }
-    (0, import_node_fs9.renameSync)(stagingDir, targetDir);
+    (0, import_node_fs10.renameSync)(stagingDir, targetDir);
     try {
       await updateConfigRecord2(version, tgzUrl);
     } catch (err) {
@@ -7346,7 +7378,7 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     }
     if (backupDir) {
       try {
-        (0, import_node_fs9.rmSync)(backupDir, { force: true, recursive: true });
+        (0, import_node_fs10.rmSync)(backupDir, { force: true, recursive: true });
       } catch {
       }
     }
@@ -7356,8 +7388,8 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
   } catch (err) {
     if (backupDir) {
       try {
-        (0, import_node_fs9.rmSync)(targetDir, { force: true, recursive: true });
-        (0, import_node_fs9.renameSync)(backupDir, targetDir);
+        (0, import_node_fs10.rmSync)(targetDir, { force: true, recursive: true });
+        (0, import_node_fs10.renameSync)(backupDir, targetDir);
         logger.info("\u5DF2\u56DE\u6EDA\u5230\u4E4B\u524D\u7248\u672C");
       } catch (rollbackErr) {
         logger.error(`\u56DE\u6EDA\u5931\u8D25: ${String(rollbackErr)}`);
@@ -7368,7 +7400,7 @@ async function executeUpdate(version, runCommand, logger, targetDir, updateConfi
     return { success: false, message: errMsg };
   } finally {
     try {
-      (0, import_node_fs9.rmSync)(workDir, { force: true, recursive: true });
+      (0, import_node_fs10.rmSync)(workDir, { force: true, recursive: true });
     } catch {
     }
   }
@@ -7383,7 +7415,7 @@ function resolveTargetDir(api) {
     if (installPath) return installPath;
   } catch {
   }
-  return (0, import_node_path9.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
+  return (0, import_node_path10.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
 }
 async function updateConfigRecord(api, version, targetDir, tgzUrl) {
   const configApi = api.runtime.config;
@@ -7571,10 +7603,10 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path17 = require("path");
+var import_node_path18 = require("path");
 
 // src/cli/auth.ts
-var import_node_fs10 = require("fs");
+var import_node_fs11 = require("fs");
 init_credentials();
 function registerAuthCli(program) {
   const auth = program.command("auth").description("\u7528\u6237\u8BA4\u8BC1\u7BA1\u7406");
@@ -7610,12 +7642,12 @@ function registerAuthCli(program) {
   });
   auth.command("clear").description("\u6E05\u9664\u5DF2\u4FDD\u5B58\u7684\u8BA4\u8BC1\u4FE1\u606F").action(() => {
     const path2 = credentialsPath();
-    if ((0, import_node_fs10.existsSync)(path2)) {
+    if ((0, import_node_fs11.existsSync)(path2)) {
       const creds = readCredentials();
       delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
-        (0, import_node_fs10.rmSync)(path2, { force: true });
+        (0, import_node_fs11.rmSync)(path2, { force: true });
       } else {
         writeCredentials(creds);
       }
@@ -7747,23 +7779,23 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.ts
-var import_node_fs11 = require("fs");
-var import_node_path10 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path11 = require("path");
 var SYNC_FETCH_LIMIT = 300;
 function checkpointPath(dir) {
-  return (0, import_node_path10.join)(dir, ".checkpoint.json");
+  return (0, import_node_path11.join)(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!(0, import_node_fs11.existsSync)(p)) return {};
+  if (!(0, import_node_fs12.existsSync)(p)) return {};
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  (0, import_node_fs11.writeFileSync)(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  (0, import_node_fs12.writeFileSync)(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");
@@ -7856,24 +7888,24 @@ function registerNtfSync(ntf, ctx) {
 }
 
 // src/cli/ntf-monitor.ts
-var import_node_fs12 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_path12 = require("path");
 function tasksDir2(ctx) {
   const base = ctx.workspaceDir || ctx.stateDir;
   if (!base) throw new Error("workspaceDir and stateDir both unavailable");
-  return (0, import_node_path11.join)(base, "tasks");
+  return (0, import_node_path12.join)(base, "tasks");
 }
 function readMeta2(taskDir) {
-  const metaPath = (0, import_node_path11.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs12.existsSync)(metaPath)) return null;
+  const metaPath = (0, import_node_path12.join)(taskDir, "meta.json");
+  if (!(0, import_node_fs13.existsSync)(metaPath)) return null;
   try {
-    return JSON.parse((0, import_node_fs12.readFileSync)(metaPath, "utf-8"));
+    return JSON.parse((0, import_node_fs13.readFileSync)(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta2(taskDir, meta) {
-  (0, import_node_fs12.writeFileSync)((0, import_node_path11.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  (0, import_node_fs13.writeFileSync)((0, import_node_path12.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateReadme(name, description) {
   return `# Monitor Task: ${name}
@@ -7892,27 +7924,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 = tasksDir2(ctx);
-    if (!(0, import_node_fs12.existsSync)(dir)) {
+    if (!(0, import_node_fs13.existsSync)(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
-    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs13.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const meta = readMeta2((0, import_node_path11.join)(dir, entry.name));
+      const meta = readMeta2((0, import_node_path12.join)(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 = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path12.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
-    const checkpointPath2 = (0, import_node_path11.join)(taskDir, "checkpoint.json");
+    const checkpointPath2 = (0, import_node_path12.join)(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if ((0, import_node_fs12.existsSync)(checkpointPath2)) {
+    if ((0, import_node_fs13.existsSync)(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse((0, import_node_fs12.readFileSync)(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse((0, import_node_fs13.readFileSync)(checkpointPath2, "utf-8"));
       } catch {
       }
     }
@@ -7927,8 +7959,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 = tasksDir2(ctx);
-      const taskDir = (0, import_node_path11.join)(dir, name);
-      if ((0, import_node_fs12.existsSync)(taskDir)) {
+      const taskDir = (0, import_node_path12.join)(dir, name);
+      if ((0, import_node_fs13.existsSync)(taskDir)) {
         exitError("ALREADY_EXISTS", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u5DF2\u5B58\u5728`);
       }
       let matchRules;
@@ -7940,7 +7972,7 @@ function registerNtfMonitor(ntf, ctx) {
           "match-rules \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON"
         );
       }
-      (0, import_node_fs12.mkdirSync)(taskDir, { recursive: true });
+      (0, import_node_fs13.mkdirSync)(taskDir, { recursive: true });
       const meta = {
         name,
         description: opts.description,
@@ -7950,13 +7982,13 @@ function registerNtfMonitor(ntf, ctx) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeMeta2(taskDir, meta);
-      (0, import_node_fs12.writeFileSync)(
-        (0, import_node_path11.join)(taskDir, "fetch.py"),
+      (0, import_node_fs13.writeFileSync)(
+        (0, import_node_path12.join)(taskDir, "fetch.py"),
         generateFetchPy(name, matchRules),
         "utf-8"
       );
-      (0, import_node_fs12.writeFileSync)(
-        (0, import_node_path11.join)(taskDir, "README.md"),
+      (0, import_node_fs13.writeFileSync)(
+        (0, import_node_path12.join)(taskDir, "README.md"),
         generateReadme(name, opts.description),
         "utf-8"
       );
@@ -7984,8 +8016,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 = (0, import_node_path11.join)(tasksDir2(ctx), name);
-    if (!(0, import_node_fs12.existsSync)(taskDir)) {
+    const taskDir = (0, import_node_path12.join)(tasksDir2(ctx), name);
+    if (!(0, import_node_fs13.existsSync)(taskDir)) {
       exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     }
     if (!opts.yes) {
@@ -7998,7 +8030,7 @@ function registerNtfMonitor(ntf, ctx) {
       });
       process.exit(1);
     }
-    (0, import_node_fs12.rmSync)(taskDir, { recursive: true, force: true });
+    (0, import_node_fs13.rmSync)(taskDir, { recursive: true, force: true });
     output({
       ok: true,
       name,
@@ -8010,7 +8042,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("\u542F\u7528\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path12.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = true;
@@ -8018,7 +8050,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 = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path12.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = false;
@@ -8327,9 +8359,9 @@ function registerLightSend(light) {
 }
 
 // src/cli/light-setup-tools.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_os2 = require("os");
-var import_node_path12 = require("path");
+var import_node_path13 = require("path");
 function isObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -8343,7 +8375,7 @@ function ensureArray(obj, key) {
 function resolveConfigPath2() {
   const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
   if (fromEnv) return fromEnv;
-  return (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
+  return (0, import_node_path13.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
 }
 function upsertLightControlAlsoAllow(cfg) {
   if (!isObject(cfg.tools)) cfg.tools = {};
@@ -8372,12 +8404,12 @@ function upsertLightControlAlsoAllow(cfg) {
 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 (!(0, import_node_fs13.existsSync)(configPath)) {
+    if (!(0, import_node_fs14.existsSync)(configPath)) {
       exitError("CONFIG_NOT_FOUND", `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
     }
     let cfg = {};
     try {
-      const raw = (0, import_node_fs13.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs14.readFileSync)(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isObject(parsed)) cfg = parsed;
     } catch (err) {
@@ -8385,8 +8417,8 @@ function registerLightSetupTools(light) {
     }
     const result = upsertLightControlAlsoAllow(cfg);
     try {
-      (0, import_node_fs13.mkdirSync)((0, import_node_path12.dirname)(configPath), { recursive: true });
-      (0, import_node_fs13.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+      (0, import_node_fs14.mkdirSync)((0, import_node_path13.dirname)(configPath), { recursive: true });
+      (0, import_node_fs14.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
     } catch (err) {
       exitError("WRITE_FAILED", `\u5199\u5165\u914D\u7F6E\u5931\u8D25: ${err?.message ?? String(err)}`);
     }
@@ -8404,17 +8436,17 @@ function registerLightSetupTools(light) {
 }
 
 // src/cli/tunnel-status.ts
-var import_node_fs14 = require("fs");
-var import_node_path13 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path14 = require("path");
 init_credentials();
 init_env();
-var STATUS_REL_PATH = (0, import_node_path13.join)("plugins", "phone-notifications", "tunnel-status.json");
+var STATUS_REL_PATH = (0, import_node_path14.join)("plugins", "phone-notifications", "tunnel-status.json");
 function readTunnelStatus(ctx) {
   if (!ctx.stateDir) return null;
-  const filePath = (0, import_node_path13.join)(ctx.stateDir, STATUS_REL_PATH);
-  if (!(0, import_node_fs14.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path14.join)(ctx.stateDir, STATUS_REL_PATH);
+  if (!(0, import_node_fs15.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs14.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs15.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -8482,24 +8514,24 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-var import_node_fs15 = require("fs");
-var import_node_path14 = require("path");
+var import_node_fs16 = require("fs");
+var import_node_path15 = require("path");
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = (0, import_node_path14.join)(
+    const dir = (0, import_node_path15.join)(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if ((0, import_node_fs15.existsSync)(dir)) return dir;
+    if ((0, import_node_fs16.existsSync)(dir)) return dir;
   }
   return null;
 }
 function listLogDateKeys(dir) {
   const pattern = /^(\d{4}-\d{2}-\d{2})\.log$/;
   const keys = [];
-  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs16.readdirSync)(dir, { withFileTypes: true })) {
     if (!entry.isFile()) continue;
     const m = pattern.exec(entry.name);
     if (m) keys.push(m[1]);
@@ -8507,9 +8539,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = (0, import_node_path14.join)(dir, `${dateKey}.log`);
-  if (!(0, import_node_fs15.existsSync)(filePath)) return;
-  const content = (0, import_node_fs15.readFileSync)(filePath, "utf-8");
+  const filePath = (0, import_node_path15.join)(dir, `${dateKey}.log`);
+  if (!(0, import_node_fs16.existsSync)(filePath)) return;
+  const content = (0, import_node_fs16.readFileSync)(filePath, "utf-8");
   const lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -8576,12 +8608,12 @@ function registerEnvCli(ntf) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_readline = require("readline");
 init_host();
 
 // src/cli/doctor/check-dangerous-flags.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 function isObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -8598,13 +8630,13 @@ var checkDangerousFlags = ({ cfg, configPath }) => {
     detail: "\u8FD9\u4F1A\u5173\u95ED Control UI \u7684\u8BBE\u5907\u8EAB\u4EFD\u9A8C\u8BC1\uFF0C\u4EFB\u4F55\u4EBA\u90FD\u53EF\u4EE5\u8BBF\u95EE\u63A7\u5236\u9762\u677F\u3002",
     fixDescription: "\u8BBE\u4E3A false",
     fix: () => {
-      const raw = (0, import_node_fs16.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs17.readFileSync)(configPath, "utf-8");
       const config = JSON.parse(raw);
       const gw = config.gateway;
       const cui = gw.controlUi;
       cui.dangerouslyDisableDeviceAuth = false;
-      (0, import_node_fs16.copyFileSync)(configPath, configPath + ".bak");
-      (0, import_node_fs16.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      (0, import_node_fs17.copyFileSync)(configPath, configPath + ".bak");
+      (0, import_node_fs17.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   };
 };
@@ -8652,11 +8684,11 @@ function warnEmpty() {
 }
 
 // src/cli/doctor/check-state-dir-perms.ts
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var checkStateDirPerms = ({ stateDir }) => {
   let mode;
   try {
-    mode = (0, import_node_fs17.statSync)(stateDir).mode;
+    mode = (0, import_node_fs18.statSync)(stateDir).mode;
   } catch {
     return null;
   }
@@ -8670,7 +8702,7 @@ var checkStateDirPerms = ({ stateDir }) => {
     detail: "\u5176\u4ED6\u7528\u6237\u53EF\u4EE5\u8BFB\u53D6\u8BE5\u76EE\u5F55\u4E0B\u7684\u51ED\u8BC1\u548C\u914D\u7F6E\u6587\u4EF6\u3002",
     fixDescription: "chmod 700 " + stateDir,
     fix: () => {
-      (0, import_node_fs17.chmodSync)(stateDir, 448);
+      (0, import_node_fs18.chmodSync)(stateDir, 448);
     }
   };
 };
@@ -8725,16 +8757,16 @@ var checkCredentials = () => {
 };
 
 // src/cli/doctor/check-tunnel.ts
-var import_node_fs18 = require("fs");
-var import_node_path15 = require("path");
-var STATUS_REL_PATH2 = (0, import_node_path15.join)(
+var import_node_fs19 = require("fs");
+var import_node_path16 = require("path");
+var STATUS_REL_PATH2 = (0, import_node_path16.join)(
   "plugins",
   "phone-notifications",
   "tunnel-status.json"
 );
 var checkTunnel = ({ stateDir }) => {
-  const filePath = (0, import_node_path15.join)(stateDir, STATUS_REL_PATH2);
-  if (!(0, import_node_fs18.existsSync)(filePath)) {
+  const filePath = (0, import_node_path16.join)(stateDir, STATUS_REL_PATH2);
+  if (!(0, import_node_fs19.existsSync)(filePath)) {
     return {
       id: "tunnel",
       severity: "warn",
@@ -8746,7 +8778,7 @@ var checkTunnel = ({ stateDir }) => {
   }
   let status;
   try {
-    status = JSON.parse((0, import_node_fs18.readFileSync)(filePath, "utf-8"));
+    status = JSON.parse((0, import_node_fs19.readFileSync)(filePath, "utf-8"));
   } catch {
     return {
       id: "tunnel",
@@ -8839,9 +8871,9 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!(0, import_node_fs19.existsSync)(configPath)) return {};
+  if (!(0, import_node_fs20.existsSync)(configPath)) return {};
   try {
-    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -9042,7 +9074,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("readline");
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -9128,9 +9160,9 @@ async function setupLocal(rl) {
 function registerRecSetup(rec, ctx) {
   rec.command("setup").description("\u4EA4\u4E92\u5F0F\u914D\u7F6E ASR \u8F6C\u5199\u53C2\u6570\uFF0C\u4FDD\u5B58\u5230\u672C\u5730\u914D\u7F6E\u6587\u4EF6").action(async () => {
     const configPath = resolveAsrConfigPath(ctx);
-    if ((0, import_node_fs20.existsSync)(configPath)) {
+    if ((0, import_node_fs21.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs20.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs21.readFileSync)(configPath, "utf-8"));
         process.stderr.write(`\u5F53\u524D\u5DF2\u6709\u914D\u7F6E\uFF1Amode = ${existing.mode}`);
         if (existing.updatedAt) process.stderr.write(`\uFF0C\u66F4\u65B0\u4E8E ${existing.updatedAt}`);
         process.stderr.write("\n");
@@ -9143,7 +9175,7 @@ function registerRecSetup(rec, ctx) {
       const modeIdx = await askChoice(rl, "\u9009\u62E9\u6A21\u5F0F", ["api\uFF08\u4E91\u7AEF model-proxy \u957F\u5F55\u97F3\uFF09", "local\uFF08\u672C\u5730 Whisper\uFF09"]);
       const config = modeIdx === 0 ? await setupApi(rl) : await setupLocal(rl);
       const stored = { ...config, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-      (0, import_node_fs20.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      (0, import_node_fs21.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
 
@@ -9157,8 +9189,8 @@ function registerRecSetup(rec, ctx) {
 
 // src/cli/update.ts
 var import_node_child_process = require("child_process");
-var import_node_fs21 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path17 = require("path");
 var import_node_os3 = __toESM(require("os"), 1);
 init_host();
 var BASE_URL2 = "https://artifact.yoooclaw.com/plugin";
@@ -9217,9 +9249,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = (0, import_node_path16.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = (0, import_node_path17.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    (0, import_node_fs21.writeFileSync)(tmpScript, installScript, "utf-8");
+    (0, import_node_fs22.writeFileSync)(tmpScript, installScript, "utf-8");
   } catch (err) {
     const msg = `\u5199\u5165\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${err?.message ?? String(err)}`;
     if (json) {
@@ -9237,7 +9269,7 @@ async function runUpdate(ctx, opts) {
     { stdio: "inherit" }
   );
   try {
-    (0, import_node_fs21.unlinkSync)(tmpScript);
+    (0, import_node_fs22.unlinkSync)(tmpScript);
   } catch {
   }
   if (result.error) {
@@ -9301,10 +9333,10 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return void 0;
   }
-  if ((0, import_node_path17.basename)(workspaceDir) !== "workspace") {
+  if ((0, import_node_path18.basename)(workspaceDir) !== "workspace") {
     return void 0;
   }
-  return (0, import_node_path17.dirname)(workspaceDir);
+  return (0, import_node_path18.dirname)(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
@@ -9550,12 +9582,12 @@ function registerLightControlTool(api, logger) {
 }
 
 // src/plugin/lifecycle.ts
-var import_node_fs30 = require("fs");
+var import_node_fs31 = require("fs");
 init_host();
 
 // src/notification/app-name-map.ts
-var import_node_fs22 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path19 = require("path");
 init_credentials();
 init_env();
 var PLUGIN_STATE_DIR = "phone-notifications";
@@ -9576,7 +9608,7 @@ function isAppNameMapApiResponse(v) {
   );
 }
 function getCachePath(stateDir) {
-  return (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+  return (0, import_node_path19.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
 }
 function createAppNameMapProvider(opts) {
   const { stateDir, logger } = opts;
@@ -9588,9 +9620,9 @@ function createAppNameMapProvider(opts) {
   let inFlightFetch = null;
   function loadFromDisk() {
     const path2 = getCachePath(stateDir);
-    if (!(0, import_node_fs22.existsSync)(path2)) return;
+    if (!(0, import_node_fs23.existsSync)(path2)) return;
     try {
-      const raw = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs23.readFileSync)(path2, "utf-8"));
       if (!isRecordOfStrings(raw)) return;
       map.clear();
       for (const [k, v] of Object.entries(raw)) map.set(k, v);
@@ -9634,10 +9666,10 @@ function createAppNameMapProvider(opts) {
         logger.warn("[app-name-map] refresh succeeded but got 0 entries");
         return;
       }
-      const dir = (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
-      (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_node_path19.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
+      (0, import_node_fs23.mkdirSync)(dir, { recursive: true });
       const cachePath = getCachePath(stateDir);
-      (0, import_node_fs22.writeFileSync)(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      (0, import_node_fs23.writeFileSync)(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);
@@ -9681,8 +9713,8 @@ function createAppNameMapProvider(opts) {
 }
 
 // src/recording/storage.ts
-var import_node_fs23 = require("fs");
-var import_node_path19 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path20 = require("path");
 
 // src/recording/state-machine.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -9743,7 +9775,7 @@ function stripMarkdownFence(markdown) {
 }
 function deriveTitleFromTranscriptPath(transcriptFile, recordingId) {
   if (!transcriptFile) return void 0;
-  const name = (0, import_node_path19.basename)(transcriptFile, ".md");
+  const name = (0, import_node_path20.basename)(transcriptFile, ".md");
   const prefix = `${recordingId}_`;
   if (name.startsWith(prefix)) {
     const derived = name.slice(prefix.length).trim();
@@ -9771,22 +9803,22 @@ function extractTranscriptContent(markdown) {
   return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 function resolveRecordingStorageDir(ctx, logger) {
-  const stateRecDir = (0, import_node_path19.join)(
+  const stateRecDir = (0, import_node_path20.join)(
     ctx.stateDir,
     "plugins",
     "phone-notifications",
     RECORDINGS_DIR
   );
   try {
-    (0, import_node_fs23.mkdirSync)(stateRecDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(stateRecDir, { recursive: true });
     logger.info(`\u5F55\u97F3\u5C06\u5199\u5165 stateDir \u8DEF\u5F84: ${stateRecDir}`);
     return stateRecDir;
   } catch {
   }
   if (ctx.workspaceDir) {
-    const wsRecDir = (0, import_node_path19.join)(ctx.workspaceDir, RECORDINGS_DIR);
+    const wsRecDir = (0, import_node_path20.join)(ctx.workspaceDir, RECORDINGS_DIR);
     try {
-      (0, import_node_fs23.mkdirSync)(wsRecDir, { recursive: true });
+      (0, import_node_fs24.mkdirSync)(wsRecDir, { recursive: true });
       logger.warn(`stateDir \u4E0D\u53EF\u7528\uFF0C\u5F55\u97F3\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${wsRecDir}`);
       return wsRecDir;
     } catch {
@@ -9798,11 +9830,11 @@ var RecordingStorage = class {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.audioDir = (0, import_node_path19.join)(dir, AUDIO_DIR);
-    this.transcriptDataDir = (0, import_node_path19.join)(dir, TRANSCRIPT_DATA_DIR);
-    this.transcriptsDir = (0, import_node_path19.join)(dir, TRANSCRIPTS_DIR);
-    this.summariesDir = (0, import_node_path19.join)(dir, SUMMARIES_DIR);
-    this.indexPath = (0, import_node_path19.join)(dir, INDEX_FILE);
+    this.audioDir = (0, import_node_path20.join)(dir, AUDIO_DIR);
+    this.transcriptDataDir = (0, import_node_path20.join)(dir, TRANSCRIPT_DATA_DIR);
+    this.transcriptsDir = (0, import_node_path20.join)(dir, TRANSCRIPTS_DIR);
+    this.summariesDir = (0, import_node_path20.join)(dir, SUMMARIES_DIR);
+    this.indexPath = (0, import_node_path20.join)(dir, INDEX_FILE);
   }
   dir;
   audioDir;
@@ -9813,10 +9845,10 @@ var RecordingStorage = class {
   index = { recordings: [] };
   /** 初始化目录结构并加载索引 */
   async init() {
-    (0, import_node_fs23.mkdirSync)(this.audioDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.transcriptDataDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.transcriptsDir, { recursive: true });
-    (0, import_node_fs23.mkdirSync)(this.summariesDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(this.audioDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(this.transcriptDataDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(this.transcriptsDir, { recursive: true });
+    (0, import_node_fs24.mkdirSync)(this.summariesDir, { recursive: true });
     this.loadIndex();
     this.logger.info(
       `\u5F55\u97F3\u5B58\u50A8\u5DF2\u521D\u59CB\u5316: ${this.dir}\uFF08\u5171 ${this.index.recordings.length} \u6761\u8BB0\u5F55\uFF09`
@@ -9860,13 +9892,13 @@ var RecordingStorage = class {
         return id;
       }
       if (existing.transcriptDataFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptDataFile), { force: true });
+        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.transcriptDataFile), { force: true });
       }
       if (existing.transcriptFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptFile), { force: true });
+        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.transcriptFile), { force: true });
       }
       if (existing.summaryFile) {
-        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.summaryFile), { force: true });
+        (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, existing.summaryFile), { force: true });
       }
       existing.metadata = metadata;
       existing.status = "syncing_openclaw";
@@ -9934,7 +9966,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptDataFile = `${TRANSCRIPT_DATA_DIR}/${filename}`;
     if (entry.transcriptDataFile && entry.transcriptDataFile !== nextTranscriptDataFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptDataFile), { force: true });
+      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.transcriptDataFile), { force: true });
     }
     entry.transcriptDataFile = nextTranscriptDataFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9948,7 +9980,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptFile = `${TRANSCRIPTS_DIR}/${filename}`;
     if (entry.transcriptFile && entry.transcriptFile !== nextTranscriptFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptFile), { force: true });
+      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.transcriptFile), { force: true });
     }
     entry.transcriptFile = nextTranscriptFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9962,7 +9994,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextSummaryFile = `${SUMMARIES_DIR}/${filename}`;
     if (entry.summaryFile && entry.summaryFile !== nextSummaryFile) {
-      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.summaryFile), { force: true });
+      (0, import_node_fs24.rmSync)((0, import_node_path20.join)(this.dir, entry.summaryFile), { force: true });
     }
     entry.summaryFile = nextSummaryFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10060,24 +10092,24 @@ var RecordingStorage = class {
     const entry = this.findById(recordingId);
     if (!entry) return false;
     if (entry.audioFile) {
-      const audioPath = (0, import_node_path19.join)(this.dir, entry.audioFile);
-      (0, import_node_fs23.rmSync)(audioPath, { force: true });
+      const audioPath = (0, import_node_path20.join)(this.dir, entry.audioFile);
+      (0, import_node_fs24.rmSync)(audioPath, { force: true });
     }
     if (entry.srtFile) {
-      const srtPath = (0, import_node_path19.join)(this.dir, entry.srtFile);
-      (0, import_node_fs23.rmSync)(srtPath, { force: true });
+      const srtPath = (0, import_node_path20.join)(this.dir, entry.srtFile);
+      (0, import_node_fs24.rmSync)(srtPath, { force: true });
     }
     if (entry.transcriptDataFile) {
-      const transcriptDataPath = (0, import_node_path19.join)(this.dir, entry.transcriptDataFile);
-      (0, import_node_fs23.rmSync)(transcriptDataPath, { force: true });
+      const transcriptDataPath = (0, import_node_path20.join)(this.dir, entry.transcriptDataFile);
+      (0, import_node_fs24.rmSync)(transcriptDataPath, { force: true });
     }
     if (entry.transcriptFile) {
-      const transcriptPath = (0, import_node_path19.join)(this.dir, entry.transcriptFile);
-      (0, import_node_fs23.rmSync)(transcriptPath, { force: true });
+      const transcriptPath = (0, import_node_path20.join)(this.dir, entry.transcriptFile);
+      (0, import_node_fs24.rmSync)(transcriptPath, { force: true });
     }
     if (entry.summaryFile) {
-      const summaryPath = (0, import_node_path19.join)(this.dir, entry.summaryFile);
-      (0, import_node_fs23.rmSync)(summaryPath, { force: true });
+      const summaryPath = (0, import_node_path20.join)(this.dir, entry.summaryFile);
+      (0, import_node_fs24.rmSync)(summaryPath, { force: true });
     }
     if (opts?.localOnly) {
       entry.audioFile = void 0;
@@ -10135,34 +10167,34 @@ var RecordingStorage = class {
    * 获取音频文件的绝对路径。ossUrl 用于推断文件扩展名
    */
   getAudioFilePath(recordingId, ossUrl) {
-    return (0, import_node_path19.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
+    return (0, import_node_path20.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
   }
   /**
    * 获取打点文件的绝对路径
    */
   getSrtFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.audioDir, this.buildSrtFilename(recordingId));
+    return (0, import_node_path20.join)(this.audioDir, this.buildSrtFilename(recordingId));
   }
   /**
    * 获取转写 JSON 文件的绝对路径
    */
   getTranscriptDataFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
+    return (0, import_node_path20.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
   }
   /**
    * 获取摘要文件的绝对路径
    */
   getSummaryFilePath(recordingId) {
-    return (0, import_node_path19.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
+    return (0, import_node_path20.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
   }
   // ─── Persistence ───
   loadIndex() {
-    if (!(0, import_node_fs23.existsSync)(this.indexPath)) {
+    if (!(0, import_node_fs24.existsSync)(this.indexPath)) {
       this.index = { recordings: [] };
       return;
     }
     try {
-      const raw = JSON.parse((0, import_node_fs23.readFileSync)(this.indexPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs24.readFileSync)(this.indexPath, "utf-8"));
       if (raw && Array.isArray(raw.recordings)) {
         let needsRewrite = false;
         const normalized = raw.recordings.filter((entry) => entry && typeof entry === "object").map((entry) => {
@@ -10200,8 +10232,8 @@ var RecordingStorage = class {
                 segments: []
               });
               const transcriptDataFilename = this.buildTranscriptDataFilename(compacted.id);
-              (0, import_node_fs23.writeFileSync)(
-                (0, import_node_path19.join)(this.transcriptDataDir, transcriptDataFilename),
+              (0, import_node_fs24.writeFileSync)(
+                (0, import_node_path20.join)(this.transcriptDataDir, transcriptDataFilename),
                 JSON.stringify(transcriptDoc, null, 2),
                 "utf-8"
               );
@@ -10213,8 +10245,8 @@ var RecordingStorage = class {
             compacted.summaryFile = entry.summaryFile;
           } else if (typeof entry.summary === "string" && entry.summary.trim()) {
             const summaryFilename = this.buildSummaryFilename(entry.id);
-            (0, import_node_fs23.writeFileSync)(
-              (0, import_node_path19.join)(this.summariesDir, summaryFilename),
+            (0, import_node_fs24.writeFileSync)(
+              (0, import_node_path20.join)(this.summariesDir, summaryFilename),
               entry.summary.trim(),
               "utf-8"
             );
@@ -10224,8 +10256,8 @@ var RecordingStorage = class {
             const summaryFromDocument = extractTranscriptSummaryFromDocument(transcriptDoc);
             if (summaryFromDocument) {
               const summaryFilename = this.buildSummaryFilename(entry.id);
-              (0, import_node_fs23.writeFileSync)(
-                (0, import_node_path19.join)(this.summariesDir, summaryFilename),
+              (0, import_node_fs24.writeFileSync)(
+                (0, import_node_path20.join)(this.summariesDir, summaryFilename),
                 summaryFromDocument,
                 "utf-8"
               );
@@ -10265,7 +10297,7 @@ var RecordingStorage = class {
   }
   readRelativeTextFile(relativePath) {
     try {
-      return (0, import_node_fs23.readFileSync)((0, import_node_path19.join)(this.dir, relativePath), "utf-8");
+      return (0, import_node_fs24.readFileSync)((0, import_node_path20.join)(this.dir, relativePath), "utf-8");
     } catch {
       return void 0;
     }
@@ -10278,7 +10310,7 @@ var RecordingStorage = class {
     return parseTranscriptDocument(raw);
   }
   saveIndex() {
-    (0, import_node_fs23.writeFileSync)(
+    (0, import_node_fs24.writeFileSync)(
       this.indexPath,
       JSON.stringify(this.index, null, 2),
       "utf-8"
@@ -10292,8 +10324,8 @@ var RecordingStorage = class {
 init_transcript_document();
 
 // src/recording/downloader.ts
-var import_node_fs24 = require("fs");
-var import_node_path20 = require("path");
+var import_node_fs25 = require("fs");
+var import_node_path21 = require("path");
 var import_promises2 = require("stream/promises");
 var import_node_stream = require("stream");
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -10303,7 +10335,7 @@ async function downloadFile(url, destPath, logger, options) {
   const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
   const maxRetries = options?.maxRetries ?? DEFAULT_MAX_RETRIES;
   const retryBackoffMs = options?.retryBackoffMs ?? DEFAULT_RETRY_BACKOFF_MS;
-  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(destPath), { recursive: true });
+  (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(destPath), { recursive: true });
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     const startMs = Date.now();
@@ -10321,11 +10353,11 @@ async function downloadFile(url, destPath, logger, options) {
         if (!res.body) {
           throw new Error("\u54CD\u5E94\u4F53\u4E3A\u7A7A");
         }
-        const writeStream = (0, import_node_fs24.createWriteStream)(destPath);
+        const writeStream = (0, import_node_fs25.createWriteStream)(destPath);
         const readable = import_node_stream.Readable.fromWeb(res.body);
         await (0, import_promises2.pipeline)(readable, writeStream);
         const elapsed = Date.now() - startMs;
-        const fileSize = (0, import_node_fs24.existsSync)(destPath) ? (0, import_node_fs24.statSync)(destPath).size : 0;
+        const fileSize = (0, import_node_fs25.existsSync)(destPath) ? (0, import_node_fs25.statSync)(destPath).size : 0;
         logger.info(
           `[downloader] \u4E0B\u8F7D\u5B8C\u6210: ${destPath} (${formatBytes(fileSize)}, ${elapsed}ms)`
         );
@@ -10336,7 +10368,7 @@ async function downloadFile(url, destPath, logger, options) {
     } catch (err) {
       lastError = err?.message ?? String(err);
       try {
-        if ((0, import_node_fs24.existsSync)(destPath)) (0, import_node_fs24.unlinkSync)(destPath);
+        if ((0, import_node_fs25.existsSync)(destPath)) (0, import_node_fs25.unlinkSync)(destPath);
       } catch {
       }
       const isAbort = err?.name === "AbortError";
@@ -10574,13 +10606,13 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
 }
 
 // src/tunnel/service.ts
-var import_node_fs29 = require("fs");
-var import_node_path25 = require("path");
+var import_node_fs30 = require("fs");
+var import_node_path26 = require("path");
 init_credentials();
 
 // src/tunnel/relay-client.ts
-var import_node_fs27 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs28 = require("fs");
+var import_node_path24 = require("path");
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -10624,8 +10656,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      (0, import_node_fs27.mkdirSync)((0, import_node_path23.dirname)(this.opts.statusFilePath), { recursive: true });
-      (0, import_node_fs27.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      (0, import_node_fs28.mkdirSync)((0, import_node_path24.dirname)(this.opts.statusFilePath), { recursive: true });
+      (0, import_node_fs28.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
     } catch {
     }
   }
@@ -11007,8 +11039,8 @@ init_host();
 
 // src/tunnel/device-identity.ts
 var import_node_crypto3 = __toESM(require("crypto"), 1);
-var import_node_fs28 = __toESM(require("fs"), 1);
-var import_node_path24 = __toESM(require("path"), 1);
+var import_node_fs29 = __toESM(require("fs"), 1);
+var import_node_path25 = __toESM(require("path"), 1);
 init_host();
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
@@ -11053,10 +11085,10 @@ function resolveClientStateDir(stateDir) {
   return stateDir ?? resolveStateDir();
 }
 function ensureDir(filePath) {
-  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
+  import_node_fs29.default.mkdirSync(import_node_path25.default.dirname(filePath), { recursive: true });
 }
 function resolveIdentityPath(stateDir) {
-  return import_node_path24.default.join(stateDir, "identity", "device.json");
+  return import_node_path25.default.join(stateDir, "identity", "device.json");
 }
 function normalizeDeviceAuthRole(role) {
   return role.trim();
@@ -11072,12 +11104,12 @@ function normalizeDeviceAuthScopes(scopes) {
   return [...out].sort();
 }
 function resolveDeviceAuthPath(stateDir) {
-  return import_node_path24.default.join(stateDir, "identity", "device-auth.json");
+  return import_node_path25.default.join(stateDir, "identity", "device-auth.json");
 }
 function readDeviceAuthStore(filePath) {
   try {
-    if (!import_node_fs28.default.existsSync(filePath)) return null;
-    const raw = import_node_fs28.default.readFileSync(filePath, "utf8");
+    if (!import_node_fs29.default.existsSync(filePath)) return null;
+    const raw = import_node_fs29.default.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;
@@ -11088,12 +11120,12 @@ function readDeviceAuthStore(filePath) {
 }
 function writeDeviceAuthStore(filePath, store) {
   ensureDir(filePath);
-  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+  import_node_fs29.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
   try {
-    import_node_fs28.default.chmodSync(filePath, 384);
+    import_node_fs29.default.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -11140,8 +11172,8 @@ function clearDeviceAuthToken(params) {
 function loadOrCreateDeviceIdentity(stateDir) {
   const filePath = resolveIdentityPath(stateDir);
   try {
-    if (import_node_fs28.default.existsSync(filePath)) {
-      const raw = import_node_fs28.default.readFileSync(filePath, "utf8");
+    if (import_node_fs29.default.existsSync(filePath)) {
+      const raw = import_node_fs29.default.readFileSync(filePath, "utf8");
       const parsed = JSON.parse(raw);
       if (parsed?.version === 1 && typeof parsed.deviceId === "string" && typeof parsed.publicKeyPem === "string" && typeof parsed.privateKeyPem === "string") {
         const derivedId = fingerprintPublicKey(parsed.publicKeyPem);
@@ -11162,14 +11194,14 @@ function loadOrCreateDeviceIdentity(stateDir) {
     publicKeyPem,
     privateKeyPem
   };
-  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
+  import_node_fs29.default.mkdirSync(import_node_path25.default.dirname(filePath), { recursive: true });
   const stored = {
     version: 1,
     ...identity,
     createdAtMs: Date.now()
   };
   ensureDir(filePath);
-  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
+  import_node_fs29.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
   });
@@ -11939,7 +11971,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse((0, import_node_fs29.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs30.readFileSync)(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -11952,23 +11984,23 @@ function createTunnelService(opts) {
     lockFd = null;
     if (fd !== null) {
       try {
-        (0, import_node_fs29.closeSync)(fd);
+        (0, import_node_fs30.closeSync)(fd);
       } catch {
       }
     }
     if (filePath) {
       try {
-        (0, import_node_fs29.unlinkSync)(filePath);
+        (0, import_node_fs30.unlinkSync)(filePath);
       } catch {
       }
     }
   }
   function acquireLock(filePath) {
-    (0, import_node_fs29.mkdirSync)((0, import_node_path25.dirname)(filePath), { recursive: true });
+    (0, import_node_fs30.mkdirSync)((0, import_node_path26.dirname)(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const fd = (0, import_node_fs29.openSync)(filePath, "wx", 384);
-        (0, import_node_fs29.writeFileSync)(
+        const fd = (0, import_node_fs30.openSync)(filePath, "wx", 384);
+        (0, import_node_fs30.writeFileSync)(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -11992,7 +12024,7 @@ function createTunnelService(opts) {
             `Relay tunnel: removing stale local lock owned by dead pid=${ownerPid}`
           );
           try {
-            (0, import_node_fs29.unlinkSync)(filePath);
+            (0, import_node_fs30.unlinkSync)(filePath);
           } catch {
           }
           continue;
@@ -12037,12 +12069,12 @@ function createTunnelService(opts) {
         return;
       }
       const { logger } = opts;
-      const baseStateDir = (0, import_node_path25.join)(ctx.stateDir, "plugins", "phone-notifications");
+      const baseStateDir = (0, import_node_path26.join)(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 = (0, import_node_path25.join)(baseStateDir, "tunnel-status.json");
-      const lockPath = (0, import_node_path25.join)(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = (0, import_node_path26.join)(baseStateDir, "tunnel-status.json");
+      const lockPath = (0, import_node_path26.join)(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
@@ -12182,7 +12214,7 @@ function readHostGatewayConfig(params) {
   let configData;
   if (configPath) {
     try {
-      configData = JSON.parse((0, import_node_fs30.readFileSync)(configPath, "utf-8"));
+      configData = JSON.parse((0, import_node_fs31.readFileSync)(configPath, "utf-8"));
     } catch (err) {
       if (err?.code !== "ENOENT") {
         params.logger.warn(