npm - codeharbor - Versions diffs - 0.1.19 → 0.1.21 - Mend

codeharbor 0.1.19 → 0.1.21

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/.env.example +10 -0
package/README.md +25 -0
package/dist/cli.js +501 -84
package/package.json +4 -2
package/scripts/local-whisper-transcribe.py +52 -0

package/.env.example CHANGED Viewed

@@ -63,6 +63,16 @@ CLI_COMPAT_PRESERVE_WHITESPACE=true
 CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT=false
 CLI_COMPAT_PROGRESS_THROTTLE_MS=300
 CLI_COMPAT_FETCH_MEDIA=true
+# Optional audio transcription for Matrix m.audio attachments.
+CLI_COMPAT_TRANSCRIBE_AUDIO=false
+CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL=gpt-4o-mini-transcribe
+CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS=120000
+CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS=6000
+# Optional local whisper command. Use {input} placeholder for the audio file path.
+# Example:
+# CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND=codeharbor-whisper-transcribe --input {input} --model small
+CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND=
+CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS=180000
 # Optional JSONL output path for executed prompt recording (for replay benchmarking).
 CLI_COMPAT_RECORD_PATH=

package/README.md CHANGED Viewed

@@ -460,6 +460,19 @@ To make IM behavior closer to local `codex` CLI interaction, enable:
   - lower update throttle for near-real-time progress
 - `CLI_COMPAT_FETCH_MEDIA=true|false`
   - download Matrix `mxc://` media (image) to temp file and pass it to codex via `--image`
+- `CLI_COMPAT_TRANSCRIBE_AUDIO=true|false`
+  - download Matrix `m.audio` attachments and transcribe them into prompt context
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL`
+  - OpenAI transcription model (default `gpt-4o-mini-transcribe`)
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS`
+  - timeout for each audio transcription request
+- `CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS`
+  - max transcript length appended to prompt for one attachment
+- `CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND`
+  - optional local whisper command template (use `{input}` placeholder for audio file path)
+  - helper command shipped by package: `codeharbor-whisper-transcribe --input {input} --model small`
+- `CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS`
+  - timeout for local whisper command execution
 - `CLI_COMPAT_RECORD_PATH=/abs/path/records.jsonl`
   - append executed prompts as JSONL for replay benchmarking
@@ -503,6 +516,18 @@ When image attachments are present and `CLI_COMPAT_FETCH_MEDIA=true`, CodeHarbor
 3. best-effort cleanup temp files after the request
 4. optional prompt record append (`CLI_COMPAT_RECORD_PATH`) for deterministic replay input
+When audio attachments are present and both `CLI_COMPAT_FETCH_MEDIA=true` and `CLI_COMPAT_TRANSCRIBE_AUDIO=true`, CodeHarbor will:
+1. download `m.audio` media to a temp file
+2. if `CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND` is configured, execute local whisper first
+3. if local whisper fails and `OPENAI_API_KEY` is available, fallback to OpenAI transcription API
+4. append transcript to `[audio_transcripts]` prompt block
+5. continue request even if transcription fails (warn log + no transcript)
+6. best-effort cleanup temp files after the request
+`OPENAI_API_KEY` is optional when local whisper command is configured, and required only for OpenAI fallback.
+For `codeharbor-whisper-transcribe`, install runtime first: `python3 -m pip install faster-whisper`.
 ## Replay Benchmark
 Replay recorded prompts directly against codex CLI to quantify drift and latency:

package/dist/cli.js CHANGED Viewed

@@ -24,14 +24,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 // src/cli.ts
-var import_node_child_process7 = require("child_process");
+var import_node_child_process8 = require("child_process");
 var import_node_fs11 = __toESM(require("fs"));
-var import_node_path14 = __toESM(require("path"));
+var import_node_path15 = __toESM(require("path"));
 var import_commander = require("commander");
 // src/app.ts
-var import_node_child_process5 = require("child_process");
-var import_node_util3 = require("util");
+var import_node_child_process6 = require("child_process");
+var import_node_util4 = require("util");
 // src/admin-server.ts
 var import_node_child_process3 = require("child_process");
@@ -353,6 +353,27 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
             <input id="global-cli-throttle" type="number" min="0" />
           </label>
           <label class="checkbox"><input id="global-cli-fetch-media" type="checkbox" /><span>Fetch media attachments</span></label>
+          <label class="checkbox"><input id="global-cli-transcribe-audio" type="checkbox" /><span>Transcribe audio attachments</span></label>
+          <label class="field">
+            <span class="field-label">Audio transcribe model</span>
+            <input id="global-cli-audio-model" type="text" />
+          </label>
+          <label class="field">
+            <span class="field-label">Audio transcribe timeout (ms)</span>
+            <input id="global-cli-audio-timeout" type="number" min="1" />
+          </label>
+          <label class="field">
+            <span class="field-label">Audio transcript max chars</span>
+            <input id="global-cli-audio-max-chars" type="number" min="1" />
+          </label>
+          <label class="field">
+            <span class="field-label">Local whisper command</span>
+            <input id="global-cli-audio-local-command" type="text" placeholder='python3 /opt/whisper/transcribe.py --input {input}' />
+          </label>
+          <label class="field">
+            <span class="field-label">Local whisper timeout (ms)</span>
+            <input id="global-cli-audio-local-timeout" type="number" min="1" />
+          </label>
           <label class="checkbox"><input id="global-agent-enabled" type="checkbox" /><span>Enable multi-agent workflow</span></label>
           <label class="field">
             <span class="field-label">Workflow auto-repair rounds</span>
@@ -687,6 +708,12 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
             document.getElementById("global-cli-disable-split").checked = Boolean(cliCompat.disableReplyChunkSplit);
             document.getElementById("global-cli-throttle").value = String(cliCompat.progressThrottleMs || 0);
             document.getElementById("global-cli-fetch-media").checked = Boolean(cliCompat.fetchMedia);
+            document.getElementById("global-cli-transcribe-audio").checked = Boolean(cliCompat.transcribeAudio);
+            document.getElementById("global-cli-audio-model").value = cliCompat.audioTranscribeModel || "gpt-4o-mini-transcribe";
+            document.getElementById("global-cli-audio-timeout").value = String(cliCompat.audioTranscribeTimeoutMs || 120000);
+            document.getElementById("global-cli-audio-max-chars").value = String(cliCompat.audioTranscribeMaxChars || 6000);
+            document.getElementById("global-cli-audio-local-command").value = cliCompat.audioLocalWhisperCommand || "";
+            document.getElementById("global-cli-audio-local-timeout").value = String(cliCompat.audioLocalWhisperTimeoutMs || 180000);
             document.getElementById("global-agent-enabled").checked = Boolean(agentWorkflow.enabled);
             document.getElementById("global-agent-repair-rounds").value = String(
               typeof agentWorkflow.autoRepairMaxRounds === "number" ? agentWorkflow.autoRepairMaxRounds : 1
@@ -728,7 +755,13 @@ var ADMIN_CONSOLE_HTML = `<!doctype html>
                 preserveWhitespace: asBool("global-cli-whitespace"),
                 disableReplyChunkSplit: asBool("global-cli-disable-split"),
                 progressThrottleMs: asNumber("global-cli-throttle", 300),
-                fetchMedia: asBool("global-cli-fetch-media")
+                fetchMedia: asBool("global-cli-fetch-media"),
+                transcribeAudio: asBool("global-cli-transcribe-audio"),
+                audioTranscribeModel: asText("global-cli-audio-model") || "gpt-4o-mini-transcribe",
+                audioTranscribeTimeoutMs: asNumber("global-cli-audio-timeout", 120000),
+                audioTranscribeMaxChars: asNumber("global-cli-audio-max-chars", 6000),
+                audioLocalWhisperCommand: asText("global-cli-audio-local-command"),
+                audioLocalWhisperTimeoutMs: asNumber("global-cli-audio-local-timeout", 180000)
               },
               agentWorkflow: {
                 enabled: asBool("global-agent-enabled"),
@@ -1966,6 +1999,65 @@ var AdminServer = class {
         envUpdates.CLI_COMPAT_FETCH_MEDIA = String(value);
         updatedKeys.push("cliCompat.fetchMedia");
       }
+      if ("transcribeAudio" in compat) {
+        const value = normalizeBoolean(compat.transcribeAudio, this.config.cliCompat.transcribeAudio);
+        this.config.cliCompat.transcribeAudio = value;
+        envUpdates.CLI_COMPAT_TRANSCRIBE_AUDIO = String(value);
+        updatedKeys.push("cliCompat.transcribeAudio");
+      }
+      if ("audioTranscribeModel" in compat) {
+        const value = normalizeString(
+          compat.audioTranscribeModel,
+          this.config.cliCompat.audioTranscribeModel,
+          "cliCompat.audioTranscribeModel"
+        );
+        this.config.cliCompat.audioTranscribeModel = value || "gpt-4o-mini-transcribe";
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL = this.config.cliCompat.audioTranscribeModel;
+        updatedKeys.push("cliCompat.audioTranscribeModel");
+      }
+      if ("audioTranscribeTimeoutMs" in compat) {
+        const value = normalizePositiveInt(
+          compat.audioTranscribeTimeoutMs,
+          this.config.cliCompat.audioTranscribeTimeoutMs,
+          1,
+          Number.MAX_SAFE_INTEGER
+        );
+        this.config.cliCompat.audioTranscribeTimeoutMs = value;
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS = String(value);
+        updatedKeys.push("cliCompat.audioTranscribeTimeoutMs");
+      }
+      if ("audioTranscribeMaxChars" in compat) {
+        const value = normalizePositiveInt(
+          compat.audioTranscribeMaxChars,
+          this.config.cliCompat.audioTranscribeMaxChars,
+          1,
+          Number.MAX_SAFE_INTEGER
+        );
+        this.config.cliCompat.audioTranscribeMaxChars = value;
+        envUpdates.CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS = String(value);
+        updatedKeys.push("cliCompat.audioTranscribeMaxChars");
+      }
+      if ("audioLocalWhisperCommand" in compat) {
+        const value = normalizeString(
+          compat.audioLocalWhisperCommand,
+          this.config.cliCompat.audioLocalWhisperCommand ?? "",
+          "cliCompat.audioLocalWhisperCommand"
+        );
+        this.config.cliCompat.audioLocalWhisperCommand = value || null;
+        envUpdates.CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND = this.config.cliCompat.audioLocalWhisperCommand ?? "";
+        updatedKeys.push("cliCompat.audioLocalWhisperCommand");
+      }
+      if ("audioLocalWhisperTimeoutMs" in compat) {
+        const value = normalizePositiveInt(
+          compat.audioLocalWhisperTimeoutMs,
+          this.config.cliCompat.audioLocalWhisperTimeoutMs,
+          1,
+          Number.MAX_SAFE_INTEGER
+        );
+        this.config.cliCompat.audioLocalWhisperTimeoutMs = value;
+        envUpdates.CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS = String(value);
+        updatedKeys.push("cliCompat.audioLocalWhisperTimeoutMs");
+      }
     }
     if ("agentWorkflow" in body) {
       const workflow = asObject(body.agentWorkflow, "agentWorkflow");
@@ -2621,6 +2713,7 @@ var MatrixChannel = class {
   splitReplies;
   preserveWhitespace;
   fetchMedia;
+  transcribeAudio;
   client;
   handler = null;
   started = false;
@@ -2631,6 +2724,7 @@ var MatrixChannel = class {
     this.splitReplies = !config.cliCompat.disableReplyChunkSplit;
     this.preserveWhitespace = config.cliCompat.preserveWhitespace;
     this.fetchMedia = config.cliCompat.fetchMedia;
+    this.transcribeAudio = config.cliCompat.transcribeAudio;
     this.client = (0, import_matrix_js_sdk.createClient)({
       baseUrl: config.matrixHomeserver,
       accessToken: config.matrixAccessToken,
@@ -2875,7 +2969,7 @@ var MatrixChannel = class {
     }
     const hydrated = await Promise.all(
       attachments.map(async (attachment, index) => {
-        if (attachment.kind !== "image" || !attachment.mxcUrl) {
+        if (!shouldHydrateAttachment(attachment.kind, this.transcribeAudio) || !attachment.mxcUrl) {
           return attachment;
         }
         try {
@@ -3093,6 +3187,15 @@ function parseMxcUrl(mxcUrl) {
   const mediaId = stripped.slice(slashIndex + 1);
   return { serverName, mediaId };
 }
+function shouldHydrateAttachment(kind, transcribeAudio) {
+  if (kind === "image") {
+    return true;
+  }
+  if (kind === "audio") {
+    return transcribeAudio;
+  }
+  return false;
+}
 function sanitizeFilename(value) {
   return value.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 80);
 }
@@ -3110,6 +3213,21 @@ function resolveFileExtension(fileName, mimeType) {
   if (mimeType === "image/webp") {
     return ".webp";
   }
+  if (mimeType === "audio/mpeg") {
+    return ".mp3";
+  }
+  if (mimeType === "audio/mp4" || mimeType === "audio/x-m4a") {
+    return ".m4a";
+  }
+  if (mimeType === "audio/wav" || mimeType === "audio/x-wav") {
+    return ".wav";
+  }
+  if (mimeType === "audio/ogg") {
+    return ".ogg";
+  }
+  if (mimeType === "audio/flac") {
+    return ".flac";
+  }
   return ".bin";
 }
 function buildMatrixRichMessageContent(body, msgtype) {
@@ -3627,17 +3745,188 @@ function stringify(value) {
 // src/orchestrator.ts
 var import_async_mutex = require("async-mutex");
-var import_promises4 = __toESM(require("fs/promises"));
+var import_promises5 = __toESM(require("fs/promises"));
+// src/audio-transcriber.ts
+var import_node_child_process5 = require("child_process");
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path8 = __toESM(require("path"));
+var import_node_util3 = require("util");
+var execAsync = (0, import_node_util3.promisify)(import_node_child_process5.exec);
+var AudioTranscriber = class {
+  enabled;
+  apiKey;
+  model;
+  timeoutMs;
+  maxChars;
+  localWhisperCommand;
+  localWhisperTimeoutMs;
+  constructor(options) {
+    this.enabled = options.enabled;
+    this.apiKey = options.apiKey;
+    this.model = options.model;
+    this.timeoutMs = options.timeoutMs;
+    this.maxChars = options.maxChars;
+    this.localWhisperCommand = options.localWhisperCommand;
+    this.localWhisperTimeoutMs = options.localWhisperTimeoutMs;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async transcribeMany(attachments) {
+    if (!this.enabled || attachments.length === 0) {
+      return [];
+    }
+    const hasLocalWhisper = Boolean(this.localWhisperCommand);
+    const hasOpenAi = Boolean(this.apiKey);
+    if (!hasLocalWhisper && !hasOpenAi) {
+      throw new Error(
+        "Audio transcription is enabled but no backend is configured. Set CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND or OPENAI_API_KEY."
+      );
+    }
+    const transcripts = [];
+    const failures = [];
+    for (const attachment of attachments) {
+      const text = await this.transcribeWithFallback(attachment, hasLocalWhisper, hasOpenAi).catch((error) => {
+        failures.push(formatError3(error));
+        return "";
+      });
+      if (!text) {
+        continue;
+      }
+      transcripts.push({
+        name: attachment.name,
+        text
+      });
+    }
+    if (transcripts.length === 0 && failures.length > 0) {
+      throw new Error(`Audio transcription failed: ${failures.join(" | ")}`);
+    }
+    return transcripts;
+  }
+  async transcribeWithFallback(attachment, hasLocalWhisper, hasOpenAi) {
+    let localError = null;
+    if (hasLocalWhisper) {
+      try {
+        const localText = await this.transcribeOneWithLocalWhisper(attachment);
+        if (localText) {
+          return localText;
+        }
+      } catch (error) {
+        localError = error;
+      }
+    }
+    if (hasOpenAi) {
+      try {
+        return await this.transcribeOneWithOpenAi(attachment);
+      } catch (error) {
+        if (!localError) {
+          throw error;
+        }
+        throw new Error(
+          `local whisper failed (${formatError3(localError)}), and OpenAI fallback also failed (${formatError3(error)}).`,
+          { cause: error }
+        );
+      }
+    }
+    if (localError) {
+      throw localError;
+    }
+    return "";
+  }
+  async transcribeOneWithOpenAi(attachment) {
+    if (!this.apiKey) {
+      return "";
+    }
+    const buffer = await import_promises3.default.readFile(attachment.localPath);
+    const formData = new FormData();
+    formData.append("model", this.model);
+    formData.append("response_format", "json");
+    formData.append(
+      "file",
+      new Blob([buffer], { type: attachment.mimeType ?? "application/octet-stream" }),
+      import_node_path8.default.basename(attachment.localPath)
+    );
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    timer.unref?.();
+    let response;
+    try {
+      response = await fetch("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: formData,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const message = typeof payload?.error?.message === "string" ? payload.error.message : `HTTP ${response.status} ${response.statusText}`;
+      throw new Error(`Audio transcription failed for ${attachment.name}: ${message}`);
+    }
+    const text = typeof payload.text === "string" ? payload.text.trim() : "";
+    return this.normalizeTranscriptText(text);
+  }
+  async transcribeOneWithLocalWhisper(attachment) {
+    if (!this.localWhisperCommand) {
+      return "";
+    }
+    const command = buildLocalWhisperCommand(this.localWhisperCommand, attachment.localPath);
+    const result = await execAsync(command, {
+      timeout: this.localWhisperTimeoutMs,
+      maxBuffer: 4 * 1024 * 1024,
+      shell: "/bin/bash"
+    });
+    const text = result.stdout.trim();
+    if (!text) {
+      const stderr = result.stderr.trim();
+      throw new Error(
+        stderr ? `Local whisper command produced empty output for ${attachment.name}: ${stderr}` : `Local whisper command produced empty output for ${attachment.name}.`
+      );
+    }
+    return this.normalizeTranscriptText(text);
+  }
+  normalizeTranscriptText(rawText) {
+    const text = rawText.trim();
+    if (!text) {
+      return "";
+    }
+    if (text.length > this.maxChars) {
+      return `${text.slice(0, this.maxChars)}...`;
+    }
+    return text;
+  }
+};
+function buildLocalWhisperCommand(template, inputPath) {
+  const escapedInput = shellEscape(inputPath);
+  if (template.includes("{input}")) {
+    return template.replaceAll("{input}", escapedInput);
+  }
+  return `${template} ${escapedInput}`;
+}
+function shellEscape(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function formatError3(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 // src/compat/cli-compat-recorder.ts
 var import_node_fs6 = __toESM(require("fs"));
-var import_node_path8 = __toESM(require("path"));
+var import_node_path9 = __toESM(require("path"));
 var CliCompatRecorder = class {
   filePath;
   chain = Promise.resolve();
   constructor(filePath) {
-    this.filePath = import_node_path8.default.resolve(filePath);
-    import_node_fs6.default.mkdirSync(import_node_path8.default.dirname(this.filePath), { recursive: true });
+    this.filePath = import_node_path9.default.resolve(filePath);
+    import_node_fs6.default.mkdirSync(import_node_path9.default.dirname(this.filePath), { recursive: true });
   }
   append(entry) {
     const payload = `${JSON.stringify(entry)}
@@ -4122,8 +4411,8 @@ function createIdleWorkflowSnapshot() {
 }
 // src/workflow/autodev.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path9 = __toESM(require("path"));
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path10 = __toESM(require("path"));
 function parseAutoDevCommand(text) {
   const normalized = text.trim();
   if (!/^\/autodev(?:\s|$)/i.test(normalized)) {
@@ -4143,8 +4432,8 @@ function parseAutoDevCommand(text) {
   };
 }
 async function loadAutoDevContext(workdir) {
-  const requirementsPath = import_node_path9.default.join(workdir, "REQUIREMENTS.md");
-  const taskListPath = import_node_path9.default.join(workdir, "TASK_LIST.md");
+  const requirementsPath = import_node_path10.default.join(workdir, "REQUIREMENTS.md");
+  const taskListPath = import_node_path10.default.join(workdir, "TASK_LIST.md");
   const requirementsContent = await readOptionalFile(requirementsPath);
   const taskListContent = await readOptionalFile(taskListPath);
   return {
@@ -4234,7 +4523,7 @@ function statusToSymbol(status) {
   return "\u{1F6AB}";
 }
 async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
-  const content = await import_promises3.default.readFile(taskListPath, "utf8");
+  const content = await import_promises4.default.readFile(taskListPath, "utf8");
   const lines = splitLines(content);
   if (task.lineIndex < 0 || task.lineIndex >= lines.length) {
     throw new Error(`task ${task.id} line index out of range`);
@@ -4244,7 +4533,7 @@ async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
     throw new Error(`failed to update task status for ${task.id}`);
   }
   lines[task.lineIndex] = updatedLine;
-  await import_promises3.default.writeFile(taskListPath, lines.join("\n"), "utf8");
+  await import_promises4.default.writeFile(taskListPath, lines.join("\n"), "utf8");
   return {
     ...task,
     status: nextStatus
@@ -4252,7 +4541,7 @@ async function updateAutoDevTaskStatus(taskListPath, task, nextStatus) {
 }
 async function readOptionalFile(filePath) {
   try {
-    return await import_promises3.default.readFile(filePath, "utf8");
+    return await import_promises4.default.readFile(filePath, "utf8");
   } catch (error) {
     if (error.code === "ENOENT") {
       return null;
@@ -4483,6 +4772,7 @@ var Orchestrator = class {
   logger;
   sessionLocks = /* @__PURE__ */ new Map();
   runningExecutions = /* @__PURE__ */ new Map();
+  pendingStopRequests = /* @__PURE__ */ new Set();
   lockTtlMs;
   lockPruneIntervalMs;
   progressUpdatesEnabled;
@@ -4499,6 +4789,7 @@ var Orchestrator = class {
   rateLimiter;
   cliCompat;
   cliCompatRecorder;
+  audioTranscriber;
   workflowRunner;
   workflowSnapshots = /* @__PURE__ */ new Map();
   autoDevSnapshots = /* @__PURE__ */ new Map();
@@ -4519,9 +4810,24 @@ var Orchestrator = class {
       disableReplyChunkSplit: false,
       progressThrottleMs: 300,
       fetchMedia: false,
+      transcribeAudio: false,
+      audioTranscribeModel: "gpt-4o-mini-transcribe",
+      audioTranscribeTimeoutMs: 12e4,
+      audioTranscribeMaxChars: 6e3,
+      audioLocalWhisperCommand: null,
+      audioLocalWhisperTimeoutMs: 18e4,
       recordPath: null
     };
     this.cliCompatRecorder = this.cliCompat.recordPath ? new CliCompatRecorder(this.cliCompat.recordPath) : null;
+    this.audioTranscriber = options?.audioTranscriber ?? new AudioTranscriber({
+      enabled: this.cliCompat.transcribeAudio,
+      apiKey: process.env.OPENAI_API_KEY?.trim() || null,
+      model: this.cliCompat.audioTranscribeModel,
+      timeoutMs: this.cliCompat.audioTranscribeTimeoutMs,
+      maxChars: this.cliCompat.audioTranscribeMaxChars,
+      localWhisperCommand: this.cliCompat.audioLocalWhisperCommand,
+      localWhisperTimeoutMs: this.cliCompat.audioLocalWhisperTimeoutMs
+    });
     const defaultProgressInterval = options?.progressMinIntervalMs ?? 2500;
     this.progressMinIntervalMs = this.cliCompat.enabled ? this.cliCompat.progressThrottleMs : defaultProgressInterval;
     this.typingTimeoutMs = options?.typingTimeoutMs ?? 1e4;
@@ -4556,7 +4862,7 @@ var Orchestrator = class {
     this.sessionRuntime = new CodexSessionRuntime(this.executor);
   }
   async handleMessage(message) {
-    const attachmentPaths = collectImagePaths(message);
+    const attachmentPaths = collectLocalAttachmentPaths(message);
     try {
       const receivedAt = Date.now();
       const requestId = message.requestId || message.eventId;
@@ -4651,7 +4957,7 @@ var Orchestrator = class {
             this.logger.error("Workflow request failed", {
               requestId,
               sessionKey,
-              error: formatError3(error)
+              error: formatError4(error)
             });
           } finally {
             rateDecision.release?.();
@@ -4682,7 +4988,7 @@ var Orchestrator = class {
             this.logger.error("AutoDev request failed", {
               requestId,
               sessionKey,
-              error: formatError3(error)
+              error: formatError4(error)
             });
           } finally {
             rateDecision.release?.();
@@ -4691,7 +4997,8 @@ var Orchestrator = class {
         }
         this.stateStore.activateSession(sessionKey, this.sessionActiveWindowMs);
         const previousCodexSessionId = this.stateStore.getCodexSessionId(sessionKey);
-        const executionPrompt = this.buildExecutionPrompt(route.prompt, message);
+        const audioTranscripts = await this.transcribeAudioAttachments(message, requestId, sessionKey);
+        const executionPrompt = this.buildExecutionPrompt(route.prompt, message, audioTranscripts);
         const imagePaths = collectImagePaths(message);
         let lastProgressAt = 0;
         let lastProgressText = "";
@@ -4701,7 +5008,7 @@ var Orchestrator = class {
         let executionDurationMs = 0;
         let sendDurationMs = 0;
         const requestStartedAt = Date.now();
-        let cancelRequested = false;
+        let cancelRequested = this.consumePendingStopRequest(sessionKey);
         this.runningExecutions.set(sessionKey, {
           requestId,
           startedAt: requestStartedAt,
@@ -4824,7 +5131,7 @@ var Orchestrator = class {
             try {
               await this.channel.sendMessage(
                 message.conversationId,
-                `[CodeHarbor] Failed to process request: ${formatError3(error)}`
+                `[CodeHarbor] Failed to process request: ${formatError4(error)}`
               );
             } catch (sendError) {
               this.logger.error("Failed to send error reply to Matrix", sendError);
@@ -4839,7 +5146,7 @@ var Orchestrator = class {
             queueWaitMs,
             executionDurationMs,
             totalDurationMs: Date.now() - receivedAt,
-            error: formatError3(error)
+            error: formatError4(error)
           });
         } finally {
           const running = this.runningExecutions.get(sessionKey);
@@ -4966,7 +5273,7 @@ var Orchestrator = class {
 - runError: ${snapshot.error ?? "N/A"}`
       );
     } catch (error) {
-      await this.channel.sendNotice(message.conversationId, `[CodeHarbor] AutoDev \u72B6\u6001\u8BFB\u53D6\u5931\u8D25: ${formatError3(error)}`);
+      await this.channel.sendNotice(message.conversationId, `[CodeHarbor] AutoDev \u72B6\u6001\u8BFB\u53D6\u5931\u8D25: ${formatError4(error)}`);
     }
   }
   async handleAutoDevRunCommand(taskId, sessionKey, message, requestId, workdir) {
@@ -5074,7 +5381,7 @@ var Orchestrator = class {
         } catch (restoreError) {
           this.logger.warn("Failed to restore AutoDev task status after failure", {
             taskId: activeTask.id,
-            error: formatError3(restoreError)
+            error: formatError4(restoreError)
           });
         }
       }
@@ -5088,7 +5395,7 @@ var Orchestrator = class {
         taskDescription: activeTask.description,
         approved: null,
         repairRounds: 0,
-        error: formatError3(error)
+        error: formatError4(error)
       });
       throw error;
     }
@@ -5170,7 +5477,7 @@ var Orchestrator = class {
         objective: normalizedObjective,
         approved: null,
         repairRounds: 0,
-        error: formatError3(error)
+        error: formatError4(error)
       });
       await this.finishProgress(progressCtx, buildFailureProgressSummary(status, requestStartedAt, error));
       throw error;
@@ -5189,7 +5496,7 @@ var Orchestrator = class {
       await this.channel.sendNotice(conversationId, "[CodeHarbor] Multi-Agent workflow \u5DF2\u53D6\u6D88\u3002");
       return Date.now() - startedAt;
     }
-    await this.channel.sendMessage(conversationId, `[CodeHarbor] Multi-Agent workflow \u5931\u8D25: ${formatError3(error)}`);
+    await this.channel.sendMessage(conversationId, `[CodeHarbor] Multi-Agent workflow \u5931\u8D25: ${formatError4(error)}`);
     return Date.now() - startedAt;
   }
   async sendAutoDevFailure(conversationId, error) {
@@ -5199,7 +5506,7 @@ var Orchestrator = class {
       await this.channel.sendNotice(conversationId, "[CodeHarbor] AutoDev \u5DF2\u53D6\u6D88\u3002");
       return Date.now() - startedAt;
     }
-    await this.channel.sendMessage(conversationId, `[CodeHarbor] AutoDev \u5931\u8D25: ${formatError3(error)}`);
+    await this.channel.sendMessage(conversationId, `[CodeHarbor] AutoDev \u5931\u8D25: ${formatError4(error)}`);
     return Date.now() - startedAt;
   }
   async handleStopCommand(sessionKey, message, requestId) {
@@ -5208,6 +5515,7 @@ var Orchestrator = class {
     this.sessionRuntime.clearSession(sessionKey);
     const running = this.runningExecutions.get(sessionKey);
     if (running) {
+      this.pendingStopRequests.delete(sessionKey);
       this.sessionRuntime.cancelRunningExecution(sessionKey);
       running.cancel();
       await this.channel.sendNotice(
@@ -5222,11 +5530,32 @@ var Orchestrator = class {
       });
       return;
     }
+    const lockEntry = this.sessionLocks.get(sessionKey);
+    if (lockEntry?.mutex.isLocked()) {
+      this.pendingStopRequests.add(sessionKey);
+      await this.channel.sendNotice(
+        message.conversationId,
+        "[CodeHarbor] \u5DF2\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u4EFB\u52A1\uFF0C\u5E76\u5DF2\u6E05\u7406\u4F1A\u8BDD\u4E0A\u4E0B\u6587\u3002"
+      );
+      this.logger.info("Stop command queued for pending execution", {
+        requestId,
+        sessionKey
+      });
+      return;
+    }
+    this.pendingStopRequests.delete(sessionKey);
     await this.channel.sendNotice(
       message.conversationId,
       "[CodeHarbor] \u4F1A\u8BDD\u5DF2\u505C\u6B62\u3002\u540E\u7EED\u5728\u7FA4\u804A\u4E2D\u8BF7\u63D0\u53CA/\u56DE\u590D\u6211\uFF0C\u6216\u5728\u79C1\u804A\u76F4\u63A5\u53D1\u9001\u6D88\u606F\u3002"
     );
   }
+  consumePendingStopRequest(sessionKey) {
+    if (!this.pendingStopRequests.has(sessionKey)) {
+      return false;
+    }
+    this.pendingStopRequests.delete(sessionKey);
+    return true;
+  }
   startTypingHeartbeat(conversationId) {
     let stopped = false;
     const refreshIntervalMs = Math.max(1e3, Math.floor(this.typingTimeoutMs / 2));
@@ -5328,8 +5657,41 @@ var Orchestrator = class {
     }
     return this.configService.resolveRoomConfig(conversationId, fallbackPolicy);
   }
-  buildExecutionPrompt(prompt, message) {
-    if (message.attachments.length === 0) {
+  async transcribeAudioAttachments(message, requestId, sessionKey) {
+    if (!this.audioTranscriber.isEnabled()) {
+      return [];
+    }
+    const audioAttachments = message.attachments.filter((attachment) => attachment.kind === "audio" && Boolean(attachment.localPath)).map((attachment) => ({
+      name: attachment.name,
+      mimeType: attachment.mimeType,
+      localPath: attachment.localPath
+    }));
+    if (audioAttachments.length === 0) {
+      return [];
+    }
+    try {
+      const transcripts = await this.audioTranscriber.transcribeMany(audioAttachments);
+      if (transcripts.length > 0) {
+        this.logger.info("Audio transcription completed", {
+          requestId,
+          sessionKey,
+          attachmentCount: audioAttachments.length,
+          transcriptCount: transcripts.length
+        });
+      }
+      return transcripts;
+    } catch (error) {
+      this.logger.warn("Audio transcription failed, continuing without transcripts", {
+        requestId,
+        sessionKey,
+        attachmentCount: audioAttachments.length,
+        error: formatError4(error)
+      });
+      return [];
+    }
+  }
+  buildExecutionPrompt(prompt, message, audioTranscripts) {
+    if (message.attachments.length === 0 && audioTranscripts.length === 0) {
       return prompt;
     }
     const attachmentSummary = message.attachments.map((attachment) => {
@@ -5340,11 +5702,19 @@ var Orchestrator = class {
       return `- kind=${attachment.kind} name=${attachment.name} mime=${mime} size=${size} source=${source} local=${local}`;
     }).join("\n");
     const promptBody = prompt.trim() ? prompt : "(no text body)";
-    return `${promptBody}
-[attachments]
+    const sections = [promptBody];
+    if (attachmentSummary) {
+      sections.push(`[attachments]
 ${attachmentSummary}
-[/attachments]`;
+[/attachments]`);
+    }
+    if (audioTranscripts.length > 0) {
+      const transcriptSummary = audioTranscripts.map((transcript) => `- name=${transcript.name} text=${transcript.text.replace(/\s+/g, " ").trim()}`).join("\n");
+      sections.push(`[audio_transcripts]
+${transcriptSummary}
+[/audio_transcripts]`);
+    }
+    return sections.join("\n\n");
   }
   async recordCliCompatPrompt(entry) {
     if (!this.cliCompatRecorder) {
@@ -5473,7 +5843,7 @@ function createIdleAutoDevSnapshot() {
 function buildSessionKey(message) {
   return `${message.channel}:${message.conversationId}:${message.senderId}`;
 }
-function formatError3(error) {
+function formatError4(error) {
   if (error instanceof Error) {
     return error.message;
   }
@@ -5489,11 +5859,21 @@ function collectImagePaths(message) {
   }
   return [...seen];
 }
-async function cleanupAttachmentFiles(imagePaths) {
+function collectLocalAttachmentPaths(message) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const attachment of message.attachments) {
+    if (!attachment.localPath) {
+      continue;
+    }
+    seen.add(attachment.localPath);
+  }
+  return [...seen];
+}
+async function cleanupAttachmentFiles(attachmentPaths) {
   await Promise.all(
-    imagePaths.map(async (imagePath) => {
+    attachmentPaths.map(async (attachmentPath) => {
       try {
-        await import_promises4.default.unlink(imagePath);
+        await import_promises5.default.unlink(attachmentPath);
       } catch {
       }
     })
@@ -5572,7 +5952,7 @@ function classifyExecutionOutcome(error) {
   if (error instanceof CodexExecutionCancelledError) {
     return "cancelled";
   }
-  const message = formatError3(error).toLowerCase();
+  const message = formatError4(error).toLowerCase();
   if (message.includes("timed out")) {
     return "timeout";
   }
@@ -5584,9 +5964,9 @@ function buildFailureProgressSummary(status, startedAt, error) {
     return `\u5904\u7406\u5DF2\u53D6\u6D88\uFF08\u8017\u65F6 ${elapsed}\uFF09`;
   }
   if (status === "timeout") {
-    return `\u5904\u7406\u8D85\u65F6\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError3(error)}`;
+    return `\u5904\u7406\u8D85\u65F6\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError4(error)}`;
   }
-  return `\u5904\u7406\u5931\u8D25\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError3(error)}`;
+  return `\u5904\u7406\u5931\u8D25\uFF08\u8017\u65F6 ${elapsed}\uFF09: ${formatError4(error)}`;
 }
 function buildWorkflowResultReply(result) {
   return `[CodeHarbor] Multi-Agent workflow \u5B8C\u6210
@@ -5610,7 +5990,7 @@ ${result.review}
 // src/store/state-store.ts
 var import_node_fs7 = __toESM(require("fs"));
-var import_node_path10 = __toESM(require("path"));
+var import_node_path11 = __toESM(require("path"));
 var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
 var PRUNE_INTERVAL_MS = 5 * 60 * 1e3;
 var SQLITE_MODULE_ID = `node:${"sqlite"}`;
@@ -5636,7 +6016,7 @@ var StateStore = class {
     this.maxProcessedEventsPerSession = maxProcessedEventsPerSession;
     this.maxSessionAgeMs = maxSessionAgeDays * ONE_DAY_MS;
     this.maxSessions = maxSessions;
-    import_node_fs7.default.mkdirSync(import_node_path10.default.dirname(this.dbPath), { recursive: true });
+    import_node_fs7.default.mkdirSync(import_node_path11.default.dirname(this.dbPath), { recursive: true });
     this.db = new DatabaseSync(this.dbPath);
     this.initializeSchema();
     this.importLegacyStateIfNeeded();
@@ -6007,7 +6387,7 @@ function boolToInt(value) {
 }
 // src/app.ts
-var execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process5.execFile);
+var execFileAsync3 = (0, import_node_util4.promisify)(import_node_child_process6.execFile);
 var CodeHarborApp = class {
   config;
   logger;
@@ -6159,7 +6539,7 @@ function isNonLoopbackHost(host) {
 // src/config.ts
 var import_node_fs8 = __toESM(require("fs"));
-var import_node_path11 = __toESM(require("path"));
+var import_node_path12 = __toESM(require("path"));
 var import_dotenv2 = __toESM(require("dotenv"));
 var import_zod = require("zod");
 var configSchema = import_zod.z.object({
@@ -6206,6 +6586,12 @@ var configSchema = import_zod.z.object({
   CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
   CLI_COMPAT_PROGRESS_THROTTLE_MS: import_zod.z.string().default("300").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().nonnegative()),
   CLI_COMPAT_FETCH_MEDIA: import_zod.z.string().default("true").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_TRANSCRIBE_AUDIO: import_zod.z.string().default("false").transform((v) => v.toLowerCase() === "true"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: import_zod.z.string().default("gpt-4o-mini-transcribe"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: import_zod.z.string().default("120000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: import_zod.z.string().default("6000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
+  CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND: import_zod.z.string().default(""),
+  CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS: import_zod.z.string().default("180000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
   CLI_COMPAT_RECORD_PATH: import_zod.z.string().default(""),
   DOCTOR_HTTP_TIMEOUT_MS: import_zod.z.string().default("10000").transform((v) => Number.parseInt(v, 10)).pipe(import_zod.z.number().int().positive()),
   ADMIN_BIND_HOST: import_zod.z.string().default("127.0.0.1"),
@@ -6222,7 +6608,7 @@ var configSchema = import_zod.z.object({
   matrixCommandPrefix: v.MATRIX_COMMAND_PREFIX,
   codexBin: v.CODEX_BIN,
   codexModel: v.CODEX_MODEL?.trim() || null,
-  codexWorkdir: import_node_path11.default.resolve(v.CODEX_WORKDIR),
+  codexWorkdir: import_node_path12.default.resolve(v.CODEX_WORKDIR),
   codexDangerousBypass: v.CODEX_DANGEROUS_BYPASS,
   codexExecTimeoutMs: v.CODEX_EXEC_TIMEOUT_MS,
   codexSandboxMode: v.CODEX_SANDBOX_MODE?.trim() || null,
@@ -6233,8 +6619,8 @@ var configSchema = import_zod.z.object({
     enabled: v.AGENT_WORKFLOW_ENABLED,
     autoRepairMaxRounds: v.AGENT_WORKFLOW_AUTO_REPAIR_MAX_ROUNDS
   },
-  stateDbPath: import_node_path11.default.resolve(v.STATE_DB_PATH),
-  legacyStateJsonPath: v.STATE_PATH.trim() ? import_node_path11.default.resolve(v.STATE_PATH) : null,
+  stateDbPath: import_node_path12.default.resolve(v.STATE_DB_PATH),
+  legacyStateJsonPath: v.STATE_PATH.trim() ? import_node_path12.default.resolve(v.STATE_PATH) : null,
   maxProcessedEventsPerSession: v.MAX_PROCESSED_EVENTS_PER_SESSION,
   maxSessionAgeDays: v.MAX_SESSION_AGE_DAYS,
   maxSessions: v.MAX_SESSIONS,
@@ -6266,7 +6652,13 @@ var configSchema = import_zod.z.object({
     disableReplyChunkSplit: v.CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT,
     progressThrottleMs: v.CLI_COMPAT_PROGRESS_THROTTLE_MS,
     fetchMedia: v.CLI_COMPAT_FETCH_MEDIA,
-    recordPath: v.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path11.default.resolve(v.CLI_COMPAT_RECORD_PATH) : null
+    transcribeAudio: v.CLI_COMPAT_TRANSCRIBE_AUDIO,
+    audioTranscribeModel: v.CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL.trim() || "gpt-4o-mini-transcribe",
+    audioTranscribeTimeoutMs: v.CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS,
+    audioTranscribeMaxChars: v.CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS,
+    audioLocalWhisperCommand: v.CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND.trim() ? v.CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND.trim() : null,
+    audioLocalWhisperTimeoutMs: v.CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS,
+    recordPath: v.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path12.default.resolve(v.CLI_COMPAT_RECORD_PATH) : null
   },
   doctorHttpTimeoutMs: v.DOCTOR_HTTP_TIMEOUT_MS,
   adminBindHost: v.ADMIN_BIND_HOST.trim() || "127.0.0.1",
@@ -6277,7 +6669,7 @@ var configSchema = import_zod.z.object({
   adminAllowedOrigins: parseCsvList(v.ADMIN_ALLOWED_ORIGINS),
   logLevel: v.LOG_LEVEL
 }));
-function loadEnvFromFile(filePath = import_node_path11.default.resolve(process.cwd(), ".env"), env = process.env) {
+function loadEnvFromFile(filePath = import_node_path12.default.resolve(process.cwd(), ".env"), env = process.env) {
   import_dotenv2.default.config({
     path: filePath,
     processEnv: env,
@@ -6290,9 +6682,9 @@ function loadConfig(env = process.env) {
     const message = parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ");
     throw new Error(`Invalid configuration: ${message}`);
   }
-  import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(parsed.data.stateDbPath), { recursive: true });
+  import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(parsed.data.stateDbPath), { recursive: true });
   if (parsed.data.legacyStateJsonPath) {
-    import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(parsed.data.legacyStateJsonPath), { recursive: true });
+    import_node_fs8.default.mkdirSync(import_node_path12.default.dirname(parsed.data.legacyStateJsonPath), { recursive: true });
   }
   return parsed.data;
 }
@@ -6460,7 +6852,7 @@ function parseAdminTokens(raw) {
 // src/config-snapshot.ts
 var import_node_fs9 = __toESM(require("fs"));
-var import_node_path12 = __toESM(require("path"));
+var import_node_path13 = __toESM(require("path"));
 var import_zod2 = require("zod");
 var CONFIG_SNAPSHOT_SCHEMA_VERSION = 1;
 var CONFIG_SNAPSHOT_ENV_KEYS = [
@@ -6507,6 +6899,12 @@ var CONFIG_SNAPSHOT_ENV_KEYS = [
   "CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT",
   "CLI_COMPAT_PROGRESS_THROTTLE_MS",
   "CLI_COMPAT_FETCH_MEDIA",
+  "CLI_COMPAT_TRANSCRIBE_AUDIO",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS",
+  "CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS",
+  "CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND",
+  "CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS",
   "CLI_COMPAT_RECORD_PATH",
   "DOCTOR_HTTP_TIMEOUT_MS",
   "ADMIN_BIND_HOST",
@@ -6573,6 +6971,19 @@ var envSnapshotSchema = import_zod2.z.object({
   CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: booleanStringSchema("CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT"),
   CLI_COMPAT_PROGRESS_THROTTLE_MS: integerStringSchema("CLI_COMPAT_PROGRESS_THROTTLE_MS", 0),
   CLI_COMPAT_FETCH_MEDIA: booleanStringSchema("CLI_COMPAT_FETCH_MEDIA"),
+  CLI_COMPAT_TRANSCRIBE_AUDIO: booleanStringSchema("CLI_COMPAT_TRANSCRIBE_AUDIO").default("false"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: import_zod2.z.string().default("gpt-4o-mini-transcribe"),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: integerStringSchema("CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS", 1).default(
+    "120000"
+  ),
+  CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: integerStringSchema("CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS", 1).default(
+    "6000"
+  ),
+  CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND: import_zod2.z.string().default(""),
+  CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS: integerStringSchema(
+    "CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS",
+    1
+  ).default("180000"),
   CLI_COMPAT_RECORD_PATH: import_zod2.z.string(),
   DOCTOR_HTTP_TIMEOUT_MS: integerStringSchema("DOCTOR_HTTP_TIMEOUT_MS", 1),
   ADMIN_BIND_HOST: import_zod2.z.string(),
@@ -6651,8 +7062,8 @@ async function runConfigExportCommand(options = {}) {
     const snapshot = buildConfigSnapshot(config, stateStore.listRoomSettings(), options.now ?? /* @__PURE__ */ new Date());
     const serialized = serializeConfigSnapshot(snapshot);
     if (options.outputPath) {
-      const targetPath = import_node_path12.default.resolve(cwd, options.outputPath);
-      import_node_fs9.default.mkdirSync(import_node_path12.default.dirname(targetPath), { recursive: true });
+      const targetPath = import_node_path13.default.resolve(cwd, options.outputPath);
+      import_node_fs9.default.mkdirSync(import_node_path13.default.dirname(targetPath), { recursive: true });
       import_node_fs9.default.writeFileSync(targetPath, serialized, "utf8");
       output.write(`Exported config snapshot to ${targetPath}
 `);
@@ -6667,7 +7078,7 @@ async function runConfigImportCommand(options) {
   const cwd = options.cwd ?? process.cwd();
   const output = options.output ?? process.stdout;
   const actor = options.actor?.trim() || "cli:config-import";
-  const sourcePath = import_node_path12.default.resolve(cwd, options.filePath);
+  const sourcePath = import_node_path13.default.resolve(cwd, options.filePath);
   if (!import_node_fs9.default.existsSync(sourcePath)) {
     throw new Error(`Config snapshot file not found: ${sourcePath}`);
   }
@@ -6698,7 +7109,7 @@ async function runConfigImportCommand(options) {
     synchronizeRoomSettings(stateStore, normalizedRooms);
     stateStore.appendConfigRevision(
       actor,
-      `import config snapshot from ${import_node_path12.default.basename(sourcePath)}`,
+      `import config snapshot from ${import_node_path13.default.basename(sourcePath)}`,
       JSON.stringify({
         type: "config_snapshot_import",
         sourcePath,
@@ -6712,7 +7123,7 @@ async function runConfigImportCommand(options) {
   output.write(
     [
       `Imported config snapshot from ${sourcePath}`,
-      `- updated .env in ${import_node_path12.default.resolve(cwd, ".env")}`,
+      `- updated .env in ${import_node_path13.default.resolve(cwd, ".env")}`,
       `- synchronized room settings: ${normalizedRooms.length}`,
       "- restart required: yes (global env settings are restart-scoped)"
     ].join("\n") + "\n"
@@ -6763,6 +7174,12 @@ function buildSnapshotEnv(config) {
     CLI_COMPAT_DISABLE_REPLY_CHUNK_SPLIT: String(config.cliCompat.disableReplyChunkSplit),
     CLI_COMPAT_PROGRESS_THROTTLE_MS: String(config.cliCompat.progressThrottleMs),
     CLI_COMPAT_FETCH_MEDIA: String(config.cliCompat.fetchMedia),
+    CLI_COMPAT_TRANSCRIBE_AUDIO: String(config.cliCompat.transcribeAudio),
+    CLI_COMPAT_AUDIO_TRANSCRIBE_MODEL: config.cliCompat.audioTranscribeModel,
+    CLI_COMPAT_AUDIO_TRANSCRIBE_TIMEOUT_MS: String(config.cliCompat.audioTranscribeTimeoutMs),
+    CLI_COMPAT_AUDIO_TRANSCRIBE_MAX_CHARS: String(config.cliCompat.audioTranscribeMaxChars),
+    CLI_COMPAT_AUDIO_LOCAL_WHISPER_COMMAND: config.cliCompat.audioLocalWhisperCommand ?? "",
+    CLI_COMPAT_AUDIO_LOCAL_WHISPER_TIMEOUT_MS: String(config.cliCompat.audioLocalWhisperTimeoutMs),
     CLI_COMPAT_RECORD_PATH: config.cliCompat.recordPath ?? "",
     DOCTOR_HTTP_TIMEOUT_MS: String(config.doctorHttpTimeoutMs),
     ADMIN_BIND_HOST: config.adminBindHost,
@@ -6788,10 +7205,10 @@ function parseJsonFile(filePath) {
 function normalizeSnapshotEnv(env, cwd) {
   return {
     ...env,
-    CODEX_WORKDIR: import_node_path12.default.resolve(cwd, env.CODEX_WORKDIR),
-    STATE_DB_PATH: import_node_path12.default.resolve(cwd, env.STATE_DB_PATH),
-    STATE_PATH: env.STATE_PATH.trim() ? import_node_path12.default.resolve(cwd, env.STATE_PATH) : "",
-    CLI_COMPAT_RECORD_PATH: env.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path12.default.resolve(cwd, env.CLI_COMPAT_RECORD_PATH) : ""
+    CODEX_WORKDIR: import_node_path13.default.resolve(cwd, env.CODEX_WORKDIR),
+    STATE_DB_PATH: import_node_path13.default.resolve(cwd, env.STATE_DB_PATH),
+    STATE_PATH: env.STATE_PATH.trim() ? import_node_path13.default.resolve(cwd, env.STATE_PATH) : "",
+    CLI_COMPAT_RECORD_PATH: env.CLI_COMPAT_RECORD_PATH.trim() ? import_node_path13.default.resolve(cwd, env.CLI_COMPAT_RECORD_PATH) : ""
   };
 }
 function normalizeSnapshotRooms(rooms, cwd) {
@@ -6806,7 +7223,7 @@ function normalizeSnapshotRooms(rooms, cwd) {
       throw new Error(`Duplicate roomId in snapshot: ${roomId}`);
     }
     seen.add(roomId);
-    const workdir = import_node_path12.default.resolve(cwd, room.workdir);
+    const workdir = import_node_path13.default.resolve(cwd, room.workdir);
     ensureDirectory2(workdir, `room workdir (${roomId})`);
     normalized.push({
       roomId,
@@ -6833,8 +7250,8 @@ function synchronizeRoomSettings(stateStore, rooms) {
   }
 }
 function persistEnvSnapshot(cwd, env) {
-  const envPath = import_node_path12.default.resolve(cwd, ".env");
-  const examplePath = import_node_path12.default.resolve(cwd, ".env.example");
+  const envPath = import_node_path13.default.resolve(cwd, ".env");
+  const examplePath = import_node_path13.default.resolve(cwd, ".env.example");
   const template = import_node_fs9.default.existsSync(envPath) ? import_node_fs9.default.readFileSync(envPath, "utf8") : import_node_fs9.default.existsSync(examplePath) ? import_node_fs9.default.readFileSync(examplePath, "utf8") : "";
   const overrides = {};
   for (const key of CONFIG_SNAPSHOT_ENV_KEYS) {
@@ -6917,11 +7334,11 @@ function jsonArrayStringSchema(key, allowEmpty) {
 }
 // src/preflight.ts
-var import_node_child_process6 = require("child_process");
+var import_node_child_process7 = require("child_process");
 var import_node_fs10 = __toESM(require("fs"));
-var import_node_path13 = __toESM(require("path"));
-var import_node_util4 = require("util");
-var execFileAsync4 = (0, import_node_util4.promisify)(import_node_child_process6.execFile);
+var import_node_path14 = __toESM(require("path"));
+var import_node_util5 = require("util");
+var execFileAsync4 = (0, import_node_util5.promisify)(import_node_child_process7.execFile);
 var REQUIRED_ENV_KEYS = ["MATRIX_HOMESERVER", "MATRIX_USER_ID", "MATRIX_ACCESS_TOKEN"];
 async function runStartupPreflight(options = {}) {
   const env = options.env ?? process.env;
@@ -6930,7 +7347,7 @@ async function runStartupPreflight(options = {}) {
   const fileExists = options.fileExists ?? import_node_fs10.default.existsSync;
   const isDirectory = options.isDirectory ?? defaultIsDirectory;
   const issues = [];
-  const envPath = import_node_path13.default.resolve(cwd, ".env");
+  const envPath = import_node_path14.default.resolve(cwd, ".env");
   let resolvedCodexBin = null;
   let usedCodexFallback = false;
   if (!fileExists(envPath)) {
@@ -7007,7 +7424,7 @@ async function runStartupPreflight(options = {}) {
     }
   }
   const configuredWorkdir = readEnv(env, "CODEX_WORKDIR");
-  const workdir = import_node_path13.default.resolve(cwd, configuredWorkdir || cwd);
+  const workdir = import_node_path14.default.resolve(cwd, configuredWorkdir || cwd);
   if (!fileExists(workdir) || !isDirectory(workdir)) {
     issues.push({
       level: "error",
@@ -7137,7 +7554,7 @@ configCommand.command("export").description("Export config snapshot as JSON").op
     const home = ensureRuntimeHomeOrExit();
     await runConfigExportCommand({ outputPath: options.output, cwd: home });
   } catch (error) {
-    process.stderr.write(`Config export failed: ${formatError4(error)}
+    process.stderr.write(`Config export failed: ${formatError5(error)}
 `);
     process.exitCode = 1;
   }
@@ -7151,7 +7568,7 @@ configCommand.command("import").description("Import config snapshot from JSON").
       cwd: home
     });
   } catch (error) {
-    process.stderr.write(`Config import failed: ${formatError4(error)}
+    process.stderr.write(`Config import failed: ${formatError5(error)}
 `);
     process.exitCode = 1;
   }
@@ -7170,7 +7587,7 @@ serviceCommand.command("install").description("Install and enable codeharbor sys
       startNow: options.start ?? true
     });
   } catch (error) {
-    process.stderr.write(`Service install failed: ${formatError4(error)}
+    process.stderr.write(`Service install failed: ${formatError5(error)}
 `);
     process.stderr.write(
       [
@@ -7191,7 +7608,7 @@ serviceCommand.command("uninstall").description("Remove codeharbor systemd servi
       removeAdmin: options.withAdmin ?? false
     });
   } catch (error) {
-    process.stderr.write(`Service uninstall failed: ${formatError4(error)}
+    process.stderr.write(`Service uninstall failed: ${formatError5(error)}
 `);
     process.stderr.write(
       [
@@ -7212,7 +7629,7 @@ serviceCommand.command("restart").description("Restart installed codeharbor syst
       restartAdmin: options.withAdmin ?? false
     });
   } catch (error) {
-    process.stderr.write(`Service restart failed: ${formatError4(error)}
+    process.stderr.write(`Service restart failed: ${formatError5(error)}
 `);
     process.stderr.write(
       [
@@ -7276,7 +7693,7 @@ function ensureRuntimeHomeOrExit() {
 `);
     process.exit(1);
   }
-  loadEnvFromFile(import_node_path14.default.resolve(home, ".env"));
+  loadEnvFromFile(import_node_path15.default.resolve(home, ".env"));
   runtimeHome = home;
   return runtimeHome;
 }
@@ -7291,7 +7708,7 @@ function parsePortOption(raw, fallback) {
 }
 function resolveCliVersion() {
   try {
-    const packagePath = import_node_path14.default.resolve(__dirname, "..", "package.json");
+    const packagePath = import_node_path15.default.resolve(__dirname, "..", "package.json");
     const content = import_node_fs11.default.readFileSync(packagePath, "utf8");
     const parsed = JSON.parse(content);
     return typeof parsed.version === "string" && parsed.version.trim() ? parsed.version : "0.0.0";
@@ -7302,9 +7719,9 @@ function resolveCliVersion() {
 function resolveCliScriptPath() {
   const argvPath = process.argv[1];
   if (argvPath && argvPath.trim()) {
-    return import_node_path14.default.resolve(argvPath);
+    return import_node_path15.default.resolve(argvPath);
   }
-  return import_node_path14.default.resolve(__dirname, "cli.js");
+  return import_node_path15.default.resolve(__dirname, "cli.js");
 }
 function maybeReexecServiceCommandWithSudo() {
   if (typeof process.getuid !== "function" || process.getuid() === 0) {
@@ -7315,7 +7732,7 @@ function maybeReexecServiceCommandWithSudo() {
     return;
   }
   const cliScriptPath = resolveCliScriptPath();
-  const child = (0, import_node_child_process7.spawnSync)("sudo", [process.execPath, cliScriptPath, ...serviceArgs], {
+  const child = (0, import_node_child_process8.spawnSync)("sudo", [process.execPath, cliScriptPath, ...serviceArgs], {
     stdio: "inherit"
   });
   if (child.error) {
@@ -7332,7 +7749,7 @@ function shellQuote(value) {
 function buildExplicitSudoCommand(subcommand) {
   return `sudo ${shellQuote(process.execPath)} ${shellQuote(resolveCliScriptPath())} ${subcommand}`;
 }
-function formatError4(error) {
+function formatError5(error) {
   if (error instanceof Error) {
     return error.message;
   }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "codeharbor",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Instant-messaging bridge for Codex CLI sessions",
   "license": "MIT",
   "main": "dist/cli.js",
@@ -13,11 +13,13 @@
     "./package.json": "./package.json"
   },
   "bin": {
-    "codeharbor": "dist/cli.js"
+    "codeharbor": "dist/cli.js",
+    "codeharbor-whisper-transcribe": "scripts/local-whisper-transcribe.py"
   },
   "files": [
     "dist",
     "scripts/postinstall-restart.cjs",
+    "scripts/local-whisper-transcribe.py",
     ".env.example",
     "README.md",
     "LICENSE"

package/scripts/local-whisper-transcribe.py ADDED Viewed

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Local audio transcription for CodeHarbor.")
+    parser.add_argument("--input", required=True, help="Path to input audio file.")
+    parser.add_argument("--model", default="small", help="Whisper model size/name.")
+    parser.add_argument("--device", default="auto", help="Execution device (auto/cpu/cuda).")
+    parser.add_argument(
+        "--compute-type",
+        default="int8",
+        help="faster-whisper compute type (int8/float16/float32).",
+    )
+    parser.add_argument("--language", default=None, help="Optional language hint (for example: zh).")
+    parser.add_argument("--beam-size", type=int, default=5, help="Beam size for decoding.")
+    return parser
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+    try:
+        from faster_whisper import WhisperModel
+    except Exception as error:  # pragma: no cover - env dependent
+        print(
+            "faster_whisper is required for local transcription. Install with: python3 -m pip install faster-whisper",
+            file=sys.stderr,
+        )
+        print(str(error), file=sys.stderr)
+        return 2
+    model = WhisperModel(args.model, device=args.device, compute_type=args.compute_type)
+    segments, _ = model.transcribe(
+        args.input,
+        language=args.language,
+        vad_filter=True,
+        beam_size=args.beam_size,
+    )
+    text = " ".join(segment.text.strip() for segment in segments if segment.text and segment.text.strip()).strip()
+    if not text:
+        return 3
+    print(text)
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())