@xdfnet/ispeak 1.6.15 → 1.6.16

package/AGENTS.md

@@ -28,11 +28,9 @@ make help       # 显示帮助
 ispeak (CLI, bash)
   └─ nc -U ~/.config/iSpeak/ispeak.sock
       └─ ispeakd (Go daemon)
-           ├─ Task Engine (任务仓库)
-           │    └─ pending FIFO
-           └─ transactionWorker (single)
-                └─ pending -> running -> delete
-                     └─ SSE PCM chunk -> AVAudioEngine
+           └─ Player (channel, buffer=1)
+                └─ loop goroutine: 单 AVAudioEngine 实例复用
+                     └─ SSE PCM chunk → AVAudioEngine
 ```
 
 - **Socket**: `~/.config/iSpeak/ispeak.sock`
@@ -42,7 +40,7 @@ ispeak (CLI, bash)
 
 ## 核心文件
 
-- `main.go` — 守护进程、任务引擎、TTS 流式请求、SSE 解析、流式播放
+- `main.go` — 守护进程、Player (channel 驱动)、TTS 流式请求、SSE 解析
 - `avaudioengine_player_darwin.go` — macOS 原生 `AVAudioEngine` PCM 播放器
 - `clean_text.go` — TTS 播报文本清洗
 - `main_test.go` — 任务引擎关键行为测试
@@ -62,18 +60,13 @@ CLI 与 daemon 通过 socket 传输原始文本，支持音色前缀：
 ## 任务策略（节省 TTS 费用）
 
 新消息到达时：
-1. 删除所有 `pending` 任务（未开始）
-2. 不打断当前 `running` 事务
-3. 创建新任务并进入 `pending`
-
-**任务状态流转：**
-```
-pending → running → delete
-```
+1. 丢弃 channel 中排队的旧消息
+2. 不打断当前正在合成/播放的任务
+3. 新消息入队
 
 ## 失败策略
 
-- 流式合成/播放失败：直接删除任务，不重试，避免重复播报
+- 流式合成/播放失败：日志记录，继续处理下一条，不重试
 
 ## 配置
 
@@ -93,11 +86,11 @@ pending → running → delete
 
 ## 稳定性设计
 
-- 单 transaction worker，合成与播放同链路，降低首播延迟
-- 关键 goroutine 有 `panic recover`
+- 单 Player goroutine，合成与播放同链路，降低首播延迟
+- AVAudioEngine 实例复用，避免重复初始化开销
+- Channel buffer=1 + drain，新消息自动丢弃旧排队消息
 - 配置热更新（mtime 缓存 + 自动重载）
 - TTS HTTP Client 复用，减少连接开销
 - 主链路使用 macOS 原生 `AVAudioEngine` 播放 PCM
-- 播放失败直接删除任务，不重试
+- 合成/播放失败直接跳过，不重试
 - 日志轮转，防止文件过大
-- 进程级 temp 目录，退出时自动清理

package/Makefile

@@ -1,6 +1,6 @@
 .PHONY: build test pack release push install deploy uninstall clean help
 
-VERSION  := 1.6.9
+VERSION  := 1.6.16
 TAG      := v$(VERSION)
 NPM_PKG  := @xdfnet/ispeak
 BIN     := build/ispeakd

package/avaudioengine_player_darwin.go

@@ -252,12 +252,6 @@ func (p *avAudioEngineStreamPlayer) CloseAndWait() error {
 	return p.closeLocked()
 }
 
-func (p *avAudioEngineStreamPlayer) Abort() error {
-	p.mu.Lock()
-	defer p.mu.Unlock()
-	return p.closeLocked()
-}
-
 func (p *avAudioEngineStreamPlayer) writeChunk(data []byte) error {
 	if len(data) == 0 {
 		return nil

package/configs/hook-speak.sh

@@ -1,15 +1,14 @@
 #!/bin/bash
 # Claude Code / Codex 共用播报 Hook：
-# 只取最后一条 assistant 回复，加 `{source:<name>}` 前缀后发给 ispeakd。
+# 取 last_assistant_message，加 {source:<name>} 前缀后发给 ispeakd。
+# Claude: payload.last_assistant_message (snake_case)
+# Codex:  payload["last-assistant-message"] (kebab-case)
 [[ "$ISPEAK_SKIP" == "1" ]] && exit 0
 
 SOURCE="${1:-claude}"
 SOCK="$HOME/.config/iSpeak/ispeak.sock"
 LOG="$HOME/.config/iSpeak/hook.log"
-STATE_FILE="$HOME/.config/iSpeak/hook.last"
 
-# Codex `notify` 会把 JSON 作为最后一个参数传入；
-# Claude/Claude 风格 Stop Hook 会把 JSON 写到 stdin。
 input="${2:-}"
 if [[ -z "$input" ]]; then
   input=$(cat)
@@ -18,183 +17,26 @@ input_file=$(mktemp)
 trap 'rm -f "$input_file"' EXIT
 printf "%s" "$input" > "$input_file"
 
-result=$(SOURCE="$SOURCE" HOOK_INPUT_FILE="$input_file" HOOK_STATE_FILE="$STATE_FILE" node <<'NODE' 2>/dev/null
+result=$(HOOK_INPUT_FILE="$input_file" node <<'NODE' 2>>"$LOG"
 const fs = require("fs");
-const crypto = require("crypto");
 
 (() => {
   const input = readFile(process.env.HOOK_INPUT_FILE || "");
   const payload = parseJSON(input) || {};
-  const source = process.env.SOURCE || "";
-  const stateFile = process.env.HOOK_STATE_FILE || "";
-  const result = source.startsWith("codex")
-    ? lastCodexAssistant(payload)
-    : lastClaudeAssistant(payload);
 
-  if (!result.text) {
-    return;
-  }
+  const text = payload.last_assistant_message
+    || payload["last-assistant-message"]
+    || "";
 
-  if (stateFile && result.turnId) {
-    if (isDuplicateTurn(stateFile, source, result.turnId)) {
-      return;
-    }
-    saveTurn(stateFile, source, result.turnId, result.text);
-  } else if (stateFile) {
-    saveTurn(stateFile, source, "", result.text);
-  }
-
-  process.stdout.write(result.text);
+  if (text) process.stdout.write(text);
 })();
 
-function lastClaudeAssistant(payload) {
-  const direct = firstString(payload.last_assistant_message, payload.message);
-  if (direct) return { text: direct, turnId: extractTurnId(payload) };
-
-  const transcript = firstString(payload.transcript_path, payload.transcriptPath);
-  return transcript ? lastClaudeTranscript(transcript, payload) : { text: "", turnId: extractTurnId(payload) };
-}
-
-function lastCodexAssistant(payload) {
-  const direct = firstString(
-    payload["last-assistant-message"],
-    payload.last_assistant_message,
-    payload.lastAssistantMessage,
-    payload.message,
-    payload.lastMessage
-  );
-  if (direct) return { text: direct, turnId: extractTurnId(payload) };
-
-  const transcript = firstString(
-    payload.transcript_path,
-    payload.transcriptPath,
-    payload["transcript-path"]
-  );
-  return transcript ? lastAssistantFromTranscript(transcript, "codex") : { text: "", turnId: extractTurnId(payload) };
-}
-
 function readFile(file) {
-  try {
-    return fs.readFileSync(file, "utf8");
-  } catch {
-    return "";
-  }
+  try { return fs.readFileSync(file, "utf8"); } catch { return ""; }
 }
-
 function parseJSON(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-
-function firstString(...values) {
-  for (const value of values) {
-    if (typeof value === "string" && value !== "") return value;
-  }
-  return "";
-}
-
-function collectText(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map(item => collectText(item))
-      .filter(Boolean)
-      .join(" ");
-  }
-  if (!content || typeof content !== "object") return "";
-  if (typeof content.text === "string") return content.text;
-  if (content.content) return collectText(content.content);
-  return "";
+  try { return JSON.parse(text); } catch { return null; }
 }
-
-function lastClaudeTranscript(file, payload) {
-  const deadline = Date.now() + 5000;
-  let result = { text: "", turnId: extractTurnId(payload) };
-
-  while (Date.now() <= deadline) {
-    result = lastAssistantFromTranscript(file, "claude");
-    if (result.text) return result;
-    sleepMs(120);
-  }
-
-  return result;
-}
-
-function lastAssistantFromTranscript(file, source) {
-  let data = "";
-  try {
-    data = fs.readFileSync(file, "utf8");
-  } catch {
-    return "";
-  }
-
-  let last = "";
-  let turnId = "";
-  for (const line of data.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    const event = parseJSON(line);
-    if (!event) continue;
-
-    if (source === "claude") {
-      if (event.role === "assistant") {
-        last = collectText(event.content) || last;
-      }
-      if (event.message && event.message.role === "assistant") {
-        last = collectText(event.message.content) || last;
-      }
-    }
-
-    if (source === "codex" &&
-      event.type === "response_item" &&
-      event.payload &&
-      event.payload.type === "message" &&
-      event.payload.role === "assistant"
-    ) {
-      last = collectText(event.payload.content) || last;
-      turnId = turnId || extractTurnId(event) || extractTurnId(event.payload);
-    }
-  }
-  return { text: last, turnId };
-}
-
-function extractTurnId(payload) {
-  return firstString(
-    payload.turn_id,
-    payload.turnId,
-    payload["turn-id"]
-  );
-}
-
-function isDuplicateTurn(stateFile, source, turnId) {
-  const current = `${source}:${turnId}`;
-  try {
-    return fs.readFileSync(stateFile, "utf8").trim() === current;
-  } catch {
-    return false;
-  }
-}
-
-function saveTurn(stateFile, source, turnId, text) {
-  const current = `${source}:${turnId || textHash(text)}`;
-  try {
-    fs.mkdirSync(require("path").dirname(stateFile), { recursive: true });
-    fs.writeFileSync(stateFile, current, "utf8");
-  } catch {
-    // 去重失败不影响播报。
-  }
-}
-
-function textHash(text) {
-  return crypto.createHash("sha1").update(text, "utf8").digest("hex");
-}
-
-function sleepMs(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
 NODE
 )
 
@@ -203,31 +45,8 @@ if [[ "$ISPEAK_HOOK_PRINT_TEXT" == "1" ]]; then
   exit 0
 fi
 
-echo "=== $(date) ===" >> "$LOG"
-echo "SOURCE: $SOURCE" >> "$LOG"
-echo "TEXT_LEN: ${#result}" >> "$LOG"
-echo "PREVIEW: ${result:0:150}" >> "$LOG"
-
-# Claude Code Stop Hook 调试
-if [[ "$SOURCE" == "claude" && -n "$input" ]]; then
-  # 用 grep 提取 transcript_path
-  tp=$(echo "$input" | grep -o '"transcript_path":"[^"]*"' | head -1 | sed 's/"transcript_path":"//;s/"$//')
-  if [[ -n "$tp" ]]; then
-    echo "CLAUDE_TRANSCRIPT_PATH: $tp" >> "$LOG"
-    if [[ -f "$tp" ]]; then
-      echo "CLAUDE_TRANSCRIPT_EXISTS: yes" >> "$LOG"
-    else
-      echo "CLAUDE_TRANSCRIPT_EXISTS: no" >> "$LOG"
-    fi
-  else
-    echo "CLAUDE_TRANSCRIPT_PATH: none" >> "$LOG"
-    echo "CLAUDE_RAW: ${input:0:300}" >> "$LOG"
-  fi
-fi
-
 if [[ -n "$result" && -S "$SOCK" ]]; then
   printf "{source:%s}%s" "$SOURCE" "$result" | nc -U -w5 "$SOCK" 2>> "$LOG"
-  echo "SPOKE: OK" >> "$LOG"
 else
-  echo "SPOKE: SKIP" >> "$LOG"
+  echo "$(date): SKIP source=$SOURCE text_len=${#result}" >> "$LOG"
 fi

package/docs/hook-text-extraction.md

@@ -1,274 +1,88 @@
 # Hook 文本提取链路
 
-本文记录 Claude Code / Codex CLI 在 Hook 中拿到“最后一条 assistant 回复”的实际方式。`hook-speak.sh` 的目标只做两件事：取最后一条 assistant 回复，发给 iSpeak socket。
+`hook-speak.sh` 只做一件事：从 Hook JSON 里取 assistant 回复文本，发给 iSpeak socket。
 
 ## 结论
 
-推荐优先级：
+一行提取，覆盖所有来源：
 
-1. **Codex `notify`**：从脚本第二个参数 `$2` 读取 JSON，取 `last-assistant-message`（kebab-case）。
-2. **Codex Stop Hook**：从 stdin 读取 JSON，取 `last_assistant_message`（snake_case）。
-3. **Claude Code Stop Hook**：从 stdin 读取 JSON，只读 `transcript_path`（官方无 direct 字段）。
-
-不扫描 `~/.codex/sessions`。没有 direct 字段也没有 `transcript_path` 时，本次不播报。
-
-## Codex CLI：notify
-
-当前本机版本：
-
-```text
-codex-cli 0.130.0
+```js
+const text = payload.last_assistant_message     // Claude Stop / Codex Stop (snake_case)
+  || payload["last-assistant-message"]            // Codex notify (kebab-case)
+  || payload.message                              // fallback
+  || "";
 ```
 
-Codex CLI 的 `notify = [...]` 是 legacy notify 机制。官方源码里会把通知 JSON 追加成命令的最后一个 argv 参数，不写 stdin。
+不再需要 transcript 轮询、去重、状态文件。
 
-配置示例：
+## 输入来源
 
-```toml
-notify = ["/Users/你的用户名/.config/iSpeak/hook-speak.sh", "codex"]
-```
+| 来源 | 传参方式 | 字段名 |
+|------|---------|--------|
+| Claude Code Stop Hook | stdin | `last_assistant_message` |
+| Codex Stop Hook | stdin | `last_assistant_message` |
+| Codex notify | `$2` (argv) | `last-assistant-message` |
 
-脚本实际收到：
+脚本统一处理：
 
 ```bash
-$1 = "codex"
-$2 = '{"type":"agent-turn-complete",...,"last-assistant-message":"..."}'
-stdin = empty
-```
-
-核心字段：
-
-```json
-{
-  "type": "agent-turn-complete",
-  "thread-id": "...",
-  "turn-id": "...",
-  "cwd": "...",
-  "input-messages": ["..."],
-  "last-assistant-message": "最后一条 assistant 回复"
-}
-```
-
-所以 Codex `notify` 的正确读取方式是：
-
-```bash
-input="${2:-}"
-```
-
-然后解析：
-
-```js
-payload["last-assistant-message"]
+input="${2:-}"          # Codex notify 走 $2
+if [[ -z "$input" ]]; then
+  input=$(cat)          # Claude / Codex Stop Hook 走 stdin
+fi
 ```
 
-源码依据：`codex-rs/hooks/src/legacy_notify.rs`（https://github.com/openai/codex，2026-05-11）。该文件把 `last_assistant_message` 序列化为 kebab-case 的 `last-assistant-message`，并在执行命令前 `command.arg(notify_payload)`。
-
-## Codex CLI：Stop Hook
+## Codex notify
 
-Codex 也支持 Claude 风格 Hook。Stop Hook 的输入 JSON 写入 stdin。
+Codex `notify = [...]` 把 JSON 追加为命令最后一个 argv 参数。
 
-配置示例：
+配置：
 
-```json
-{
-  "hooks": {
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash $HOME/.config/iSpeak/hook-speak.sh codex",
-            "timeout": 30
-          }
-        ]
-      }
-    ]
-  }
-}
+```toml
+notify = ["/Users/xxx/.config/iSpeak/hook-speak.sh", "codex"]
 ```
 
-脚本实际收到：
+脚本收到：
 
 ```bash
 $1 = "codex"
-$2 = empty
-stdin = '{"hook_event_name":"Stop",...,"last_assistant_message":"..."}'
+$2 = '{"type":"agent-turn-complete",...,"last-assistant-message":"..."}'
 ```
 
-核心字段（源码 `StopCommandInput` struct）：
+源码：`codex-rs/hooks/src/legacy_notify.rs` — `last_assistant_message` 序列化为 kebab-case `last-assistant-message`，通过 `command.arg(notify_payload)` 传入。
 
-```rust
-struct StopCommandInput {
-    session_id: String,
-    turn_id: String,
-    transcript_path: NullableString,
-    cwd: String,
-    hook_event_name: String,
-    model: String,
-    permission_mode: String,
-    stop_hook_active: bool,
-    last_assistant_message: NullableString,  // ← Codex 有此字段
-}
-```
+## Codex Stop Hook
 
-对应 JSON：
+stdin JSON：
 
 ```json
 {
-  "session_id": "...",
   "turn_id": "...",
   "transcript_path": "...",
-  "cwd": "...",
-  "hook_event_name": "Stop",
-  "model": "...",
-  "permission_mode": "bypassPermissions",
-  "stop_hook_active": false,
   "last_assistant_message": "最后一条 assistant 回复"
 }
 ```
 
-源码依据：
-
-- `codex-rs/hooks/src/events/stop.rs`（https://github.com/openai/codex，2026-05-11）：构造 `StopCommandInput`，包含 `last_assistant_message` 和 `transcript_path`。
-- `codex-rs/hooks/src/engine/command_runner.rs`（同上）：Hook 命令通过 stdin 接收 `input_json`。
+源码：`codex-rs/hooks/src/events/stop.rs` — `StopCommandInput` struct 包含 `last_assistant_message`。
 
-## Codex Transcript
+## Claude Code Stop Hook
 
-Codex 的 transcript/session 文件是 JSONL。实际 assistant 回复形态：
+stdin JSON（实测，2026-05）：
 
 ```json
 {
-  "type": "response_item",
-  "payload": {
-    "type": "message",
-    "role": "assistant",
-    "content": [
-      {
-        "type": "output_text",
-        "text": "最后一条 assistant 回复"
-      }
-    ]
-  }
-}
-```
-
-提取规则：
-
-```js
-event.type === "response_item" &&
-event.payload?.type === "message" &&
-event.payload?.role === "assistant"
-```
-
-然后拼接：
-
-```js
-event.payload.content[].text
-```
-
-## Claude Code：Stop Hook
-
-> **来源**：[Claude Code Hooks Reference](https://code.claude.com/docs/en/hooks.md)，更新时间：2026-05-11
-
-Claude Code 官方 Stop Hook **没有 `last_assistant_message` 字段**。
-
-根据官方文档，Stop Hook 的 Common Input Fields 为：
-
-```json
-{
-  "session_id": "abc123",
-  "transcript_path": "/home/user/.claude/projects/.../transcript.jsonl",
-  "cwd": "/home/user/my-project",
-  "permission_mode": "default",
+  "session_id": "...",
+  "transcript_path": "/Users/admin/.claude/projects/.../xxx.jsonl",
+  "cwd": "...",
   "hook_event_name": "Stop",
-  "effort": {
-    "level": "medium"
-  }
-}
-```
-
-子 agent 上下文中额外字段：
-
-```json
-{
-  "agent_id": "subagent_xyz",
-  "agent_type": "Explore"
+  "last_assistant_message": "最后一条 assistant 回复"
 }
 ```
 
-**结论**：Claude Code Stop Hook 官方设计只提供 `transcript_path`，没有直接内嵌 `last_assistant_message`。旧版本脚本的 `last_assistant_message` / `message` fallback 实际上**从未被官方文档支持**。
-
-Claude transcript 常见 assistant 形态：
-
-```json
-{"role":"assistant","content":[{"type":"text","text":"..."}]}
-```
-
-或：
-
-```json
-{"message":{"role":"assistant","content":[{"type":"text","text":"..."}]}}
-```
-
-## 当前脚本策略
-
-`configs/hook-speak.sh` 当前入口：
-
-```bash
-input="${2:-}"
-if [[ -z "$input" ]]; then
-  input=$(cat)
-fi
-```
-
-含义：
-
-- Codex `notify`：读 `$2`
-- Claude / Codex Stop Hook：读 stdin
-- 如果 Codex 的 `notify` 和 `Stop` 同时启用，脚本会按 `turn_id` 去重，避免同一回合播两次
-
-Codex 文本字段优先级（源码确认）：
-
-```js
-payload["last-assistant-message"]  // notify: kebab-case
-payload.last_assistant_message      // Stop Hook: snake_case
-payload.lastAssistantMessage
-payload.message
-payload.lastMessage
-payload.transcript_path
-payload.transcriptPath
-payload["transcript-path"]
-```
-
-Claude Code 文本字段优先级（官方文档）：
-
-```js
-payload.transcript_path  // 官方支持的唯一方式
-```
-
-> **注**：Claude Code Stop Hook 官方 payload 中**没有 `last_assistant_message` 字段**，这是与 Codex 的本质区别。
-
-## 为什么不能只读 stdin
-
-因为 Codex `notify` 不走 stdin。只读 stdin 会导致：
-
-```text
-TEXT_LEN: 0
-SPOKE: SKIP
-```
-
-正确做法是先读 `$2`，再读 stdin；不扫历史 session。
-
-## Claude Code TEXT_LEN: 0 的根因
-
-当 Claude Code Stop Hook 触发但 `TEXT_LEN: 0` 时：
-
-1. **官方字段不存在**：Claude Code Stop Hook 官方 payload 中**没有 `last_assistant_message` 字段**，只有 `transcript_path`
-2. **transcript 文件可能晚一点才写完**：Hook 触发时文件虽已存在，但最后一条 assistant 文本还没落盘
-3. **结果**：如果只读一次，`hook-speak.sh` 可能拿到空串，本次不播报
-
-当前脚本对 Claude transcript 做了很短的轮询，等最后一条 assistant 文本真正出现再播，避免这个时序窗。
+Claude Code 官方文档只列出 `transcript_path`，但实际 payload **包含 `last_assistant_message`**（实测确认）。优先用 direct 字段，无需读 transcript。
 
-这是 **Claude Code 与 Codex 的设计差异**，非 bug。Codex CLI（无论 notify 还是 Stop Hook）都提供 `last_assistant_message`，而 Claude Code 官方只提供 `transcript_path`。
+## 历史演进
 
-解决方案：从 `transcript_path` 读取并解析为最终一条 assistant 回复，并在 Claude 路径上补一个短轮询。
+- v1（250 行）：transcript 轮询 + turn_id 去重 + state file + text hash。复杂度高，`session_id` 做去重 key 导致同一 session 只播第一条。
+- v2（53 行）：省略去重和 transcript 轮询，但 Claude/Codex 分开写提取逻辑。
+- v3（当前，51 行）：统一提取，一行覆盖所有来源。

package/main.go

@@ -40,7 +40,6 @@ var errAlreadyRunning = errors.New("iSpeak already running")
 type StreamPlayer interface {
 	Write(audio []byte) error
 	CloseAndWait() error
-	Abort() error
 }
 
 // 最简单的播放器：channel 队列，串行播报
@@ -55,25 +54,31 @@ type job struct {
 }
 
 func NewPlayer() *Player {
-	p := &Player{ch: make(chan job, 256)}
+	p := &Player{ch: make(chan job, 1)}
 	go p.loop()
 	return p
 }
 
 func (p *Player) Submit(text string, voice VoiceInfo, cfg Config) {
 	log.Printf("TTS: %s", text)
+	// 丢弃队列中的旧消息，只保留最新
+	select {
+	case <-p.ch:
+	default:
+	}
 	p.ch <- job{text, voice, cfg}
 }
 
 func (p *Player) loop() {
+	player, err := newDefaultStreamPlayer()
+	if err != nil {
+		log.Printf("启动播放器失败: %v", err)
+		return
+	}
+	defer player.CloseAndWait()
+
 	for j := range p.ch {
-		player, err := newDefaultStreamPlayer()
-		if err != nil {
-			log.Printf("启动播放器失败: %v", err)
-			continue
-		}
 		p.play(j, player)
-		_ = player.CloseAndWait()
 	}
 }
 
@@ -231,7 +236,7 @@ func synthesizeStream(ctx context.Context, cfg Config, text string, voice *Voice
 		return fmt.Errorf("http request: %w", err)
 	}
 	if resp.StatusCode != 200 {
-		io.Copy(io.Discard, resp.Body) // 消费 body 以释放连接
+		io.Copy(io.Discard, resp.Body)
 		resp.Body.Close()
 		return fmt.Errorf("http status %d", resp.StatusCode)
 	}
@@ -240,28 +245,6 @@ func synthesizeStream(ctx context.Context, cfg Config, text string, voice *Voice
 	return parseSSEStream(resp.Body, onAudio)
 }
 
-// 解析 SSE 流，提取 base64 音频数据
-func parseSSE(r io.Reader) ([]byte, error) {
-	var chunks [][]byte
-	if err := parseSSEStream(r, func(audio []byte) error {
-		chunk := append([]byte(nil), audio...)
-		chunks = append(chunks, chunk)
-		return nil
-	}); err != nil {
-		return nil, err
-	}
-
-	total := 0
-	for _, c := range chunks {
-		total += len(c)
-	}
-	result := make([]byte, 0, total)
-	for _, c := range chunks {
-		result = append(result, c...)
-	}
-	return result, nil
-}
-
 func parseSSEStream(r io.Reader, onAudio func([]byte) error) error {
 	audioChunks := 0
 	reader := bufio.NewReaderSize(r, 64*1024)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdfnet/ispeak",
-  "version": "1.6.15",
+  "version": "1.6.16",
   "description": "Local macOS TTS daemon for AI coding assistants, powered by Volcengine streaming TTS.",
   "license": "MIT",
   "homepage": "https://github.com/xdfnet/iSpeak#readme",

package/scripts/ispeak

@@ -2,7 +2,7 @@
 # ispeak — iSpeak 控制命令
 set -euo pipefail
 
-VERSION="1.6.9"
+VERSION="1.6.16"
 SOCK="$HOME/.config/iSpeak/ispeak.sock"
 PLIST="$HOME/Library/LaunchAgents/com.ispeak.plist"
 LEGACY_PLIST="$HOME/Library/LaunchAgents/com.iSpeak.plist"