@mingxy/ocosay 1.1.33 → 1.2.0

package/dist/core/backends/index.js

@@ -45,21 +45,6 @@ export var BackendType;
     BackendType["SPEAKER"] = "speaker";
     BackendType["AUTO"] = "auto";
 })(BackendType || (BackendType = {}));
-let naudiodonCache = null;
-async function tryLoadNaudiodon() {
-    if (naudiodonCache !== null) {
-        return naudiodonCache;
-    }
-    try {
-        naudiodonCache = await import('naudiodon');
-        return naudiodonCache;
-    }
-    catch (err) {
-        logger.warn({ err }, 'failed to load naudiodon module');
-        naudiodonCache = false;
-        return null;
-    }
-}
 function isNaudiodonAvailable() {
     try {
         require.resolve('naudiodon');
@@ -80,12 +65,27 @@ function isSpeakerAvailable() {
         return false;
     }
 }
+/**
+ * 检测是否运行在 WSL (Windows Subsystem for Linux) 环境中
+ */
+function isWSL() {
+    if (process.platform !== 'linux')
+        return false;
+    try {
+        const output = execSync('uname -r', { stdio: 'pipe', encoding: 'utf8' });
+        return output.toLowerCase().includes('microsoft');
+    }
+    catch {
+        return false;
+    }
+}
 export function createBackend(type = BackendType.AUTO, options = {}) {
     const platform = process.platform;
     if (type !== BackendType.AUTO) {
         return createBackendByType(type, options);
     }
-    if (isNaudiodonAvailable()) {
+    // WSL 环境下 naudiodon 可能无法工作（无法访问 Windows 音频设备），跳过
+    if (!isWSL() && isNaudiodonAvailable()) {
         try {
             const naudiodon = require('naudiodon');
             if (naudiodon) {
@@ -104,8 +104,29 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
     switch (platform) {
         case 'darwin':
             return new AfplayBackend(options);
-        case 'linux':
+        case 'linux': {
+            const wsl = isWSL();
+            if (wsl) {
+                logger.debug('Running on WSL, skipping naudiodon (may not work with Windows audio)');
+            }
             // Linux 环境检测顺序：naudiodon → aplay → play-sound → speaker → Howler
+            // WSL 环境下 naudiodon 可能无法工作，直接尝试其他后端
+            if (!wsl && isNaudiodonAvailable()) {
+                try {
+                    const naudiodon = require('naudiodon');
+                    if (naudiodon) {
+                        const devices = naudiodon.getDevices();
+                        if (devices && devices.length > 0) {
+                            return new NaudiodonBackend(options);
+                        }
+                        logger.debug('naudiodon has no audio devices, skipping');
+                    }
+                }
+                catch (err) {
+                    logger.error({ err }, 'failed to initialize naudiodon backend');
+                }
+            }
+            // aplay 后端
             if (isCommandAvailable('aplay')) {
                 const test = execCmd('aplay -l');
                 if (test.success && !test.output.includes('no soundcards')) {
@@ -123,6 +144,7 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
             // 彻底失败，使用 Howler 作为最后的回退
             logger.warn('All Linux audio backends failed, using HowlerBackend as fallback');
             return new HowlerBackend(options);
+        }
         case 'win32':
             return new PowerShellBackend(options);
         default:

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

@@ -7,6 +7,8 @@ import { execFile } from 'child_process';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { writeFileSync, unlinkSync, existsSync } from 'fs';
+import { promisify } from 'util';
+const execFileAsync = promisify(execFile);
 // 白名单：只允许特定路径格式（禁止 - 防止命令注入）
 const SAFE_PATH_REGEX = /^[\w\/\.]+$/;
 /**
@@ -45,59 +47,91 @@ export class PlaySoundBackend {
         // 等待 play-sound 播放完成
         await this.playWithPlaySound(filePath);
     }
-    async playWithPlaySound(filePath) {
-        try {
+    playWithPlaySound(filePath) {
+        return new Promise((resolve, reject) => {
             // 异步导入 play-sound
-            const play = (await import('play-sound')).default;
-            // 配置播放器选项
-            const opts = {
-                players: ['ffplay', 'aplay', 'mpg123', 'afplay'] // 优先级
-            };
-            // 对于 ffplay，使用无声模式
-            if (process.platform === 'linux') {
-                // ffplay 无声卡播放参数
-                this.player = execFile('ffplay', [
-                    '-nodisp', // 不显示窗口
-                    '-autoexit', // 播放完自动退出
-                    '-loglevel', 'error', // 减少日志输出
-                    filePath
-                ], (error) => {
-                    if (this._stopped)
-                        return;
-                    if (error) {
+            import('play-sound').then((playModule) => {
+                const play = playModule.default;
+                // 对于 ffplay，使用无声模式
+                if (process.platform === 'linux') {
+                    // ffplay 无声卡播放参数
+                    execFileAsync('ffplay', [
+                        '-nodisp', // 不显示窗口
+                        '-autoexit', // 播放完自动退出
+                        '-loglevel', 'error', // 减少日志输出
+                        filePath
+                    ]).then(() => {
+                        if (this._stopped) {
+                            resolve();
+                            return;
+                        }
+                        this._started = false;
+                        this.events?.onEnd?.();
+                        resolve();
+                    }).catch((error) => {
+                        if (this._stopped) {
+                            resolve();
+                            return;
+                        }
+                        this._started = false;
                         this.handleError(error);
-                        return;
+                        reject(error);
+                    });
+                }
+                else {
+                    // 使用 play-sound 的 Promise API
+                    // play-sound 的类型定义不完善，需要用 any 访问 .play() 方法
+                    const playerSound = play;
+                    const p = playerSound.play(filePath);
+                    if (p && p.then) {
+                        // 返回 Promise 的情况
+                        p.then(() => {
+                            if (this._stopped) {
+                                resolve();
+                                return;
+                            }
+                            this._started = false;
+                            this.events?.onEnd?.();
+                            resolve();
+                        }).catch((err) => {
+                            if (this._stopped) {
+                                resolve();
+                                return;
+                            }
+                            this._started = false;
+                            this.handleError(err);
+                            reject(err);
+                        });
                     }
-                    this._started = false;
-                    this.events?.onEnd?.();
-                });
-            }
-            else {
-                // 使用 play-sound 的默认行为
-                const audio = play;
-                const p = audio.play(filePath, (err) => {
-                    if (this._stopped)
-                        return;
-                    if (err) {
-                        this.handleError(err);
-                        return;
+                    else if (p && p.kill) {
+                        // 返回 ChildProcess 的情况
+                        this.player = p;
+                        p.on('error', (error) => {
+                            this.handleError(error);
+                            reject(error);
+                        });
+                        p.on('close', () => {
+                            if (this._stopped) {
+                                resolve();
+                                return;
+                            }
+                            this._started = false;
+                            this.events?.onEnd?.();
+                            resolve();
+                        });
+                    }
+                    else {
+                        // 无法识别的返回类型，直接 resolve
+                        resolve();
                     }
-                    this._started = false;
-                    this.events?.onEnd?.();
-                });
-                if (p && p.kill) {
-                    this.player = p;
                 }
-            }
-            if (this.player) {
-                this.player.on('error', (error) => {
-                    this.handleError(error);
-                });
-            }
-        }
-        catch (err) {
-            this.handleError(err instanceof Error ? err : new Error(String(err)));
-        }
+            }).catch((err) => {
+                const error = err instanceof Error ? err : new Error(String(err));
+                error.message = `play-sound load failed: ${error.message}`;
+                this.handleError(error);
+                reject(error);
+            });
+        });
     }
     write(chunk) {
         if (this._stopped)

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

@@ -92,7 +92,8 @@ export class SpeakerBackend {
     }
     stripWavHeader(chunk) {
         // 跳过 44 字节的 WAV 头
-        return chunk.slice(44);
+        // 使用 subarray 替代 deprecated 的 slice
+        return chunk.subarray(44);
     }
     createSpeaker() {
         try {

package/dist/core/notification.d.ts

@@ -1,6 +1,6 @@
 export type ToastVariant = 'success' | 'error' | 'info' | 'warning';
 export interface ToastOptions {
-    title: string;
+    title?: string;
     message: string;
     variant?: ToastVariant;
     duration?: number;
@@ -17,10 +17,16 @@ declare class NotificationService {
     showToast(options: ToastOptions): boolean;
     private scheduleRetry;
     private flushPending;
+    success(message: string, duration?: number): boolean;
     success(title: string, message: string, duration?: number): boolean;
+    error(message: string, duration?: number): boolean;
     error(title: string, message: string, duration?: number): boolean;
+    info(message: string, duration?: number): boolean;
     info(title: string, message: string, duration?: number): boolean;
+    warning(message: string, duration?: number): boolean;
     warning(title: string, message: string, duration?: number): boolean;
+    showSpinnerToast(title: string, message: string, duration?: number): Promise<void>;
+    private getTitleForVariant;
 }
 export declare const notificationService: NotificationService;
 export default notificationService;

package/dist/core/notification.js

@@ -1,6 +1,7 @@
 // src/core/notification.ts
 import { createModuleLogger } from '../utils/logger';
 const logger = createModuleLogger('NotificationService');
+const SISYPHUS_SPINNER = ['·', '•', '●', '○', '◌', '◦', ' '];
 /**
  * NotificationService - 统一 Toast 通知管理
  * 参照 DCP 实现，不做防御性检查，直接调用并用 try-catch 处理
@@ -15,10 +16,11 @@ class NotificationService {
         this.flushPending();
     }
     showToast(options) {
-        const { title, message, variant = 'info', duration = 5000 } = options;
+        const title = options.title || this.getTitleForVariant(options.variant || 'info');
+        const { message, variant = 'info', duration = 5000 } = options;
         if (!this.tui) {
             logger.debug({ title }, 'tui not ready, queueing toast');
-            this.pendingToasts.push(options);
+            this.pendingToasts.push({ ...options, title });
             this.scheduleRetry();
             return false;
         }
@@ -38,7 +40,7 @@ class NotificationService {
         catch (err) {
             // 参照 DCP：捕获异常但不抛出
             logger.warn({ err, title }, 'toast call failed, queueing for retry');
-            this.pendingToasts.push(options);
+            this.pendingToasts.push({ ...options, title });
             this.scheduleRetry();
             return false;
         }
@@ -68,17 +70,68 @@ class NotificationService {
             }
         }
     }
-    success(title, message, duration) {
-        return this.showToast({ title, message, variant: 'success', duration });
+    success(titleOrMessage, messageOrDuration, duration) {
+        if (typeof messageOrDuration === 'string') {
+            // 3参数: success(title, message, duration)
+            return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: 'success', duration });
+        }
+        // 2参数: success(message, duration) 或 success(message)
+        return this.showToast({ message: titleOrMessage, variant: 'success', duration: messageOrDuration });
     }
-    error(title, message, duration) {
-        return this.showToast({ title, message, variant: 'error', duration });
+    error(titleOrMessage, messageOrDuration, duration) {
+        if (typeof messageOrDuration === 'string') {
+            return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: 'error', duration });
+        }
+        return this.showToast({ message: titleOrMessage, variant: 'error', duration: messageOrDuration || 8000 });
     }
-    info(title, message, duration) {
-        return this.showToast({ title, message, variant: 'info', duration });
+    info(titleOrMessage, messageOrDuration, duration) {
+        if (typeof messageOrDuration === 'string') {
+            return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: 'info', duration });
+        }
+        return this.showToast({ message: titleOrMessage, variant: 'info', duration: messageOrDuration });
+    }
+    warning(titleOrMessage, messageOrDuration, duration) {
+        if (typeof messageOrDuration === 'string') {
+            return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: 'warning', duration });
+        }
+        return this.showToast({ message: titleOrMessage, variant: 'warning', duration: messageOrDuration });
+    }
+    async showSpinnerToast(title, message, duration = 2000) {
+        const frameInterval = 100;
+        const totalFrames = Math.ceil(duration / frameInterval);
+        for (let i = 0; i < totalFrames; i++) {
+            const spinner = SISYPHUS_SPINNER[i % SISYPHUS_SPINNER.length];
+            const toastDuration = Math.min(frameInterval + 50, duration - i * frameInterval);
+            if (toastDuration <= 0)
+                break;
+            if (this.tui?.showToast) {
+                try {
+                    await this.tui.showToast({
+                        body: {
+                            title: `${spinner} ${title}`,
+                            message,
+                            variant: 'info',
+                            duration: toastDuration
+                        },
+                    });
+                }
+                catch (err) {
+                    logger.warn({ err }, 'showSpinnerToast failed');
+                }
+            }
+            if (i < totalFrames - 1) {
+                await new Promise((resolve) => setTimeout(resolve, frameInterval));
+            }
+        }
     }
-    warning(title, message, duration) {
-        return this.showToast({ title, message, variant: 'warning', duration });
+    getTitleForVariant(variant) {
+        const titles = {
+            success: 'Success',
+            error: 'Error',
+            warning: 'Warning',
+            info: 'Info'
+        };
+        return titles[variant];
     }
 }
 export const notificationService = new NotificationService();

package/dist/core/player.js

@@ -121,7 +121,7 @@ export class AudioPlayer extends EventEmitter {
      * 使用 AudioBackend 统一后端播放
      */
     async playFile(filePath, _format) {
-        await this.backend.start(filePath);
+        await Promise.resolve(this.backend.start(filePath));
     }
     pause() {
         if (!this._playing || this._paused)

package/dist/core/stream-player.d.ts

@@ -38,6 +38,7 @@ export declare class StreamPlayer extends EventEmitter {
     private _started;
     private _paused;
     private _stopped;
+    private _starting;
     private format;
     private events?;
     constructor(options?: StreamPlayerOptions);
@@ -45,12 +46,12 @@ export declare class StreamPlayer extends EventEmitter {
      * 开始播放
      * 初始化后端，准备接收音频数据
      */
-    start(): void;
+    start(): Promise<void>;
     /**
      * 写入音频数据块（边收边播）
      * 如果尚未 start()，会自动调用
      */
-    write(chunk: Buffer): void;
+    write(chunk: Buffer): Promise<void>;
     /**
      * 结束写入
      * 通知后端写入完成，但保持播放直到结束

package/dist/core/stream-player.js

@@ -18,14 +18,15 @@ export class StreamPlayer extends EventEmitter {
     _started = false;
     _paused = false;
     _stopped = false;
+    _starting = false;
     format = 'mp3';
     events;
     constructor(options = {}) {
         super();
         this.format = options.format || 'mp3';
         this.events = options.events;
-        // 创建音频后端
-        const backendType = options.backendType || BackendType.NAUDIODON;
+        // 创建音频后端，默认使用 AUTO 自动选择合适的后端
+        const backendType = options.backendType || BackendType.AUTO;
         this.backend = createBackend(backendType, {
             format: this.format,
             events: {
@@ -65,7 +66,7 @@ export class StreamPlayer extends EventEmitter {
      * 开始播放
      * 初始化后端，准备接收音频数据
      */
-    start() {
+    async start() {
         if (this._started) {
             return;
         }
@@ -73,8 +74,8 @@ export class StreamPlayer extends EventEmitter {
             this.handleError(new Error('Audio backend not initialized'));
             return;
         }
-        // 初始化后端
-        this.backend.start('');
+        // 初始化后端（playsound-backend 是异步的，需 await）
+        await Promise.resolve(this.backend.start(''));
         this._started = true;
         this._stopped = false;
         this._paused = false;
@@ -84,18 +85,29 @@ export class StreamPlayer extends EventEmitter {
      * 写入音频数据块（边收边播）
      * 如果尚未 start()，会自动调用
      */
-    write(chunk) {
+    async write(chunk) {
         // 如果已停止，直接忽略
         if (this._stopped) {
             return;
         }
-        // 如果未启动，自动启动
+        // 如果未启动，防止竞态条件并自动启动
         if (!this._started) {
-            this.start();
+            // 防止并发启动
+            while (this._starting) {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            }
+            this._starting = true;
+            try {
+                await this.start();
+            }
+            finally {
+                this._starting = false;
+            }
         }
         // 写入数据到后端
         if (this.backend) {
-            this.backend.write(chunk);
+            // backend.write() 可能返回 Promise 或 void，用 Promise.resolve 处理
+            await Promise.resolve(this.backend.write(chunk));
             this._bytesWritten += chunk.length;
             this.events?.onProgress?.(this._bytesWritten);
             this.emit('progress', this._bytesWritten);

package/dist/index.js

@@ -65,7 +65,7 @@ function initializeStreamComponents(config) {
     const playerEvents = {
         onStart: () => { },
         onEnd: () => { },
-        onProgress: (bytesWritten) => { },
+        onProgress: (_bytesWritten) => { },
         onError: (error) => logger.error({ error }, 'stream player error'),
         onStop: () => { }
     };
@@ -161,7 +161,7 @@ export async function destroy() {
         streamingSynthesizer = undefined;
     }
     if (streamPlayer) {
-        await streamPlayer.stop();
+        streamPlayer.stop();
         streamPlayer = undefined;
     }
     if (speaker) {

package/dist/package.json

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

package/dist/plugin.js

@@ -7471,6 +7471,8 @@ import { execFile as execFile3 } from "child_process";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join5 } from "path";
 import { writeFileSync as writeFileSync4, unlinkSync as unlinkSync4, existsSync as existsSync5 } from "fs";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile3);
 var SAFE_PATH_REGEX4 = /^[\w\/\.]+$/;
 var PlaySoundBackend = class {
   name = "play-sound";
@@ -7498,55 +7500,84 @@ var PlaySoundBackend = class {
     this.events?.onStart?.();
     await this.playWithPlaySound(filePath);
   }
-  async playWithPlaySound(filePath) {
-    try {
-      const play = (await import("play-sound")).default;
-      const opts = {
-        players: ["ffplay", "aplay", "mpg123", "afplay"]
-        // 优先级
-      };
-      if (process.platform === "linux") {
-        this.player = execFile3("ffplay", [
-          "-nodisp",
-          // 不显示窗口
-          "-autoexit",
-          // 播放完自动退出
-          "-loglevel",
-          "error",
-          // 减少日志输出
-          filePath
-        ], (error) => {
-          if (this._stopped) return;
-          if (error) {
+  playWithPlaySound(filePath) {
+    return new Promise((resolve, reject) => {
+      import("play-sound").then((playModule) => {
+        const play = playModule.default;
+        if (process.platform === "linux") {
+          execFileAsync("ffplay", [
+            "-nodisp",
+            // 不显示窗口
+            "-autoexit",
+            // 播放完自动退出
+            "-loglevel",
+            "error",
+            // 减少日志输出
+            filePath
+          ]).then(() => {
+            if (this._stopped) {
+              resolve();
+              return;
+            }
+            this._started = false;
+            this.events?.onEnd?.();
+            resolve();
+          }).catch((error) => {
+            if (this._stopped) {
+              resolve();
+              return;
+            }
+            this._started = false;
             this.handleError(error);
-            return;
-          }
-          this._started = false;
-          this.events?.onEnd?.();
-        });
-      } else {
-        const audio = play;
-        const p = audio.play(filePath, (err) => {
-          if (this._stopped) return;
-          if (err) {
-            this.handleError(err);
-            return;
+            reject(error);
+          });
+        } else {
+          const playerSound = play;
+          const p = playerSound.play(filePath);
+          if (p && p.then) {
+            p.then(() => {
+              if (this._stopped) {
+                resolve();
+                return;
+              }
+              this._started = false;
+              this.events?.onEnd?.();
+              resolve();
+            }).catch((err) => {
+              if (this._stopped) {
+                resolve();
+                return;
+              }
+              this._started = false;
+              this.handleError(err);
+              reject(err);
+            });
+          } else if (p && p.kill) {
+            this.player = p;
+            p.on("error", (error) => {
+              this.handleError(error);
+              reject(error);
+            });
+            p.on("close", () => {
+              if (this._stopped) {
+                resolve();
+                return;
+              }
+              this._started = false;
+              this.events?.onEnd?.();
+              resolve();
+            });
+          } else {
+            resolve();
           }
-          this._started = false;
-          this.events?.onEnd?.();
-        });
-        if (p && p.kill) {
-          this.player = p;
         }
-      }
-      if (this.player) {
-        this.player.on("error", (error) => {
-          this.handleError(error);
-        });
-      }
-    } catch (err) {
-      this.handleError(err instanceof Error ? err : new Error(String(err)));
-    }
+      }).catch((err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        error.message = `play-sound load failed: ${error.message}`;
+        this.handleError(error);
+        reject(error);
+      });
+    });
   }
   write(chunk) {
     if (this._stopped) return;
@@ -7694,7 +7725,7 @@ var SpeakerBackend = class {
     return false;
   }
   stripWavHeader(chunk) {
-    return chunk.slice(44);
+    return chunk.subarray(44);
   }
   createSpeaker() {
     try {
@@ -7770,6 +7801,7 @@ import { execSync } from "child_process";
 
 // src/core/notification.ts
 var logger3 = createModuleLogger("NotificationService");
+var SISYPHUS_SPINNER = ["\xB7", "\u2022", "\u25CF", "\u25CB", "\u25CC", "\u25E6", " "];
 var NotificationService = class {
   tui = null;
   pendingToasts = [];
@@ -7780,10 +7812,11 @@ var NotificationService = class {
     this.flushPending();
   }
   showToast(options) {
-    const { title, message, variant = "info", duration = 5e3 } = options;
+    const title = options.title || this.getTitleForVariant(options.variant || "info");
+    const { message, variant = "info", duration = 5e3 } = options;
     if (!this.tui) {
       logger3.debug({ title }, "tui not ready, queueing toast");
-      this.pendingToasts.push(options);
+      this.pendingToasts.push({ ...options, title });
       this.scheduleRetry();
       return false;
     }
@@ -7800,7 +7833,7 @@ var NotificationService = class {
       return true;
     } catch (err) {
       logger3.warn({ err, title }, "toast call failed, queueing for retry");
-      this.pendingToasts.push(options);
+      this.pendingToasts.push({ ...options, title });
       this.scheduleRetry();
       return false;
     }
@@ -7826,17 +7859,64 @@ var NotificationService = class {
       }
     }
   }
-  success(title, message, duration) {
-    return this.showToast({ title, message, variant: "success", duration });
+  success(titleOrMessage, messageOrDuration, duration) {
+    if (typeof messageOrDuration === "string") {
+      return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: "success", duration });
+    }
+    return this.showToast({ message: titleOrMessage, variant: "success", duration: messageOrDuration });
+  }
+  error(titleOrMessage, messageOrDuration, duration) {
+    if (typeof messageOrDuration === "string") {
+      return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: "error", duration });
+    }
+    return this.showToast({ message: titleOrMessage, variant: "error", duration: messageOrDuration || 8e3 });
+  }
+  info(titleOrMessage, messageOrDuration, duration) {
+    if (typeof messageOrDuration === "string") {
+      return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: "info", duration });
+    }
+    return this.showToast({ message: titleOrMessage, variant: "info", duration: messageOrDuration });
   }
-  error(title, message, duration) {
-    return this.showToast({ title, message, variant: "error", duration });
+  warning(titleOrMessage, messageOrDuration, duration) {
+    if (typeof messageOrDuration === "string") {
+      return this.showToast({ title: titleOrMessage, message: messageOrDuration, variant: "warning", duration });
+    }
+    return this.showToast({ message: titleOrMessage, variant: "warning", duration: messageOrDuration });
   }
-  info(title, message, duration) {
-    return this.showToast({ title, message, variant: "info", duration });
+  async showSpinnerToast(title, message, duration = 2e3) {
+    const frameInterval = 100;
+    const totalFrames = Math.ceil(duration / frameInterval);
+    for (let i = 0; i < totalFrames; i++) {
+      const spinner = SISYPHUS_SPINNER[i % SISYPHUS_SPINNER.length];
+      const toastDuration = Math.min(frameInterval + 50, duration - i * frameInterval);
+      if (toastDuration <= 0) break;
+      if (this.tui?.showToast) {
+        try {
+          await this.tui.showToast({
+            body: {
+              title: `${spinner} ${title}`,
+              message,
+              variant: "info",
+              duration: toastDuration
+            }
+          });
+        } catch (err) {
+          logger3.warn({ err }, "showSpinnerToast failed");
+        }
+      }
+      if (i < totalFrames - 1) {
+        await new Promise((resolve) => setTimeout(resolve, frameInterval));
+      }
+    }
   }
-  warning(title, message, duration) {
-    return this.showToast({ title, message, variant: "warning", duration });
+  getTitleForVariant(variant) {
+    const titles = {
+      success: "Success",
+      error: "Error",
+      warning: "Warning",
+      info: "Info"
+    };
+    return titles[variant];
   }
 };
 var notificationService = new NotificationService();
@@ -7871,12 +7951,21 @@ function isSpeakerAvailable() {
     return false;
   }
 }
+function isWSL() {
+  if (process.platform !== "linux") return false;
+  try {
+    const output = execSync("uname -r", { stdio: "pipe", encoding: "utf8" });
+    return output.toLowerCase().includes("microsoft");
+  } catch {
+    return false;
+  }
+}
 function createBackend(type = "auto" /* AUTO */, options = {}) {
   const platform = process.platform;
   if (type !== "auto" /* AUTO */) {
     return createBackendByType(type, options);
   }
-  if (isNaudiodonAvailable()) {
+  if (!isWSL() && isNaudiodonAvailable()) {
     try {
       const naudiodon = __require("naudiodon");
       if (naudiodon) {
@@ -7898,7 +7987,25 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
   switch (platform) {
     case "darwin":
       return new AfplayBackend(options);
-    case "linux":
+    case "linux": {
+      const wsl = isWSL();
+      if (wsl) {
+        logger.debug("Running on WSL, skipping naudiodon (may not work with Windows audio)");
+      }
+      if (!wsl && isNaudiodonAvailable()) {
+        try {
+          const naudiodon = __require("naudiodon");
+          if (naudiodon) {
+            const devices = naudiodon.getDevices();
+            if (devices && devices.length > 0) {
+              return new NaudiodonBackend(options);
+            }
+            logger.debug("naudiodon has no audio devices, skipping");
+          }
+        } catch (err) {
+          logger.error({ err }, "failed to initialize naudiodon backend");
+        }
+      }
       if (isCommandAvailable("aplay")) {
         const test = execCmd("aplay -l");
         if (test.success && !test.output.includes("no soundcards")) {
@@ -7913,6 +8020,7 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
       }
       logger.warn("All Linux audio backends failed, using HowlerBackend as fallback");
       return new HowlerBackend(options);
+    }
     case "win32":
       return new PowerShellBackend(options);
     default:
@@ -8047,7 +8155,7 @@ var AudioPlayer = class extends EventEmitter {
    * 使用 AudioBackend 统一后端播放
    */
   async playFile(filePath, _format) {
-    await this.backend.start(filePath);
+    await Promise.resolve(this.backend.start(filePath));
   }
   pause() {
     if (!this._playing || this._paused) return;
@@ -8298,12 +8406,10 @@ async function listVoices(providerName) {
 
 // src/services/speaker-service.ts
 var SpeakerService = class {
-  constructor(options = {}) {
-    this.options = options;
+  speaker;
+  constructor(_options = {}) {
     this.speaker = getDefaultSpeaker();
   }
-  options;
-  speaker;
   async speak(text, options) {
     const timestamp = this.getTimestamp();
     logger.info(`[Ocosay][${timestamp}][INFO][Speaker] \u5BF9\u5E94\u4E8B\u4EF6{\u64AD\u653E\u5F00\u59CB} - \u6587\u672C\u957F\u5EA6: ${text.length}`);
@@ -8379,13 +8485,14 @@ var StreamPlayer = class extends EventEmitter3 {
   _started = false;
   _paused = false;
   _stopped = false;
+  _starting = false;
   format = "mp3";
   events;
   constructor(options = {}) {
     super();
     this.format = options.format || "mp3";
     this.events = options.events;
-    const backendType = options.backendType || "naudiodon" /* NAUDIODON */;
+    const backendType = options.backendType || "auto" /* AUTO */;
     this.backend = createBackend(backendType, {
       format: this.format,
       events: {
@@ -8425,7 +8532,7 @@ var StreamPlayer = class extends EventEmitter3 {
    * 开始播放
    * 初始化后端，准备接收音频数据
    */
-  start() {
+  async start() {
     if (this._started) {
       return;
     }
@@ -8433,7 +8540,7 @@ var StreamPlayer = class extends EventEmitter3 {
       this.handleError(new Error("Audio backend not initialized"));
       return;
     }
-    this.backend.start("");
+    await Promise.resolve(this.backend.start(""));
     this._started = true;
     this._stopped = false;
     this._paused = false;
@@ -8443,15 +8550,23 @@ var StreamPlayer = class extends EventEmitter3 {
    * 写入音频数据块（边收边播）
    * 如果尚未 start()，会自动调用
    */
-  write(chunk) {
+  async write(chunk) {
     if (this._stopped) {
       return;
     }
     if (!this._started) {
-      this.start();
+      while (this._starting) {
+        await new Promise((resolve) => setTimeout(resolve, 10));
+      }
+      this._starting = true;
+      try {
+        await this.start();
+      } finally {
+        this._starting = false;
+      }
     }
     if (this.backend) {
-      this.backend.write(chunk);
+      await Promise.resolve(this.backend.write(chunk));
       this._bytesWritten += chunk.length;
       this.events?.onProgress?.(this._bytesWritten);
       this.emit("progress", this._bytesWritten);
@@ -8641,7 +8756,7 @@ var StreamingService = class extends EventEmitter4 {
         );
       }
       const player = this.initPlayer();
-      player.start();
+      await player.start();
       this._isActive = true;
       this._bytesWritten = 0;
       const result = await provider.speak(text, {
@@ -8667,7 +8782,7 @@ var StreamingService = class extends EventEmitter4 {
     if (result.isStream && result.audioData instanceof ReadableStream) {
       await this.streamAudioChunks(result.audioData, player);
     } else if (Buffer.isBuffer(result.audioData)) {
-      player.write(result.audioData);
+      await player.write(result.audioData);
       player.end();
     }
   }
@@ -8684,7 +8799,7 @@ var StreamingService = class extends EventEmitter4 {
         }
         if (value) {
           const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
-          player.write(chunk);
+          await player.write(chunk);
         }
       }
     } finally {
@@ -8946,7 +9061,6 @@ var MiniMaxProvider = class extends BaseTTSProvider {
   config;
   httpClient;
   wsConnection;
-  currentAudioData = [];
   audioFormat = "mp3";
   constructor(config) {
     super();
@@ -9672,7 +9786,7 @@ function initializeStreamComponents(config) {
     },
     onEnd: () => {
     },
-    onProgress: (bytesWritten) => {
+    onProgress: (_bytesWritten) => {
     },
     onError: (error) => logger.error({ error }, "stream player error"),
     onStop: () => {
@@ -10123,9 +10237,8 @@ async function ensureSpeakerInstalledAsync() {
   await ensurePlaySoundInstalled();
 }
 async function initAsync() {
-  setTimeout(async () => {
-    await ensureSpeakerInstalledAsync();
-  }, 100);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  await ensureSpeakerInstalledAsync();
 }
 async function ensurePlaySoundInstalled() {
   const dep = "play-sound";
@@ -10434,6 +10547,45 @@ var server = (async (input, _options) => {
   global.__opencode_tui__ = opencodeTui;
   notificationService.setTui(opencodeTui);
   const config = loadOrCreateConfig();
+  function collectEnvironmentInfo() {
+    const lines = [];
+    lines.push(`Auto-read: ${config.autoRead ? "ON" : "OFF"}`);
+    let naudiodonOk = false;
+    try {
+      pluginRequire.resolve("naudiodon");
+      naudiodonOk = true;
+    } catch {
+      naudiodonOk = false;
+    }
+    const playSoundOk = isModuleInstalled("play-sound");
+    const platform = process.platform;
+    let backend = "unknown";
+    if (naudiodonOk) {
+      backend = "naudiodon";
+    } else if (platform === "linux") {
+      if (checkAlsa()) {
+        backend = "aplay";
+      } else if (checkFFplay()) {
+        backend = "ffplay";
+      } else {
+        backend = "howler";
+      }
+    } else if (platform === "darwin") {
+      backend = "afplay";
+    } else if (platform === "win32") {
+      backend = "powershell";
+    } else {
+      backend = "howler";
+    }
+    const ffplayOk = checkFFplay();
+    const alsaOk = checkAlsa();
+    lines.push(`naudiodon: ${naudiodonOk ? "\u2713" : "\u2717"}`);
+    lines.push(`play-sound: ${playSoundOk ? "\u2713" : "\u2717"}`);
+    lines.push(`backend: ${backend}`);
+    lines.push(`ffplay: ${ffplayOk ? "\u2713" : "\u2717"}`);
+    lines.push(`alsa: ${alsaOk ? "\u2713" : "\u2717"}`);
+    return lines.join("\n");
+  }
   try {
     await initialize({
       autoRead: config.autoRead,
@@ -10449,21 +10601,22 @@ var server = (async (input, _options) => {
     initError = err instanceof Error ? err : new Error(String(err));
     logger8.error({ error: initError }, "initialization failed");
   }
-  initAsync();
+  await initAsync();
   await ensureNaudiodonCompiled();
   await ensureOptionalDepsInstalled();
   await checkAudioEnvironmentForBackend();
   setTimeout(() => {
+    const envInfo = collectEnvironmentInfo();
     if (initError) {
       notificationService.error(
-        `Ocosay v${pluginVersion} Init Failed`,
-        "Please check your config file",
+        `Ocosay v${pluginVersion} Init Failed
+Please check your config file`,
         8e3
       );
     } else {
-      notificationService.success(
+      notificationService.showSpinnerToast(
         `Ocosay v${pluginVersion} Ready`,
-        `Auto-read: ${config.autoRead ? "ON" : "OFF"}`,
+        envInfo,
         5e3
       );
     }

package/dist/providers/minimax.d.ts

@@ -35,7 +35,6 @@ export declare class MiniMaxProvider extends BaseTTSProvider {
     private config;
     private httpClient;
     private wsConnection?;
-    private currentAudioData;
     private audioFormat;
     constructor(config: MiniMaxConfig);
     initialize(): Promise<void>;

package/dist/providers/minimax.js

@@ -24,7 +24,6 @@ export class MiniMaxProvider extends BaseTTSProvider {
     config;
     httpClient;
     wsConnection;
-    currentAudioData = [];
     audioFormat = 'mp3';
     constructor(config) {
         super();

package/dist/services/notification-service.d.ts

@@ -1,17 +1,26 @@
 export type ToastType = 'success' | 'error' | 'warning' | 'info';
+export interface ShowToastOptions {
+    title?: string;
+    message: string;
+    variant?: ToastType;
+    duration?: number;
+}
 export declare class NotificationService {
     private constructor();
     static getInstance(): NotificationService;
     initialize(tuiInstance: any): void;
     isReady(): boolean;
+    showToast(options: ShowToastOptions): void;
     showToast(message: string, type?: ToastType): void;
-    success(message: string): void;
-    error(message: string): void;
-    warning(message: string): void;
-    info(message: string): void;
+    success(message: string, duration?: number): void;
+    error(message: string, duration?: number): void;
+    warning(message: string, duration?: number): void;
+    info(message: string, duration?: number): void;
+    showSpinnerToast(title: string, message: string, duration?: number): Promise<void>;
     private getTitleForType;
     private fallbackLog;
 }
+export declare function showToast(options: ShowToastOptions): void;
 export declare function showToast(message: string, type?: ToastType): void;
 export declare function initializeNotificationService(tuiInstance: any): void;
 //# sourceMappingURL=notification-service.d.ts.map

package/dist/services/notification-service.js

@@ -1,4 +1,5 @@
 import { logger } from '../utils/logger.js';
+const SISYPHUS_SPINNER = ['·', '•', '●', '○', '◌', '◦', ' '];
 let instance;
 let tui = null;
 let initialized = false;
@@ -20,15 +21,30 @@ export class NotificationService {
     isReady() {
         return initialized && tui !== null;
     }
-    showToast(message, type = 'info') {
-        const title = this.getTitleForType(type);
+    showToast(options, type) {
+        let title;
+        let message;
+        let variant;
+        let duration;
+        if (typeof options === 'string') {
+            message = options;
+            variant = type || 'info';
+            title = this.getTitleForType(variant);
+            duration = variant === 'error' ? 8000 : 5000;
+        }
+        else {
+            message = options.message;
+            variant = options.variant || 'info';
+            title = options.title || this.getTitleForType(variant);
+            duration = options.duration || (variant === 'error' ? 8000 : 5000);
+        }
         if (tui?.showToast) {
             try {
                 tui.showToast({
                     title,
                     message,
-                    variant: type,
-                    duration: type === 'error' ? 8000 : 5000
+                    variant,
+                    duration
                 });
                 return;
             }
@@ -36,12 +52,46 @@ export class NotificationService {
                 logger.warn({ err }, 'tui.showToast failed');
             }
         }
-        this.fallbackLog(type, title, message);
+        this.fallbackLog(variant, title, message);
+    }
+    success(message, duration) {
+        this.showToast({ message, variant: 'success', duration });
+    }
+    error(message, duration) {
+        this.showToast({ message, variant: 'error', duration: duration || 8000 });
+    }
+    warning(message, duration) {
+        this.showToast({ message, variant: 'warning', duration });
+    }
+    info(message, duration) {
+        this.showToast({ message, variant: 'info', duration });
+    }
+    async showSpinnerToast(title, message, duration = 2000) {
+        const frameInterval = 100;
+        const totalFrames = Math.ceil(duration / frameInterval);
+        for (let i = 0; i < totalFrames; i++) {
+            const spinner = SISYPHUS_SPINNER[i % SISYPHUS_SPINNER.length];
+            const toastDuration = Math.min(frameInterval + 50, duration - i * frameInterval);
+            if (toastDuration <= 0)
+                break;
+            if (tui?.showToast) {
+                try {
+                    await tui.showToast({
+                        title: `${spinner} ${title}`,
+                        message,
+                        variant: 'info',
+                        duration: toastDuration
+                    });
+                }
+                catch (err) {
+                    logger.warn({ err }, 'tui.showSpinnerToast failed');
+                }
+            }
+            if (i < totalFrames - 1) {
+                await new Promise((resolve) => setTimeout(resolve, frameInterval));
+            }
+        }
     }
-    success(message) { this.showToast(message, 'success'); }
-    error(message) { this.showToast(message, 'error'); }
-    warning(message) { this.showToast(message, 'warning'); }
-    info(message) { this.showToast(message, 'info'); }
     getTitleForType(type) {
         const titles = {
             success: 'Success',
@@ -65,8 +115,8 @@ export class NotificationService {
         }
     }
 }
-export function showToast(message, type = 'info') {
-    NotificationService.getInstance().showToast(message, type);
+export function showToast(options, type) {
+    NotificationService.getInstance().showToast(options, type);
 }
 export function initializeNotificationService(tuiInstance) {
     NotificationService.getInstance().initialize(tuiInstance);

package/dist/services/speaker-service.d.ts

@@ -5,9 +5,8 @@ export interface speakerServiceOptions {
     defaultVoice?: string;
 }
 export declare class SpeakerService {
-    private options;
     private speaker;
-    constructor(options?: speakerServiceOptions);
+    constructor(_options?: speakerServiceOptions);
     speak(text: string, options?: SpeakOptions & {
         provider?: string;
     }): Promise<void>;

package/dist/services/speaker-service.js

@@ -1,10 +1,8 @@
 import { getDefaultSpeaker, speak as coreSpeak, stop as coreStop, pause as corePause, resume as coreResume, listVoices as coreListVoices } from '../core/speaker';
 import { logger } from '../utils/logger';
 export class SpeakerService {
-    options;
     speaker;
-    constructor(options = {}) {
-        this.options = options;
+    constructor(_options = {}) {
         this.speaker = getDefaultSpeaker();
     }
     async speak(text, options) {

package/dist/services/streaming-service.js

@@ -117,7 +117,7 @@ export class StreamingService extends EventEmitter {
             }
             // 初始化播放器
             const player = this.initPlayer();
-            player.start();
+            await player.start();
             this._isActive = true;
             this._bytesWritten = 0;
             // 调用 Provider 的流式合成
@@ -149,7 +149,7 @@ export class StreamingService extends EventEmitter {
         }
         else if (Buffer.isBuffer(result.audioData)) {
             // 非流式数据：直接写入
-            player.write(result.audioData);
+            await player.write(result.audioData);
             player.end();
         }
     }
@@ -166,7 +166,7 @@ export class StreamingService extends EventEmitter {
                 }
                 if (value) {
                     const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
-                    player.write(chunk);
+                    await player.write(chunk);
                 }
             }
         }

package/package.json

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