@memef1f1y/dsh-plugin-tts 0.6.0

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@memef1f1y/dsh-plugin-tts",
+  "description": "Edge TTS 语音大集成插件：消息朗读按钮、自动朗读开关、语音设置面板（Edge TTS / RVC / Index-TTS2 / CosyVoice / Google Cloud TTS）",
+  "version": "0.6.0",
+  "type": "module",
+  "engines": {
+    "node": ">=22"
+  },
+  "main": "lib/index.mjs",
+  "exports": {
+    ".": {
+      "default": "./lib/index.mjs"
+    },
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-web": ">=0.1.0-rc.6",
+    "react": "^18.2.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-base": ">=0.1.0-rc.6"
+  },
+  "scripts": {
+    "test": "node tests/smoke.mjs",
+    "test:live": "node tests/rvc-server-live.mjs",
+    "test:patch": "node tests/package-runtime-patch.mjs",
+    "test:i18n": "node tests/i18n-keys.mjs",
+    "test:client": "node tests/client-load.mjs",
+    "test:all": "node tests/smoke.mjs && node tests/rvc-server-live.mjs && node tests/package-runtime-patch.mjs && node tests/i18n-keys.mjs && node tests/client-load.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/1624318455/dsh-plugin-tts.git"
+  },
+  "license": "MIT"
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,7 @@
+allowBuilds:
+  '@deepseek-ai/dsh-subprocess-local': false
+  '@google/genai': false
+  koffi: false
+  node-pty: false
+  protobufjs: false
+autoInstallPeers: true

package/rvc-server.py

@@ -0,0 +1,564 @@
+# rvc-server.py — local RVC voice-conversion HTTP service for dsh-plugin-tts.
+#
+# Runs on the user's machine with ANY RVC-Project WebUI installation (v1/v2).
+# It wraps the RVC inference core (infer/modules/vc) with a tiny JSON API:
+#   GET  /health                 -> service + loaded-model status
+#   POST /load   { model, index? }  -> load a voice pack (model + optional index)
+#   POST /convert{ audio_base64, params } -> convert an audio clip to the voice
+#
+# Protocol is JSON + base64 so no extra deps (python-multipart etc.) are needed.
+# Input audio may be wav or mp3 (mp3 is decoded via the RVC env's bundled ffmpeg).
+#
+# Usage (Windows, RVC WebUI with bundled runtime):
+#   E:\AI\RVC20240604Nvidia\RVC20240604Nvidia\runtime\python.exe rvc-server.py \
+#       --rvc-dir "E:\AI\RVC20240604Nvidia\RVC20240604Nvidia" \
+#       --model "E:\...\assets\weights\azusa-test.pth" \
+#       --index "E:\...\assets\indices\azusa-test_..._v2.index" \
+#       --port 4892
+# Usage (macOS/Linux, portable or manually prepared env):
+#   ~/rvc-work/venv/bin/python ~/rvc-work/rvc-server.py --port 4892
+#   # or: <rvc-dir>/runtime/bin/python <rvc-dir>/rvc-server.py --port 4892
+import argparse
+import binascii
+import io
+import os
+import subprocess
+import sys
+import tempfile
+import threading
+import traceback
+
+BASE = os.path.dirname(os.path.abspath(__file__))
+
+
+def resolve_rvc_dir(value):
+    if value:
+        return os.path.abspath(value)
+    if os.path.exists(os.path.join(BASE, "infer")):
+        return BASE
+    return None
+
+
+ap = argparse.ArgumentParser(description="dsh-plugin-tts RVC inference server")
+ap.add_argument("--port", type=int, default=4892)
+ap.add_argument("--host", default="127.0.0.1")
+ap.add_argument("--device", default="auto", help="cuda:0 / cpu / auto")
+ap.add_argument("--fp32", action="store_true", help="force fp32 (16xx GPUs)")
+ap.add_argument("--rvc-dir", default=None, help="RVC WebUI root (default: script dir if it is one)")
+ap.add_argument("--model", default=None, help="preload model (.pth) path")
+ap.add_argument("--index", default=None, help="preload index (.index) path")
+a = ap.parse_args()
+
+RVC_DIR = resolve_rvc_dir(a.rvc_dir)
+if not RVC_DIR or not os.path.exists(os.path.join(RVC_DIR, "infer")):
+    print("ERROR: cannot locate RVC WebUI root (no infer/ dir). Pass --rvc-dir.", file=sys.stderr)
+    sys.exit(1)
+
+os.chdir(RVC_DIR)
+sys.path.insert(0, RVC_DIR)
+os.environ.setdefault("weight_root", os.path.join(RVC_DIR, "assets", "weights"))
+os.environ.setdefault("index_root", os.path.join(RVC_DIR, "assets", "indices"))
+os.environ.setdefault("rmvpe_root", os.path.join(RVC_DIR, "assets", "rmvpe"))
+
+import numpy as np
+import soundfile as sf
+import torch
+
+# torch >= 2.6 defaults torch.load to weights_only=True, which breaks fairseq's
+# hubert checkpoint loading (contains non-allowlisted globals). All checkpoints
+# here are local + trusted (model .pth, hubert, rmvpe), so restore the legacy
+# behavior. Harmless on older torch.
+_orig_torch_load = torch.load
+
+
+def _tts_torch_load(*args, **kwargs):
+    if "weights_only" not in kwargs:
+        kwargs["weights_only"] = False
+    return _orig_torch_load(*args, **kwargs)
+
+
+torch.load = _tts_torch_load
+
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
+
+from infer.modules.vc.modules import VC
+from infer.modules.vc.pipeline import Pipeline
+from infer.lib.infer_pack.models import (
+    SynthesizerTrnMs256NSFsid,
+    SynthesizerTrnMs256NSFsid_nono,
+    SynthesizerTrnMs768NSFsid,
+    SynthesizerTrnMs768NSFsid_nono,
+)
+
+# --- Index cache -----------------------------------------------------------
+# The RVC pipeline calls faiss.read_index() + index.reconstruct_n() on EVERY
+# convert, re-reading a ~400MB index file from disk each time. For chunked
+# progressive playback that cost is paid per chunk, so we cache the loaded
+# faiss Index objects by path (read_index is the dominant disk cost). The
+# cache is cleared on every /load (the index may have changed).
+try:
+    import faiss as _faiss
+
+    _orig_faiss_read = _faiss.read_index
+    _faiss_index_cache = {}
+    _faiss_lock = threading.Lock()
+
+    def _cached_faiss_read(path, *args, **kwargs):
+        key = os.path.abspath(str(path))
+        with _faiss_lock:
+            idx = _faiss_index_cache.get(key)
+            if idx is None:
+                idx = _orig_faiss_read(path, *args, **kwargs)
+                _faiss_index_cache[key] = idx
+            return idx
+
+    _faiss.read_index = _cached_faiss_read
+
+    def _clear_index_cache():
+        with _faiss_lock:
+            _faiss_index_cache.clear()
+
+    INDEX_CACHE = True
+except Exception as _ie:  # pragma: no cover - faiss always present in RVC env
+    _clear_index_cache = lambda: None
+    INDEX_CACHE = False
+    print("faiss index cache disabled: %s" % _ie, file=sys.stderr)
+
+
+def resolve_device(dev):
+    if dev and dev != "auto":
+        return dev
+    return "cuda:0" if torch.cuda.is_available() else "cpu"
+
+
+class Config:
+    """Minimal config mirroring RVC configs/config.py device_config()."""
+
+    def __init__(self, device, fp32=False):
+        self.device = device
+        if device.startswith("cuda"):
+            self.is_half = True
+            try:
+                name = torch.cuda.get_device_name(int(device.split(":")[-1]))
+                weak = (
+                    ("16" in name and "V100" not in name.upper())
+                    or "P40" in name.upper()
+                    or "P10" in name.upper()
+                    or "1060" in name
+                    or "1070" in name
+                    or "1080" in name
+                )
+            except Exception:
+                weak = False
+            if weak or fp32:
+                self.is_half = False
+                self.x_pad, self.x_query, self.x_center, self.x_max = 1, 6, 38, 41
+            else:
+                self.x_pad, self.x_query, self.x_center, self.x_max = 3, 10, 60, 65
+        else:
+            self.is_half = False
+            self.x_pad, self.x_query, self.x_center, self.x_max = 1, 6, 38, 41
+
+
+config = Config(resolve_device(a.device), fp32=a.fp32)
+vc = VC(config)
+app = FastAPI(title="dsh-plugin-tts RVC server")
+_lock = threading.Lock()
+_state = {"model": None, "index": None}
+
+
+def load_model(model_path, index_path):
+    model_path = os.path.abspath(str(model_path or "").strip().strip('"'))
+    if not os.path.exists(model_path):
+        raise HTTPException(400, "model not found: %s" % model_path)
+    index_path = str(index_path or "").strip().strip('"')
+    if index_path:
+        index_path = os.path.abspath(index_path)
+        if not os.path.exists(index_path):
+            raise HTTPException(400, "index not found: %s" % index_path)
+
+    cpt = torch.load(model_path, map_location="cpu")
+    vc.cpt = cpt
+    vc.tgt_sr = cpt["config"][-1]
+    cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
+    vc.if_f0 = cpt.get("f0", 1)
+    vc.version = cpt.get("version", "v1")
+
+    cls = {
+        ("v1", 1): SynthesizerTrnMs256NSFsid,
+        ("v1", 0): SynthesizerTrnMs256NSFsid_nono,
+        ("v2", 1): SynthesizerTrnMs768NSFsid,
+        ("v2", 0): SynthesizerTrnMs768NSFsid_nono,
+    }.get((vc.version, vc.if_f0), SynthesizerTrnMs256NSFsid)
+
+    vc.net_g = cls(*cpt["config"], is_half=config.is_half)
+    del vc.net_g.enc_q
+    vc.net_g.load_state_dict(cpt["weight"], strict=False)
+    vc.net_g.eval().to(config.device)
+    vc.net_g = vc.net_g.half() if config.is_half else vc.net_g.float()
+    vc.pipeline = Pipeline(vc.tgt_sr, config)
+    vc.hubert_model = None  # lazy-loaded by vc_single
+    vc.index_path = index_path if index_path else ""
+
+    _state["model"] = model_path
+    _state["index"] = vc.index_path
+    print("Loaded model %s (v%s, f0=%s, sr=%s, half=%s)" % (os.path.basename(model_path), vc.version, vc.if_f0, vc.tgt_sr, config.is_half), flush=True)
+
+
+def decode_to_wav(data):
+    """Return a wav file path for the input bytes; decodes mp3/etc via ffmpeg or PyAV.
+
+    The Windows portable runtime ships ffmpeg.exe; macOS/Linux portable builds may
+    not have a bundled ffmpeg, so we fall back to PyAV (already a Python dep in
+    the RVC runtime) to decode and downmix to mono WAV.
+    """
+    if data[:4] == b"RIFF":
+        fd, path = tempfile.mkstemp(suffix=".wav")
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+        return path
+    src = tempfile.mktemp(suffix=".in")
+    with open(src, "wb") as f:
+        f.write(data)
+    dst = tempfile.mktemp(suffix=".wav")
+    ff = os.path.join(RVC_DIR, "ffmpeg.exe") if os.path.exists(os.path.join(RVC_DIR, "ffmpeg.exe")) else "ffmpeg"
+    ffmpeg_err = b""
+    try:
+        r = subprocess.run([ff, "-y", "-i", src, "-ac", "1", dst], capture_output=True)
+        if r.returncode == 0 and os.path.exists(dst):
+            try:
+                os.unlink(src)
+            except OSError:
+                pass
+            return dst
+        ffmpeg_err = r.stderr or b""
+    except FileNotFoundError:
+        ffmpeg_err = b"ffmpeg not found; trying PyAV fallback"
+    except Exception as e:
+        ffmpeg_err = str(e).encode("utf-8", "ignore")
+    # PyAV fallback: self-contained for macOS/Linux portable builds and also
+    # useful when the system has no ffmpeg in PATH.
+    try:
+        import av
+        from av.audio.resampler import AudioResampler
+        with av.open(src) as container:
+            stream = container.streams.audio[0]
+            rate = stream.rate or 44100
+            with av.open(dst, "w", format="wav") as out:
+                out_stream = out.add_stream("pcm_s16le", rate=rate)
+                out_stream.layout = "mono"
+                resampler = AudioResampler(format="s16", layout="mono", rate=rate)
+                for frame in container.decode(stream):
+                    for rf in resampler.resample(frame):
+                        for packet in out_stream.encode(rf):
+                            out.mux(packet)
+                for rf in resampler.resample(None):
+                    for packet in out_stream.encode(rf):
+                        out.mux(packet)
+                for packet in out_stream.encode(None):
+                    out.mux(packet)
+        try:
+            os.unlink(src)
+        except OSError:
+            pass
+        return dst
+    except Exception as e:
+        try:
+            os.unlink(src)
+        except OSError:
+            pass
+        try:
+            os.unlink(dst)
+        except OSError:
+            pass
+        detail = str(e)[-300:]
+        if ffmpeg_err:
+            detail = "%s | PyAV: %s" % (ffmpeg_err.decode("utf-8", "ignore")[-300:], detail)
+        raise HTTPException(400, "audio decode failed: %s" % detail)
+
+
+def b64(data):
+    import base64
+    return base64.b64encode(data).decode("ascii")
+
+
+def unb64(s):
+    import base64
+    try:
+        return base64.b64decode(str(s), validate=False)
+    except (binascii.Error, ValueError) as e:
+        raise HTTPException(400, "invalid audio_base64: %s" % e)
+
+
+def trim_edges(audio, sr, lead_ms=250, tail_ms=700, lead_keep_ms=20, tail_keep_ms=120, thr=0.003, fade_ms=5):
+    """Trim per-chunk edge silence so chunked playback joins seamlessly.
+
+    Edge TTS and the RVC pipeline both leave padding silence at clip edges
+    (measured: ~140ms lead, ~540ms tail per chunk). Played back-to-back those
+    add up to a ~680ms dead gap at every chunk boundary. Trim near-silence
+    below `thr` (default -50dB), keep a short natural breath at each edge, and
+    apply a tiny fade to avoid clicks.
+
+    vc_single returns INT16 audio; integer dtypes are normalized to float
+    [-1, 1] here (sf.write expects float in [-1,1] and would otherwise clip).
+    Returns a float32 array in [-1, 1].
+    """
+    x = np.asarray(audio)
+    if np.issubdtype(x.dtype, np.integer):
+        info = np.iinfo(x.dtype)
+        x = x.astype(np.float32) / float(info.max)
+    else:
+        x = x.astype(np.float32)
+    n = len(x)
+    if n < int(sr * 0.1):
+        return x
+    absx = np.abs(x)
+    lead_n = min(int(sr * lead_ms / 1000), n)
+    tail_n = min(int(sr * tail_ms / 1000), n)
+    lead = 0
+    while lead < lead_n and absx[lead] < thr:
+        lead += 1
+    tail = 0
+    while tail < tail_n and absx[n - 1 - tail] < thr:
+        tail += 1
+    lead = max(0, lead - int(sr * lead_keep_ms / 1000))
+    tail = max(0, tail - int(sr * tail_keep_ms / 1000))
+    if lead == 0 and tail == 0:
+        return x
+    out = np.copy(x[lead: n - tail])
+    fade_n = int(sr * fade_ms / 1000)
+    if fade_n > 0 and len(out) > 2 * fade_n:
+        ramp = np.linspace(0.0, 1.0, fade_n, dtype=np.float32)
+        out[:fade_n] *= ramp
+        out[-fade_n:] *= ramp[::-1]
+    return out
+
+
+@app.get("/health")
+def health():
+    gpu_name = None
+    vram_gb = None
+    if config.device.startswith("cuda") and torch.cuda.is_available():
+        try:
+            dev_idx = int(config.device.split(":")[-1])
+            gpu_name = torch.cuda.get_device_name(dev_idx)
+            vram_gb = round(torch.cuda.get_device_properties(dev_idx).total_memory / (1024 ** 3), 1)
+        except Exception:
+            pass
+    return {
+        "ok": True,
+        "model_loaded": _state["model"] is not None,
+        "model": os.path.basename(_state["model"]) if _state["model"] else None,
+        "index": os.path.basename(_state["index"]) if _state["index"] else None,
+        "device": config.device,
+        "is_half": config.is_half,
+        "cuda_available": torch.cuda.is_available(),
+        "gpu_name": gpu_name,
+        "vram_gb": vram_gb,
+        "index_cache": INDEX_CACHE,
+        "index_cache_entries": len(_faiss_index_cache) if INDEX_CACHE else 0,
+    }
+
+
+def scan_files(kind):
+    """Discover local model/index files so the web UI can pick them by path."""
+    exts = {".pth"} if kind == "pth" else {".index"}
+    roots = [
+        os.environ.get("weight_root", os.path.join(RVC_DIR, "assets", "weights")),
+        os.environ.get("index_root", os.path.join(RVC_DIR, "assets", "indices")),
+    ]
+    logs = os.path.join(RVC_DIR, "logs")
+    if os.path.isdir(logs):
+        roots.append(logs)
+    # the plugin's voice-pack install dir, so downloaded packs show up in the
+    # browse picker (installed files are named <packId>.pth / <packId>.index)
+    pack_root = os.path.expanduser(os.path.join("~", ".dsh", "tts-rvc", "packs"))
+    if os.path.isdir(pack_root):
+        roots.append(pack_root)
+    out = []
+    seen = set()
+    for root in roots:
+        if not os.path.isdir(root):
+            continue
+        for dirpath, _, names in os.walk(root):
+            for n in names:
+                if os.path.splitext(n)[1].lower() in exts:
+                    p = os.path.abspath(os.path.join(dirpath, n))
+                    if p in seen:
+                        continue
+                    seen.add(p)
+                    try:
+                        size = os.path.getsize(p)
+                    except OSError:
+                        size = 0
+                    out.append({"name": n, "path": p, "size": size})
+    out.sort(key=lambda f: f["name"].lower())
+    return out
+
+
+@app.get("/files")
+def files(kind: str = "pth"):
+    if kind not in ("pth", "index"):
+        raise HTTPException(400, "kind must be pth|index")
+    return {"ok": True, "kind": kind, "files": scan_files(kind)}
+
+
+@app.post("/load")
+def load(payload: dict):
+    with _lock:
+        load_model(payload.get("model"), payload.get("index"))
+        _clear_index_cache()  # index may have changed; drop cached faiss objects
+    return {"ok": True, "model": _state["model"], "index": _state["index"]}
+
+
+@app.post("/compact-index")
+def compact_index(payload: dict):
+    """Build a compact index from a big trained index.
+
+    RVC indexes (IVF, ~hundreds of MB) are sub-sampled into a small exact flat
+    index with the SAME metric as the source (RVC trains with index_factory
+    which defaults to L2; the pipeline's square(1/score) weighting is built for
+    L2, so a wrong metric inverts the neighbor ranking). Flat search over the
+    sample is exact over the sample. Output is written next to the source (or
+    into out_dir) and never overwrites it.
+    """
+    src = str(payload.get("index") or "").strip().strip('"')
+    if not src or not os.path.exists(src):
+        raise HTTPException(400, "index not found: %s" % src)
+    try:
+        target = int(payload.get("target_vectors", 10000))
+    except (TypeError, ValueError):
+        target = 10000
+    target = max(500, min(target, 200000))
+    out_dir = str(payload.get("out_dir") or "").strip().strip('"')
+    if not out_dir:
+        out_dir = os.path.dirname(os.path.abspath(src))
+    out_dir = os.path.abspath(out_dir)
+    with _lock:
+        try:
+            idx = _faiss.read_index(src)
+            ntotal = int(idx.ntotal)
+            d = int(idx.d)
+            try:
+                metric = int(getattr(idx, "metric_type", _faiss.METRIC_L2))
+            except Exception:
+                metric = _faiss.METRIC_L2
+            src_size = os.path.getsize(src)
+            if ntotal <= target:
+                return {
+                    "ok": True, "already_small": True,
+                    "path": os.path.abspath(src),
+                    "vectors": ntotal, "source_vectors": ntotal,
+                    "size": src_size, "source_size": src_size,
+                    "reduction_pct": 0.0,
+                }
+            big = idx.reconstruct_n(0, ntotal)
+            rng = np.random.RandomState(42)
+            sample = np.ascontiguousarray(big[rng.permutation(ntotal)[:target]], dtype="float32")
+            new_idx = (
+                _faiss.IndexFlatIP(d) if metric == _faiss.METRIC_INNER_PRODUCT
+                else _faiss.IndexFlatL2(d)
+            )
+            new_idx.add(sample)
+            stem = os.path.splitext(os.path.basename(src))[0]
+            out_path = os.path.join(out_dir, "%s_compact_%d.index" % (stem, target))
+            _faiss.write_index(new_idx, out_path)
+            out_size = os.path.getsize(out_path)
+            return {
+                "ok": True, "path": out_path, "size": out_size,
+                "vectors": target, "source_vectors": ntotal,
+                "source_size": src_size,
+                "reduction_pct": round((1 - out_size / src_size) * 100, 1),
+            }
+        except HTTPException:
+            raise
+        except Exception as e:
+            return JSONResponse(
+                status_code=500,
+                content={"code": "compact_index_error",
+                         "message": "%s\n%s" % (e, traceback.format_exc()[-600:])},
+            )
+
+
+@app.post("/convert")
+def convert(payload: dict):
+    if _state["model"] is None:
+        raise HTTPException(400, "no model loaded; call /load first")
+    audio_b64 = payload.get("audio_base64")
+    if not audio_b64:
+        raise HTTPException(400, "audio_base64 required")
+    p = payload.get("params") or {}
+    spk_id = int(p.get("spk_id", 0))
+    f0_file = str(p.get("f0_file") or "").strip().strip('"')
+    f0_up_key = int(p.get("f0_up_key", 0))
+    f0_method = str(p.get("f0_method", "rmvpe"))
+    # validate early so a bad f0_method never reaches infer (which crashes with
+    # an UnboundLocalError and a 500). Keep the RVC f0 method set.
+    _F0_METHODS = {"rmvpe", "pm", "harvest", "crepe", "rmvpe+", "mangio-crepe", "fcpe"}
+    if f0_method not in _F0_METHODS:
+        raise HTTPException(400, "unknown f0_method: %r (expected one of %s)" % (f0_method, sorted(_F0_METHODS)))
+    index_rate = float(p.get("index_rate", 0.75))
+    filter_radius = int(p.get("filter_radius", 3))
+    resample_sr = int(p.get("resample_sr", 40000))
+    rms_mix_rate = float(p.get("rms_mix_rate", 0.25))
+    protect = float(p.get("protect", 0.33))
+
+    with _lock:
+        try:
+            data = unb64(audio_b64)
+            wav_path = decode_to_wav(data)
+            try:
+                # Validate the decoded audio is actually decodable + has samples.
+                # Without this, an empty/corrupt wav falls through to infer's
+                # load_audio which dies with a RuntimeError -> 500. Treat it as
+                # a client error (400) instead.
+                try:
+                    with sf.SoundFile(wav_path) as s:
+                        frames = s.frames
+                except Exception:
+                    frames = 0
+                if frames <= 0:
+                    raise HTTPException(400, "audio decode failed: empty or unreadable audio")
+                # pipeline expects f0_file to be an object with a `.name` path
+                f0_handle = (
+                    type("F0File", (), {"name": os.path.abspath(f0_file)})()
+                    if f0_file
+                    else None
+                )
+                # file_index="" + file_index2=<index> bypasses the WebUI's
+                # "trained"->"added" auto-rewrite; empty index = index-free mode.
+                info, opt = vc.vc_single(
+                    spk_id, wav_path, f0_up_key, f0_handle, f0_method,
+                    "", _state["index"], index_rate,
+                    filter_radius, resample_sr, rms_mix_rate, protect,
+                )
+            finally:
+                try:
+                    os.unlink(wav_path)
+                except OSError:
+                    pass
+            if opt is None or opt[0] is None:
+                raise HTTPException(500, "inference failed: %s" % str(info)[-500:])
+            tgt_sr, audio = opt
+            audio = trim_edges(audio, int(tgt_sr))
+            buf = io.BytesIO()
+            sf.write(buf, audio, int(tgt_sr), format="wav")
+            return {"audio_base64": b64(buf.getvalue()), "sample_rate": int(tgt_sr)}
+        except HTTPException:
+            raise
+        except Exception as e:
+            return JSONResponse(
+                status_code=500,
+                content={"code": "inference_error", "message": "%s\n%s" % (e, traceback.format_exc()[-600:])},
+            )
+
+
+if a.model:
+    print("Preloading model...", flush=True)
+    load_model(a.model, a.index or "")
+
+if __name__ == "__main__":
+    import uvicorn
+    print("dsh-plugin-tts RVC server: http://%s:%d  (device=%s, half=%s)" % (a.host, a.port, config.device, config.is_half), flush=True)
+    uvicorn.run(app, host=a.host, port=a.port, log_level="warning")

package/tests/README.md

@@ -0,0 +1,45 @@
+# 测试标准（dsh-plugin-tts）
+
+统一测试入口，分三层：**烟测（smoke）→ 场景+边界（live）→（可选）真实链路**。
+所有测试用 `node` 跑，`PASS/FAIL` 逐行输出 + 末尾汇总 + 退出码（0=全过，1=有失败）。
+
+## 快速开始
+
+```bash
+npm test            # 烟测：43 项，纯 mock + 真实 Edge TTS，无需本地 RVC 服务
+npm run test:live   # 场景 + 边界：需要本地 rvc-server.py（可自启），见下
+npm run test:patch  # 边界：package-runtime.py 的 darwin PyAV 补丁逻辑（纯临时目录，无需 RVC）
+npm run test:i18n   # i18n 回归：所有 t(key) 都有中英文、无缺失/多余、UI 无残留硬编码中文
+npm run test:client # 客户端加载+渲染：mock 浏览器环境跑 lib/client.js，验证国际化后 UI 不崩
+npm run test:all    # 以上全部
+```
+
+## 各层说明
+
+| 层 | 文件 | 依赖 | 覆盖 |
+|---|---|---|---|
+| 烟测 | `tests/smoke.mjs` (`npm test`) | 无需本地 RVC；会用真实 Edge TTS 联网合成 | 路由注册、Edge 合成、mock RVC 链路、分块渐进播放、文件代理、compact-index 代理、诊断、音色包注册表（sha256/代理/进度/多索引/卸载）、make-pack 工具 |
+| 场景+边界 | `tests/rvc-server-live.mjs` (`npm run test:live`) | 本地 RVC 服务（见下） | 真实 `health/files/load/convert/compact-index` 场景 + 协议边界（坏 base64、空音频、未知 f0_method、缺失模型/索引、并发转换、未知路由） |
+| 打包边界 | `tests/package-runtime-patch.mjs` (`npm run test:patch`) | 仅 python3（临时目录） | `package-runtime.py` 的 darwin PyAV 补丁：`av.open` `rb/wb→r/w`、不动 Python `open(file,"rb")`、幂等 |
+| i18n 回归 | `tests/i18n-keys.mjs` (`npm run test:i18n`) | 无 | 中英文词典键集一致、所有 `t(key)` 有双语定义、UI 区无残留硬编码中文、无死键 |
+| 客户端加载/渲染 | `tests/client-load.mjs` (`npm run test:client`) | 无（mock 浏览器） | `lib/client.js` 在 mock 环境加载、`apply()` 运行、4 个组件（auto-read/read/xml/设置面板）渲染不抛错 |
+
+## test:live 的环境约定（跨平台友好）
+
+`tests/rvc-server-live.mjs` 是**环境感知**的：
+
+- 优先连已运行的服务：`RVC_URL`（默认 `http://127.0.0.1:4892`）；
+- 没有服务时，尝试从 `RVC_WORK`（默认 `~/rvc-work`，macOS 实测目录）用
+  `venv/bin/python rvc-server.py` 自启；
+- 两者都不可用时打印 `SKIP` 并以 0 退出（CI 安全，不会误报失败）。
+
+```bash
+RVC_URL=http://127.0.0.1:4892 npm run test:live   # 连已启动的服务
+RVC_WORK=/path/to/rvc-work npm run test:live      # 指定工作目录
+```
+
+## 历史遗留
+
+`tests/e2e-*.mjs`（`e2e-real-rvc` / `e2e-index-ab` / `e2e-compact-index`）是
+**为 Windows 一次性写的真实链路脚本**（硬编码 `E:/AI/.../azusa-test.pth`），不可移植，
+已被 `tests/rvc-server-live.mjs` 取代并标记 deprecated，仅作 Windows 参考保留。