@xdfnet/ispeak 1.6.10 → 1.6.12

package/main.go

@@ -47,199 +47,81 @@ type StreamPlayer interface {
 	Abort() error
 }
 
-// 任务状态
-// 生命周期：pending -> running -> delete
-type TaskStatus int
-
-const (
-	TaskStatusPending TaskStatus = iota
-	TaskStatusRunning
-)
-
-// 单个 TTS 任务
-type Task struct {
-	ID     uint64
-	Text   string
-	Status TaskStatus
-	Voice  VoiceInfo
-	Cfg    Config
-}
-
-// 任务引擎：任务仓库 + 单事务 worker
-type TaskEngine struct {
-	mu sync.Mutex
-
-	nextID   uint64
-	latestID uint64
-	tasks    map[uint64]*Task
-	pending  []uint64
-
-	wake chan struct{}
-
-	synthesizeStreamFn func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error
-	newStreamPlayerFn  func() (StreamPlayer, error)
-}
-
-func NewTaskEngine() *TaskEngine {
-	return &TaskEngine{
-		tasks:              make(map[uint64]*Task),
-		wake:               make(chan struct{}, 1),
-		synthesizeStreamFn: synthesizeStream,
-		newStreamPlayerFn:  newDefaultStreamPlayer,
-	}
+// 单播放器：新的打断旧的，不用队列
+type Player struct {
+	mu        sync.Mutex
+	gen       int64
+	currentGen int64
+	player    StreamPlayer
 }
 
-func (e *TaskEngine) Start() {
-	go e.transactionWorker()
+func NewPlayer() *Player {
+	return &Player{}
 }
 
-func (e *TaskEngine) Submit(text string, voice VoiceInfo, cfg Config) uint64 {
-	e.mu.Lock()
-
-	// 新任务进来先删所有未开始的任务。
-	for _, id := range e.pending {
-		delete(e.tasks, id)
-		log.Printf("删除待执行任务: id=%d", id)
-	}
-	e.pending = e.pending[:0]
-
-	e.nextID++
-	task := &Task{
-		ID:     e.nextID,
-		Text:   text,
-		Status: TaskStatusPending,
-		Voice:  voice,
-		Cfg:    cfg,
-	}
-	e.tasks[task.ID] = task
-	e.latestID = task.ID
-	e.pending = append(e.pending, task.ID)
-	log.Printf("任务创建: id=%d text=%s", task.ID, text)
-
-	notify(e.wake)
-	e.mu.Unlock()
-
-	return task.ID
-}
+func (p *Player) Submit(text string, voice VoiceInfo, cfg Config) {
+	p.mu.Lock()
+	p.gen++
+	currentGen := p.gen
+	p.player = nil
 
-func (e *TaskEngine) transactionWorker() {
-	for {
-		id := e.claimPending()
-		if id == 0 {
-			<-e.wake
-			continue
-		}
-
-		e.processTransaction(id)
-	}
-}
-
-func (e *TaskEngine) processTransaction(id uint64) {
-	defer func() {
-		if r := recover(); r != nil {
-			log.Printf("播报任务崩溃并删除: id=%d err=%v", id, r)
-			e.deleteTask(id)
-		}
-	}()
-
-	task, ok := e.getTask(id)
-	if !ok {
-		return
-	}
-	if !e.isLatestTask(id) {
-		log.Printf("跳过过期播报任务: id=%d", id)
-		e.deleteTask(id)
-		return
-	}
-
-	if err := e.runTransaction(task); err != nil {
-		log.Printf("播报失败并删除任务: id=%d err=%v", id, err)
-		e.deleteTask(id)
+	player, err := newDefaultStreamPlayer()
+	if err != nil {
+		log.Printf("启动播放器失败: %v", err)
+		p.mu.Unlock()
 		return
 	}
+	p.player = player
+	log.Printf("TTS: %s", text)
 
-	log.Printf("播报完成并删除任务: id=%d", id)
-	e.deleteTask(id)
-}
-
-func (e *TaskEngine) runTransaction(task *Task) error {
 	startedAt := time.Now()
-	player, err := e.newStreamPlayerFn()
-	if err != nil {
-		return fmt.Errorf("启动播放器失败: %w", err)
-	}
-
-	firstChunkLogged := false
-	onAudio := func(audio []byte) error {
-		if len(audio) > 0 && !firstChunkLogged {
-			firstChunkLogged = true
-			log.Printf("首个音频 chunk: id=%d elapsed=%s bytes=%d", task.ID, time.Since(startedAt).Round(time.Millisecond), len(audio))
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("播报崩溃: %v", r)
+			}
+		}()
+
+		onAudio := func(audio []byte) error {
+			p.mu.Lock()
+			stale := currentGen != p.gen
+			p.mu.Unlock()
+			if stale {
+				return errors.New("stale")
+			}
+			if err := player.Write(audio); err != nil {
+				return err
+			}
+			if len(audio) > 0 {
+				log.Printf("首个音频 chunk elapsed=%s bytes=%d", time.Since(startedAt).Round(time.Millisecond), len(audio))
+			}
+			return nil
 		}
-		return player.Write(audio)
-	}
-
-	if err := e.synthesizeStreamFn(context.Background(), task.Cfg, task.Text, &task.Voice, onAudio); err != nil {
-		_ = player.Abort()
-		return fmt.Errorf("TTS 合成失败: id=%d: %w", task.ID, err)
-	}
-	log.Printf("TTS 流结束: id=%d elapsed=%s", task.ID, time.Since(startedAt).Round(time.Millisecond))
 
-	if err := player.CloseAndWait(); err != nil {
-		_ = player.Abort()
-		return fmt.Errorf("播放器失败: id=%d: %w", task.ID, err)
-	}
-	return nil
-}
-
-func (e *TaskEngine) claimPending() uint64 {
-	e.mu.Lock()
-	defer e.mu.Unlock()
+		if err := synthesizeStream(context.Background(), cfg, text, &voice, onAudio); err != nil {
+			if !strings.Contains(err.Error(), "stale") {
+				log.Printf("TTS 合成失败: %v", err)
+			}
+			_ = player.Abort()
+			p.mu.Lock()
+			if p.player == player {
+				p.player = nil
+			}
+			p.mu.Unlock()
+			return
+		}
 
-	for len(e.pending) > 0 {
-		id := e.pending[0]
-		e.pending = e.pending[1:]
-		task, ok := e.tasks[id]
-		if !ok {
-			continue
+		log.Printf("TTS 流结束 elapsed=%s", time.Since(startedAt).Round(time.Millisecond))
+		if err := player.CloseAndWait(); err != nil {
+			log.Printf("播放器失败: %v", err)
 		}
-		if task.Status != TaskStatusPending {
-			continue
+		p.mu.Lock()
+		if p.player == player {
+			p.player = nil
 		}
-		task.Status = TaskStatusRunning
-		return id
-	}
-	return 0
-}
-
-func (e *TaskEngine) getTask(id uint64) (*Task, bool) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-
-	task, ok := e.tasks[id]
-	if !ok {
-		return nil, false
-	}
-	clone := *task
-	return &clone, true
-}
-
-func (e *TaskEngine) deleteTask(id uint64) {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	delete(e.tasks, id)
-}
-
-func (e *TaskEngine) isLatestTask(id uint64) bool {
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	return e.latestID == id
-}
-
-func notify(ch chan struct{}) {
-	select {
-	case ch <- struct{}{}:
-	default:
-	}
+		p.mu.Unlock()
+	}()
+	p.mu.Unlock()
 }
 
 // 音色信息
@@ -601,8 +483,7 @@ func main() {
 		listener.Close()
 	}()
 
-	engine := NewTaskEngine()
-	engine.Start()
+	player := NewPlayer()
 
 	log.Printf("iSpeak 已启动，监听 %s", socketPath)
 	for {
@@ -613,7 +494,7 @@ func main() {
 			}
 			continue
 		}
-		go handleConnection(conn, engine)
+		go handleConnection(conn, player)
 	}
 }
 
@@ -694,7 +575,7 @@ func validateVoiceInfo(name string, voice *VoiceInfo) error {
 	return nil
 }
 
-func handleConnection(conn net.Conn, engine *TaskEngine) {
+func handleConnection(conn net.Conn, player *Player) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Printf("连接处理崩溃: %v", r)
@@ -741,8 +622,7 @@ func handleConnection(conn net.Conn, engine *TaskEngine) {
 		return
 	}
 
-	log.Printf("TTS: %s", cleaned)
-	engine.Submit(cleaned, *voice, cfg)
+	player.Submit(cleaned, *voice, cfg)
 }
 
 // 解析消息中的音色前缀，返回 VoiceInfo

package/main_test.go

@@ -1,234 +1,16 @@
 package main
 
 import (
-	"context"
 	"encoding/base64"
 	"errors"
 	"net"
 	"os"
 	"path/filepath"
 	"strings"
-	"sync"
 	"testing"
 	"time"
 )
 
-func TestSubmitClearsPendingOnly(t *testing.T) {
-	e := NewTaskEngine()
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		return onAudio([]byte("ok"))
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-
-	e.Submit("a", voice, cfg)
-	e.Submit("b", voice, cfg)
-
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	if len(e.pending) != 1 {
-		t.Fatalf("expected 1 pending, got %d", len(e.pending))
-	}
-	id := e.pending[0]
-	task, ok := e.tasks[id]
-	if !ok {
-		t.Fatalf("expected pending task exists")
-	}
-	if task.Text != "b" {
-		t.Fatalf("expected latest task text b, got %s", task.Text)
-	}
-}
-
-func TestTransactionDeletesOnSynthesisFailureWithoutRetry(t *testing.T) {
-	e := NewTaskEngine()
-	var mu sync.Mutex
-	calls := 0
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		mu.Lock()
-		defer mu.Unlock()
-		calls++
-		return errors.New("fail")
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	id := e.Submit("x", voice, cfg)
-
-	waitFor(t, 2*time.Second, func() bool {
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		_, ok := e.tasks[id]
-		return !ok
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if calls != 1 {
-		t.Fatalf("expected synth attempts=1, got %d", calls)
-	}
-}
-
-func TestTransactionDeletesOnPlayerWriteFailureWithoutRetry(t *testing.T) {
-	e := NewTaskEngine()
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		return onAudio([]byte("audio"))
-	}
-	var mu sync.Mutex
-	calls := 0
-	e.newStreamPlayerFn = func() (StreamPlayer, error) {
-		mu.Lock()
-		defer mu.Unlock()
-		calls++
-		return &fakeStreamPlayer{writeErr: calls == 1}, nil
-	}
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	id := e.Submit("x", voice, cfg)
-
-	waitFor(t, 2*time.Second, func() bool {
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		_, ok := e.tasks[id]
-		return !ok
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if calls != 1 {
-		t.Fatalf("expected player attempts=1, got %d", calls)
-	}
-}
-
-func TestSubmitDoesNotInterruptRunningTask(t *testing.T) {
-	e := NewTaskEngine()
-	start := make(chan struct{}, 1)
-	release := make(chan struct{})
-	var mu sync.Mutex
-	processed := make([]string, 0, 2)
-
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		if text == "a" {
-			start <- struct{}{}
-		}
-		if text == "a" {
-			<-release
-		}
-		mu.Lock()
-		processed = append(processed, text)
-		mu.Unlock()
-		return onAudio([]byte(text))
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	e.Submit("a", voice, cfg)
-	<-start // a 已进入 running
-	secondID := e.Submit("b", voice, cfg)
-
-	e.mu.Lock()
-	if len(e.pending) != 1 || e.pending[0] != secondID {
-		t.Fatalf("expected second task pending while first keeps running, got %#v", e.pending)
-	}
-	e.mu.Unlock()
-
-	close(release)
-
-	waitFor(t, 3*time.Second, func() bool {
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		return len(e.tasks) == 0
-	})
-
-	mu.Lock()
-	defer mu.Unlock()
-	if strings.Join(processed, "") != "ab" {
-		t.Fatalf("expected processed [a b], got %#v", processed)
-	}
-}
-
-func TestClaimedStaleTaskIsSkippedBeforeTransaction(t *testing.T) {
-	e := NewTaskEngine()
-	calls := 0
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		calls++
-		return onAudio([]byte(text))
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	firstID := e.Submit("a", voice, cfg)
-	claimedID := e.claimPending()
-	if claimedID != firstID {
-		t.Fatalf("expected claimed first task %d, got %d", firstID, claimedID)
-	}
-	e.Submit("b", voice, cfg)
-
-	e.processTransaction(firstID)
-
-	if calls != 0 {
-		t.Fatalf("expected stale task skipped before transaction, got calls=%d", calls)
-	}
-	e.mu.Lock()
-	_, firstExists := e.tasks[firstID]
-	e.mu.Unlock()
-	if firstExists {
-		t.Fatalf("expected stale task deleted")
-	}
-}
-
-func TestSynthesisPanicDeletesTaskAndWorkerContinues(t *testing.T) {
-	e := NewTaskEngine()
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		if text == "panic" {
-			panic("boom")
-		}
-		return onAudio([]byte(text))
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	panicID := e.Submit("panic", voice, cfg)
-	waitForTaskDeleted(t, e, panicID)
-
-	okID := e.Submit("ok", voice, cfg)
-	waitForTaskDeleted(t, e, okID)
-}
-
-func TestPlaybackPanicDeletesTaskAndWorkerContinues(t *testing.T) {
-	e := NewTaskEngine()
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		return onAudio([]byte(text))
-	}
-	var mu sync.Mutex
-	calls := 0
-	e.newStreamPlayerFn = func() (StreamPlayer, error) {
-		mu.Lock()
-		defer mu.Unlock()
-		calls++
-		return &fakeStreamPlayer{panicOnWrite: calls == 1}, nil
-	}
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	panicID := e.Submit("panic", voice, cfg)
-	waitForTaskDeleted(t, e, panicID)
-
-	okID := e.Submit("ok", voice, cfg)
-	waitForTaskDeleted(t, e, okID)
-}
-
 func TestParseSSEStreamWritesChunksInOrder(t *testing.T) {
 	stream := strings.NewReader(
 		"data: {\"audio\":\"YQ==\"}\n\n" +
@@ -474,96 +256,6 @@ func TestCleanTextSingleLineArtifactDoesNotSwallowFollowingText(t *testing.T) {
 	}
 }
 
-func TestHandleConnectionPreservesMultilineBeforeCleaning(t *testing.T) {
-	oldConfigDir := configDir
-	oldCacheValid := configCacheValid
-	oldCachePath := configCachePath
-	oldCacheModTime := configCacheModTime
-	oldCache := configCache
-	t.Cleanup(func() {
-		configDir = oldConfigDir
-		configCacheValid = oldCacheValid
-		configCachePath = oldCachePath
-		configCacheModTime = oldCacheModTime
-		configCache = oldCache
-	})
-
-	dir := t.TempDir()
-	configDir = dir
-	configCacheValid = false
-	cfg := `{
-		"apiKey": "key",
-		"endpoint": "https://example.com/tts",
-		"defaultVoice": {"voice_type": "voice", "resourceId": "resource"}
-	}`
-	if err := os.WriteFile(filepath.Join(dir, "config.json"), []byte(cfg), 0644); err != nil {
-		t.Fatalf("write config: %v", err)
-	}
-
-	server, client := net.Pipe()
-	e := NewTaskEngine()
-	done := make(chan struct{})
-	go func() {
-		handleConnection(server, e)
-		close(done)
-	}()
-
-	msg := strings.Join([]string{
-		"不是，飞哥。",
-		"",
-		"| 部分 | 是否常驻 |",
-		"|---|---|",
-		"| ispeakd | 是 |",
-		"",
-		"也就是说：daemon 常驻，播放器不是常驻。",
-	}, "\n")
-	if _, err := client.Write([]byte(msg)); err != nil {
-		t.Fatalf("write client: %v", err)
-	}
-	if err := client.Close(); err != nil {
-		t.Fatalf("close client: %v", err)
-	}
-	select {
-	case <-done:
-	case <-time.After(time.Second):
-		t.Fatalf("handleConnection did not return")
-	}
-
-	e.mu.Lock()
-	defer e.mu.Unlock()
-	if len(e.pending) != 1 {
-		t.Fatalf("expected one pending task, got %d", len(e.pending))
-	}
-	task := e.tasks[e.pending[0]]
-	if !strings.Contains(task.Text, "不是，飞哥。") ||
-		!strings.Contains(task.Text, "也就是说：daemon 常驻，播放器不是常驻。") {
-		t.Fatalf("expected surrounding text preserved, got %q", task.Text)
-	}
-	if strings.Contains(task.Text, "是否常驻") || strings.Contains(task.Text, "ispeakd | 是") {
-		t.Fatalf("expected table removed, got %q", task.Text)
-	}
-}
-
-func TestInvalidSSEAudioDeletesTaskAndWorkerContinues(t *testing.T) {
-	e := NewTaskEngine()
-	e.synthesizeStreamFn = func(ctx context.Context, cfg Config, text string, voice *VoiceInfo, onAudio func([]byte) error) error {
-		if text == "bad" {
-			return parseSSEStream(strings.NewReader("data: {\"audio\":\"***\"}\n\n"), onAudio)
-		}
-		return onAudio([]byte(text))
-	}
-	e.newStreamPlayerFn = newFakeStreamPlayerFactory()
-	e.Start()
-
-	cfg := Config{}
-	voice := VoiceInfo{VoiceType: "v", ResourceID: "r"}
-	badID := e.Submit("bad", voice, cfg)
-	waitForTaskDeleted(t, e, badID)
-
-	okID := e.Submit("ok", voice, cfg)
-	waitForTaskDeleted(t, e, okID)
-}
-
 func TestValidateConfigRequiresDefaultVoiceResourceID(t *testing.T) {
 	cfg := Config{
 		APIKey:   "key",
@@ -600,59 +292,6 @@ func TestValidateConfigRequiresSourceVoiceResourceID(t *testing.T) {
 	}
 }
 
-type fakeStreamPlayer struct {
-	writeErr     bool
-	closeErr     bool
-	panicOnWrite bool
-	chunks       [][]byte
-	aborted      bool
-	closed       bool
-	closeBlock   chan struct{}
-	closeStarted chan struct{}
-	closeOnce    sync.Once
-}
-
-func newFakeStreamPlayerFactory() func() (StreamPlayer, error) {
-	return func() (StreamPlayer, error) {
-		return &fakeStreamPlayer{}, nil
-	}
-}
-
-func (p *fakeStreamPlayer) Write(audio []byte) error {
-	if p.panicOnWrite {
-		panic("boom")
-	}
-	if p.writeErr {
-		return errors.New("write failed")
-	}
-	p.chunks = append(p.chunks, append([]byte(nil), audio...))
-	return nil
-}
-
-func (p *fakeStreamPlayer) CloseAndWait() error {
-	p.closed = true
-	if p.closeStarted != nil {
-		p.closeStarted <- struct{}{}
-	}
-	if p.closeBlock != nil {
-		<-p.closeBlock
-	}
-	if p.closeErr {
-		return errors.New("close failed")
-	}
-	return nil
-}
-
-func (p *fakeStreamPlayer) Abort() error {
-	p.aborted = true
-	if p.closeBlock != nil {
-		p.closeOnce.Do(func() {
-			close(p.closeBlock)
-		})
-	}
-	return nil
-}
-
 func TestListenUnixSocketRemovesStalePath(t *testing.T) {
 	socketPath := shortSocketPath(t)
 	if err := os.WriteFile(socketPath, []byte("stale"), 0644); err != nil {
@@ -727,25 +366,3 @@ func shortSocketPath(t *testing.T) string {
 	})
 	return filepath.Join(dir, "sock")
 }
-
-func waitForTaskDeleted(t *testing.T, e *TaskEngine, id uint64) {
-	t.Helper()
-	waitFor(t, 2*time.Second, func() bool {
-		e.mu.Lock()
-		defer e.mu.Unlock()
-		_, ok := e.tasks[id]
-		return !ok
-	})
-}
-
-func waitFor(t *testing.T, timeout time.Duration, fn func() bool) {
-	t.Helper()
-	deadline := time.Now().Add(timeout)
-	for time.Now().Before(deadline) {
-		if fn() {
-			return
-		}
-		time.Sleep(10 * time.Millisecond)
-	}
-	t.Fatalf("condition not met within %s", timeout)
-}

package/package.json

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