talk/cmd/talk/say.go

package main

import (
	"context"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"

	"code.m3ta.dev/m3tam3re/talk/internal/config"
	"code.m3ta.dev/m3tam3re/talk/internal/queue"
	"code.m3ta.dev/m3tam3re/talk/internal/speak"
)

// getenv ist die Env-Seam von run (Tests injizieren hier TALK_AUDIO_SINK,
// TALK_PORT etc., ohne den Prozess-Environment anzufassen). Default:
// os.Getenv.
var getenv = os.Getenv

// sayOptions bündelt die Flags von say (identisch im Default-Pfad
// `talk "Text"`).
type sayOptions struct {
	wait     bool
	now      bool
	priority string
	voice    string
	lang     string
	provider string
}

// runSay ist der say-Eingangspfad: Text aus Argumenten oder stdin sammeln
// und validieren, dann über den Daemon sprechen — non-blocking als
// Default, --wait pollt bis zur Fertigstellung, --now springt vor; Läuft
// kein Daemon, startet talk ihn selbst (daemon.autostart). Geht auch das
// nicht, spricht talk direkt im eigenen Prozess (sayDirect) — ohne
// Warteschlange, aber nie still.
func runSay(args []string, opts *sayOptions, stdin io.Reader, stdout, stderr io.Writer) int {
	text := strings.Join(args, " ")
	if text == "" {
		if isCharDevice(stdin) {
			fmt.Fprintln(stderr, "talk: kein Text — bitte als Argument übergeben oder über stdin pipen")
			return exitUsage
		}
		b, err := io.ReadAll(stdin)
		if err != nil {
			fmt.Fprintf(stderr, "talk: stdin lesen: %v\n", err)
			return exitFailure
		}
		text = strings.TrimSpace(string(b))
		if text == "" {
			fmt.Fprintln(stderr, "talk: kein Text (Argument und stdin sind leer)")
			return exitFailure
		}
	}

	// Validierung vor jedem Daemon-Kontakt (auch wrap erbt die say-Flags):
	// Benutzungsfehler sollen schnell und ohne Netzwerk-Umwege auffallen.
	if code, bad := validateSayOptions(opts, stderr); bad {
		return code
	}

	cfg, err := config.Load(config.Options{Getenv: getenv})
	if err != nil {
		fmt.Fprintf(stderr, "talk: %v\n", err)
		return exitFailure
	}
	return announce(cfg, text, opts, stdout, stderr)
}

// announce ist der gemeinsame Ansage-Weg von say und wrap: Daemon sicher-
// stellen (ggf. starten) und einreihen; ohne Daemon direkt sprechen. info
// ist der Writer für Informations-Token (Item-ID, muted, discarded).
func announce(cfg config.Config, text string, opts *sayOptions, info, stderr io.Writer) int {
	if client, ok := ensureDaemon(cfg, stderr); ok {
		if code, handled := sayViaDaemon(client, text, opts, info, stderr); handled {
			return code
		}
	}
	fmt.Fprintln(stderr, "talk: kein Daemon erreichbar — spreche direkt (ohne Warteschlange)")
	return sayDirect(cfg, text, opts, info, stderr)
}

// sayDirect ist der Notfallpfad ohne Daemon: Mute respektieren (dieselbe
// Datei, die der Daemon liest), dann über den Sprech-Kern sprechen —
// blockierend im CLI-Prozess, unserialisiert (zwei gleichzeitige Aufrufe
// können überlappen; der Daemon ist der Normalfall). Ohne Config-Dir läuft
// es ohne Mute weiter, statt zu scheitern.
func sayDirect(cfg config.Config, text string, opts *sayOptions, info, stderr io.Writer) int {
	if dir, err := config.Dir(getenv); err == nil {
		mute := queue.MuteStore{Path: filepath.Join(dir, queue.MuteFileName)}
		if mute.Muted() {
			fmt.Fprintln(info, "muted")
			fmt.Fprintln(stderr, "talk: stumm geschaltet (mute) — Ansage verworfen")
			return exitOK
		}
	}
	engine, err := speak.New(cfg, getenv, stderr)
	if err != nil {
		fmt.Fprintf(stderr, "talk: %v\n", err)
		return exitFailure
	}
	err = engine.Speak(context.Background(), speak.Request{
		Text:     text,
		Lang:     opts.lang,
		Provider: opts.provider,
		Voice:    opts.voice,
	})
	if err != nil {
		fmt.Fprintf(stderr, "talk: %v\n", err)
		return exitFailure
	}
	return exitOK
}

// validateSayOptions prüft die say-Flags (wrap erbt sie): --lang auf de |
// en, --priority auf low | normal | high. Rückgabe (code, true) heißt:
// Benutzungsfehler, bereits auf stderr gemeldet.
func validateSayOptions(opts *sayOptions, stderr io.Writer) (int, bool) {
	if opts.lang != "" && opts.lang != "de" && opts.lang != "en" {
		fmt.Fprintf(stderr, "talk: --lang: ungültiger Wert %q (erlaubt: de, en)\n", opts.lang)
		return exitFailure, true
	}
	if opts.priority != "" && !queue.Priority(opts.priority).Valid() {
		fmt.Fprintf(stderr, "talk: --priority: ungültiger Wert %q (erlaubt: low, normal, high)\n", opts.priority)
		return exitFailure, true
	}
	return 0, false
}

// isCharDevice meldet, ob r ein Terminal ist (dann darf talk nicht auf
// stdin-Input warten, sondern meldet einen Benutzungsfehler).
func isCharDevice(r io.Reader) bool {
	f, ok := r.(*os.File)
	if !ok {
		return false
	}
	st, err := f.Stat()
	if err != nil {
		return false
	}
	return st.Mode()&os.ModeCharDevice != 0
}