@mingxy/ocosay 1.1.32 → 1.2.0

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";
@@ -7487,7 +7489,7 @@ var PlaySoundBackend = class {
   constructor(options = {}) {
     this.events = options.events;
   }
-  start(filePath) {
+  async start(filePath) {
     if (this._started) return;
     if (!SAFE_PATH_REGEX4.test(filePath)) {
       throw new Error(`Invalid file path: ${filePath}`);
@@ -7496,57 +7498,86 @@ var PlaySoundBackend = class {
     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) {
+    await this.playWithPlaySound(filePath);
+  }
+  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 {
@@ -7767,6 +7798,130 @@ var SpeakerBackend = class {
 
 // src/core/backends/index.ts
 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 = [];
+  retryTimer;
+  setTui(tui) {
+    this.tui = tui;
+    logger3.debug("tui reference set");
+    this.flushPending();
+  }
+  showToast(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, title });
+      this.scheduleRetry();
+      return false;
+    }
+    try {
+      this.tui.showToast({
+        body: {
+          title,
+          message,
+          variant,
+          duration
+        }
+      });
+      logger3.debug({ title, variant }, "toast shown");
+      return true;
+    } catch (err) {
+      logger3.warn({ err, title }, "toast call failed, queueing for retry");
+      this.pendingToasts.push({ ...options, title });
+      this.scheduleRetry();
+      return false;
+    }
+  }
+  scheduleRetry() {
+    if (this.retryTimer) return;
+    this.retryTimer = setTimeout(() => {
+      this.retryTimer = void 0;
+      this.flushPending();
+    }, 2e3);
+  }
+  flushPending() {
+    if (this.pendingToasts.length === 0 || !this.tui) return;
+    logger3.info({ count: this.pendingToasts.length }, "flushing pending toasts");
+    const pending = [...this.pendingToasts];
+    this.pendingToasts = [];
+    for (const toast of pending) {
+      try {
+        this.showToast(toast);
+      } catch (err) {
+        this.pendingToasts.push(toast);
+        logger3.warn({ err }, "showToast threw unexpected error, re-queued");
+      }
+    }
+  }
+  success(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 });
+  }
+  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 = 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));
+      }
+    }
+  }
+  getTitleForVariant(variant) {
+    const titles = {
+      success: "Success",
+      error: "Error",
+      warning: "Warning",
+      info: "Info"
+    };
+    return titles[variant];
+  }
+};
+var notificationService = new NotificationService();
+
+// src/core/backends/index.ts
 function execCmd(cmd) {
   try {
     const output = execSync(cmd, { stdio: "pipe", encoding: "utf8" });
@@ -7796,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) {
@@ -7813,12 +7977,35 @@ function createBackend(type = "auto" /* AUTO */, options = {}) {
       }
     } catch (err) {
       logger.error({ err }, "failed to initialize naudiodon backend");
+      notificationService.warning(
+        "naudiodon \u521D\u59CB\u5316\u5931\u8D25",
+        "\u5C06\u4F7F\u7528\u5176\u4ED6\u97F3\u9891\u540E\u7AEF",
+        5e3
+      );
     }
   }
   switch (platform) {
     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")) {
@@ -7833,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:
@@ -7966,11 +8154,8 @@ var AudioPlayer = class extends EventEmitter {
    * 播放音频文件
    * 使用 AudioBackend 统一后端播放
    */
-  playFile(filePath, _format) {
-    return new Promise((resolve) => {
-      this.backend.start(filePath);
-      resolve();
-    });
+  async playFile(filePath, _format) {
+    await Promise.resolve(this.backend.start(filePath));
   }
   pause() {
     if (!this._playing || this._paused) return;
@@ -8016,79 +8201,6 @@ var AudioPlayer = class extends EventEmitter {
   }
 };
 
-// src/core/notification.ts
-var logger3 = createModuleLogger("NotificationService");
-var NotificationService = class {
-  tui = null;
-  pendingToasts = [];
-  retryTimer;
-  setTui(tui) {
-    this.tui = tui;
-    logger3.debug("tui reference set");
-    this.flushPending();
-  }
-  showToast(options) {
-    const { title, message, variant = "info", duration = 5e3 } = options;
-    if (!this.tui) {
-      logger3.debug({ title }, "tui not ready, queueing toast");
-      this.pendingToasts.push(options);
-      this.scheduleRetry();
-      return false;
-    }
-    try {
-      this.tui.showToast({
-        body: {
-          title,
-          message,
-          variant,
-          duration
-        }
-      });
-      logger3.debug({ title, variant }, "toast shown");
-      return true;
-    } catch (err) {
-      logger3.warn({ err, title }, "toast call failed, queueing for retry");
-      this.pendingToasts.push(options);
-      this.scheduleRetry();
-      return false;
-    }
-  }
-  scheduleRetry() {
-    if (this.retryTimer) return;
-    this.retryTimer = setTimeout(() => {
-      this.retryTimer = void 0;
-      this.flushPending();
-    }, 2e3);
-  }
-  flushPending() {
-    if (this.pendingToasts.length === 0 || !this.tui) return;
-    logger3.info({ count: this.pendingToasts.length }, "flushing pending toasts");
-    const pending = [...this.pendingToasts];
-    this.pendingToasts = [];
-    for (const toast of pending) {
-      try {
-        this.showToast(toast);
-      } catch (err) {
-        this.pendingToasts.push(toast);
-        logger3.warn({ err }, "showToast threw unexpected error, re-queued");
-      }
-    }
-  }
-  success(title, message, duration) {
-    return this.showToast({ title, message, variant: "success", duration });
-  }
-  error(title, message, duration) {
-    return this.showToast({ title, message, variant: "error", duration });
-  }
-  info(title, message, duration) {
-    return this.showToast({ title, message, variant: "info", duration });
-  }
-  warning(title, message, duration) {
-    return this.showToast({ title, message, variant: "warning", duration });
-  }
-};
-var notificationService = new NotificationService();
-
 // src/core/speaker.ts
 var logger4 = createModuleLogger("Speaker");
 var Speaker2 = class extends EventEmitter2 {
@@ -8294,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}`);
@@ -8375,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: {
@@ -8421,7 +8532,7 @@ var StreamPlayer = class extends EventEmitter3 {
    * 开始播放
    * 初始化后端，准备接收音频数据
    */
-  start() {
+  async start() {
     if (this._started) {
       return;
     }
@@ -8429,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;
@@ -8439,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);
@@ -8637,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, {
@@ -8663,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();
     }
   }
@@ -8680,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 {
@@ -8942,7 +9061,6 @@ var MiniMaxProvider = class extends BaseTTSProvider {
   config;
   httpClient;
   wsConnection;
-  currentAudioData = [];
   audioFormat = "mp3";
   constructor(config) {
     super();
@@ -9668,7 +9786,7 @@ function initializeStreamComponents(config) {
     },
     onEnd: () => {
     },
-    onProgress: (bytesWritten) => {
+    onProgress: (_bytesWritten) => {
     },
     onError: (error) => logger.error({ error }, "stream player error"),
     onStop: () => {
@@ -10119,15 +10237,15 @@ 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";
   if (isModuleInstalled(dep)) {
     logger8.info("play-sound already installed");
     if (await verifyModuleLoad(dep)) {
+      notificationService.success("play-sound \u5DF2\u5C31\u7EEA", "\u97F3\u9891\u540E\u7AEF\u6B63\u5E38", 5e3);
       return;
     }
   }
@@ -10429,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,
@@ -10444,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();