@yoooclaw/phone-notifications 1.10.2 → 1.10.3

package/dist/index.cjs

@@ -461,8 +461,8 @@ __export(whisper_local_exports, {
   transcribeWithWhisperLocal: () => transcribeWithWhisperLocal
 });
 function detectEnvironment(logger) {
-  const os2 = (0, import_node_os3.platform)();
-  const cpuArch = (0, import_node_os3.arch)();
+  const os2 = (0, import_node_os4.platform)();
+  const cpuArch = (0, import_node_os4.arch)();
   const isAppleSilicon = os2 === "darwin" && cpuArch === "arm64";
   const hasCuda = detectCuda(logger);
   let recommendedBackend;
@@ -500,20 +500,20 @@ function selectModelByMemory(availableGB, isAppleSilicon = false) {
   return "tiny";
 }
 function resolveModelsDir(dataDir) {
-  const dir = (0, import_node_path19.join)(dataDir, WHISPER_MODELS_DIR);
-  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path21.join)(dataDir, WHISPER_MODELS_DIR);
+  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function resolveBinDir(dataDir) {
-  const dir = (0, import_node_path19.join)(dataDir, WHISPER_BIN_DIR);
-  (0, import_node_fs24.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_node_path21.join)(dataDir, WHISPER_BIN_DIR);
+  (0, import_node_fs25.mkdirSync)(dir, { recursive: true });
   return dir;
 }
 function isModelDownloaded(modelsDir, modelSize) {
-  const modelPath = (0, import_node_path19.join)(modelsDir, MODEL_FILENAMES[modelSize]);
-  if (!(0, import_node_fs24.existsSync)(modelPath)) return false;
+  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  if (!(0, import_node_fs25.existsSync)(modelPath)) return false;
   try {
-    const stat = (0, import_node_fs24.statSync)(modelPath);
+    const stat = (0, import_node_fs25.statSync)(modelPath);
     const expectedSize = MODEL_DISK_SIZES[modelSize];
     return stat.size >= expectedSize * 0.8;
   } catch {
@@ -522,7 +522,7 @@ function isModelDownloaded(modelsDir, modelSize) {
 }
 async function downloadModel(modelsDir, modelSize, logger, modelSource, mirrorUrl) {
   const filename = MODEL_FILENAMES[modelSize];
-  const modelPath = (0, import_node_path19.join)(modelsDir, filename);
+  const modelPath = (0, import_node_path21.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 +588,7 @@ async function probeUrl(url, logger) {
 async function downloadFromUrl(url, modelPath, logger) {
   const tmpPath = `${modelPath}.downloading`;
   try {
-    (0, import_node_fs24.mkdirSync)((0, import_node_path19.dirname)(modelPath), { recursive: true });
+    (0, import_node_fs25.mkdirSync)((0, import_node_path21.dirname)(modelPath), { recursive: true });
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), 30 * 60 * 1e3);
     try {
@@ -604,7 +604,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_fs24.createWriteStream)(tmpPath);
+      const writeStream = (0, import_node_fs25.createWriteStream)(tmpPath);
       const readable = import_node_stream2.Readable.fromWeb(res.body);
       let downloaded = 0;
       let lastLogPercent = 0;
@@ -624,16 +624,16 @@ async function downloadFromUrl(url, modelPath, logger) {
     } finally {
       clearTimeout(timer);
     }
-    const { renameSync } = await import("fs");
-    renameSync(tmpPath, modelPath);
-    const fileSize = (0, import_node_fs24.statSync)(modelPath).size;
+    const { renameSync: renameSync2 } = await import("fs");
+    renameSync2(tmpPath, modelPath);
+    const fileSize = (0, import_node_fs25.statSync)(modelPath).size;
     logger.info(
-      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path19.basename)(modelPath)} (${formatBytes2(fileSize)})`
+      `[whisper-local] \u6A21\u578B\u4E0B\u8F7D\u5B8C\u6210: ${(0, import_node_path21.basename)(modelPath)} (${formatBytes2(fileSize)})`
     );
     return { ok: true, modelPath };
   } catch (err) {
     try {
-      if ((0, import_node_fs24.existsSync)(tmpPath)) (0, import_node_fs24.unlinkSync)(tmpPath);
+      if ((0, import_node_fs25.existsSync)(tmpPath)) (0, import_node_fs25.unlinkSync)(tmpPath);
     } catch {
     }
     const msg = err?.name === "AbortError" ? "\u6A21\u578B\u4E0B\u8F7D\u8D85\u65F6\uFF0830 \u5206\u949F\uFF09" : err?.message ?? String(err);
@@ -643,18 +643,18 @@ async function downloadFromUrl(url, modelPath, logger) {
 }
 function findWhisperBinary(dataDir, logger) {
   const binDir = resolveBinDir(dataDir);
-  const binNames = (0, import_node_os3.platform)() === "win32" ? ["whisper-cli.exe", "whisper.exe", "main.exe"] : ["whisper-cli", "whisper", "main"];
+  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_path19.join)(binDir, name);
-    if ((0, import_node_fs24.existsSync)(binPath)) {
+    const binPath = (0, import_node_path21.join)(binDir, name);
+    if ((0, import_node_fs25.existsSync)(binPath)) {
       logger.info(`[whisper-local] \u627E\u5230\u672C\u5730\u4E8C\u8FDB\u5236: ${binPath}`);
       return binPath;
     }
   }
-  const pathNames = (0, import_node_os3.platform)() === "win32" ? ["whisper-cli", "whisper-cpp", "whisper"] : ["whisper-cli", "whisper-cpp", "whisper"];
+  const pathNames = (0, import_node_os4.platform)() === "win32" ? ["whisper-cli", "whisper-cpp", "whisper"] : ["whisper-cli", "whisper-cpp", "whisper"];
   for (const name of pathNames) {
     try {
-      const cmd = (0, import_node_os3.platform)() === "win32" ? "where" : "which";
+      const cmd = (0, import_node_os4.platform)() === "win32" ? "where" : "which";
       const result = (0, import_node_child_process2.execSync)(`${cmd} ${name}`, { encoding: "utf-8", stdio: "pipe" }).trim();
       if (result) {
         logger.info(`[whisper-local] \u627E\u5230\u7CFB\u7EDF PATH \u4E8C\u8FDB\u5236: ${result}`);
@@ -697,7 +697,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_path19.join)(modelsDir, MODEL_FILENAMES[modelSize]);
+  const modelPath = (0, import_node_path21.join)(modelsDir, MODEL_FILENAMES[modelSize]);
   let inputPath = audioFilePath;
   let tmpWavPath = null;
   const actualFmt = detectAudioFormat(audioFilePath);
@@ -749,10 +749,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_fs24.existsSync)(jsonPath)) {
-      jsonContent = (0, import_node_fs24.readFileSync)(jsonPath, "utf-8");
+    if ((0, import_node_fs25.existsSync)(jsonPath)) {
+      jsonContent = (0, import_node_fs25.readFileSync)(jsonPath, "utf-8");
       try {
-        (0, import_node_fs24.unlinkSync)(jsonPath);
+        (0, import_node_fs25.unlinkSync)(jsonPath);
       } catch {
       }
     } else {
@@ -785,7 +785,7 @@ function detectCuda(logger) {
     return true;
   } catch {
   }
-  if ((0, import_node_os3.platform)() === "linux") {
+  if ((0, import_node_os4.platform)() === "linux") {
     try {
       const ldconfig = (0, import_node_child_process2.execSync)("ldconfig -p 2>/dev/null | grep libcudart", {
         encoding: "utf-8",
@@ -816,24 +816,24 @@ function getAvailableMemoryGB(backend, logger) {
       logger.warn("[whisper-local] \u65E0\u6CD5\u83B7\u53D6 GPU VRAM\uFF0C\u4F7F\u7528\u7CFB\u7EDF RAM \u4EE3\u66FF");
     }
   }
-  const totalGB = (0, import_node_os3.totalmem)() / (1024 * 1024 * 1024);
-  const freeGB = (0, import_node_os3.freemem)() / (1024 * 1024 * 1024);
+  const totalGB = (0, import_node_os4.totalmem)() / (1024 * 1024 * 1024);
+  const freeGB = (0, import_node_os4.freemem)() / (1024 * 1024 * 1024);
   return Math.max(freeGB, totalGB * 0.6);
 }
 function getPhysicalCoreCount() {
-  const cpuList = (0, import_node_os3.cpus)();
+  const cpuList = (0, import_node_os4.cpus)();
   if (cpuList.length === 0) return 4;
-  if ((0, import_node_os3.platform)() === "darwin" && (0, import_node_os3.arch)() === "arm64") {
+  if ((0, import_node_os4.platform)() === "darwin" && (0, import_node_os4.arch)() === "arm64") {
     return cpuList.length;
   }
   return Math.max(1, Math.floor(cpuList.length / 2));
 }
 function detectAudioFormat(filePath) {
   try {
-    const fd = (0, import_node_fs24.openSync)(filePath, "r");
+    const fd = (0, import_node_fs25.openSync)(filePath, "r");
     const buf = Buffer.alloc(12);
-    (0, import_node_fs24.readSync)(fd, buf, 0, 12, 0);
-    (0, import_node_fs24.closeSync)(fd);
+    (0, import_node_fs25.readSync)(fd, buf, 0, 12, 0);
+    (0, import_node_fs25.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 +868,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
       timeout: 12e4,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (ffmpegResult.status === 0 && (0, import_node_fs24.existsSync)(outputPath)) {
+    if (ffmpegResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
       logger.info(`[whisper-local] ffmpeg \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
       return { ok: true };
     }
@@ -881,7 +881,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_fs24.existsSync)(outputPath)) {
+      if (opusResult.status === 0 && (0, import_node_fs25.existsSync)(outputPath)) {
         logger.info(`[whisper-local] opusdec \u8F6C\u6362\u5B8C\u6210: ${outputPath}`);
         return { ok: true };
       }
@@ -895,7 +895,7 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
     if (detectedExt && !inputPath.endsWith(detectedExt)) {
       tmpCopy = inputPath + ".detected" + detectedExt;
       try {
-        (0, import_node_fs24.copyFileSync)(inputPath, tmpCopy);
+        (0, import_node_fs25.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 +919,22 @@ function convertToWav(inputPath, outputPath, actualFmt, logger) {
         timeout: 12e4,
         stdio: ["pipe", "pipe", "pipe"]
       });
-      if (tmpCopy && (0, import_node_fs24.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs24.unlinkSync)(tmpCopy);
+          (0, import_node_fs25.unlinkSync)(tmpCopy);
         } catch {
         }
       }
-      if (afResult.status === 0 && (0, import_node_fs24.existsSync)(outputPath)) {
+      if (afResult.status === 0 && (0, import_node_fs25.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_fs24.existsSync)(tmpCopy)) {
+      if (tmpCopy && (0, import_node_fs25.existsSync)(tmpCopy)) {
         try {
-          (0, import_node_fs24.unlinkSync)(tmpCopy);
+          (0, import_node_fs25.unlinkSync)(tmpCopy);
         } catch {
         }
       }
@@ -945,9 +945,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_fs24.existsSync)(path2)) {
+  if (path2 && (0, import_node_fs25.existsSync)(path2)) {
     try {
-      (0, import_node_fs24.unlinkSync)(path2);
+      (0, import_node_fs25.unlinkSync)(path2);
     } catch {
     }
   }
@@ -1033,16 +1033,16 @@ 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_fs24, import_node_path19, import_promises3, import_node_stream2, import_node_os3, 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_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 init_whisper_local = __esm({
   "src/recording/whisper-local.ts"() {
     "use strict";
     import_node_child_process2 = require("child_process");
-    import_node_fs24 = require("fs");
-    import_node_path19 = require("path");
+    import_node_fs25 = require("fs");
+    import_node_path21 = require("path");
     import_promises3 = require("stream/promises");
     import_node_stream2 = require("stream");
-    import_node_os3 = require("os");
+    import_node_os4 = require("os");
     WHISPER_MODELS_DIR = "whisper-models";
     WHISPER_BIN_DIR = "whisper-bin";
     HF_MODEL_URL_TEMPLATE = "https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-{model}.bin";
@@ -1194,7 +1194,7 @@ async function initializeAsr(config, dataDir, logger) {
   }
 }
 async function transcribeAudio(audioFilePath, config, logger, options = {}) {
-  if (!(0, import_node_fs25.existsSync)(audioFilePath)) {
+  if (!(0, import_node_fs26.existsSync)(audioFilePath)) {
     return { ok: false, error: `\u97F3\u9891\u6587\u4EF6\u4E0D\u5B58\u5728: ${audioFilePath}` };
   }
   logger.info(
@@ -1310,7 +1310,7 @@ async function runTranscriptionWorkflow(params) {
     return { ok: false, error: result.error };
   }
   const title = normalizeOptionalText2(result.summary) ? normalizeOptionalText2(result.summary) : extractSummary(result.text ?? "");
-  const summary = normalizeOptionalText2(result.summaryText) ? normalizeOptionalText2(result.summaryText) : extractTranscriptSummary(result.text ?? "");
+  const summary = normalizeOptionalText2(result.summaryText);
   result.summary = title;
   const transcriptData = buildTranscriptDocument({
     recordingId,
@@ -1338,8 +1338,8 @@ async function runTranscriptionWorkflow(params) {
     createdAt
   );
   const transcriptDataFilename = buildTranscriptDataFilename(recordingId);
-  const transcriptDataPath = (0, import_node_path20.join)(transcriptDataDir, transcriptDataFilename);
-  (0, import_node_fs25.writeFileSync)(
+  const transcriptDataPath = (0, import_node_path22.join)(transcriptDataDir, transcriptDataFilename);
+  (0, import_node_fs26.writeFileSync)(
     transcriptDataPath,
     JSON.stringify(transcriptData, null, 2),
     "utf-8"
@@ -1347,13 +1347,16 @@ 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_path20.join)(transcriptsDir, filename);
-  (0, import_node_fs25.writeFileSync)(filePath, markdown, "utf-8");
+  const filePath = (0, import_node_path22.join)(transcriptsDir, filename);
+  (0, import_node_fs26.writeFileSync)(filePath, markdown, "utf-8");
   logger.info(`[asr] \u8F6C\u5199\u6587\u672C\u5DF2\u5199\u5165: ${filePath}`);
-  const summaryFilename = `${recordingId}.md`;
-  const summaryFilePath = (0, import_node_path20.join)(summariesDir, summaryFilename);
-  (0, import_node_fs25.writeFileSync)(summaryFilePath, summary, "utf-8");
-  logger.info(`[asr] \u6458\u8981\u6587\u672C\u5DF2\u5199\u5165: ${summaryFilePath}`);
+  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");
+    logger.info(`[asr] \u6458\u8981\u6587\u672C\u5DF2\u5199\u5165: ${summaryFilePath}`);
+  }
   return {
     ok: true,
     transcriptFilename: filename,
@@ -1436,7 +1439,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_path20.join)(audioFilePath, "..", "..", "..");
+  const dataDir = process.env.OPENCLAW_STATE_DIR ?? process.env.QCLAW_STATE_DIR ?? (0, import_node_path22.join)(audioFilePath, "..", "..", "..");
   const localConfig = config.local ?? {};
   const result = await runLocal(
     audioFilePath,
@@ -1590,8 +1593,8 @@ function buildLongRecordingSuccessResult(taskId, requestId, data, logger) {
     ok: true,
     text,
     segments: listResult.segments,
-    summary: title ?? extractSummary(text),
-    summaryText: summaryText ?? extractTranscriptSummary(text),
+    summary: title,
+    summaryText,
     category,
     sourceInfo: {
       provider: "model-proxy",
@@ -1711,15 +1714,6 @@ function stringifyForLog(value, maxLength = 500) {
 async function sleep2(ms) {
   await new Promise((resolve) => setTimeout(resolve, ms));
 }
-function extractTranscriptSummary(text) {
-  const normalized = text.replace(/\s+/g, " ").trim();
-  if (!normalized) {
-    return "";
-  }
-  const sentence = normalized.split(/[。！？!?]/).map((part) => part.trim()).find((part) => part.length > 0);
-  const candidate = sentence || normalized;
-  return candidate.length <= 120 ? candidate : `${candidate.slice(0, 117).trimEnd()}...`;
-}
 function formatTimestamp(ms) {
   const totalSeconds = Math.floor(ms / 1e3);
   const minutes = Math.floor(totalSeconds / 60);
@@ -1748,12 +1742,12 @@ function formatTranscriptSegmentText(segment) {
   }
   return text;
 }
-var import_node_fs25, import_node_path20, DEFAULT_LONG_RECORDING_POLL_INTERVAL_MS, DEFAULT_LONG_RECORDING_MAX_POLL_ATTEMPTS, LONG_RECORDING_RUNNING_STATUSES, LONG_RECORDING_TERMINAL_FAILURE_STATUSES;
+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 init_asr = __esm({
   "src/recording/asr.ts"() {
     "use strict";
-    import_node_fs25 = require("fs");
-    import_node_path20 = require("path");
+    import_node_fs26 = require("fs");
+    import_node_path22 = require("path");
     init_credentials();
     init_env();
     init_transcript_document();
@@ -5398,7 +5392,7 @@ function readBuildInjectedVersion() {
   if (false) {
     return void 0;
   }
-  const version = "1.10.2".trim();
+  const version = "1.10.3".trim();
   return version || void 0;
 }
 function readPluginVersionFromPackageJson() {
@@ -7201,8 +7195,48 @@ function resolveUpdateChannel(params) {
   return params.envName === "development" ? "beta" : "latest";
 }
 
+// src/update/index.ts
+var import_node_path9 = require("path");
+
 // src/update/checker.ts
-var CDN_BASE_URL = "https://cdn.yoootek.com/openclaw-plugin";
+function parseSemver(v) {
+  const [main, pre = null] = v.split("-", 2);
+  const [major = 0, minor = 0, patch = 0] = main.split(".").map(Number);
+  return { major, minor, patch, pre: pre ?? null };
+}
+function comparePreRelease(a, b) {
+  const aParts = a.split(".");
+  const bParts = b.split(".");
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    const ap = aParts[i] ?? "";
+    const bp = bParts[i] ?? "";
+    const an = Number(ap);
+    const bn = Number(bp);
+    let diff;
+    if (!Number.isNaN(an) && !Number.isNaN(bn)) {
+      diff = an - bn;
+    } else if (ap < bp) {
+      diff = -1;
+    } else if (ap > bp) {
+      diff = 1;
+    } else {
+      diff = 0;
+    }
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function isNewerVersion(candidate, current) {
+  const a = parseSemver(candidate);
+  const b = parseSemver(current);
+  if (a.major !== b.major) return a.major > b.major;
+  if (a.minor !== b.minor) return a.minor > b.minor;
+  if (a.patch !== b.patch) return a.patch > b.patch;
+  if (a.pre === null) return b.pre !== null;
+  if (b.pre === null) return false;
+  return comparePreRelease(a.pre, b.pre) > 0;
+}
+var CDN_BASE_URL = "https://artifact.yoooclaw.com/plugin";
 var NPM_BASE_URL = "https://registry.npmjs.org/@yoooclaw/phone-notifications";
 var FETCH_TIMEOUT_MS = 5e3;
 var UpdateChecker = class {
@@ -7231,6 +7265,7 @@ var UpdateChecker = class {
     if (!latest || latest === PLUGIN_VERSION) return;
     if (latest === this.notifiedVersion) return;
     if (PLUGIN_VERSION.includes("-") && this.channel !== "beta") return;
+    if (!isNewerVersion(latest, PLUGIN_VERSION)) return;
     this.notifiedVersion = latest;
     this.logger.info(`\u53D1\u73B0\u65B0\u7248\u672C: ${PLUGIN_VERSION} \u2192 ${latest}`);
     this.onUpdateFound({ current: PLUGIN_VERSION, latest });
@@ -7263,36 +7298,109 @@ var UpdateChecker = class {
 };
 
 // src/update/executor.ts
+var import_node_fs9 = require("fs");
+var import_node_path8 = require("path");
+var import_node_os = require("os");
 var VERSION_PATTERN = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
-async function executeUpdate(version, runCommand, logger) {
+var BASE_URL = "https://artifact.yoooclaw.com/plugin";
+async function executeUpdate(version, runCommand, logger, targetDir, updateConfigRecord2) {
   if (!VERSION_PATTERN.test(version)) {
     return { success: false, message: `\u975E\u6CD5\u7248\u672C\u53F7: ${version}` };
   }
-  const argv = [
-    "openclaw",
-    "extension",
-    "install",
-    `@yoooclaw/phone-notifications@${version}`
-  ];
-  logger.info(`\u6267\u884C\u66F4\u65B0: ${argv.join(" ")}`);
+  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");
+  let backupDir = null;
   try {
-    const result = await runCommand(argv, { timeoutMs: 12e4 });
-    if (result.code === 0) {
-      const msg = `\u5DF2\u66F4\u65B0\u5230 ${version}\uFF0C\u8BF7\u91CD\u542F gateway \u751F\u6548`;
-      logger.info(msg);
-      return { success: true, message: msg };
+    logger.info("\u4E0B\u8F7D\u63D2\u4EF6\u5305...");
+    const response = await fetch(tgzUrl, { signal: AbortSignal.timeout(6e4) });
+    if (!response.ok) {
+      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);
+    logger.info(`\u4E0B\u8F7D\u5B8C\u6210 (${buffer.length} bytes)`);
+    (0, import_node_fs9.mkdirSync)(stagingDir, { recursive: true });
+    const tarResult = await runCommand(
+      ["tar", "-xzf", tgzPath, "-C", stagingDir, "--strip-components=1"],
+      { timeoutMs: 3e4 }
+    );
+    if (tarResult.code !== 0) {
+      const err = tarResult.stderr || tarResult.stdout || "unknown error";
+      return { success: false, message: `\u89E3\u538B\u5931\u8D25: ${err}` };
     }
-    const errMsg = `\u66F4\u65B0\u5931\u8D25 (exit ${result.code}): ${result.stderr || result.stdout}`;
-    logger.error(errMsg);
-    return { success: false, message: errMsg };
+    (0, import_node_fs9.mkdirSync)((0, import_node_path8.dirname)(targetDir), { recursive: true });
+    try {
+      backupDir = `${targetDir}.bak.${Date.now()}`;
+      (0, import_node_fs9.renameSync)(targetDir, backupDir);
+    } catch {
+      backupDir = null;
+    }
+    (0, import_node_fs9.renameSync)(stagingDir, targetDir);
+    try {
+      await updateConfigRecord2(version, tgzUrl);
+    } catch (err) {
+      logger.warn(`\u914D\u7F6E\u8BB0\u5F55\u66F4\u65B0\u5931\u8D25\uFF08\u63D2\u4EF6\u6587\u4EF6\u5DF2\u5C31\u4F4D\uFF09: ${String(err)}`);
+    }
+    if (backupDir) {
+      try {
+        (0, import_node_fs9.rmSync)(backupDir, { force: true, recursive: true });
+      } catch {
+      }
+    }
+    const msg = `\u5DF2\u66F4\u65B0\u5230 ${version}\uFF0C\u8BF7\u91CD\u542F gateway \u751F\u6548`;
+    logger.info(msg);
+    return { success: true, message: msg };
   } catch (err) {
-    const errMsg = `\u66F4\u65B0\u547D\u4EE4\u6267\u884C\u5F02\u5E38: ${String(err)}`;
+    if (backupDir) {
+      try {
+        (0, import_node_fs9.rmSync)(targetDir, { force: true, recursive: true });
+        (0, import_node_fs9.renameSync)(backupDir, targetDir);
+        logger.info("\u5DF2\u56DE\u6EDA\u5230\u4E4B\u524D\u7248\u672C");
+      } catch (rollbackErr) {
+        logger.error(`\u56DE\u6EDA\u5931\u8D25: ${String(rollbackErr)}`);
+      }
+    }
+    const errMsg = `\u66F4\u65B0\u6267\u884C\u5F02\u5E38: ${String(err)}`;
     logger.error(errMsg);
     return { success: false, message: errMsg };
+  } finally {
+    try {
+      (0, import_node_fs9.rmSync)(workDir, { force: true, recursive: true });
+    } catch {
+    }
   }
 }
 
 // src/update/index.ts
+var PLUGIN_ID = "phone-notifications";
+function resolveTargetDir(api) {
+  try {
+    const cfg = api.runtime.config?.loadConfig?.();
+    const installPath = cfg?.plugins?.installs?.[PLUGIN_ID]?.installPath;
+    if (installPath) return installPath;
+  } catch {
+  }
+  return (0, import_node_path9.join)(api.runtime.state.resolveStateDir(), "extensions", PLUGIN_ID);
+}
+async function updateConfigRecord(api, version, targetDir, tgzUrl) {
+  const configApi = api.runtime.config;
+  if (!configApi) return;
+  const cfg = configApi.loadConfig();
+  if (!cfg.plugins) cfg.plugins = {};
+  if (!cfg.plugins.installs) cfg.plugins.installs = {};
+  cfg.plugins.installs[PLUGIN_ID] = {
+    ...cfg.plugins.installs[PLUGIN_ID],
+    source: "archive",
+    sourcePath: tgzUrl,
+    installPath: targetDir,
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await configApi.writeConfigFile(cfg);
+}
 function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast, externalUpdateNotifier) {
   if (config.enabled === false) {
     logger.info("\u81EA\u52A8\u66F4\u65B0\u5DF2\u7981\u7528 (autoUpdate.enabled = false)");
@@ -7338,10 +7446,13 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
     },
     async execute(_toolCallId, params) {
       const { version } = params;
+      const targetDir = resolveTargetDir(api);
       const result = await executeUpdate(
         version,
         api.runtime.system.runCommandWithTimeout,
-        logger
+        logger,
+        targetDir,
+        (v, url) => updateConfigRecord(api, v, targetDir, url)
       );
       if (result.success) {
         pendingUpdate = null;
@@ -7363,10 +7474,13 @@ function registerAutoUpdate(api, logger, config, getBroadcast, rememberBroadcast
       });
       return;
     }
+    const targetDir = resolveTargetDir(api);
     const result = await executeUpdate(
       version,
       api.runtime.system.runCommandWithTimeout,
-      logger
+      logger,
+      targetDir,
+      (v, url) => updateConfigRecord(api, v, targetDir, url)
     );
     if (result.success) {
       pendingUpdate = null;
@@ -7457,10 +7571,10 @@ function registerAutoUpdateLifecycle(deps) {
 }
 
 // src/plugin/cli.ts
-var import_node_path15 = require("path");
+var import_node_path17 = require("path");
 
 // src/cli/auth.ts
-var import_node_fs9 = require("fs");
+var import_node_fs10 = require("fs");
 init_credentials();
 function registerAuthCli(program) {
   const auth = program.command("auth").description("\u7528\u6237\u8BA4\u8BC1\u7BA1\u7406");
@@ -7496,12 +7610,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_fs9.existsSync)(path2)) {
+    if ((0, import_node_fs10.existsSync)(path2)) {
       const creds = readCredentials();
       delete creds.apiKey;
       delete creds.token;
       if (Object.keys(creds).length === 0) {
-        (0, import_node_fs9.rmSync)(path2, { force: true });
+        (0, import_node_fs10.rmSync)(path2, { force: true });
       } else {
         writeCredentials(creds);
       }
@@ -7633,23 +7747,23 @@ function registerNtfStats(ntf, ctx) {
 }
 
 // src/cli/ntf-sync.ts
-var import_node_fs10 = require("fs");
-var import_node_path8 = require("path");
+var import_node_fs11 = require("fs");
+var import_node_path10 = require("path");
 var SYNC_FETCH_LIMIT = 300;
 function checkpointPath(dir) {
-  return (0, import_node_path8.join)(dir, ".checkpoint.json");
+  return (0, import_node_path10.join)(dir, ".checkpoint.json");
 }
 function readCheckpoint(dir) {
   const p = checkpointPath(dir);
-  if (!(0, import_node_fs10.existsSync)(p)) return {};
+  if (!(0, import_node_fs11.existsSync)(p)) return {};
   try {
-    return JSON.parse((0, import_node_fs10.readFileSync)(p, "utf-8"));
+    return JSON.parse((0, import_node_fs11.readFileSync)(p, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeCheckpoint(dir, data) {
-  (0, import_node_fs10.writeFileSync)(checkpointPath(dir), JSON.stringify(data, null, 2), "utf-8");
+  (0, import_node_fs11.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");
@@ -7742,24 +7856,24 @@ function registerNtfSync(ntf, ctx) {
 }
 
 // src/cli/ntf-monitor.ts
-var import_node_fs11 = require("fs");
-var import_node_path9 = require("path");
+var import_node_fs12 = require("fs");
+var import_node_path11 = 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_path9.join)(base, "tasks");
+  return (0, import_node_path11.join)(base, "tasks");
 }
 function readMeta2(taskDir) {
-  const metaPath = (0, import_node_path9.join)(taskDir, "meta.json");
-  if (!(0, import_node_fs11.existsSync)(metaPath)) return null;
+  const metaPath = (0, import_node_path11.join)(taskDir, "meta.json");
+  if (!(0, import_node_fs12.existsSync)(metaPath)) return null;
   try {
-    return JSON.parse((0, import_node_fs11.readFileSync)(metaPath, "utf-8"));
+    return JSON.parse((0, import_node_fs12.readFileSync)(metaPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeMeta2(taskDir, meta) {
-  (0, import_node_fs11.writeFileSync)((0, import_node_path9.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
+  (0, import_node_fs12.writeFileSync)((0, import_node_path11.join)(taskDir, "meta.json"), JSON.stringify(meta, null, 2), "utf-8");
 }
 function generateReadme(name, description) {
   return `# Monitor Task: ${name}
@@ -7778,27 +7892,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_fs11.existsSync)(dir)) {
+    if (!(0, import_node_fs12.existsSync)(dir)) {
       output({ ok: true, tasks: [] });
       return;
     }
     const tasks = [];
-    for (const entry of (0, import_node_fs11.readdirSync)(dir, { withFileTypes: true })) {
+    for (const entry of (0, import_node_fs12.readdirSync)(dir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const meta = readMeta2((0, import_node_path9.join)(dir, entry.name));
+      const meta = readMeta2((0, import_node_path11.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_path9.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.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_path9.join)(taskDir, "checkpoint.json");
+    const checkpointPath2 = (0, import_node_path11.join)(taskDir, "checkpoint.json");
     let checkpoint = {};
-    if ((0, import_node_fs11.existsSync)(checkpointPath2)) {
+    if ((0, import_node_fs12.existsSync)(checkpointPath2)) {
       try {
-        checkpoint = JSON.parse((0, import_node_fs11.readFileSync)(checkpointPath2, "utf-8"));
+        checkpoint = JSON.parse((0, import_node_fs12.readFileSync)(checkpointPath2, "utf-8"));
       } catch {
       }
     }
@@ -7813,8 +7927,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_path9.join)(dir, name);
-      if ((0, import_node_fs11.existsSync)(taskDir)) {
+      const taskDir = (0, import_node_path11.join)(dir, name);
+      if ((0, import_node_fs12.existsSync)(taskDir)) {
         exitError("ALREADY_EXISTS", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u5DF2\u5B58\u5728`);
       }
       let matchRules;
@@ -7826,7 +7940,7 @@ function registerNtfMonitor(ntf, ctx) {
           "match-rules \u5FC5\u987B\u662F\u5408\u6CD5\u7684 JSON"
         );
       }
-      (0, import_node_fs11.mkdirSync)(taskDir, { recursive: true });
+      (0, import_node_fs12.mkdirSync)(taskDir, { recursive: true });
       const meta = {
         name,
         description: opts.description,
@@ -7836,13 +7950,13 @@ function registerNtfMonitor(ntf, ctx) {
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       writeMeta2(taskDir, meta);
-      (0, import_node_fs11.writeFileSync)(
-        (0, import_node_path9.join)(taskDir, "fetch.py"),
+      (0, import_node_fs12.writeFileSync)(
+        (0, import_node_path11.join)(taskDir, "fetch.py"),
         generateFetchPy(name, matchRules),
         "utf-8"
       );
-      (0, import_node_fs11.writeFileSync)(
-        (0, import_node_path9.join)(taskDir, "README.md"),
+      (0, import_node_fs12.writeFileSync)(
+        (0, import_node_path11.join)(taskDir, "README.md"),
         generateReadme(name, opts.description),
         "utf-8"
       );
@@ -7870,8 +7984,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_path9.join)(tasksDir2(ctx), name);
-    if (!(0, import_node_fs11.existsSync)(taskDir)) {
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
+    if (!(0, import_node_fs12.existsSync)(taskDir)) {
       exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     }
     if (!opts.yes) {
@@ -7884,7 +7998,7 @@ function registerNtfMonitor(ntf, ctx) {
       });
       process.exit(1);
     }
-    (0, import_node_fs11.rmSync)(taskDir, { recursive: true, force: true });
+    (0, import_node_fs12.rmSync)(taskDir, { recursive: true, force: true });
     output({
       ok: true,
       name,
@@ -7896,7 +8010,7 @@ function registerNtfMonitor(ntf, ctx) {
     });
   });
   monitor.command("enable <name>").description("\u542F\u7528\u76D1\u63A7\u4EFB\u52A1").action((name) => {
-    const taskDir = (0, import_node_path9.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = true;
@@ -7904,7 +8018,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_path9.join)(tasksDir2(ctx), name);
+    const taskDir = (0, import_node_path11.join)(tasksDir2(ctx), name);
     const meta = readMeta2(taskDir);
     if (!meta) exitError("NOT_FOUND", `\u76D1\u63A7\u4EFB\u52A1 '${name}' \u4E0D\u5B58\u5728`);
     meta.enabled = false;
@@ -8213,9 +8327,9 @@ function registerLightSend(light) {
 }
 
 // src/cli/light-setup-tools.ts
-var import_node_fs12 = require("fs");
-var import_node_os = require("os");
-var import_node_path10 = require("path");
+var import_node_fs13 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path12 = require("path");
 function isObject(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -8229,7 +8343,7 @@ function ensureArray(obj, key) {
 function resolveConfigPath2() {
   const fromEnv = process.env.OPENCLAW_CONFIG_PATH?.trim();
   if (fromEnv) return fromEnv;
-  return (0, import_node_path10.join)((0, import_node_os.homedir)(), ".openclaw", "openclaw.json");
+  return (0, import_node_path12.join)((0, import_node_os2.homedir)(), ".openclaw", "openclaw.json");
 }
 function upsertLightControlAlsoAllow(cfg) {
   if (!isObject(cfg.tools)) cfg.tools = {};
@@ -8258,12 +8372,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_fs12.existsSync)(configPath)) {
+    if (!(0, import_node_fs13.existsSync)(configPath)) {
       exitError("CONFIG_NOT_FOUND", `\u672A\u627E\u5230\u914D\u7F6E\u6587\u4EF6: ${configPath}`);
     }
     let cfg = {};
     try {
-      const raw = (0, import_node_fs12.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs13.readFileSync)(configPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (isObject(parsed)) cfg = parsed;
     } catch (err) {
@@ -8271,8 +8385,8 @@ function registerLightSetupTools(light) {
     }
     const result = upsertLightControlAlsoAllow(cfg);
     try {
-      (0, import_node_fs12.mkdirSync)((0, import_node_path10.dirname)(configPath), { recursive: true });
-      (0, import_node_fs12.writeFileSync)(configPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+      (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");
     } catch (err) {
       exitError("WRITE_FAILED", `\u5199\u5165\u914D\u7F6E\u5931\u8D25: ${err?.message ?? String(err)}`);
     }
@@ -8290,17 +8404,17 @@ function registerLightSetupTools(light) {
 }
 
 // src/cli/tunnel-status.ts
-var import_node_fs13 = require("fs");
-var import_node_path11 = require("path");
+var import_node_fs14 = require("fs");
+var import_node_path13 = require("path");
 init_credentials();
 init_env();
-var STATUS_REL_PATH = (0, import_node_path11.join)("plugins", "phone-notifications", "tunnel-status.json");
+var STATUS_REL_PATH = (0, import_node_path13.join)("plugins", "phone-notifications", "tunnel-status.json");
 function readTunnelStatus(ctx) {
   if (!ctx.stateDir) return null;
-  const filePath = (0, import_node_path11.join)(ctx.stateDir, STATUS_REL_PATH);
-  if (!(0, import_node_fs13.existsSync)(filePath)) return null;
+  const filePath = (0, import_node_path13.join)(ctx.stateDir, STATUS_REL_PATH);
+  if (!(0, import_node_fs14.existsSync)(filePath)) return null;
   try {
-    return JSON.parse((0, import_node_fs13.readFileSync)(filePath, "utf-8"));
+    return JSON.parse((0, import_node_fs14.readFileSync)(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -8368,24 +8482,24 @@ function registerNtfStoragePath(ntf, ctx) {
 }
 
 // src/cli/log-search.ts
-var import_node_fs14 = require("fs");
-var import_node_path12 = require("path");
+var import_node_fs15 = require("fs");
+var import_node_path14 = require("path");
 function resolveLogsDir(ctx) {
   if (ctx.stateDir) {
-    const dir = (0, import_node_path12.join)(
+    const dir = (0, import_node_path14.join)(
       ctx.stateDir,
       "plugins",
       "phone-notifications",
       "logs"
     );
-    if ((0, import_node_fs14.existsSync)(dir)) return dir;
+    if ((0, import_node_fs15.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_fs14.readdirSync)(dir, { withFileTypes: true })) {
+  for (const entry of (0, import_node_fs15.readdirSync)(dir, { withFileTypes: true })) {
     if (!entry.isFile()) continue;
     const m = pattern.exec(entry.name);
     if (m) keys.push(m[1]);
@@ -8393,9 +8507,9 @@ function listLogDateKeys(dir) {
   return keys.sort().reverse();
 }
 function collectLogLines(dir, dateKey, keyword, limit, collected) {
-  const filePath = (0, import_node_path12.join)(dir, `${dateKey}.log`);
-  if (!(0, import_node_fs14.existsSync)(filePath)) return;
-  const content = (0, import_node_fs14.readFileSync)(filePath, "utf-8");
+  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 lowerKeyword = keyword?.toLowerCase();
   for (const line of content.split("\n")) {
     if (collected.length >= limit) return;
@@ -8462,12 +8576,12 @@ function registerEnvCli(ntf) {
 }
 
 // src/cli/doctor.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_node_readline = require("readline");
 init_host();
 
 // src/cli/doctor/check-dangerous-flags.ts
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 function isObject2(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
@@ -8484,13 +8598,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_fs15.readFileSync)(configPath, "utf-8");
+      const raw = (0, import_node_fs16.readFileSync)(configPath, "utf-8");
       const config = JSON.parse(raw);
       const gw = config.gateway;
       const cui = gw.controlUi;
       cui.dangerouslyDisableDeviceAuth = false;
-      (0, import_node_fs15.copyFileSync)(configPath, configPath + ".bak");
-      (0, import_node_fs15.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      (0, import_node_fs16.copyFileSync)(configPath, configPath + ".bak");
+      (0, import_node_fs16.writeFileSync)(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     }
   };
 };
@@ -8538,11 +8652,11 @@ function warnEmpty() {
 }
 
 // src/cli/doctor/check-state-dir-perms.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var checkStateDirPerms = ({ stateDir }) => {
   let mode;
   try {
-    mode = (0, import_node_fs16.statSync)(stateDir).mode;
+    mode = (0, import_node_fs17.statSync)(stateDir).mode;
   } catch {
     return null;
   }
@@ -8556,7 +8670,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_fs16.chmodSync)(stateDir, 448);
+      (0, import_node_fs17.chmodSync)(stateDir, 448);
     }
   };
 };
@@ -8611,16 +8725,16 @@ var checkCredentials = () => {
 };
 
 // src/cli/doctor/check-tunnel.ts
-var import_node_fs17 = require("fs");
-var import_node_path13 = require("path");
-var STATUS_REL_PATH2 = (0, import_node_path13.join)(
+var import_node_fs18 = require("fs");
+var import_node_path15 = require("path");
+var STATUS_REL_PATH2 = (0, import_node_path15.join)(
   "plugins",
   "phone-notifications",
   "tunnel-status.json"
 );
 var checkTunnel = ({ stateDir }) => {
-  const filePath = (0, import_node_path13.join)(stateDir, STATUS_REL_PATH2);
-  if (!(0, import_node_fs17.existsSync)(filePath)) {
+  const filePath = (0, import_node_path15.join)(stateDir, STATUS_REL_PATH2);
+  if (!(0, import_node_fs18.existsSync)(filePath)) {
     return {
       id: "tunnel",
       severity: "warn",
@@ -8632,7 +8746,7 @@ var checkTunnel = ({ stateDir }) => {
   }
   let status;
   try {
-    status = JSON.parse((0, import_node_fs17.readFileSync)(filePath, "utf-8"));
+    status = JSON.parse((0, import_node_fs18.readFileSync)(filePath, "utf-8"));
   } catch {
     return {
       id: "tunnel",
@@ -8725,9 +8839,9 @@ function isObject5(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 function readConfig(configPath) {
-  if (!(0, import_node_fs18.existsSync)(configPath)) return {};
+  if (!(0, import_node_fs19.existsSync)(configPath)) return {};
   try {
-    const parsed = JSON.parse((0, import_node_fs18.readFileSync)(configPath, "utf-8"));
+    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
     return isObject5(parsed) ? parsed : {};
   } catch {
     return {};
@@ -8928,7 +9042,7 @@ function registerRecStoragePath(rec, ctx) {
 
 // src/cli/rec-setup.ts
 var import_node_readline2 = require("readline");
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 function ask(rl, question) {
   return new Promise((resolve) => rl.question(question, resolve));
 }
@@ -9014,9 +9128,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_fs19.existsSync)(configPath)) {
+    if ((0, import_node_fs20.existsSync)(configPath)) {
       try {
-        const existing = JSON.parse((0, import_node_fs19.readFileSync)(configPath, "utf-8"));
+        const existing = JSON.parse((0, import_node_fs20.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");
@@ -9029,7 +9143,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_fs19.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
+      (0, import_node_fs20.writeFileSync)(configPath, JSON.stringify(stored, null, 2), "utf-8");
       process.stderr.write(`
 \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58\u5230 ${configPath}
 
@@ -9043,11 +9157,11 @@ function registerRecSetup(rec, ctx) {
 
 // src/cli/update.ts
 var import_node_child_process = require("child_process");
-var import_node_fs20 = require("fs");
-var import_node_path14 = require("path");
-var import_node_os2 = __toESM(require("os"), 1);
+var import_node_fs21 = require("fs");
+var import_node_path16 = require("path");
+var import_node_os3 = __toESM(require("os"), 1);
 init_host();
-var BASE_URL = "https://cdn.yoootek.com/openclaw-plugin";
+var BASE_URL2 = "https://artifact.yoooclaw.com/plugin";
 async function fetchText(url) {
   const res = await fetch(url, { signal: AbortSignal.timeout(3e4) });
   if (!res.ok) {
@@ -9067,7 +9181,7 @@ async function runUpdate(ctx, opts) {
   log(`\u68C0\u67E5${beta ? " beta" : ""}\u6700\u65B0\u7248\u672C ...`);
   let latest;
   try {
-    latest = (await fetchText(`${BASE_URL}/${channel}`)).trim();
+    latest = (await fetchText(`${BASE_URL2}/${channel}`)).trim();
   } catch (err) {
     const msg = `\u65E0\u6CD5\u83B7\u53D6\u6700\u65B0\u7248\u672C: ${err?.message ?? String(err)}`;
     if (json) {
@@ -9092,7 +9206,7 @@ async function runUpdate(ctx, opts) {
   log("\u4E0B\u8F7D\u5B89\u88C5\u811A\u672C ...");
   let installScript;
   try {
-    installScript = await fetchText(`${BASE_URL}/install-core.mjs`);
+    installScript = await fetchText(`${BASE_URL2}/install-core.mjs`);
   } catch (err) {
     const msg = `\u4E0B\u8F7D\u5B89\u88C5\u811A\u672C\u5931\u8D25: ${err?.message ?? String(err)}`;
     if (json) {
@@ -9103,9 +9217,9 @@ async function runUpdate(ctx, opts) {
 `);
     process.exit(1);
   }
-  const tmpScript = (0, import_node_path14.join)(import_node_os2.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
+  const tmpScript = (0, import_node_path16.join)(import_node_os3.default.tmpdir(), `openclaw-install-${Date.now()}.mjs`);
   try {
-    (0, import_node_fs20.writeFileSync)(tmpScript, installScript, "utf-8");
+    (0, import_node_fs21.writeFileSync)(tmpScript, installScript, "utf-8");
   } catch (err) {
     const msg = `\u5199\u5165\u4E34\u65F6\u6587\u4EF6\u5931\u8D25: ${err?.message ?? String(err)}`;
     if (json) {
@@ -9123,7 +9237,7 @@ async function runUpdate(ctx, opts) {
     { stdio: "inherit" }
   );
   try {
-    (0, import_node_fs20.unlinkSync)(tmpScript);
+    (0, import_node_fs21.unlinkSync)(tmpScript);
   } catch {
   }
   if (result.error) {
@@ -9187,10 +9301,10 @@ function inferOpenClawRootDir(workspaceDir) {
   if (!workspaceDir) {
     return void 0;
   }
-  if ((0, import_node_path15.basename)(workspaceDir) !== "workspace") {
+  if ((0, import_node_path17.basename)(workspaceDir) !== "workspace") {
     return void 0;
   }
-  return (0, import_node_path15.dirname)(workspaceDir);
+  return (0, import_node_path17.dirname)(workspaceDir);
 }
 function registerPluginCli(api, params) {
   const { logger, openclawDir } = params;
@@ -9436,12 +9550,12 @@ function registerLightControlTool(api, logger) {
 }
 
 // src/plugin/lifecycle.ts
-var import_node_fs29 = require("fs");
+var import_node_fs30 = require("fs");
 init_host();
 
 // src/notification/app-name-map.ts
-var import_node_fs21 = require("fs");
-var import_node_path16 = require("path");
+var import_node_fs22 = require("fs");
+var import_node_path18 = require("path");
 init_credentials();
 init_env();
 var PLUGIN_STATE_DIR = "phone-notifications";
@@ -9462,7 +9576,7 @@ function isAppNameMapApiResponse(v) {
   );
 }
 function getCachePath(stateDir) {
-  return (0, import_node_path16.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
+  return (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR, CACHE_FILE);
 }
 function createAppNameMapProvider(opts) {
   const { stateDir, logger } = opts;
@@ -9474,9 +9588,9 @@ function createAppNameMapProvider(opts) {
   let inFlightFetch = null;
   function loadFromDisk() {
     const path2 = getCachePath(stateDir);
-    if (!(0, import_node_fs21.existsSync)(path2)) return;
+    if (!(0, import_node_fs22.existsSync)(path2)) return;
     try {
-      const raw = JSON.parse((0, import_node_fs21.readFileSync)(path2, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs22.readFileSync)(path2, "utf-8"));
       if (!isRecordOfStrings(raw)) return;
       map.clear();
       for (const [k, v] of Object.entries(raw)) map.set(k, v);
@@ -9520,10 +9634,10 @@ function createAppNameMapProvider(opts) {
         logger.warn("[app-name-map] refresh succeeded but got 0 entries");
         return;
       }
-      const dir = (0, import_node_path16.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
-      (0, import_node_fs21.mkdirSync)(dir, { recursive: true });
+      const dir = (0, import_node_path18.join)(stateDir, "plugins", PLUGIN_STATE_DIR);
+      (0, import_node_fs22.mkdirSync)(dir, { recursive: true });
       const cachePath = getCachePath(stateDir);
-      (0, import_node_fs21.writeFileSync)(cachePath, JSON.stringify(Object.fromEntries(map), null, 2), "utf-8");
+      (0, import_node_fs22.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);
@@ -9567,8 +9681,8 @@ function createAppNameMapProvider(opts) {
 }
 
 // src/recording/storage.ts
-var import_node_fs22 = require("fs");
-var import_node_path17 = require("path");
+var import_node_fs23 = require("fs");
+var import_node_path19 = require("path");
 
 // src/recording/state-machine.ts
 var VALID_TRANSITIONS = /* @__PURE__ */ new Map([
@@ -9629,7 +9743,7 @@ function stripMarkdownFence(markdown) {
 }
 function deriveTitleFromTranscriptPath(transcriptFile, recordingId) {
   if (!transcriptFile) return void 0;
-  const name = (0, import_node_path17.basename)(transcriptFile, ".md");
+  const name = (0, import_node_path19.basename)(transcriptFile, ".md");
   const prefix = `${recordingId}_`;
   if (name.startsWith(prefix)) {
     const derived = name.slice(prefix.length).trim();
@@ -9657,22 +9771,22 @@ function extractTranscriptContent(markdown) {
   return lines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
 }
 function resolveRecordingStorageDir(ctx, logger) {
-  const stateRecDir = (0, import_node_path17.join)(
+  const stateRecDir = (0, import_node_path19.join)(
     ctx.stateDir,
     "plugins",
     "phone-notifications",
     RECORDINGS_DIR
   );
   try {
-    (0, import_node_fs22.mkdirSync)(stateRecDir, { recursive: true });
+    (0, import_node_fs23.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_path17.join)(ctx.workspaceDir, RECORDINGS_DIR);
+    const wsRecDir = (0, import_node_path19.join)(ctx.workspaceDir, RECORDINGS_DIR);
     try {
-      (0, import_node_fs22.mkdirSync)(wsRecDir, { recursive: true });
+      (0, import_node_fs23.mkdirSync)(wsRecDir, { recursive: true });
       logger.warn(`stateDir \u4E0D\u53EF\u7528\uFF0C\u5F55\u97F3\u5DF2\u56DE\u9000\u5230 workspace \u8DEF\u5F84: ${wsRecDir}`);
       return wsRecDir;
     } catch {
@@ -9684,11 +9798,11 @@ var RecordingStorage = class {
   constructor(dir, logger) {
     this.logger = logger;
     this.dir = dir;
-    this.audioDir = (0, import_node_path17.join)(dir, AUDIO_DIR);
-    this.transcriptDataDir = (0, import_node_path17.join)(dir, TRANSCRIPT_DATA_DIR);
-    this.transcriptsDir = (0, import_node_path17.join)(dir, TRANSCRIPTS_DIR);
-    this.summariesDir = (0, import_node_path17.join)(dir, SUMMARIES_DIR);
-    this.indexPath = (0, import_node_path17.join)(dir, INDEX_FILE);
+    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);
   }
   dir;
   audioDir;
@@ -9699,10 +9813,10 @@ var RecordingStorage = class {
   index = { recordings: [] };
   /** 初始化目录结构并加载索引 */
   async init() {
-    (0, import_node_fs22.mkdirSync)(this.audioDir, { recursive: true });
-    (0, import_node_fs22.mkdirSync)(this.transcriptDataDir, { recursive: true });
-    (0, import_node_fs22.mkdirSync)(this.transcriptsDir, { recursive: true });
-    (0, import_node_fs22.mkdirSync)(this.summariesDir, { recursive: true });
+    (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 });
     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`
@@ -9746,13 +9860,13 @@ var RecordingStorage = class {
         return id;
       }
       if (existing.transcriptDataFile) {
-        (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, existing.transcriptDataFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptDataFile), { force: true });
       }
       if (existing.transcriptFile) {
-        (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, existing.transcriptFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.transcriptFile), { force: true });
       }
       if (existing.summaryFile) {
-        (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, existing.summaryFile), { force: true });
+        (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, existing.summaryFile), { force: true });
       }
       existing.metadata = metadata;
       existing.status = "syncing_openclaw";
@@ -9820,7 +9934,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptDataFile = `${TRANSCRIPT_DATA_DIR}/${filename}`;
     if (entry.transcriptDataFile && entry.transcriptDataFile !== nextTranscriptDataFile) {
-      (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, entry.transcriptDataFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptDataFile), { force: true });
     }
     entry.transcriptDataFile = nextTranscriptDataFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9834,7 +9948,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextTranscriptFile = `${TRANSCRIPTS_DIR}/${filename}`;
     if (entry.transcriptFile && entry.transcriptFile !== nextTranscriptFile) {
-      (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, entry.transcriptFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.transcriptFile), { force: true });
     }
     entry.transcriptFile = nextTranscriptFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9848,7 +9962,7 @@ var RecordingStorage = class {
     if (!entry) return;
     const nextSummaryFile = `${SUMMARIES_DIR}/${filename}`;
     if (entry.summaryFile && entry.summaryFile !== nextSummaryFile) {
-      (0, import_node_fs22.rmSync)((0, import_node_path17.join)(this.dir, entry.summaryFile), { force: true });
+      (0, import_node_fs23.rmSync)((0, import_node_path19.join)(this.dir, entry.summaryFile), { force: true });
     }
     entry.summaryFile = nextSummaryFile;
     entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9946,24 +10060,24 @@ var RecordingStorage = class {
     const entry = this.findById(recordingId);
     if (!entry) return false;
     if (entry.audioFile) {
-      const audioPath = (0, import_node_path17.join)(this.dir, entry.audioFile);
-      (0, import_node_fs22.rmSync)(audioPath, { force: true });
+      const audioPath = (0, import_node_path19.join)(this.dir, entry.audioFile);
+      (0, import_node_fs23.rmSync)(audioPath, { force: true });
     }
     if (entry.srtFile) {
-      const srtPath = (0, import_node_path17.join)(this.dir, entry.srtFile);
-      (0, import_node_fs22.rmSync)(srtPath, { force: true });
+      const srtPath = (0, import_node_path19.join)(this.dir, entry.srtFile);
+      (0, import_node_fs23.rmSync)(srtPath, { force: true });
     }
     if (entry.transcriptDataFile) {
-      const transcriptDataPath = (0, import_node_path17.join)(this.dir, entry.transcriptDataFile);
-      (0, import_node_fs22.rmSync)(transcriptDataPath, { force: true });
+      const transcriptDataPath = (0, import_node_path19.join)(this.dir, entry.transcriptDataFile);
+      (0, import_node_fs23.rmSync)(transcriptDataPath, { force: true });
     }
     if (entry.transcriptFile) {
-      const transcriptPath = (0, import_node_path17.join)(this.dir, entry.transcriptFile);
-      (0, import_node_fs22.rmSync)(transcriptPath, { force: true });
+      const transcriptPath = (0, import_node_path19.join)(this.dir, entry.transcriptFile);
+      (0, import_node_fs23.rmSync)(transcriptPath, { force: true });
     }
     if (entry.summaryFile) {
-      const summaryPath = (0, import_node_path17.join)(this.dir, entry.summaryFile);
-      (0, import_node_fs22.rmSync)(summaryPath, { force: true });
+      const summaryPath = (0, import_node_path19.join)(this.dir, entry.summaryFile);
+      (0, import_node_fs23.rmSync)(summaryPath, { force: true });
     }
     if (opts?.localOnly) {
       entry.audioFile = void 0;
@@ -10021,34 +10135,34 @@ var RecordingStorage = class {
    * 获取音频文件的绝对路径。ossUrl 用于推断文件扩展名
    */
   getAudioFilePath(recordingId, ossUrl) {
-    return (0, import_node_path17.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
+    return (0, import_node_path19.join)(this.audioDir, this.buildAudioFilename(recordingId, ossUrl));
   }
   /**
    * 获取打点文件的绝对路径
    */
   getSrtFilePath(recordingId) {
-    return (0, import_node_path17.join)(this.audioDir, this.buildSrtFilename(recordingId));
+    return (0, import_node_path19.join)(this.audioDir, this.buildSrtFilename(recordingId));
   }
   /**
    * 获取转写 JSON 文件的绝对路径
    */
   getTranscriptDataFilePath(recordingId) {
-    return (0, import_node_path17.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
+    return (0, import_node_path19.join)(this.transcriptDataDir, this.buildTranscriptDataFilename(recordingId));
   }
   /**
    * 获取摘要文件的绝对路径
    */
   getSummaryFilePath(recordingId) {
-    return (0, import_node_path17.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
+    return (0, import_node_path19.join)(this.summariesDir, this.buildSummaryFilename(recordingId));
   }
   // ─── Persistence ───
   loadIndex() {
-    if (!(0, import_node_fs22.existsSync)(this.indexPath)) {
+    if (!(0, import_node_fs23.existsSync)(this.indexPath)) {
       this.index = { recordings: [] };
       return;
     }
     try {
-      const raw = JSON.parse((0, import_node_fs22.readFileSync)(this.indexPath, "utf-8"));
+      const raw = JSON.parse((0, import_node_fs23.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) => {
@@ -10086,8 +10200,8 @@ var RecordingStorage = class {
                 segments: []
               });
               const transcriptDataFilename = this.buildTranscriptDataFilename(compacted.id);
-              (0, import_node_fs22.writeFileSync)(
-                (0, import_node_path17.join)(this.transcriptDataDir, transcriptDataFilename),
+              (0, import_node_fs23.writeFileSync)(
+                (0, import_node_path19.join)(this.transcriptDataDir, transcriptDataFilename),
                 JSON.stringify(transcriptDoc, null, 2),
                 "utf-8"
               );
@@ -10099,8 +10213,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_fs22.writeFileSync)(
-              (0, import_node_path17.join)(this.summariesDir, summaryFilename),
+            (0, import_node_fs23.writeFileSync)(
+              (0, import_node_path19.join)(this.summariesDir, summaryFilename),
               entry.summary.trim(),
               "utf-8"
             );
@@ -10110,8 +10224,8 @@ var RecordingStorage = class {
             const summaryFromDocument = extractTranscriptSummaryFromDocument(transcriptDoc);
             if (summaryFromDocument) {
               const summaryFilename = this.buildSummaryFilename(entry.id);
-              (0, import_node_fs22.writeFileSync)(
-                (0, import_node_path17.join)(this.summariesDir, summaryFilename),
+              (0, import_node_fs23.writeFileSync)(
+                (0, import_node_path19.join)(this.summariesDir, summaryFilename),
                 summaryFromDocument,
                 "utf-8"
               );
@@ -10151,7 +10265,7 @@ var RecordingStorage = class {
   }
   readRelativeTextFile(relativePath) {
     try {
-      return (0, import_node_fs22.readFileSync)((0, import_node_path17.join)(this.dir, relativePath), "utf-8");
+      return (0, import_node_fs23.readFileSync)((0, import_node_path19.join)(this.dir, relativePath), "utf-8");
     } catch {
       return void 0;
     }
@@ -10164,7 +10278,7 @@ var RecordingStorage = class {
     return parseTranscriptDocument(raw);
   }
   saveIndex() {
-    (0, import_node_fs22.writeFileSync)(
+    (0, import_node_fs23.writeFileSync)(
       this.indexPath,
       JSON.stringify(this.index, null, 2),
       "utf-8"
@@ -10178,8 +10292,8 @@ var RecordingStorage = class {
 init_transcript_document();
 
 // src/recording/downloader.ts
-var import_node_fs23 = require("fs");
-var import_node_path18 = require("path");
+var import_node_fs24 = require("fs");
+var import_node_path20 = require("path");
 var import_promises2 = require("stream/promises");
 var import_node_stream = require("stream");
 var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
@@ -10189,7 +10303,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_fs23.mkdirSync)((0, import_node_path18.dirname)(destPath), { recursive: true });
+  (0, import_node_fs24.mkdirSync)((0, import_node_path20.dirname)(destPath), { recursive: true });
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     const startMs = Date.now();
@@ -10207,11 +10321,11 @@ async function downloadFile(url, destPath, logger, options) {
         if (!res.body) {
           throw new Error("\u54CD\u5E94\u4F53\u4E3A\u7A7A");
         }
-        const writeStream = (0, import_node_fs23.createWriteStream)(destPath);
+        const writeStream = (0, import_node_fs24.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_fs23.existsSync)(destPath) ? (0, import_node_fs23.statSync)(destPath).size : 0;
+        const fileSize = (0, import_node_fs24.existsSync)(destPath) ? (0, import_node_fs24.statSync)(destPath).size : 0;
         logger.info(
           `[downloader] \u4E0B\u8F7D\u5B8C\u6210: ${destPath} (${formatBytes(fileSize)}, ${elapsed}ms)`
         );
@@ -10222,7 +10336,7 @@ async function downloadFile(url, destPath, logger, options) {
     } catch (err) {
       lastError = err?.message ?? String(err);
       try {
-        if ((0, import_node_fs23.existsSync)(destPath)) (0, import_node_fs23.unlinkSync)(destPath);
+        if ((0, import_node_fs24.existsSync)(destPath)) (0, import_node_fs24.unlinkSync)(destPath);
       } catch {
       }
       const isAbort = err?.name === "AbortError";
@@ -10460,13 +10574,13 @@ async function triggerTranscription(recordingId, storage, asrConfig, logger, opt
 }
 
 // src/tunnel/service.ts
-var import_node_fs28 = require("fs");
-var import_node_path23 = require("path");
+var import_node_fs29 = require("fs");
+var import_node_path25 = require("path");
 init_credentials();
 
 // src/tunnel/relay-client.ts
-var import_node_fs26 = require("fs");
-var import_node_path21 = require("path");
+var import_node_fs27 = require("fs");
+var import_node_path23 = require("path");
 
 // node_modules/.pnpm/ws@8.19.0/node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -10510,8 +10624,8 @@ var RelayClient = class {
       lastDisconnectReason
     };
     try {
-      (0, import_node_fs26.mkdirSync)((0, import_node_path21.dirname)(this.opts.statusFilePath), { recursive: true });
-      (0, import_node_fs26.writeFileSync)(this.opts.statusFilePath, JSON.stringify(info, null, 2));
+      (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));
     } catch {
     }
   }
@@ -10893,8 +11007,8 @@ init_host();
 
 // src/tunnel/device-identity.ts
 var import_node_crypto3 = __toESM(require("crypto"), 1);
-var import_node_fs27 = __toESM(require("fs"), 1);
-var import_node_path22 = __toESM(require("path"), 1);
+var import_node_fs28 = __toESM(require("fs"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 init_host();
 var ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
 function base64UrlEncode(buf) {
@@ -10939,10 +11053,10 @@ function resolveClientStateDir(stateDir) {
   return stateDir ?? resolveStateDir();
 }
 function ensureDir(filePath) {
-  import_node_fs27.default.mkdirSync(import_node_path22.default.dirname(filePath), { recursive: true });
+  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
 }
 function resolveIdentityPath(stateDir) {
-  return import_node_path22.default.join(stateDir, "identity", "device.json");
+  return import_node_path24.default.join(stateDir, "identity", "device.json");
 }
 function normalizeDeviceAuthRole(role) {
   return role.trim();
@@ -10958,12 +11072,12 @@ function normalizeDeviceAuthScopes(scopes) {
   return [...out].sort();
 }
 function resolveDeviceAuthPath(stateDir) {
-  return import_node_path22.default.join(stateDir, "identity", "device-auth.json");
+  return import_node_path24.default.join(stateDir, "identity", "device-auth.json");
 }
 function readDeviceAuthStore(filePath) {
   try {
-    if (!import_node_fs27.default.existsSync(filePath)) return null;
-    const raw = import_node_fs27.default.readFileSync(filePath, "utf8");
+    if (!import_node_fs28.default.existsSync(filePath)) return null;
+    const raw = import_node_fs28.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;
@@ -10974,12 +11088,12 @@ function readDeviceAuthStore(filePath) {
 }
 function writeDeviceAuthStore(filePath, store) {
   ensureDir(filePath);
-  import_node_fs27.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
+  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(store, null, 2)}
 `, {
     mode: 384
   });
   try {
-    import_node_fs27.default.chmodSync(filePath, 384);
+    import_node_fs28.default.chmodSync(filePath, 384);
   } catch {
   }
 }
@@ -11026,8 +11140,8 @@ function clearDeviceAuthToken(params) {
 function loadOrCreateDeviceIdentity(stateDir) {
   const filePath = resolveIdentityPath(stateDir);
   try {
-    if (import_node_fs27.default.existsSync(filePath)) {
-      const raw = import_node_fs27.default.readFileSync(filePath, "utf8");
+    if (import_node_fs28.default.existsSync(filePath)) {
+      const raw = import_node_fs28.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);
@@ -11048,14 +11162,14 @@ function loadOrCreateDeviceIdentity(stateDir) {
     publicKeyPem,
     privateKeyPem
   };
-  import_node_fs27.default.mkdirSync(import_node_path22.default.dirname(filePath), { recursive: true });
+  import_node_fs28.default.mkdirSync(import_node_path24.default.dirname(filePath), { recursive: true });
   const stored = {
     version: 1,
     ...identity,
     createdAtMs: Date.now()
   };
   ensureDir(filePath);
-  import_node_fs27.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
+  import_node_fs28.default.writeFileSync(filePath, `${JSON.stringify(stored, null, 2)}
 `, {
     mode: 384
   });
@@ -11825,7 +11939,7 @@ function createTunnelService(opts) {
   }
   function readLockOwner(filePath) {
     try {
-      const parsed = JSON.parse((0, import_node_fs28.readFileSync)(filePath, "utf-8"));
+      const parsed = JSON.parse((0, import_node_fs29.readFileSync)(filePath, "utf-8"));
       return typeof parsed.pid === "number" ? parsed.pid : null;
     } catch {
       return null;
@@ -11838,23 +11952,23 @@ function createTunnelService(opts) {
     lockFd = null;
     if (fd !== null) {
       try {
-        (0, import_node_fs28.closeSync)(fd);
+        (0, import_node_fs29.closeSync)(fd);
       } catch {
       }
     }
     if (filePath) {
       try {
-        (0, import_node_fs28.unlinkSync)(filePath);
+        (0, import_node_fs29.unlinkSync)(filePath);
       } catch {
       }
     }
   }
   function acquireLock(filePath) {
-    (0, import_node_fs28.mkdirSync)((0, import_node_path23.dirname)(filePath), { recursive: true });
+    (0, import_node_fs29.mkdirSync)((0, import_node_path25.dirname)(filePath), { recursive: true });
     for (let attempt = 0; attempt < 2; attempt++) {
       try {
-        const fd = (0, import_node_fs28.openSync)(filePath, "wx", 384);
-        (0, import_node_fs28.writeFileSync)(
+        const fd = (0, import_node_fs29.openSync)(filePath, "wx", 384);
+        (0, import_node_fs29.writeFileSync)(
           fd,
           JSON.stringify({
             pid: process.pid,
@@ -11878,7 +11992,7 @@ function createTunnelService(opts) {
             `Relay tunnel: removing stale local lock owned by dead pid=${ownerPid}`
           );
           try {
-            (0, import_node_fs28.unlinkSync)(filePath);
+            (0, import_node_fs29.unlinkSync)(filePath);
           } catch {
           }
           continue;
@@ -11923,12 +12037,12 @@ function createTunnelService(opts) {
         return;
       }
       const { logger } = opts;
-      const baseStateDir = (0, import_node_path23.join)(ctx.stateDir, "plugins", "phone-notifications");
+      const baseStateDir = (0, import_node_path25.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_path23.join)(baseStateDir, "tunnel-status.json");
-      const lockPath = (0, import_node_path23.join)(baseStateDir, "relay-tunnel.lock");
+      const statusFilePath = (0, import_node_path25.join)(baseStateDir, "tunnel-status.json");
+      const lockPath = (0, import_node_path25.join)(baseStateDir, "relay-tunnel.lock");
       if (!acquireLock(lockPath)) {
         return;
       }
@@ -12068,7 +12182,7 @@ function readHostGatewayConfig(params) {
   let configData;
   if (configPath) {
     try {
-      configData = JSON.parse((0, import_node_fs29.readFileSync)(configPath, "utf-8"));
+      configData = JSON.parse((0, import_node_fs30.readFileSync)(configPath, "utf-8"));
     } catch (err) {
       if (err?.code !== "ENOENT") {
         params.logger.warn(