@mingxy/ocosay 1.1.32 → 1.2.0

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' });
@@ -44,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');
@@ -79,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) {
@@ -97,13 +98,35 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
         }
         catch (err) {
             logger.error({ err }, 'failed to initialize naudiodon backend');
+            notificationService.warning('naudiodon 初始化失败', '将使用其他音频后端', 5000);
         }
     }
     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')) {
@@ -121,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.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

@@ -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\/\.]+$/;
 /**
@@ -32,7 +34,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,62 +44,94 @@ 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 {
+    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

@@ -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 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.31",
+  "version": "1.2.0",
   "description": "OpenCode TTS 播放插件 - 支持豆包模式边接收边朗读",
   "type": "module",
   "main": "dist/plugin.js",