@mingxy/ocosay 1.1.23 → 1.1.25

package/dist/plugin.js

@@ -2437,7 +2437,7 @@ var require_thread_stream = __commonJS({
 var require_transport = __commonJS({
   "node_modules/pino/lib/transport.js"(exports, module) {
     "use strict";
-    var { createRequire: createRequire2 } = __require("module");
+    var { createRequire: createRequire3 } = __require("module");
     var { existsSync: existsSync8 } = __require("node:fs");
     var getCallers = require_caller();
     var { join: join9, isAbsolute, sep } = __require("node:path");
@@ -2640,7 +2640,7 @@ var require_transport = __commonJS({
         for (const filePath of callers) {
           try {
             const context = filePath === "node:repl" ? process.cwd() + sep : filePath;
-            fixTarget2 = createRequire2(context).resolve(origin);
+            fixTarget2 = createRequire3(context).resolve(origin);
             break;
           } catch (err) {
             continue;
@@ -9901,13 +9901,365 @@ import { readFileSync as readFileSync2, existsSync as existsSync7, writeFileSync
 import { fileURLToPath } from "url";
 import { dirname as dirname2, join as join8 } from "path";
 import { homedir as homedir3 } from "os";
+import { execSync as execSync4 } from "child_process";
+import { createRequire as createRequire2 } from "module";
+
+// src/core/dependency-detector.ts
 import { execSync as execSync2 } from "child_process";
+function parseMissingHeaders(errorOutput) {
+  const pattern = /fatal error:\s+([^:]+):\s+No such file or directory/g;
+  const headers = [];
+  let match = pattern.exec(errorOutput);
+  while (match !== null) {
+    headers.push(match[1]);
+    match = pattern.exec(errorOutput);
+  }
+  return headers;
+}
+function execCapture(cmd, cwd) {
+  try {
+    const stdout = execSync2(cmd, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return { success: true, stdout, stderr: "" };
+  } catch (err) {
+    const error = err;
+    return {
+      success: false,
+      stdout: error.stdout ? error.stdout.toString() : "",
+      stderr: error.stderr ? error.stderr.toString() : ""
+    };
+  }
+}
+function detectMissingDependencies(cmd, cwd) {
+  const result = execCapture(cmd, cwd);
+  const missingHeaders = parseMissingHeaders(result.stderr);
+  return {
+    missingHeaders,
+    rawOutput: result.stderr
+  };
+}
+
+// src/core/dependency-mapper.ts
 import { createRequire } from "module";
-var logger8 = createModuleLogger("Plugin");
 var require2 = createRequire(import.meta.url);
-var pluginPath = dirname2(fileURLToPath(import.meta.url));
-var opencodeNodeModules = join8(pluginPath, "..", "node_modules");
-var pluginRequire = createRequire(join8(opencodeNodeModules, "package.json"));
+var HEADER_TO_PACKAGE = [
+  // ALSA - Linux音频库
+  {
+    header: "alsa/asoundlib.h",
+    package: "libasound2-dev"
+  },
+  // PortAudio - 跨平台音频I/O库
+  {
+    header: "portaudio.h",
+    package: "libportaudio-dev",
+    packageMac: "portaudio",
+    packageWin: "portaudio"
+  },
+  // FFmpeg相关
+  {
+    header: "libavcodec/avcodec.h",
+    package: "libavcodec-dev",
+    packageMac: "ffmpeg",
+    packageWin: "ffmpeg"
+  },
+  {
+    header: "libavformat/avformat.h",
+    package: "libavformat-dev",
+    packageMac: "ffmpeg",
+    packageWin: "ffmpeg"
+  },
+  {
+    header: "libavutil/avutil.h",
+    package: "libavutil-dev",
+    packageMac: "ffmpeg",
+    packageWin: "ffmpeg"
+  },
+  {
+    header: "libswresample/swresample.h",
+    package: "libswresample-dev",
+    packageMac: "ffmpeg",
+    packageWin: "ffmpeg"
+  },
+  // OpenAL - 3D音频API
+  {
+    header: "AL/al.h",
+    package: "libopenal-dev",
+    packageMac: "openal",
+    packageWin: "openal"
+  },
+  // SDL - 多媒体库
+  {
+    header: "SDL2/SDL.h",
+    package: "libsdl2-dev",
+    packageMac: "sdl2",
+    packageWin: "sdl2"
+  },
+  // PulseAudio - Linux音频服务
+  {
+    header: "pulse/pulseaudio.h",
+    package: "libpulse-dev"
+  },
+  // CoreAudio - macOS音频框架 (无头文件，纯框架)
+  {
+    header: "CoreAudio/CoreAudio.h",
+    package: "\u81FA",
+    // macOS系统框架，无需安装包
+    packageMac: ""
+  },
+  // Windows特定
+  {
+    header: "windows.h",
+    package: "",
+    // Linux上不存在
+    packageWin: ""
+    // Windows SDK自带
+  }
+];
+function detectPlatform() {
+  const platform = process.platform;
+  const isWsl3 = detectWsl();
+  let packageManager;
+  let installCommand;
+  if (platform === "linux" || isWsl3) {
+    packageManager = "apt-get";
+    installCommand = "sudo apt-get install -y";
+  } else if (platform === "darwin") {
+    packageManager = "brew";
+    installCommand = "brew install";
+  } else {
+    packageManager = "choco";
+    installCommand = "choco install -y";
+  }
+  return {
+    platform,
+    isWsl: isWsl3,
+    packageManager,
+    installCommand
+  };
+}
+function detectWsl() {
+  if (process.platform !== "linux") return false;
+  try {
+    return require2("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+  } catch {
+    return false;
+  }
+}
+function getPackageForPlatform(mapping, platform, isWsl3) {
+  if (platform === "win32") {
+    if (isWsl3) {
+      return mapping.package || null;
+    }
+    return mapping.packageWin || mapping.package || null;
+  }
+  if (platform === "darwin") {
+    if (mapping.packageMac === "") return null;
+    return mapping.packageMac || mapping.package || null;
+  }
+  if (mapping.package === "") return null;
+  return mapping.package || null;
+}
+function mapHeaderToPackages(header, platform) {
+  const exactMatch = HEADER_TO_PACKAGE.find(
+    (m) => m.header.toLowerCase() === header.toLowerCase()
+  );
+  if (exactMatch) {
+    const pkg = getPackageForPlatform(exactMatch, platform, detectWsl());
+    if (pkg && pkg.length > 0 && pkg !== "\u81FA") {
+      return [pkg];
+    }
+    return [];
+  }
+  const headerBasename = header.split("/").pop()?.toLowerCase() || "";
+  const fuzzyMatch = HEADER_TO_PACKAGE.find((m) => {
+    const mappingBasename = m.header.split("/").pop()?.toLowerCase() || "";
+    return mappingBasename === headerBasename;
+  });
+  if (fuzzyMatch) {
+    const pkg = getPackageForPlatform(fuzzyMatch, platform, detectWsl());
+    if (pkg && pkg.length > 0 && pkg !== "\u81FA") {
+      return [pkg];
+    }
+    return [];
+  }
+  return [];
+}
+function mapHeadersToPackages(headers, platform) {
+  const packageSet = /* @__PURE__ */ new Set();
+  for (const header of headers) {
+    const packages = mapHeaderToPackages(header, platform);
+    for (const pkg of packages) {
+      if (pkg.length > 0) {
+        packageSet.add(pkg);
+      }
+    }
+  }
+  return Array.from(packageSet);
+}
+
+// src/core/dependency-installer.ts
+import { execSync as execSync3 } from "child_process";
+var logger8 = createModuleLogger("DependencyInstaller");
+function getInstallCommandPrefix() {
+  const { platform, isWsl: isWsl3 } = detectPlatform();
+  if (platform === "linux" || isWsl3) {
+    return "sudo apt-get install -y";
+  } else if (platform === "darwin") {
+    return "brew install";
+  }
+  return "choco install -y";
+}
+function getCheckCommand(packageName) {
+  const { platform, isWsl: isWsl3 } = detectPlatform();
+  if (platform === "linux" || isWsl3) {
+    return `dpkg -s ${packageName} 2>/dev/null | grep -q "Status: install ok installed"`;
+  } else if (platform === "darwin") {
+    return `brew list ${packageName} &>/dev/null`;
+  }
+  return `choco list --local-only ${packageName} &>/dev/null`;
+}
+function silentLog(level2, message, extra) {
+  switch (level2) {
+    case "info":
+      logger8.info(extra || {}, message);
+      break;
+    case "warn":
+      logger8.warn(extra || {}, message);
+      break;
+    case "error":
+      logger8.error(extra || {}, message);
+      break;
+  }
+}
+function canSudoWithoutPassword() {
+  try {
+    execSync3("sudo -n true 2>&1", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installSystemPackages(packages, notifSvc) {
+  const result = {
+    success: false,
+    installedPackages: [],
+    failedPackages: []
+  };
+  const validPackages = packages.filter((p) => p && p.length > 0 && p !== "\u81FA");
+  if (validPackages.length === 0) {
+    silentLog("info", "\u6CA1\u6709\u9700\u8981\u5B89\u88C5\u7684\u5305");
+    return { ...result, success: true };
+  }
+  silentLog("info", `\u5F00\u59CB\u5B89\u88C5\u7CFB\u7EDF\u4F9D\u8D56: ${validPackages.join(", ")}`, { packages: validPackages });
+  notifSvc?.info("\u6B63\u5728\u5B89\u88C5\u7CFB\u7EDF\u4F9D\u8D56...", "Ocosay", 3e3);
+  const installCommand = getInstallCommandPrefix();
+  const fullCommand = `${installCommand} ${validPackages.join(" ")}`;
+  silentLog("info", `\u6267\u884C\u5B89\u88C5\u547D\u4EE4: ${fullCommand}`);
+  if (!canSudoWithoutPassword()) {
+    const msg = "\u9700\u8981 sudo \u6743\u9650\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E NOPASSWD";
+    result.error = msg;
+    notifSvc?.error("\u9700\u8981 sudo \u6743\u9650", "\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C: sudo visudo \u6DFB\u52A0 NOPASSWD \u914D\u7F6E\uFF0C\u914D\u7F6E\u597D\u540E\u8BF7\u91CD\u542F OpenCode", 1e4);
+    silentLog("error", msg);
+    return result;
+  }
+  try {
+    const { platform, isWsl: isWsl3 } = detectPlatform();
+    if (platform === "linux" || isWsl3) {
+      notifSvc?.info("\u6B63\u5728\u66F4\u65B0\u5305\u5217\u8868...", "Ocosay", 3e3);
+      silentLog("info", "\u66F4\u65B0 apt \u5305\u5217\u8868");
+      try {
+        execSync3("sudo apt-get update", {
+          timeout: 12e4,
+          encoding: "utf8"
+        });
+        silentLog("info", "apt-get update \u5B8C\u6210");
+      } catch (updateErr) {
+        silentLog("warn", "apt-get update \u5931\u8D25\uFF0C\u7EE7\u7EED\u5C1D\u8BD5\u5B89\u88C5", { error: String(updateErr) });
+      }
+    }
+    notifSvc?.info(`\u6B63\u5728\u5B89\u88C5 ${validPackages.length} \u4E2A\u5305...`, "Ocosay", 5e3);
+    const output = execSync3(fullCommand, {
+      timeout: 3e5,
+      encoding: "utf8"
+    });
+    silentLog("info", `\u5B89\u88C5\u8F93\u51FA: ${output.substring(0, 500)}`);
+    const verifiedPackages = [];
+    const failedPackages = [];
+    for (const pkg of validPackages) {
+      const isInstalled = await verifyInstallation([pkg]);
+      if (isInstalled) {
+        verifiedPackages.push(pkg);
+        silentLog("info", `\u5305 ${pkg} \u5B89\u88C5\u9A8C\u8BC1\u6210\u529F`);
+      } else {
+        failedPackages.push(pkg);
+        silentLog("warn", `\u5305 ${pkg} \u5B89\u88C5\u9A8C\u8BC1\u5931\u8D25`);
+      }
+    }
+    result.installedPackages = verifiedPackages;
+    result.failedPackages = failedPackages;
+    result.success = failedPackages.length === 0;
+    if (result.success) {
+      notifSvc?.success("\u7CFB\u7EDF\u4F9D\u8D56\u5B89\u88C5\u6210\u529F", verifiedPackages.join(", "), 5e3);
+      silentLog("info", `\u6240\u6709\u5305\u5B89\u88C5\u6210\u529F: ${verifiedPackages.join(", ")}`);
+    } else {
+      const errorMsg = failedPackages.length > 0 ? `\u4EE5\u4E0B\u5305\u5B89\u88C5\u5931\u8D25: ${failedPackages.join(", ")}` : "\u90E8\u5206\u5305\u5B89\u88C5\u5931\u8D25";
+      result.error = errorMsg;
+      notifSvc?.warning("\u90E8\u5206\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", errorMsg, 8e3);
+      silentLog("warn", errorMsg);
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    silentLog("error", `\u5B89\u88C5\u547D\u4EE4\u6267\u884C\u5931\u8D25: ${errorMessage}`, { error: errorMessage });
+    if (errorMessage.includes("sudo") || errorMessage.toLowerCase().includes("password")) {
+      result.error = "\u9700\u8981 sudo \u6743\u9650\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u914D\u7F6E NOPASSWD";
+      notifSvc?.error("\u9700\u8981 sudo \u6743\u9650", "\u8BF7\u5728\u7EC8\u7AEF\u6267\u884C: sudo visudo", 1e4);
+    } else if (errorMessage.includes("already") || errorMessage.includes("is already")) {
+      result.success = true;
+      result.installedPackages = validPackages;
+      notifSvc?.success("\u4F9D\u8D56\u5DF2\u5B58\u5728", "\u65E0\u9700\u91CD\u65B0\u5B89\u88C5", 3e3);
+    } else {
+      result.error = errorMessage;
+      notifSvc?.error("\u4F9D\u8D56\u5B89\u88C5\u5931\u8D25", errorMessage.substring(0, 200), 8e3);
+    }
+  }
+  return result;
+}
+async function verifyInstallation(packages) {
+  if (packages.length === 0) {
+    return true;
+  }
+  const validPackages = packages.filter((p) => p && p.length > 0 && p !== "\u81FA");
+  if (validPackages.length === 0) {
+    return true;
+  }
+  silentLog("info", `\u9A8C\u8BC1\u5305\u5B89\u88C5\u72B6\u6001: ${validPackages.join(", ")}`);
+  try {
+    for (const pkg of validPackages) {
+      const checkCmd = getCheckCommand(pkg);
+      const { success } = execCapture(checkCmd);
+      if (!success) {
+        silentLog("warn", `\u5305 ${pkg} \u9A8C\u8BC1\u5931\u8D25`);
+        return false;
+      }
+    }
+    silentLog("info", `\u6240\u6709\u5305\u9A8C\u8BC1\u901A\u8FC7: ${validPackages.join(", ")}`);
+    return true;
+  } catch (err) {
+    silentLog("error", `\u9A8C\u8BC1\u8FC7\u7A0B\u5F02\u5E38: ${String(err)}`);
+    return false;
+  }
+}
+
+// src/plugin.ts
+var logger9 = createModuleLogger("Plugin");
+var require3 = createRequire2(import.meta.url);
+var opencodeBinPath = execSync4("which opencode").toString().trim();
+var opencodeRoot = dirname2(dirname2(opencodeBinPath));
+var opencodeNodeModules = join8(opencodeRoot, "node_modules");
+var pluginRequire = createRequire2(join8(opencodeNodeModules, "package.json"));
 function getSkipFilePath() {
   return join8(homedir3(), ".config", "opencode", ".naudiodon_skip");
 }
@@ -9918,7 +10270,7 @@ function markNaudiodonSkipped() {
   try {
     const dir = join8(homedir3(), ".config", "opencode");
     if (!existsSync7(dir)) {
-      execSync2("mkdir -p", { cwd: dir });
+      execSync4("mkdir -p", { cwd: dir });
     }
     writeFileSync6(getSkipFilePath(), Date.now().toString(), "utf-8");
   } catch {
@@ -9926,70 +10278,70 @@ function markNaudiodonSkipped() {
 }
 async function verifyNaudiodonLoad() {
   try {
-    require2("naudiodon");
-    logger8.info("naudiodon loaded successfully");
+    require3("naudiodon");
+    logger9.info("naudiodon loaded successfully");
     return true;
   } catch (err) {
-    logger8.warn({ err }, "naudiodon load failed after rebuild");
+    logger9.warn({ err }, "naudiodon load failed after rebuild");
     return false;
   }
 }
 async function rebuildNaudiodonDependency(dep) {
-  const naudiodonPath = dirname2(require2.resolve("naudiodon"));
+  const naudiodonPath = dirname2(require3.resolve("naudiodon"));
   try {
     notificationService.info(`\u6B63\u5728\u7F16\u8BD1 ${dep}...`, "Ocosay \u4F9D\u8D56", 4e3);
-    execSync2(`npm rebuild ${dep}`, {
+    execSync4(`npm rebuild ${dep}`, {
       cwd: naudiodonPath,
       stdio: "inherit"
     });
-    logger8.info(`${dep} rebuilt successfully`);
+    logger9.info(`${dep} rebuilt successfully`);
     return true;
   } catch (err) {
-    logger8.warn({ err }, `${dep} rebuild failed`);
+    logger9.warn({ err }, `${dep} rebuild failed`);
     return false;
   }
 }
 async function fixNaudiodonDependencies(maxRetries = 5) {
-  const naudiodonPath = dirname2(require2.resolve("naudiodon"));
+  const naudiodonPath = dirname2(require3.resolve("naudiodon"));
   const criticalDeps = ["segfault-handler", "bindings", "node-pre-gyp"];
   for (let attempt = 0; attempt < maxRetries; attempt++) {
     if (await verifyNaudiodonLoad()) {
       return true;
     }
-    logger8.info({ attempt }, "naudiodon not loadable, trying dependency rebuild");
+    logger9.info({ attempt }, "naudiodon not loadable, trying dependency rebuild");
     notificationService.info(`\u6B63\u5728\u68C0\u67E5\u4F9D\u8D56 (${attempt + 1}/${maxRetries})...`, "Ocosay", 3e3);
     let anySuccess = false;
     for (const dep of criticalDeps) {
       try {
-        require2.resolve(dep, { paths: [naudiodonPath] });
+        require3.resolve(dep, { paths: [naudiodonPath] });
         if (await rebuildNaudiodonDependency(dep)) {
           anySuccess = true;
         }
       } catch {
         try {
           notificationService.info(`\u6B63\u5728\u5B89\u88C5 ${dep}...`, "Ocosay", 4e3);
-          execSync2(`npm install ${dep}`, {
+          execSync4(`npm install ${dep}`, {
             cwd: naudiodonPath,
             stdio: "inherit"
           });
-          logger8.info(`${dep} installed successfully`);
+          logger9.info(`${dep} installed successfully`);
           anySuccess = true;
         } catch (installErr) {
-          logger8.warn({ err: installErr }, `${dep} install failed`);
+          logger9.warn({ err: installErr }, `${dep} install failed`);
         }
       }
     }
     if (!anySuccess || !await verifyNaudiodonLoad()) {
       try {
         notificationService.info("\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 naudiodon...", "Ocosay", 4e3);
-        execSync2("npm rebuild naudiodon", {
+        execSync4("npm rebuild naudiodon", {
           cwd: naudiodonPath,
           stdio: "inherit"
         });
-        logger8.info("naudiodon rebuilt");
+        logger9.info("naudiodon rebuilt");
         anySuccess = true;
       } catch (err) {
-        logger8.warn({ err }, "naudiodon rebuild failed");
+        logger9.warn({ err }, "naudiodon rebuild failed");
       }
     }
     if (await verifyNaudiodonLoad()) {
@@ -10003,25 +10355,25 @@ async function fixNaudiodonDependencies(maxRetries = 5) {
 }
 async function ensureNaudiodonCompiled() {
   if (shouldSkipNaudiodon()) {
-    logger8.info("naudiodon skipped previously");
+    logger9.info("naudiodon skipped previously");
     return;
   }
   try {
-    require2("naudiodon");
-    logger8.info("naudiodon already compiled");
+    require3("naudiodon");
+    logger9.info("naudiodon already compiled");
     return;
   } catch {
-    logger8.info("naudiodon not compiled, will attempt to compile");
+    logger9.info("naudiodon not compiled, will attempt to compile");
     notificationService.info("\u6B63\u5728\u7F16\u8BD1 naudiodon...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
   }
   try {
-    const naudiodonPath = dirname2(require2.resolve("naudiodon"));
-    logger8.info({ naudiodonPath }, "found naudiodon, rebuilding");
-    execSync2("npm rebuild naudiodon", {
+    const naudiodonPath = dirname2(require3.resolve("naudiodon"));
+    logger9.info({ naudiodonPath }, "found naudiodon, rebuilding");
+    execSync4("npm rebuild naudiodon", {
       cwd: naudiodonPath,
       stdio: "inherit"
     });
-    logger8.info("naudiodon compiled, verifying...");
+    logger9.info("naudiodon compiled, verifying...");
     const loadSuccess = await verifyNaudiodonLoad();
     if (loadSuccess) {
       notificationService.success("naudiodon \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10035,18 +10387,18 @@ async function ensureNaudiodonCompiled() {
       }
     }
   } catch (err) {
-    logger8.warn({ err }, "naudiodon rebuild failed, checking for PortAudio");
+    logger9.warn({ err }, "naudiodon rebuild failed, checking for PortAudio");
     notificationService.warning("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5 PortAudio...", 5e3);
     const installed = await installPortAudio();
     if (installed.success) {
       try {
-        const naudiodonPath = dirname2(require2.resolve("naudiodon"));
+        const naudiodonPath = dirname2(require3.resolve("naudiodon"));
         notificationService.info("\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 naudiodon...", "Ocosay", 5e3);
-        execSync2("npm rebuild naudiodon", {
+        execSync4("npm rebuild naudiodon", {
           cwd: naudiodonPath,
           stdio: "inherit"
         });
-        logger8.info("naudiodon compiled successfully after PortAudio install");
+        logger9.info("naudiodon compiled successfully after PortAudio install");
         const loadSuccess = await verifyNaudiodonLoad();
         if (loadSuccess) {
           notificationService.success("naudiodon \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10060,12 +10412,12 @@ async function ensureNaudiodonCompiled() {
           }
         }
       } catch (retryErr) {
-        logger8.error({ err: retryErr }, "naudiodon compile failed even after PortAudio install");
+        logger9.error({ err: retryErr }, "naudiodon compile failed even after PortAudio install");
         notificationService.error("naudiodon \u7F16\u8BD1\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
         markNaudiodonSkipped();
       }
     } else {
-      logger8.error("PortAudio install failed");
+      logger9.error("PortAudio install failed");
       notificationService.error("PortAudio \u5B89\u88C5\u5931\u8D25", "\u81EA\u52A8\u5B89\u88C5\u5931\u8D25\uFF0C\u8BF7\u5C1D\u8BD5\u624B\u52A8\u5B89\u88C5", 8e3);
       markNaudiodonSkipped();
     }
@@ -10082,46 +10434,113 @@ function isModuleInstalled(moduleName) {
 async function verifyModuleLoad(dep) {
   try {
     pluginRequire(dep);
-    logger8.info(`${dep} loaded successfully`);
+    logger9.info(`${dep} loaded successfully`);
     return true;
   } catch (err) {
-    logger8.warn({ err }, `${dep} load failed`);
+    logger9.warn({ err }, `${dep} load failed`);
     return false;
   }
 }
+async function tryCompileSpeaker() {
+  const dep = "speaker";
+  const result = { success: false, stderr: "" };
+  if (isModuleInstalled(dep)) {
+    if (await verifyModuleLoad(dep)) {
+      result.success = true;
+      return result;
+    }
+  }
+  if (!isModuleInstalled(dep)) {
+    try {
+      execSync4("npm install speaker", {
+        cwd: opencodeNodeModules,
+        stdio: "pipe"
+      });
+    } catch {
+    }
+  }
+  try {
+    execSync4("npm rebuild speaker", {
+      cwd: opencodeNodeModules,
+      stdio: "pipe"
+    });
+    if (await verifyModuleLoad(dep)) {
+      result.success = true;
+    }
+  } catch (err) {
+    result.stderr = err.stderr?.toString() || err.message || "";
+  }
+  return result;
+}
+async function ensureSpeakerCompiledAsync() {
+  const compileResult = await tryCompileSpeaker();
+  if (compileResult.success) {
+    logger9.info("speaker compiled successfully");
+    return;
+  }
+  const detectResult = detectMissingDependencies(compileResult.stderr);
+  if (detectResult.missingHeaders.length === 0) {
+    logger9.info("speaker compile failed with unknown error");
+    return;
+  }
+  logger9.info({ missingHeaders: detectResult.missingHeaders }, "detected missing headers");
+  const platformInfo = detectPlatform();
+  const packages = mapHeadersToPackages(detectResult.missingHeaders, platformInfo.platform);
+  if (packages.length === 0) {
+    logger9.info("no known packages for missing headers");
+    return;
+  }
+  logger9.info({ packages }, "mapped headers to packages, installing");
+  await installSystemPackages(packages, notificationService);
+  const retryResult = await tryCompileSpeaker();
+  if (retryResult.success) {
+    logger9.info("speaker compiled successfully after installing dependencies");
+  } else {
+    logger9.warn("speaker compile still failed after dependency installation");
+  }
+}
+async function ensureSpeakerInstalledAsync() {
+  await ensurePlaySoundInstalled();
+}
+async function initAsync() {
+  setTimeout(async () => {
+    await ensureSpeakerCompiledAsync();
+    await ensureSpeakerInstalledAsync();
+  }, 100);
+}
 async function ensureSpeakerCompiled(maxRetries = 5) {
   const dep = "speaker";
   if (isModuleInstalled(dep)) {
-    logger8.info("speaker already installed");
+    logger9.info("speaker already installed");
     if (await verifyModuleLoad(dep)) {
       return;
     }
-    logger8.info("speaker installed but not loadable, rebuilding");
+    logger9.info("speaker installed but not loadable, rebuilding");
     notificationService.info("\u6B63\u5728\u7F16\u8BD1 speaker...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
     try {
-      execSync2("npm rebuild speaker", {
+      execSync4("npm rebuild speaker", {
         cwd: opencodeNodeModules,
         stdio: "inherit"
       });
-      logger8.info("speaker rebuilt");
+      logger9.info("speaker rebuilt");
     } catch (err) {
-      logger8.warn({ err }, "speaker rebuild failed");
+      logger9.warn({ err }, "speaker rebuild failed");
     }
     if (await verifyModuleLoad(dep)) {
       notificationService.success("speaker \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
       return;
     }
   } else {
-    logger8.info("speaker not found, installing");
+    logger9.info("speaker not found, installing");
     notificationService.info("\u6B63\u5728\u5B89\u88C5 speaker...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
     try {
-      execSync2("npm install speaker", {
+      execSync4("npm install speaker", {
         cwd: opencodeNodeModules,
         stdio: "inherit"
       });
-      logger8.info("speaker installed");
+      logger9.info("speaker installed");
     } catch (err) {
-      logger8.warn({ err }, "speaker install failed");
+      logger9.warn({ err }, "speaker install failed");
     }
   }
   for (let attempt = 0; attempt < maxRetries; attempt++) {
@@ -10129,16 +10548,16 @@ async function ensureSpeakerCompiled(maxRetries = 5) {
       notificationService.success("speaker \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
       return;
     }
-    logger8.info({ attempt, dep }, "speaker not loadable, trying rebuild");
+    logger9.info({ attempt, dep }, "speaker not loadable, trying rebuild");
     notificationService.info(`\u6B63\u5728\u91CD\u65B0\u7F16\u8BD1 speaker (${attempt + 1}/${maxRetries})...`, "Ocosay", 3e3);
     try {
-      execSync2("npm rebuild speaker", {
+      execSync4("npm rebuild speaker", {
         cwd: opencodeNodeModules,
         stdio: "inherit"
       });
-      logger8.info("speaker rebuilt");
+      logger9.info("speaker rebuilt");
     } catch (err) {
-      logger8.warn({ err }, "speaker rebuild failed");
+      logger9.warn({ err }, "speaker rebuild failed");
     }
     if (await verifyModuleLoad(dep)) {
       notificationService.success("speaker \u7F16\u8BD1\u6210\u529F", "\u97F3\u9891\u540E\u7AEF\u5DF2\u5C31\u7EEA", 5e3);
@@ -10148,27 +10567,27 @@ async function ensureSpeakerCompiled(maxRetries = 5) {
       await new Promise((resolve) => setTimeout(resolve, 1e3));
     }
   }
-  logger8.error({ dep }, "speaker could not be compiled");
+  logger9.error({ dep }, "speaker could not be compiled");
   notificationService.error("speaker \u7F16\u8BD1\u5931\u8D25", "\u8BF7\u624B\u52A8\u8FD0\u884C: npm install speaker && npm rebuild speaker", 8e3);
 }
 async function ensurePlaySoundInstalled() {
   const dep = "play-sound";
   if (isModuleInstalled(dep)) {
-    logger8.info("play-sound already installed");
+    logger9.info("play-sound already installed");
     if (await verifyModuleLoad(dep)) {
       return;
     }
   }
-  logger8.info("play-sound not found, installing");
+  logger9.info("play-sound not found, installing");
   notificationService.info("\u6B63\u5728\u5B89\u88C5 play-sound...", "Ocosay \u97F3\u9891\u540E\u7AEF", 5e3);
   try {
-    execSync2("npm install play-sound", {
+    execSync4("npm install play-sound", {
       cwd: opencodeNodeModules,
       stdio: "inherit"
     });
-    logger8.info("play-sound installed");
+    logger9.info("play-sound installed");
   } catch (err) {
-    logger8.warn({ err }, "play-sound install failed");
+    logger9.warn({ err }, "play-sound install failed");
     notificationService.warning(
       "play-sound \u5B89\u88C5\u5931\u8D25",
       "\u8BF7\u624B\u52A8\u8FD0\u884C: npm install play-sound",
@@ -10192,7 +10611,7 @@ async function ensureOptionalDepsInstalled() {
 }
 function execCmd2(cmd) {
   try {
-    const output = execSync2(cmd, { stdio: "pipe", encoding: "utf8" });
+    const output = execSync4(cmd, { stdio: "pipe", encoding: "utf8" });
     return { success: true, output };
   } catch (err) {
     return { success: false, output: err.message || "" };
@@ -10201,7 +10620,7 @@ function execCmd2(cmd) {
 function isWsl2() {
   if (process.platform !== "linux") return false;
   try {
-    return require2("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return require3("fs").readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -10238,12 +10657,12 @@ async function checkAudioEnvironmentForBackend() {
 async function installPortAudio() {
   const platform = process.platform;
   const wsl = isWsl2();
-  logger8.info({ platform, wsl }, "installing PortAudio");
+  logger9.info({ platform, wsl }, "installing PortAudio");
   const runInstall = async (cmd, desc) => {
-    logger8.info(`Running: ${cmd}`);
+    logger9.info(`Running: ${cmd}`);
     notificationService.info(desc, "\u6B63\u5728\u5B89\u88C5...", 5e3);
     try {
-      execSync2(cmd, { stdio: "inherit" });
+      execSync4(cmd, { stdio: "inherit" });
       return true;
     } catch (err) {
       const msg = err.message || "";
@@ -10253,15 +10672,15 @@ async function installPortAudio() {
           "# \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21\nsudo visudo\n# \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL",
           1e4
         );
-        logger8.error({ err }, "\u9700\u8981 sudo \u6743\u9650 \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21sudo visudo # \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL");
+        logger9.error({ err }, "\u9700\u8981 sudo \u6743\u9650 \u8BF7\u5728WSL\u7EC8\u7AEF\u6267\u884C\u4E00\u6B21sudo visudo # \u6DFB\u52A0\u884C\uFF1Ayour user name ALL=(ALL) NOPASSWD: ALL");
         return false;
       }
       if (msg.includes("already") || msg.includes("is already")) {
-        logger8.info("already installed");
+        logger9.info("already installed");
         return true;
       }
       notificationService.error(desc + " \u5931\u8D25", msg.substring(0, 100), 8e3);
-      logger8.error({ err }, `install failed: ${desc}`);
+      logger9.error({ err }, `install failed: ${desc}`);
       return false;
     }
   };
@@ -10269,7 +10688,7 @@ async function installPortAudio() {
     notificationService.info("\u68C0\u6D4B ffmpeg...", "\u97F3\u9891\u540E\u7AEF", 5e3);
     const ffmpegCheck = execCmd2("which ffplay");
     if (ffmpegCheck.success) {
-      logger8.info("ffmpeg already available");
+      logger9.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);
@@ -10285,7 +10704,7 @@ async function installPortAudio() {
     }
     notificationService.info("\u68C0\u6D4B\u97F3\u9891\u8BBE\u5907...", "\u97F3\u9891\u540E\u7AEF", 5e3);
     if (checkAlsa()) {
-      logger8.info("alsa-utils already available and working");
+      logger9.info("alsa-utils already available and working");
       notificationService.success("alsa-utils \u5C31\u7EEA", "\u97F3\u9891\u540E\u7AEF\u5DF2\u53EF\u7528", 5e3);
       return { success: true, message: "alsa" };
     }
@@ -10476,8 +10895,9 @@ var server = (async (input, _options) => {
     });
   } catch (err) {
     initError = err instanceof Error ? err : new Error(String(err));
-    logger8.error({ error: initError }, "initialization failed");
+    logger9.error({ error: initError }, "initialization failed");
   }
+  initAsync();
   await ensureNaudiodonCompiled();
   await ensureOptionalDepsInstalled();
   await checkAudioEnvironmentForBackend();