@mingxy/ocosay 1.1.11 → 1.1.13

package/dist/core/backends/index.d.ts

@@ -7,6 +7,8 @@ export { AfplayBackend } from './afplay-backend';
 export { AplayBackend } from './aplay-backend';
 export { PowerShellBackend } from './powershell-backend';
 export { HowlerBackend } from './howler-backend';
+export { PlaySoundBackend } from './playsound-backend';
+export { SpeakerBackend } from './speaker-backend';
 import { AudioBackend, BackendOptions } from './base';
 /**
  * 后端类型枚举
@@ -17,15 +19,10 @@ export declare enum BackendType {
     APLAY = "aplay",
     POWERSHELL = "powershell",
     HOWLER = "howler",
+    PLAY_SOUND = "play-sound",
+    SPEAKER = "speaker",
     AUTO = "auto"
 }
-export declare function isWsl(): boolean;
-/**
- * 创建音频后端
- * @param type 后端类型，默认 AUTO（自动选择）
- * @param options 后端配置选项
- * @returns 音频后端实例
- */
 export declare function createBackend(type?: BackendType, options?: BackendOptions): AudioBackend;
 export declare function supportsStreaming(type: BackendType): boolean;
 export declare function getDefaultBackendType(): BackendType;

package/dist/core/backends/index.js

@@ -7,12 +7,29 @@ export { AfplayBackend } from './afplay-backend';
 export { AplayBackend } from './aplay-backend';
 export { PowerShellBackend } from './powershell-backend';
 export { HowlerBackend } from './howler-backend';
+export { PlaySoundBackend } from './playsound-backend';
+export { SpeakerBackend } from './speaker-backend';
+import { execSync } from 'child_process';
 import { NaudiodonBackend } from './naudiodon-backend';
 import { AfplayBackend } from './afplay-backend';
 import { AplayBackend } from './aplay-backend';
 import { PowerShellBackend } from './powershell-backend';
 import { HowlerBackend } from './howler-backend';
+import { PlaySoundBackend } from './playsound-backend';
+import { SpeakerBackend } from './speaker-backend';
 import { logger } from '../../utils/logger';
+function execCmd(cmd) {
+    try {
+        const output = execSync(cmd, { stdio: 'pipe', encoding: 'utf8' });
+        return { success: true, output };
+    }
+    catch (err) {
+        return { success: false, output: err.message || '' };
+    }
+}
+function isCommandAvailable(cmd) {
+    return execCmd(`which ${cmd}`).success;
+}
 /**
  * 后端类型枚举
  */
@@ -23,6 +40,8 @@ export var BackendType;
     BackendType["APLAY"] = "aplay";
     BackendType["POWERSHELL"] = "powershell";
     BackendType["HOWLER"] = "howler";
+    BackendType["PLAY_SOUND"] = "play-sound";
+    BackendType["SPEAKER"] = "speaker";
     BackendType["AUTO"] = "auto";
 })(BackendType || (BackendType = {}));
 let naudiodonCache = null;
@@ -50,22 +69,16 @@ function isNaudiodonAvailable() {
         return false;
     }
 }
-export function isWsl() {
-    if (process.platform !== 'linux')
-        return false;
+function isSpeakerAvailable() {
     try {
-        return require('fs').readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+        require.resolve('speaker');
+        return true;
     }
-    catch {
+    catch (err) {
+        logger.debug({ err }, 'speaker not available');
         return false;
     }
 }
-/**
- * 创建音频后端
- * @param type 后端类型，默认 AUTO（自动选择）
- * @param options 后端配置选项
- * @returns 音频后端实例
- */
 export function createBackend(type = BackendType.AUTO, options = {}) {
     const platform = process.platform;
     if (type !== BackendType.AUTO) {
@@ -90,10 +103,24 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
         case 'darwin':
             return new AfplayBackend(options);
         case 'linux':
-            if (isWsl()) {
-                return new PowerShellBackend(options);
+            // Linux 环境检测顺序：naudiodon → aplay → play-sound → speaker → Howler
+            if (isCommandAvailable('aplay')) {
+                const test = execCmd('aplay -l');
+                if (test.success && !test.output.includes('no soundcards')) {
+                    return new AplayBackend(options);
+                }
             }
-            return new AplayBackend(options);
+            // 检测 play-sound (ffplay)
+            if (isCommandAvailable('ffplay')) {
+                return new PlaySoundBackend(options);
+            }
+            // 检测 speaker (需要 speaker npm 包)
+            if (isSpeakerAvailable()) {
+                return new SpeakerBackend(options);
+            }
+            // 彻底失败，使用 Howler 作为最后的回退
+            logger.warn('All Linux audio backends failed, using HowlerBackend as fallback');
+            return new HowlerBackend(options);
         case 'win32':
             return new PowerShellBackend(options);
         default:
@@ -112,6 +139,10 @@ function createBackendByType(type, options) {
             return new PowerShellBackend(options);
         case BackendType.HOWLER:
             return new HowlerBackend(options);
+        case BackendType.PLAY_SOUND:
+            return new PlaySoundBackend(options);
+        case BackendType.SPEAKER:
+            return new SpeakerBackend(options);
         default:
             throw new Error(`Unknown backend type: ${type}`);
     }
@@ -120,7 +151,7 @@ export function supportsStreaming(type) {
     if (type === BackendType.AUTO) {
         return isNaudiodonAvailable();
     }
-    return type === BackendType.NAUDIODON;
+    return type === BackendType.NAUDIODON || type === BackendType.SPEAKER;
 }
 export function getDefaultBackendType() {
     const platform = process.platform;

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

@@ -0,0 +1,39 @@
+/**
+ * PlaySound Backend - 跨平台音频播放后端
+ * 使用 play-sound npm 包调用系统工具（ffplay/aplay/mpg123）
+ * 支持 Linux/macOS/Windows，可无声卡播放（ffplay）
+ */
+import { AudioBackend, BackendOptions } from './base';
+/**
+ * PlaySoundBackend - 使用 play-sound 包的后端
+ * play-sound 会自动选择最佳播放器：
+ * - Linux: ffplay > aplay > mpg123
+ * - macOS: afplay > aplay > mpg123
+ * - Windows: Powershell > vlc > afplay
+ * ffplay 支持无声卡播放（-nodisp -autoexit）
+ */
+export declare class PlaySoundBackend implements AudioBackend {
+    readonly name = "play-sound";
+    readonly supportsStreaming = false;
+    private player?;
+    private tempFile?;
+    private events?;
+    private _started;
+    private _paused;
+    private _stopped;
+    private chunks;
+    private hasEnded;
+    constructor(options?: BackendOptions);
+    start(filePath: string): void;
+    private playWithPlaySound;
+    write(chunk: Buffer): void;
+    end(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    setVolume(_volume: number): void;
+    destroy(): void;
+    private cleanup;
+    private handleError;
+}
+//# sourceMappingURL=playsound-backend.d.ts.map

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

@@ -0,0 +1,189 @@
+/**
+ * PlaySound Backend - 跨平台音频播放后端
+ * 使用 play-sound npm 包调用系统工具（ffplay/aplay/mpg123）
+ * 支持 Linux/macOS/Windows，可无声卡播放（ffplay）
+ */
+import { execFile } from 'child_process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { writeFileSync, unlinkSync, existsSync } from 'fs';
+// 白名单：只允许特定路径格式（禁止 - 防止命令注入）
+const SAFE_PATH_REGEX = /^[\w\/\.]+$/;
+/**
+ * PlaySoundBackend - 使用 play-sound 包的后端
+ * play-sound 会自动选择最佳播放器：
+ * - Linux: ffplay > aplay > mpg123
+ * - macOS: afplay > aplay > mpg123
+ * - Windows: Powershell > vlc > afplay
+ * ffplay 支持无声卡播放（-nodisp -autoexit）
+ */
+export class PlaySoundBackend {
+    name = 'play-sound';
+    supportsStreaming = false;
+    player;
+    tempFile;
+    events;
+    _started = false;
+    _paused = false;
+    _stopped = false;
+    // P0-4: 缓冲所有chunk，等end()时一次性写入文件
+    chunks = [];
+    hasEnded = false;
+    constructor(options = {}) {
+        this.events = options.events;
+    }
+    start(filePath) {
+        if (this._started)
+            return;
+        if (!SAFE_PATH_REGEX.test(filePath)) {
+            throw new Error(`Invalid file path: ${filePath}`);
+        }
+        this.tempFile = filePath;
+        this._started = true;
+        this._stopped = false;
+        this.events?.onStart?.();
+        // 动态导入 play-sound
+        this.playWithPlaySound(filePath);
+    }
+    async playWithPlaySound(filePath) {
+        try {
+            // 异步导入 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) {
+                        this.handleError(error);
+                        return;
+                    }
+                    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;
+                    }
+                    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)));
+        }
+    }
+    write(chunk) {
+        if (this._stopped)
+            return;
+        // P0-4: 缓冲所有chunk，等end()时一次性写入
+        this.chunks.push(chunk);
+    }
+    end() {
+        if (this._stopped || this.hasEnded)
+            return;
+        this.hasEnded = true;
+        if (this.chunks.length === 0)
+            return;
+        // P0-4: 所有chunk缓冲完毕后，一次性写入文件并播放
+        this.tempFile = join(tmpdir(), `ocosay-${Date.now()}.wav`);
+        writeFileSync(this.tempFile, Buffer.concat(this.chunks));
+        this.chunks = [];
+        this.start(this.tempFile);
+    }
+    pause() {
+        if (!this._started || this._paused || this._stopped)
+            return;
+        if (this.player) {
+            try {
+                this.player.kill('SIGSTOP');
+                this._paused = true;
+                this.events?.onPause?.();
+            }
+            catch (e) {
+                // SIGSTOP 可能失败
+            }
+        }
+    }
+    resume() {
+        if (!this._paused || this._stopped)
+            return;
+        if (this.player) {
+            try {
+                this.player.kill('SIGCONT');
+                this._paused = false;
+                this.events?.onResume?.();
+            }
+            catch (e) {
+                // SIGCONT 可能失败
+            }
+        }
+    }
+    stop() {
+        this._stopped = true;
+        this._started = false;
+        this._paused = false;
+        if (this.player) {
+            try {
+                this.player.kill('SIGTERM');
+            }
+            catch (e) {
+                // 忽略错误
+            }
+            this.player = undefined;
+        }
+        this.cleanup();
+        this.chunks = [];
+        this.hasEnded = false;
+        this.events?.onStop?.();
+    }
+    setVolume(_volume) {
+        // play-sound/ffplay 不支持命令行设置音量
+    }
+    destroy() {
+        this.stop();
+    }
+    cleanup() {
+        if (this.tempFile && this.tempFile.startsWith(tmpdir())) {
+            try {
+                if (existsSync(this.tempFile)) {
+                    unlinkSync(this.tempFile);
+                }
+            }
+            catch (e) {
+                // 忽略清理错误
+            }
+            this.tempFile = undefined;
+        }
+    }
+    handleError(error) {
+        this.events?.onError?.(error);
+    }
+}
+//# sourceMappingURL=playsound-backend.js.map

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

@@ -6,7 +6,16 @@ import { spawn } from 'child_process';
 import { tmpdir } from 'os';
 import { join } from 'path';
 import { writeFileSync, unlinkSync, existsSync } from 'fs';
-import { isWsl } from './index';
+function isWsl() {
+    if (process.platform !== 'linux')
+        return false;
+    try {
+        return require('fs').readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+    }
+    catch {
+        return false;
+    }
+}
 // 白名单：Windows/WSL 路径格式（禁止 - 防止命令注入）
 // 允许: 字母数字 \w, Windows盘符 : \:, 反斜杠 \\, 下划线 _, 点 ., $ @ /, 以及 -
 const SAFE_PATH_REGEX = /^[\w\:\\_.\-$@\/]+$/i;

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

@@ -0,0 +1,34 @@
+/**
+ * Speaker Backend - Linux/macOS 音频播放后端
+ * 使用 speaker npm 包直接输出 PCM 到 ALSA/PulseAudio
+ * 支持流式播放，但需要完整的音频头信息
+ */
+import { AudioBackend, BackendOptions } from './base';
+/**
+ * SpeakerBackend - 使用 speaker 包的后端
+ * speaker 直接将 PCM 数据输出到系统音频设备
+ * 支持流式播放，但需要正确的音频格式参数
+ */
+export declare class SpeakerBackend implements AudioBackend {
+    readonly name = "speaker";
+    readonly supportsStreaming = true;
+    private speaker?;
+    private events?;
+    private _started;
+    private _paused;
+    private _stopped;
+    private _format;
+    constructor(options?: BackendOptions);
+    start(_filePath: string): void;
+    write(chunk: Buffer): void;
+    private isWavHeader;
+    private stripWavHeader;
+    private createSpeaker;
+    end(): void;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    destroy(): void;
+    private handleError;
+}
+//# sourceMappingURL=speaker-backend.d.ts.map

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

@@ -0,0 +1,163 @@
+/**
+ * Speaker Backend - Linux/macOS 音频播放后端
+ * 使用 speaker npm 包直接输出 PCM 到 ALSA/PulseAudio
+ * 支持流式播放，但需要完整的音频头信息
+ */
+import Speaker from 'speaker';
+/**
+ * SpeakerBackend - 使用 speaker 包的后端
+ * speaker 直接将 PCM 数据输出到系统音频设备
+ * 支持流式播放，但需要正确的音频格式参数
+ */
+export class SpeakerBackend {
+    name = 'speaker';
+    supportsStreaming = true;
+    speaker;
+    events;
+    _started = false;
+    _paused = false;
+    _stopped = false;
+    _format = {
+        channels: 1,
+        sampleRate: 16000,
+        bitDepth: 16,
+        signed: true,
+        float: false
+    };
+    constructor(options = {}) {
+        this.events = options.events;
+        if (options.sampleRate) {
+            this._format.sampleRate = options.sampleRate;
+        }
+        if (options.channels) {
+            this._format.channels = options.channels;
+        }
+        if (options.format === 'wav') {
+            this._format.bitDepth = 16;
+        }
+    }
+    start(_filePath) {
+        if (this._started)
+            return;
+        this._started = true;
+        this._stopped = false;
+        this._paused = false;
+        this.events?.onStart?.();
+    }
+    write(chunk) {
+        if (this._stopped || this._paused)
+            return;
+        if (!this._started) {
+            this.start('');
+        }
+        try {
+            if (!this.speaker) {
+                this.createSpeaker();
+            }
+            if (this.speaker) {
+                // 检查是否是 WAV 文件头
+                if (this.isWavHeader(chunk)) {
+                    // 跳过 WAV 头，只播放数据
+                    const audioData = this.stripWavHeader(chunk);
+                    if (audioData.length > 0) {
+                        this.speaker.write(audioData);
+                    }
+                }
+                else {
+                    this.speaker.write(chunk);
+                }
+            }
+        }
+        catch (err) {
+            this.handleError(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    isWavHeader(chunk) {
+        // 检查 RIFF 头
+        if (chunk.length >= 44) {
+            const riff = chunk.toString('ascii', 0, 4);
+            const wave = chunk.toString('ascii', 8, 12);
+            return riff === 'RIFF' && wave === 'WAVE';
+        }
+        return false;
+    }
+    stripWavHeader(chunk) {
+        // 跳过 44 字节的 WAV 头
+        return chunk.slice(44);
+    }
+    createSpeaker() {
+        try {
+            const format = {
+                channels: this._format.channels,
+                sampleRate: this._format.sampleRate,
+                bitDepth: this._format.bitDepth,
+                signed: this._format.signed,
+                float: this._format.float
+            };
+            this.speaker = new Speaker(format);
+            this.speaker.on('close', () => {
+                if (!this._stopped) {
+                    this._started = false;
+                    this.events?.onEnd?.();
+                }
+            });
+            this.speaker.on('error', (err) => {
+                this.handleError(err);
+            });
+        }
+        catch (err) {
+            this.handleError(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    end() {
+        if (this._stopped)
+            return;
+        if (this.speaker) {
+            try {
+                this.speaker.close();
+            }
+            catch (e) {
+                // 忽略关闭错误
+            }
+            this.speaker = undefined;
+        }
+        this._started = false;
+        this._stopped = true;
+        this.events?.onEnd?.();
+    }
+    pause() {
+        if (this._started && !this._paused) {
+            this._paused = true;
+            this.events?.onPause?.();
+        }
+    }
+    resume() {
+        // speaker 不支持暂停恢复
+        if (this._paused) {
+            this._paused = false;
+            this.events?.onResume?.();
+        }
+    }
+    stop() {
+        this._stopped = true;
+        this._started = false;
+        this._paused = false;
+        if (this.speaker) {
+            try {
+                this.speaker.close();
+            }
+            catch (e) {
+                // 忽略关闭错误
+            }
+            this.speaker = undefined;
+        }
+        this.events?.onStop?.();
+    }
+    destroy() {
+        this.stop();
+    }
+    handleError(error) {
+        this.events?.onError?.(error);
+    }
+}
+//# sourceMappingURL=speaker-backend.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/ocosay",
-"version": "1.1.10",
+"version": "1.1.12",
   "description": "OpenCode TTS 播放插件 - 支持豆包模式边接收边朗读",
   "type": "module",
   "main": "dist/plugin.js",
@@ -26,7 +26,7 @@
   },
   "scripts": {
     "build": "tsc && npm run build:plugin && node -e \"require('fs').copyFileSync('package.json', 'dist/package.json')\"",
-    "build:plugin": "esbuild src/plugin.ts --bundle --platform=node --format=esm --outdir=dist --sourcemap --external:@opencode-ai/plugin --external:axios --external:ws --external:zod",
+    "build:plugin": "esbuild src/plugin.ts --bundle --platform=node --format=esm --outdir=dist --sourcemap --external:@opencode-ai/plugin --external:axios --external:ws --external:zod --external:naudiodon --external:play-sound --external:speaker",
     "watch": "tsc --watch",
     "test": "jest",
     "lint": "eslint src --ext .ts"
@@ -48,7 +48,9 @@
     "zod": "^4.3.6"
   },
   "optionalDependencies": {
-    "naudiodon": "^2.3.6"
+    "naudiodon": "^2.3.6",
+    "play-sound": "^1.1.5",
+    "speaker": "^1.4.2"
   },
   "devDependencies": {
     "@types/howler": "^2.2.12",