@mingxy/ocosay 1.1.12 → 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,6 +19,8 @@ export declare enum BackendType {
     APLAY = "aplay",
     POWERSHELL = "powershell",
     HOWLER = "howler",
+    PLAY_SOUND = "play-sound",
+    SPEAKER = "speaker",
     AUTO = "auto"
 }
 export declare function createBackend(type?: BackendType, options?: BackendOptions): AudioBackend;

package/dist/core/backends/index.js

@@ -7,12 +7,16 @@ 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 {
@@ -36,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;
@@ -63,6 +69,16 @@ function isNaudiodonAvailable() {
         return false;
     }
 }
+function isSpeakerAvailable() {
+    try {
+        require.resolve('speaker');
+        return true;
+    }
+    catch (err) {
+        logger.debug({ err }, 'speaker not available');
+        return false;
+    }
+}
 export function createBackend(type = BackendType.AUTO, options = {}) {
     const platform = process.platform;
     if (type !== BackendType.AUTO) {
@@ -87,12 +103,23 @@ export function createBackend(type = BackendType.AUTO, options = {}) {
         case 'darwin':
             return new AfplayBackend(options);
         case 'linux':
+            // 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);
                 }
             }
+            // 检测 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);
@@ -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/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

@@ -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",

package/dist/plugin.js

@@ -2013,7 +2013,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package();
     var { EventEmitter: EventEmitter7 } = __require("events");
     var { Worker } = __require("worker_threads");
-    var { join: join8 } = __require("path");
+    var { join: join9 } = __require("path");
     var { pathToFileURL } = __require("url");
     var { wait } = require_wait();
     var {
@@ -2049,7 +2049,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream2, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join8(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join9(__dirname, "lib", "worker.js");
       const worker = new Worker(toExecute, {
         ...opts.workerOpts,
         trackUnmanagedFds: false,
@@ -2438,9 +2438,9 @@ var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports, module) {
     "use strict";
     var { createRequire: createRequire2 } = __require("module");
-    var { existsSync: existsSync7 } = __require("node:fs");
+    var { existsSync: existsSync8 } = __require("node:fs");
     var getCallers = require_caller();
-    var { join: join8, isAbsolute, sep } = __require("node:path");
+    var { join: join9, isAbsolute, sep } = __require("node:path");
     var { fileURLToPath: fileURLToPath2 } = __require("node:url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
@@ -2512,7 +2512,7 @@ var require_transport = __commonJS({
           return false;
         }
       }
-      return isAbsolute(path2) && !existsSync7(path2);
+      return isAbsolute(path2) && !existsSync8(path2);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -2593,7 +2593,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join8(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join9(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -2611,7 +2611,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join8(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join9(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2634,7 +2634,7 @@ var require_transport = __commonJS({
           return origin;
         }
         if (origin === "pino/file") {
-          return join8(__dirname, "..", "file.js");
+          return join9(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
@@ -3614,7 +3614,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join8 = ",";
+            let join9 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -3628,7 +3628,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join8 = `,
+                join9 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3636,13 +3636,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join8;
+                res += join9;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join8}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3663,7 +3663,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join8 = `,
+              join9 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3677,13 +3677,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join8;
+                separator = join9;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join8;
+              separator = join9;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3724,7 +3724,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join8 = ",";
+            let join9 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3737,7 +3737,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join8 = `,
+                join9 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3745,13 +3745,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join8;
+                res += join9;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join8}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3764,7 +3764,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join8 = `,
+              join9 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3773,7 +3773,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join8;
+                separator = join9;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3831,20 +3831,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join9 = `,
+              const join10 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join9;
+                res2 += join10;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join9}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join10}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3860,16 +3860,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join8 = `,
+            const join9 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join8, maximumBreadth);
+              res += stringifyTypedArray(value, join9, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join8;
+              separator = join9;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -3880,13 +3880,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join8;
+                separator = join9;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join8;
+              separator = join9;
             }
             if (separator !== "") {
               res = `
@@ -6737,8 +6737,8 @@ var BaseTTSProvider = class {
 import { EventEmitter } from "events";
 import fs from "fs";
 import { createWriteStream } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-import { join as join5 } from "path";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join6 } from "path";
 
 // src/utils/logger.ts
 var import_pino = __toESM(require_pino(), 1);
@@ -7466,6 +7466,299 @@ var HowlerBackend = class {
   }
 };
 
+// src/core/backends/playsound-backend.ts
+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";
+var SAFE_PATH_REGEX4 = /^[\w\/\.]+$/;
+var PlaySoundBackend = class {
+  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_REGEX4.test(filePath)) {
+      throw new Error(`Invalid file path: ${filePath}`);
+    }
+    this.tempFile = filePath;
+    this._started = true;
+    this._stopped = false;
+    this.events?.onStart?.();
+    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) {
+            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;
+          }
+          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;
+    this.chunks.push(chunk);
+  }
+  end() {
+    if (this._stopped || this.hasEnded) return;
+    this.hasEnded = true;
+    if (this.chunks.length === 0) return;
+    this.tempFile = join5(tmpdir4(), `ocosay-${Date.now()}.wav`);
+    writeFileSync4(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) {
+      }
+    }
+  }
+  resume() {
+    if (!this._paused || this._stopped) return;
+    if (this.player) {
+      try {
+        this.player.kill("SIGCONT");
+        this._paused = false;
+        this.events?.onResume?.();
+      } catch (e) {
+      }
+    }
+  }
+  stop() {
+    this._stopped = true;
+    this._started = false;
+    this._paused = false;
+    if (this.player) {
+      try {
+        this.player.kill("SIGTERM");
+      } catch (e) {
+      }
+      this.player = void 0;
+    }
+    this.cleanup();
+    this.chunks = [];
+    this.hasEnded = false;
+    this.events?.onStop?.();
+  }
+  setVolume(_volume) {
+  }
+  destroy() {
+    this.stop();
+  }
+  cleanup() {
+    if (this.tempFile && this.tempFile.startsWith(tmpdir4())) {
+      try {
+        if (existsSync5(this.tempFile)) {
+          unlinkSync4(this.tempFile);
+        }
+      } catch (e) {
+      }
+      this.tempFile = void 0;
+    }
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
+  }
+};
+
+// src/core/backends/speaker-backend.ts
+import Speaker from "speaker";
+var SpeakerBackend = class {
+  name = "speaker";
+  supportsStreaming = true;
+  speaker;
+  events;
+  _started = false;
+  _paused = false;
+  _stopped = false;
+  _format = {
+    channels: 1,
+    sampleRate: 16e3,
+    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) {
+        if (this.isWavHeader(chunk)) {
+          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) {
+    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) {
+    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 = void 0;
+    }
+    this._started = false;
+    this._stopped = true;
+    this.events?.onEnd?.();
+  }
+  pause() {
+    if (this._started && !this._paused) {
+      this._paused = true;
+      this.events?.onPause?.();
+    }
+  }
+  resume() {
+    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 = void 0;
+    }
+    this.events?.onStop?.();
+  }
+  destroy() {
+    this.stop();
+  }
+  handleError(error) {
+    this.events?.onError?.(error);
+  }
+};
+
 // src/core/backends/index.ts
 import { execSync } from "child_process";
 function execCmd(cmd) {
@@ -7488,6 +7781,15 @@ function isNaudiodonAvailable() {
     return false;
   }
 }
+function isSpeakerAvailable() {
+  try {
+    __require.resolve("speaker");
+    return true;
+  } catch (err) {
+    logger.debug({ err }, "speaker not available");
+    return false;
+  }
+}
 function createBackend(type = "auto" /* AUTO */, options = {}) {
   const platform = process.platform;
   if (type !== "auto" /* AUTO */) {
@@ -7517,6 +7819,13 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
           return new AplayBackend(options);
         }
       }
+      if (isCommandAvailable("ffplay")) {
+        return new PlaySoundBackend(options);
+      }
+      if (isSpeakerAvailable()) {
+        return new SpeakerBackend(options);
+      }
+      logger.warn("All Linux audio backends failed, using HowlerBackend as fallback");
       return new HowlerBackend(options);
     case "win32":
       return new PowerShellBackend(options);
@@ -7536,6 +7845,10 @@ function createBackendByType(type, options) {
       return new PowerShellBackend(options);
     case "howler" /* HOWLER */:
       return new HowlerBackend(options);
+    case "play-sound" /* PLAY_SOUND */:
+      return new PlaySoundBackend(options);
+    case "speaker" /* SPEAKER */:
+      return new SpeakerBackend(options);
     default:
       throw new Error(`Unknown backend type: ${type}`);
   }
@@ -7600,7 +7913,7 @@ var AudioPlayer = class extends EventEmitter {
     this._playing = true;
     this._paused = false;
     try {
-      const tempFile = join5(tmpdir4(), `ocosay-${Date.now()}.${format}`);
+      const tempFile = join6(tmpdir5(), `ocosay-${Date.now()}.${format}`);
       this.currentFile = tempFile;
       if (Buffer.isBuffer(audioData)) {
         fs.writeFileSync(tempFile, audioData);
@@ -7772,7 +8085,7 @@ var notificationService = new NotificationService();
 
 // src/core/speaker.ts
 var logger4 = createModuleLogger("Speaker");
-var Speaker = class extends EventEmitter2 {
+var Speaker2 = class extends EventEmitter2 {
   constructor(options = {}) {
     super();
     this.options = options;
@@ -7948,7 +8261,7 @@ var Speaker = class extends EventEmitter2 {
 var defaultSpeaker;
 function getDefaultSpeaker() {
   if (!defaultSpeaker) {
-    defaultSpeaker = new Speaker();
+    defaultSpeaker = new Speaker2();
   }
   return defaultSpeaker;
 }
@@ -9319,7 +9632,7 @@ async function initialize(config) {
       defaultModel: config?.defaultModel || "stream",
       defaultVoice: config?.defaultVoice
     };
-    speaker = new Speaker(speakerOptions);
+    speaker = new Speaker2(speakerOptions);
     if (config?.autoRead) {
       autoReadEnabled = true;
       initializeStreamComponents(config);
@@ -9578,27 +9891,27 @@ function loadOrCreateConfig() {
 }
 
 // src/plugin.ts
-import { readFileSync as readFileSync2, existsSync as existsSync6, writeFileSync as writeFileSync5 } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync7, writeFileSync as writeFileSync6 } from "fs";
 import { fileURLToPath } from "url";
-import { dirname as dirname2, join as join7 } from "path";
+import { dirname as dirname2, join as join8 } from "path";
 import { homedir as homedir3 } from "os";
 import { execSync as execSync2 } from "child_process";
 import { createRequire } from "module";
 var logger8 = createModuleLogger("Plugin");
 var require2 = createRequire(import.meta.url);
 function getSkipFilePath() {
-  return join7(homedir3(), ".config", "opencode", ".naudiodon_skip");
+  return join8(homedir3(), ".config", "opencode", ".naudiodon_skip");
 }
 function shouldSkipNaudiodon() {
-  return existsSync6(getSkipFilePath());
+  return existsSync7(getSkipFilePath());
 }
 function markNaudiodonSkipped() {
   try {
-    const dir = join7(homedir3(), ".config", "opencode");
-    if (!existsSync6(dir)) {
+    const dir = join8(homedir3(), ".config", "opencode");
+    if (!existsSync7(dir)) {
       execSync2("mkdir -p", { cwd: dir });
     }
-    writeFileSync5(getSkipFilePath(), Date.now().toString(), "utf-8");
+    writeFileSync6(getSkipFilePath(), Date.now().toString(), "utf-8");
   } catch {
   }
 }
@@ -9771,6 +10084,29 @@ function checkAlsa() {
   const test = execCmd2("aplay -l");
   return test.success && !test.output.includes("no soundcards");
 }
+function checkFFplay() {
+  return execCmd2("which ffplay").success;
+}
+async function checkAudioEnvironmentForBackend() {
+  const platform = process.platform;
+  if (platform === "linux") {
+    const hasAlsa = checkAlsa();
+    const hasFFplay = checkFFplay();
+    if (!hasAlsa && !hasFFplay) {
+      notificationService.warning(
+        "\u672A\u68C0\u6D4B\u5230\u97F3\u9891\u8BBE\u5907",
+        "\u8BF7\u5B89\u88C5 ffmpeg \u6216\u914D\u7F6E PulseAudio",
+        8e3
+      );
+    } else if (hasFFplay && !hasAlsa) {
+      notificationService.info(
+        "ffplay \u53EF\u7528",
+        "\u5C06\u4F7F\u7528 ffplay \u8FDB\u884C\u65E0\u58F0\u5361\u64AD\u653E",
+        5e3
+      );
+    }
+  }
+}
 async function installPortAudio() {
   const platform = process.platform;
   const wsl = isWsl2();
@@ -9802,6 +10138,23 @@ async function installPortAudio() {
     }
   };
   if (platform === "linux" || wsl) {
+    notificationService.info("\u68C0\u6D4B ffmpeg...", "\u97F3\u9891\u540E\u7AEF", 5e3);
+    const ffmpegCheck = execCmd2("which ffplay");
+    if (ffmpegCheck.success) {
+      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);
+      const ffmpegInstalled = await runInstall(
+        "sudo apt-get update && sudo apt-get install -y ffmpeg",
+        "\u5B89\u88C5 ffmpeg"
+      );
+      if (ffmpegInstalled) {
+        notificationService.success("ffmpeg \u5B89\u88C5\u6210\u529F", "ffplay \u53EF\u7528\u4E8E\u65E0\u58F0\u5361\u64AD\u653E", 5e3);
+      } else {
+        notificationService.warning("ffmpeg \u5B89\u88C5\u5931\u8D25", "play-sound \u540E\u7AEF\u53EF\u80FD\u65E0\u6CD5\u5DE5\u4F5C", 5e3);
+      }
+    }
     notificationService.info("\u68C0\u6D4B\u97F3\u9891\u8BBE\u5907...", "\u97F3\u9891\u540E\u7AEF", 5e3);
     if (checkAlsa()) {
       logger8.info("alsa-utils already available and working");
@@ -9858,7 +10211,7 @@ var __dirname2 = dirname2(__filename);
 var id = "ocosay";
 var pluginVersion = "0.0.0";
 try {
-  const pkg = JSON.parse(readFileSync2(join7(__dirname2, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync2(join8(__dirname2, "package.json"), "utf-8"));
   pluginVersion = pkg.version || "0.0.0";
 } catch {
 }
@@ -9998,6 +10351,7 @@ var server = (async (input, _options) => {
     logger8.error({ error: initError }, "initialization failed");
   }
   await ensureNaudiodonCompiled();
+  await checkAudioEnvironmentForBackend();
   setTimeout(() => {
     if (initError) {
       notificationService.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mingxy/ocosay",
-"version": "1.1.12",
+"version": "1.1.13",
   "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",