@mingxy/ocosay 1.1.31 → 1.1.33

package/dist/core/backends/index.js

@@ -18,6 +18,7 @@ import { HowlerBackend } from './howler-backend';
 import { PlaySoundBackend } from './playsound-backend';
 import { SpeakerBackend } from './speaker-backend';
 import { logger } from '../../utils/logger';
+import { notificationService } from '../notification';
 function execCmd(cmd) {
     try {
         const output = execSync(cmd, { stdio: 'pipe', encoding: 'utf8' });
@@ -97,6 +98,7 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
         }
         catch (err) {
             logger.error({ err }, 'failed to initialize naudiodon backend');
+            notificationService.warning('naudiodon 初始化失败', '将使用其他音频后端', 5000);
         }
     }
     switch (platform) {

package/dist/core/backends/playsound-backend.d.ts

@@ -24,7 +24,7 @@ export declare class PlaySoundBackend implements AudioBackend {
     private chunks;
     private hasEnded;
     constructor(options?: BackendOptions);
-    start(filePath: string): void;
+    start(filePath: string): Promise<void>;
     private playWithPlaySound;
     write(chunk: Buffer): void;
     end(): void;

package/dist/core/backends/playsound-backend.js

@@ -32,7 +32,7 @@ export class PlaySoundBackend {
     constructor(options = {}) {
         this.events = options.events;
     }
-    start(filePath) {
+    async start(filePath) {
         if (this._started)
             return;
         if (!SAFE_PATH_REGEX.test(filePath)) {
@@ -42,8 +42,8 @@ export class PlaySoundBackend {
         this._started = true;
         this._stopped = false;
         this.events?.onStart?.();
-        // 动态导入 play-sound
-        this.playWithPlaySound(filePath);
+        // 等待 play-sound 播放完成
+        await this.playWithPlaySound(filePath);
     }
     async playWithPlaySound(filePath) {
         try {

package/dist/core/player.js

@@ -120,11 +120,8 @@ export class AudioPlayer extends EventEmitter {
      * 播放音频文件
      * 使用 AudioBackend 统一后端播放
      */
-    playFile(filePath, _format) {
-        return new Promise((resolve) => {
-            this.backend.start(filePath);
-            resolve(); // backend.start() 是同步的，立即 resolve
-        });
+    async playFile(filePath, _format) {
+        await this.backend.start(filePath);
     }
     pause() {
         if (!this._playing || this._paused)

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/ocosay",
-  "version": "1.1.30",
+  "version": "1.1.32",
   "description": "OpenCode TTS 播放插件 - 支持豆包模式边接收边朗读",
   "type": "module",
   "main": "dist/plugin.js",

package/dist/plugin.js

@@ -2437,7 +2437,7 @@ var require_thread_stream = __commonJS({
 var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports, module) {
     "use strict";
-    var { createRequire: createRequire3 } = __require("module");
+    var { createRequire: createRequire2 } = __require("module");
     var { existsSync: existsSync8 } = __require("node:fs");
     var getCallers = require_caller();
     var { join: join9, isAbsolute, sep } = __require("node:path");
@@ -2640,7 +2640,7 @@ var require_transport = __commonJS({
         for (const filePath of callers) {
           try {
             const context = filePath === "node:repl" ? process.cwd() + sep : filePath;
-            fixTarget2 = createRequire3(context).resolve(origin);
+            fixTarget2 = createRequire2(context).resolve(origin);
             break;
           } catch (err) {
             continue;
@@ -7487,7 +7487,7 @@ var PlaySoundBackend = class {
   constructor(options = {}) {
     this.events = options.events;
   }
-  start(filePath) {
+  async start(filePath) {
     if (this._started) return;
     if (!SAFE_PATH_REGEX4.test(filePath)) {
       throw new Error(`Invalid file path: ${filePath}`);
@@ -7496,7 +7496,7 @@ var PlaySoundBackend = class {
     this._started = true;
     this._stopped = false;
     this.events?.onStart?.();
-    this.playWithPlaySound(filePath);
+    await this.playWithPlaySound(filePath);
   }
   async playWithPlaySound(filePath) {
     try {
@@ -7767,6 +7767,81 @@ var SpeakerBackend = class {
 
 // src/core/backends/index.ts
 import { execSync } from "child_process";
+
+// src/core/notification.ts
+var logger3 = createModuleLogger("NotificationService");
+var NotificationService = class {
+  tui = null;
+  pendingToasts = [];
+  retryTimer;
+  setTui(tui) {
+    this.tui = tui;
+    logger3.debug("tui reference set");
+    this.flushPending();
+  }
+  showToast(options) {
+    const { title, message, variant = "info", duration = 5e3 } = options;
+    if (!this.tui) {
+      logger3.debug({ title }, "tui not ready, queueing toast");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
+    }
+    try {
+      this.tui.showToast({
+        body: {
+          title,
+          message,
+          variant,
+          duration
+        }
+      });
+      logger3.debug({ title, variant }, "toast shown");
+      return true;
+    } catch (err) {
+      logger3.warn({ err, title }, "toast call failed, queueing for retry");
+      this.pendingToasts.push(options);
+      this.scheduleRetry();
+      return false;
+    }
+  }
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.flushPending();
+    }, 2e3);
+  }
+  flushPending() {
+    if (this.pendingToasts.length === 0 || !this.tui) return;
+    logger3.info({ count: this.pendingToasts.length }, "flushing pending toasts");
+    const pending = [...this.pendingToasts];
+    this.pendingToasts = [];
+    for (const toast of pending) {
+      try {
+        this.showToast(toast);
+      } catch (err) {
+        this.pendingToasts.push(toast);
+        logger3.warn({ err }, "showToast threw unexpected error, re-queued");
+      }
+    }
+  }
+  success(title, message, duration) {
+    return this.showToast({ title, message, variant: "success", duration });
+  }
+  error(title, message, duration) {
+    return this.showToast({ title, message, variant: "error", duration });
+  }
+  info(title, message, duration) {
+    return this.showToast({ title, message, variant: "info", duration });
+  }
+  warning(title, message, duration) {
+    return this.showToast({ title, message, variant: "warning", duration });
+  }
+};
+var notificationService = new NotificationService();
+
+// src/core/backends/index.ts
 function execCmd(cmd) {
   try {
     const output = execSync(cmd, { stdio: "pipe", encoding: "utf8" });
@@ -7813,6 +7888,11 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
       }
     } catch (err) {
       logger.error({ err }, "failed to initialize naudiodon backend");
+      notificationService.warning(
+        "naudiodon \u521D\u59CB\u5316\u5931\u8D25",
+        "\u5C06\u4F7F\u7528\u5176\u4ED6\u97F3\u9891\u540E\u7AEF",
+        5e3
+      );
     }
   }
   switch (platform) {
@@ -7966,11 +8046,8 @@ var AudioPlayer = class extends EventEmitter {
    * 播放音频文件
    * 使用 AudioBackend 统一后端播放
    */
-  playFile(filePath, _format) {
-    return new Promise((resolve) => {
-      this.backend.start(filePath);
-      resolve();
-    });
+  async playFile(filePath, _format) {
+    await this.backend.start(filePath);
   }
   pause() {
     if (!this._playing || this._paused) return;
@@ -8016,79 +8093,6 @@ var AudioPlayer = class extends EventEmitter {
   }
 };
 
-// src/core/notification.ts
-var logger3 = createModuleLogger("NotificationService");
-var NotificationService = class {
-  tui = null;
-  pendingToasts = [];
-  retryTimer;
-  setTui(tui) {
-    this.tui = tui;
-    logger3.debug("tui reference set");
-    this.flushPending();
-  }
-  showToast(options) {
-    const { title, message, variant = "info", duration = 5e3 } = options;
-    if (!this.tui) {
-      logger3.debug({ title }, "tui not ready, queueing toast");
-      this.pendingToasts.push(options);
-      this.scheduleRetry();
-      return false;
-    }
-    try {
-      this.tui.showToast({
-        body: {
-          title,
-          message,
-          variant,
-          duration
-        }
-      });
-      logger3.debug({ title, variant }, "toast shown");
-      return true;
-    } catch (err) {
-      logger3.warn({ err, title }, "toast call failed, queueing for retry");
-      this.pendingToasts.push(options);
-      this.scheduleRetry();
-      return false;
-    }
-  }
-  scheduleRetry() {
-    if (this.retryTimer) return;
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = void 0;
-      this.flushPending();
-    }, 2e3);
-  }
-  flushPending() {
-    if (this.pendingToasts.length === 0 || !this.tui) return;
-    logger3.info({ count: this.pendingToasts.length }, "flushing pending toasts");
-    const pending = [...this.pendingToasts];
-    this.pendingToasts = [];
-    for (const toast of pending) {
-      try {
-        this.showToast(toast);
-      } catch (err) {
-        this.pendingToasts.push(toast);
-        logger3.warn({ err }, "showToast threw unexpected error, re-queued");
-      }
-    }
-  }
-  success(title, message, duration) {
-    return this.showToast({ title, message, variant: "success", duration });
-  }
-  error(title, message, duration) {
-    return this.showToast({ title, message, variant: "error", duration });
-  }
-  info(title, message, duration) {
-    return this.showToast({ title, message, variant: "info", duration });
-  }
-  warning(title, message, duration) {
-    return this.showToast({ title, message, variant: "warning", duration });
-  }
-};
-var notificationService = new NotificationService();
-
 // src/core/speaker.ts
 var logger4 = createModuleLogger("Speaker");
 var Speaker2 = class extends EventEmitter2 {
@@ -9901,360 +9905,8 @@ import { readFileSync as readFileSync2, existsSync as existsSync7, writeFileSync
 import { fileURLToPath } from "url";
 import { dirname as dirname2, join as join8 } from "path";
 import { homedir as homedir3 } from "os";
-import { exec, execSync as execSync4 } from "child_process";
-import { createRequire as createRequire2 } from "module";
-
-// src/core/dependency-detector.ts
-import { execSync as execSync2 } from "child_process";
-function parseMissingHeaders(errorOutput) {
-  const pattern = /fatal error:\s+([^:]+):\s+No such file or directory/g;
-  const headers = [];
-  let match = pattern.exec(errorOutput);
-  while (match !== null) {
-    headers.push(match[1]);
-    match = pattern.exec(errorOutput);
-  }
-  return headers;
-}
-function execCapture(cmd, cwd) {
-  try {
-    const stdout = execSync2(cmd, {
-      cwd,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    return { success: true, stdout, stderr: "" };
-  } catch (err) {
-    const error = err;
-    return {
-      success: false,
-      stdout: error.stdout ? error.stdout.toString() : "",
-      stderr: error.stderr ? error.stderr.toString() : ""
-    };
-  }
-}
-function detectMissingDependencies(errorOutput) {
-  const missingHeaders = parseMissingHeaders(errorOutput);
-  return {
-    missingHeaders,
-    rawOutput: errorOutput
-  };
-}
-
-// src/core/dependency-mapper.ts
+import { exec, execSync as execSync2 } from "child_process";
 import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var HEADER_TO_PACKAGE = [
-  // ALSA - Linux音频库
-  {
-    header: "alsa/asoundlib.h",
-    package: "libasound2-dev"
-  },
-  // PortAudio - 跨平台音频I/O库
-  {
-    header: "portaudio.h",
-    package: "libportaudio-dev",
-    packageMac: "portaudio",
-    packageWin: "portaudio"
-  },
-  // FFmpeg相关
-  {
-    header: "libavcodec/avcodec.h",
-    package: "libavcodec-dev",
-    packageMac: "ffmpeg",
-    packageWin: "ffmpeg"
-  },
-  {
-    header: "libavformat/avformat.h",
-    package: "libavformat-dev",
-    packageMac: "ffmpeg",
-    packageWin: "ffmpeg"
-  },
-  {
-    header: "libavutil/avutil.h",
-    package: "libavutil-dev",
-    packageMac: "ffmpeg",
-    packageWin: "ffmpeg"
-  },
-  {
-    header: "libswresample/swresample.h",
-    package: "libswresample-dev",
-    packageMac: "ffmpeg",
-    packageWin: "ffmpeg"
-  },
-  // OpenAL - 3D音频API
-  {
-    header: "AL/al.h",
-    package: "libopenal-dev",
-    packageMac: "openal",
-    packageWin: "openal"
-  },
-  // SDL - 多媒体库
-  {
-    header: "SDL2/SDL.h",
-    package: "libsdl2-dev",
-    packageMac: "sdl2",
-    packageWin: "sdl2"
-  },
-  // PulseAudio - Linux音频服务
-  {
-    header: "pulse/pulseaudio.h",
-    package: "libpulse-dev"
-  },
-  // CoreAudio - macOS音频框架 (无头文件，纯框架)
-  {
-    header: "CoreAudio/CoreAudio.h",
-    package: "\u81FA",
-    // macOS系统框架，无需安装包
-    packageMac: ""
-  },
-  // Windows特定
-  {
-    header: "windows.h",
-    package: "",
-    // Linux上不存在
-    packageWin: ""
-    // Windows SDK自带
-  }
-];
-function detectPlatform() {
-  const platform = process.platform;
-  const isWsl3 = detectWsl();
-  let packageManager;
-  let installCommand;
-  if (platform === "linux" || isWsl3) {
-    packageManager = "apt-get";
-    installCommand = "sudo apt-get install -y";
-  } else if (platform === "darwin") {
-    packageManager = "brew";
-    installCommand = "brew install";
-  } else {
-    packageManager = "choco";
-    installCommand = "choco install -y";
-  }
-  return {
-    platform,
-    isWsl: isWsl3,
-    packageManager,
-    installCommand
-  };
-}
-function detectWsl() {
-  if (process.platform !== "linux") return false;
-  try {
-    return require2("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
-  } catch {
-    return false;
-  }
-}
-function getPackageForPlatform(mapping, platform, isWsl3) {
-  if (platform === "win32") {
-    if (isWsl3) {
-      return mapping.package || null;
-    }
-    return mapping.packageWin || mapping.package || null;
-  }
-  if (platform === "darwin") {
-    if (mapping.packageMac === "") return null;
-    return mapping.packageMac || mapping.package || null;
-  }
-  if (mapping.package === "") return null;
-  return mapping.package || null;
-}
-function mapHeaderToPackages(header, platform) {
-  const exactMatch = HEADER_TO_PACKAGE.find(
-    (m) => m.header.toLowerCase() === header.toLowerCase()
-  );
-  if (exactMatch) {
-    const pkg = getPackageForPlatform(exactMatch, platform, detectWsl());
-    if (pkg && pkg.length > 0 && pkg !== "\u81FA") {
-      return [pkg];
-    }
-    return [];
-  }
-  const headerBasename = header.split("/").pop()?.toLowerCase() || "";
-  const fuzzyMatch = HEADER_TO_PACKAGE.find((m) => {
-    const mappingBasename = m.header.split("/").pop()?.toLowerCase() || "";
-    return mappingBasename === headerBasename;
-  });
-  if (fuzzyMatch) {
-    const pkg = getPackageForPlatform(fuzzyMatch, platform, detectWsl());
-    if (pkg && pkg.length > 0 && pkg !== "\u81FA") {
-      return [pkg];
-    }
-    return [];
-  }
-  return [];
-}
-function mapHeadersToPackages(headers, platform) {
-  const packageSet = /* @__PURE__ */ new Set();
-  for (const header of headers) {
-    const packages = mapHeaderToPackages(header, platform);
-    for (const pkg of packages) {
-      if (pkg.length > 0) {
-        packageSet.add(pkg);
-      }
-    }
-  }
-  return Array.from(packageSet);
-}
-
-// src/core/dependency-installer.ts
-import { execSync as execSync3 } from "child_process";
-var logger8 = createModuleLogger("DependencyInstaller");
-function getInstallCommandPrefix() {
-  const { platform, isWsl: isWsl3 } = detectPlatform();
-  if (platform === "linux" || isWsl3) {
-    return "sudo apt-get install -y";
-  } else if (platform === "darwin") {
-    return "brew install";
-  }
-  return "choco install -y";
-}
-function getCheckCommand(packageName) {
-  const { platform, isWsl: isWsl3 } = detectPlatform();
-  if (platform === "linux" || isWsl3) {
-    return `dpkg -s ${packageName} 2>/dev/null | grep -q "Status: install ok installed"`;
-  } else if (platform === "darwin") {
-    return `brew list ${packageName} &>/dev/null`;
-  }
-  return `choco list --local-only ${packageName} &>/dev/null`;
-}
-function silentLog(level2, message, extra) {
-  switch (level2) {
-    case "info":
-      logger8.info(extra || {}, message);
-      break;
-    case "warn":
-      logger8.warn(extra || {}, message);
-      break;
-    case "error":
-      logger8.error(extra || {}, message);
-      break;
-  }
-}
-function canSudoWithoutPassword() {
-  try {
-    execSync3("sudo -n true 2>&1", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function installSystemPackages(packages, notifSvc) {
-  const result = {
-    success: false,
-    installedPackages: [],
-    failedPackages: []
-  };
-  const validPackages = packages.filter((p) => p && p.length > 0 && p !== "\u81FA");
-  if (validPackages.length === 0) {
-    silentLog("info", "\u6CA1\u6709\u9700\u8981\u5B89\u88C5\u7684\u5305");
-    return { ...result, success: true };
-  }
-  silentLog("info", `\u5F00\u59CB\u5B89\u88C5\u7CFB\u7EDF\u4F9D\u8D56: ${validPackages.join(", ")}`, { packages: validPackages });
-  notifSvc?.info("\u6B63\u5728\u5B89\u88C5\u7CFB\u7EDF\u4F9D\u8D56...", "Ocosay", 3e3);
-  const installCommand = getInstallCommandPrefix();
-  const fullCommand = `${installCommand} ${validPackages.join(" ")}`;
-  silentLog("info", `\u6267\u884C\u5B89\u88C5\u547D\u4EE4: ${fullCommand}`);
-  if (!canSudoWithoutPassword()) {
-    const msg = "\u9700\u8981 sudo \u6743\u9650\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E NOPASSWD";
-    result.error = msg;
-    notifSvc?.error("\u9700\u8981 sudo \u6743\u9650", "\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C: sudo visudo \u6DFB\u52A0 NOPASSWD \u914D\u7F6E\uFF0C\u914D\u7F6E\u597D\u540E\u8BF7\u91CD\u542F OpenCode", 1e4);
-    silentLog("error", msg);
-    return result;
-  }
-  try {
-    const { platform, isWsl: isWsl3 } = detectPlatform();
-    if (platform === "linux" || isWsl3) {
-      notifSvc?.info("\u6B63\u5728\u66F4\u65B0\u5305\u5217\u8868...", "Ocosay", 3e3);
-      silentLog("info", "\u66F4\u65B0 apt \u5305\u5217\u8868");
-      try {
-        execSync3("sudo apt-get update", {
-          timeout: 12e4,
-          encoding: "utf8",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        silentLog("info", "apt-get update \u5B8C\u6210");
-      } catch (updateErr) {
-        silentLog("warn", "apt-get update \u5931\u8D25\uFF0C\u7EE7\u7EED\u5C1D\u8BD5\u5B89\u88C5", { error: String(updateErr) });
-      }
-    }
-    notifSvc?.info(`\u6B63\u5728\u5B89\u88C5 ${validPackages.length} \u4E2A\u5305...`, "Ocosay", 5e3);
-    const output = execSync3(fullCommand, {
-      timeout: 3e5,
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    silentLog("info", `\u5B89\u88C5\u8F93\u51FA: ${output.substring(0, 500)}`);
-    const verifiedPackages = [];
-    const failedPackages = [];
-    for (const pkg of validPackages) {
-      const isInstalled = await verifyInstallation([pkg]);
-      if (isInstalled) {
-        verifiedPackages.push(pkg);
-        silentLog("info", `\u5305 ${pkg} \u5B89\u88C5\u9A8C\u8BC1\u6210\u529F`);
-      } else {
-        failedPackages.push(pkg);
-        silentLog("warn", `\u5305 ${pkg} \u5B89\u88C5\u9A8C\u8BC1\u5931\u8D25`);
-      }
-    }
-    result.installedPackages = verifiedPackages;
-    result.failedPackages = failedPackages;
-    result.success = failedPackages.length === 0;
-    if (result.success) {
-      notifSvc?.success("\u7CFB\u7EDF\u4F9D\u8D56\u5B89\u88C5\u6210\u529F", verifiedPackages.join(", "), 5e3);
-      silentLog("info", `\u6240\u6709\u5305\u5B89\u88C5\u6210\u529F: ${verifiedPackages.join(", ")}`);
-    } else {
-      const errorMsg = failedPackages.length > 0 ? `\u4EE5\u4E0B\u5305\u5B89\u88C5\u5931\u8D25: ${failedPackages.join(", ")}` : "\u90E8\u5206\u5305\u5B89\u88C5\u5931\u8D25";
-      result.error = errorMsg;
-      notifSvc?.warning("\u90E8\u5206\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", errorMsg, 8e3);
-      silentLog("warn", errorMsg);
-    }
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    silentLog("error", `\u5B89\u88C5\u547D\u4EE4\u6267\u884C\u5931\u8D25: ${errorMessage}`, { error: errorMessage });
-    if (errorMessage.includes("sudo") || errorMessage.toLowerCase().includes("password")) {
-      result.error = "\u9700\u8981 sudo \u6743\u9650\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E NOPASSWD";
-      notifSvc?.error("\u9700\u8981 sudo \u6743\u9650", "\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C: sudo visudo", 1e4);
-    } else if (errorMessage.includes("already") || errorMessage.includes("is already")) {
-      result.success = true;
-      result.installedPackages = validPackages;
-      notifSvc?.success("\u4F9D\u8D56\u5DF2\u5B58\u5728", "\u65E0\u9700\u91CD\u65B0\u5B89\u88C5", 3e3);
-    } else {
-      result.error = errorMessage;
-      notifSvc?.error("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", errorMessage.substring(0, 200), 8e3);
-    }
-  }
-  return result;
-}
-async function verifyInstallation(packages) {
-  if (packages.length === 0) {
-    return true;
-  }
-  const validPackages = packages.filter((p) => p && p.length > 0 && p !== "\u81FA");
-  if (validPackages.length === 0) {
-    return true;
-  }
-  silentLog("info", `\u9A8C\u8BC1\u5305\u5B89\u88C5\u72B6\u6001: ${validPackages.join(", ")}`);
-  try {
-    for (const pkg of validPackages) {
-      const checkCmd = getCheckCommand(pkg);
-      const { success } = execCapture(checkCmd);
-      if (!success) {
-        silentLog("warn", `\u5305 ${pkg} \u9A8C\u8BC1\u5931\u8D25`);
-        return false;
-      }
-    }
-    silentLog("info", `\u6240\u6709\u5305\u9A8C\u8BC1\u901A\u8FC7: ${validPackages.join(", ")}`);
-    return true;
-  } catch (err) {
-    silentLog("error", `\u9A8C\u8BC1\u8FC7\u7A0B\u5F02\u5E38: ${String(err)}`);
-    return false;
-  }
-}
-
-// src/plugin.ts
 function execAsync(cmd, cwd) {
   return new Promise((resolve) => {
     exec(cmd, { cwd, encoding: "utf8" }, (error, stdout, stderr) => {
@@ -10262,12 +9914,12 @@ function execAsync(cmd, cwd) {
     });
   });
 }
-var logger9 = createModuleLogger("Plugin");
-var require3 = createRequire2(import.meta.url);
-var opencodeBinPath = execSync4("which opencode").toString().trim();
+var logger8 = createModuleLogger("Plugin");
+var require2 = createRequire(import.meta.url);
+var opencodeBinPath = execSync2("which opencode").toString().trim();
 var opencodeRoot = dirname2(dirname2(opencodeBinPath));
 var opencodeNodeModules = join8(opencodeRoot, "node_modules");
-var pluginRequire = createRequire2(join8(opencodeNodeModules, "package.json"));
+var pluginRequire = createRequire(join8(opencodeNodeModules, "package.json"));
 function getSkipFilePath() {
   return join8(homedir3(), ".config", "opencode", ".naudiodon_skip");
 }
@@ -10286,38 +9938,38 @@ async function markNaudiodonSkipped() {
 }
 async function verifyNaudiodonLoad() {
   try {
-    require3("naudiodon");
-    logger9.info("naudiodon loaded successfully");
+    require2("naudiodon");
+    logger8.info("naudiodon loaded successfully");
     return true;
   } catch (err) {
-    logger9.warn({ err }, "naudiodon load failed after rebuild");
+    logger8.warn({ err }, "naudiodon load failed after rebuild");
     return false;
   }
 }
 async function rebuildNaudiodonDependency(dep) {
-  const naudiodonPath = dirname2(require3.resolve("naudiodon"));
+  const naudiodonPath = dirname2(require2.resolve("naudiodon"));
   notificationService.info(`\u6B63\u5728\u7F16\u8BD1 ${dep}...`, "Ocosay \u4F9D\u8D56", 4e3);
   const result = await execAsync(`npm rebuild ${dep}`, naudiodonPath);
   if (result.error) {
-    logger9.warn({ err: result.error }, `${dep} rebuild failed`);
+    logger8.warn({ err: result.error }, `${dep} rebuild failed`);
     return false;
   }
-  logger9.info(`${dep} rebuilt successfully`);
+  logger8.info(`${dep} rebuilt successfully`);
   return true;
 }
 async function fixNaudiodonDependencies(maxRetries = 5) {
-  const naudiodonPath = dirname2(require3.resolve("naudiodon"));
+  const naudiodonPath = dirname2(require2.resolve("naudiodon"));
   const criticalDeps = ["segfault-handler", "bindings", "node-pre-gyp"];
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     if (await verifyNaudiodonLoad()) {
       return true;
     }
-    logger9.info({ attempt }, "naudiodon not loadable, trying dependency rebuild");
+    logger8.info({ attempt }, "naudiodon not loadable, trying dependency rebuild");
     notificationService.info(`\u6B63\u5728\u68C0\u67E5\u4F9D\u8D56 (${attempt + 1}/${maxRetries})...`, "Ocosay", 3e3);
     let anySuccess = false;
     for (const dep of criticalDeps) {
       try {
-        require3.resolve(dep, { paths: [naudiodonPath] });
+        require2.resolve(dep, { paths: [naudiodonPath] });
         if (await rebuildNaudiodonDependency(dep)) {
           anySuccess = true;
         }
@@ -10325,9 +9977,9 @@ async function fixNaudiodonDependencies(maxRetries = 5) {
         notificationService.info(`\u6B63\u5728\u5B89\u88C5 ${dep}...`, "Ocosay", 4e3);
         const installResult = await execAsync(`npm install ${dep}`, naudiodonPath);
         if (installResult.error) {
-          logger9.warn({ err: installResult.error }, `${dep} install failed`);
+          logger8.warn({ err: installResult.error }, `${dep} install failed`);
         } else {
-          logger9.info(`${dep} installed successfully`);
+          logger8.info(`${dep} installed successfully`);
           anySuccess = true;
         }
       }
@@ -10336,9 +9988,9 @@ async function fixNaudiodonDependencies(maxRetries = 5) {
       notificationService.info("\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 naudiodon...", "Ocosay", 4e3);
       const rebuildResult = await execAsync("npm rebuild naudiodon", naudiodonPath);
       if (rebuildResult.error) {
-        logger9.warn({ err: rebuildResult.error }, "naudiodon rebuild failed");
+        logger8.warn({ err: rebuildResult.error }, "naudiodon rebuild failed");
       } else {
-        logger9.info("naudiodon rebuilt");
+        logger8.info("naudiodon rebuilt");
         anySuccess = true;
       }
     }
@@ -10353,35 +10005,35 @@ async function fixNaudiodonDependencies(maxRetries = 5) {
 }
 async function ensureNaudiodonCompiled() {
   if (shouldSkipNaudiodon()) {
-    logger9.info("naudiodon skipped previously");
+    logger8.info("naudiodon skipped previously");
     return;
   }
   try {
-    require3("naudiodon");
-    logger9.info("naudiodon already compiled");
+    require2("naudiodon");
+    logger8.info("naudiodon already compiled");
     return;
   } catch {
-    logger9.info("naudiodon not compiled, will attempt to compile");
+    logger8.info("naudiodon not compiled, will attempt to compile");
     notificationService.info("\u6B63\u5728\u7F16\u8BD1 naudiodon...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
   }
   try {
-    const naudiodonPath = dirname2(require3.resolve("naudiodon"));
-    logger9.info({ naudiodonPath }, "found naudiodon, rebuilding");
+    const naudiodonPath = dirname2(require2.resolve("naudiodon"));
+    logger8.info({ naudiodonPath }, "found naudiodon, rebuilding");
     const rebuildResult = await execAsync("npm rebuild naudiodon", naudiodonPath);
     if (rebuildResult.error) {
-      logger9.warn({ err: rebuildResult.error }, "naudiodon rebuild failed, checking for PortAudio");
+      logger8.warn({ err: rebuildResult.error }, "naudiodon rebuild failed, checking for PortAudio");
       notificationService.warning("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5 PortAudio...", 5e3);
       const installed = await installPortAudio();
       if (installed.success) {
-        const retryPath = dirname2(require3.resolve("naudiodon"));
+        const retryPath = dirname2(require2.resolve("naudiodon"));
         notificationService.info("\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 naudiodon...", "Ocosay", 5e3);
         const retryResult = await execAsync("npm rebuild naudiodon", retryPath);
         if (retryResult.error) {
-          logger9.error({ err: retryResult.error }, "naudiodon compile failed even after PortAudio install");
+          logger8.error({ err: retryResult.error }, "naudiodon compile failed even after PortAudio install");
           notificationService.error("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
           markNaudiodonSkipped();
         } else {
-          logger9.info("naudiodon compiled successfully after PortAudio install");
+          logger8.info("naudiodon compiled successfully after PortAudio install");
           const loadSuccess = await verifyNaudiodonLoad();
           if (loadSuccess) {
             notificationService.success("naudiodon \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10396,12 +10048,12 @@ async function ensureNaudiodonCompiled() {
           }
         }
       } else {
-        logger9.error("PortAudio install failed");
+        logger8.error("PortAudio install failed");
         notificationService.error("PortAudio \u5B89\u88C5\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
         markNaudiodonSkipped();
       }
     } else {
-      logger9.info("naudiodon compiled, verifying...");
+      logger8.info("naudiodon compiled, verifying...");
       const loadSuccess = await verifyNaudiodonLoad();
       if (loadSuccess) {
         notificationService.success("naudiodon \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10416,19 +10068,19 @@ async function ensureNaudiodonCompiled() {
       }
     }
   } catch (err) {
-    logger9.warn({ err }, "naudiodon rebuild failed, checking for PortAudio");
+    logger8.warn({ err }, "naudiodon rebuild failed, checking for PortAudio");
     notificationService.warning("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5 PortAudio...", 5e3);
     const installed = await installPortAudio();
     if (installed.success) {
-      const retryPath = dirname2(require3.resolve("naudiodon"));
+      const retryPath = dirname2(require2.resolve("naudiodon"));
       notificationService.info("\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 naudiodon...", "Ocosay", 5e3);
       const retryResult = await execAsync("npm rebuild naudiodon", retryPath);
       if (retryResult.error) {
-        logger9.error({ err: retryResult.error }, "naudiodon compile failed even after PortAudio install");
+        logger8.error({ err: retryResult.error }, "naudiodon compile failed even after PortAudio install");
         notificationService.error("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
         markNaudiodonSkipped();
       } else {
-        logger9.info("naudiodon compiled successfully after PortAudio install");
+        logger8.info("naudiodon compiled successfully after PortAudio install");
         const loadSuccess = await verifyNaudiodonLoad();
         if (loadSuccess) {
           notificationService.success("naudiodon \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10443,7 +10095,7 @@ async function ensureNaudiodonCompiled() {
         }
       }
     } else {
-      logger9.error("PortAudio install failed");
+      logger8.error("PortAudio install failed");
       notificationService.error("PortAudio \u5B89\u88C5\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
       markNaudiodonSkipped();
     }
@@ -10460,87 +10112,35 @@ function isModuleInstalled(moduleName) {
 async function verifyModuleLoad(dep) {
   try {
     pluginRequire(dep);
-    logger9.info(`${dep} loaded successfully`);
+    logger8.info(`${dep} loaded successfully`);
     return true;
   } catch (err) {
-    logger9.warn({ err }, `${dep} load failed`);
+    logger8.warn({ err }, `${dep} load failed`);
     return false;
   }
 }
-async function tryCompileSpeaker() {
-  const dep = "speaker";
-  const result = { success: false, stderr: "" };
-  if (isModuleInstalled(dep)) {
-    if (await verifyModuleLoad(dep)) {
-      result.success = true;
-      return result;
-    }
-  }
-  if (!isModuleInstalled(dep)) {
-    const installResult = await execAsync("npm install speaker", opencodeNodeModules);
-    if (installResult.error) {
-      logger9.warn({ err: installResult.error }, "speaker install failed");
-    }
-  }
-  const rebuildResult = await execAsync("npm rebuild speaker", opencodeNodeModules);
-  result.stderr = (rebuildResult.stdout || "") + "\n" + (rebuildResult.stderr || "");
-  if (rebuildResult.error) {
-    result.stderr += "\n" + (rebuildResult.error.message || "");
-  }
-  if (await verifyModuleLoad(dep)) {
-    result.success = true;
-  }
-  return result;
-}
-async function ensureSpeakerCompiledAsync() {
-  const compileResult = await tryCompileSpeaker();
-  if (compileResult.success) {
-    logger9.info("speaker compiled successfully");
-    return;
-  }
-  const detectResult = detectMissingDependencies(compileResult.stderr);
-  if (detectResult.missingHeaders.length === 0) {
-    logger9.info("speaker compile failed with unknown error");
-    return;
-  }
-  logger9.info({ missingHeaders: detectResult.missingHeaders }, "detected missing headers");
-  const platformInfo = detectPlatform();
-  const packages = mapHeadersToPackages(detectResult.missingHeaders, platformInfo.platform);
-  if (packages.length === 0) {
-    logger9.info("no known packages for missing headers");
-    return;
-  }
-  logger9.info({ packages }, "mapped headers to packages, installing");
-  await installSystemPackages(packages, notificationService);
-  const retryResult = await tryCompileSpeaker();
-  if (retryResult.success) {
-    logger9.info("speaker compiled successfully after installing dependencies");
-  } else {
-    logger9.warn("speaker compile still failed after dependency installation");
-  }
-}
 async function ensureSpeakerInstalledAsync() {
   await ensurePlaySoundInstalled();
 }
 async function initAsync() {
   setTimeout(async () => {
-    await ensureSpeakerCompiledAsync();
     await ensureSpeakerInstalledAsync();
   }, 100);
 }
 async function ensurePlaySoundInstalled() {
   const dep = "play-sound";
   if (isModuleInstalled(dep)) {
-    logger9.info("play-sound already installed");
+    logger8.info("play-sound already installed");
     if (await verifyModuleLoad(dep)) {
+      notificationService.success("play-sound \u5DF2\u5C31\u7EEA", "\u97F3\u9891\u540E\u7AEF\u6B63\u5E38", 5e3);
       return;
     }
   }
-  logger9.info("play-sound not found, installing");
+  logger8.info("play-sound not found, installing");
   notificationService.info("\u6B63\u5728\u5B89\u88C5 play-sound...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
   const installResult = await execAsync("npm install play-sound", opencodeNodeModules);
   if (installResult.error) {
-    logger9.warn({ err: installResult.error }, "play-sound install failed");
+    logger8.warn({ err: installResult.error }, "play-sound install failed");
     notificationService.warning(
       "play-sound \u5B89\u88C5\u5931\u8D25",
       "\u8BF7\u624B\u52A8\u8FD0\u884C: npm install play-sound",
@@ -10548,7 +10148,7 @@ async function ensurePlaySoundInstalled() {
     );
     return;
   }
-  logger9.info("play-sound installed");
+  logger8.info("play-sound installed");
   if (await verifyModuleLoad(dep)) {
     notificationService.success("play-sound \u5B89\u88C5\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
   } else {
@@ -10560,14 +10160,11 @@ async function ensurePlaySoundInstalled() {
   }
 }
 async function ensureOptionalDepsInstalled() {
-  ensureSpeakerCompiledAsync().catch((err) => {
-    logger9.warn({ err }, "ensureSpeakerCompiledAsync failed");
-  });
   await ensurePlaySoundInstalled();
 }
 function execCmd2(cmd) {
   try {
-    const output = execSync4(cmd, { stdio: "pipe", encoding: "utf8" });
+    const output = execSync2(cmd, { stdio: "pipe", encoding: "utf8" });
     return { success: true, output };
   } catch (err) {
     return { success: false, output: err.message || "" };
@@ -10576,7 +10173,7 @@ function execCmd2(cmd) {
 function isWsl2() {
   if (process.platform !== "linux") return false;
   try {
-    return require3("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return require2("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -10613,9 +10210,9 @@ async function checkAudioEnvironmentForBackend() {
 async function installPortAudio() {
   const platform = process.platform;
   const wsl = isWsl2();
-  logger9.info({ platform, wsl }, "installing PortAudio");
+  logger8.info({ platform, wsl }, "installing PortAudio");
   const runInstall = async (cmd, desc) => {
-    logger9.info(`Running: ${cmd}`);
+    logger8.info(`Running: ${cmd}`);
     notificationService.info(desc, "\u6B63\u5728\u5B89\u88C5...", 5e3);
     const result = await execAsync(cmd);
     if (result.error) {
@@ -10626,15 +10223,15 @@ async function installPortAudio() {
           "# \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21\nsudo visudo\n# \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL",
           1e4
         );
-        logger9.error({ err: result.error }, "\u9700\u8981 sudo \u6743\u9650 \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21sudo visudo # \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL");
+        logger8.error({ err: result.error }, "\u9700\u8981 sudo \u6743\u9650 \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21sudo visudo # \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL");
         return false;
       }
       if (msg.includes("already") || msg.includes("is already")) {
-        logger9.info("already installed");
+        logger8.info("already installed");
         return true;
       }
       notificationService.error(desc + " \u5931\u8D25", msg.substring(0, 100), 8e3);
-      logger9.error({ err: result.error }, `install failed: ${desc}`);
+      logger8.error({ err: result.error }, `install failed: ${desc}`);
       return false;
     }
     return true;
@@ -10643,7 +10240,7 @@ async function installPortAudio() {
     notificationService.info("\u68C0\u6D4B ffmpeg...", "\u97F3\u9891\u540E\u7AEF", 5e3);
     const ffmpegCheck = execCmd2("which ffplay");
     if (ffmpegCheck.success) {
-      logger9.info("ffmpeg already available");
+      logger8.info("ffmpeg already available");
       notificationService.success("ffmpeg \u5C31\u7EEA", "ffplay \u53EF\u7528\u4E8E\u65E0\u58F0\u5361\u64AD\u653E", 5e3);
     } else {
       notificationService.info("\u5B89\u88C5 ffmpeg...", "\u97F3\u9891\u540E\u7AEF", 5e3);
@@ -10659,7 +10256,7 @@ async function installPortAudio() {
     }
     notificationService.info("\u68C0\u6D4B\u97F3\u9891\u8BBE\u5907...", "\u97F3\u9891\u540E\u7AEF", 5e3);
     if (checkAlsa()) {
-      logger9.info("alsa-utils already available and working");
+      logger8.info("alsa-utils already available and working");
       notificationService.success("alsa-utils \u5C31\u7EEA", "\u97F3\u9891\u540E\u7AEF\u5DF2\u53EF\u7528", 5e3);
       return { success: true, message: "alsa" };
     }
@@ -10850,7 +10447,7 @@ var server = (async (input, _options) => {
     });
   } catch (err) {
     initError = err instanceof Error ? err : new Error(String(err));
-    logger9.error({ error: initError }, "initialization failed");
+    logger8.error({ error: initError }, "initialization failed");
   }
   initAsync();
   await ensureNaudiodonCompiled();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/ocosay",
-  "version": "1.1.31",
+  "version": "1.1.33",
   "description": "OpenCode TTS 播放插件 - 支持豆包模式边接收边朗读",
   "type": "module",
   "main": "dist/plugin.js",