@co0ontty/wand 4.97.0 → 4.98.0

package/dist/speech-service.js

@@ -1,420 +0,0 @@
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { constants, createReadStream } from "node:fs";
-import { access, mkdir, open, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { buildChildEnv, systemEnvValue } from "./env-utils.js";
-import { SPEECH_MODELS, speechModel, speechModelUrl } from "./speech-models.js";
-import { SPEECH_MAX_SECONDS, SPEECH_MAX_WAV_BYTES, SPEECH_SAMPLE_RATE } from "./speech-types.js";
-import { configTemporaryRoot, createManagedTemporary, registerTemporaryChild } from "./managed-temp.js";
-export const SPEECH_SETTINGS_KEY = "pref:speechRecognition";
-export class SpeechError extends Error {
-    code;
-    status;
-    constructor(code, message, status = 400) {
-        super(message);
-        this.code = code;
-        this.status = status;
-    }
-}
-export function defaultSpeechSettings() {
-    return { enabled: false, model: "base", acceleration: "auto", language: "auto", threads: Math.max(1, Math.min(4, os.availableParallelism() - 1)) };
-}
-export function parseSpeechSettings(value, previous = defaultSpeechSettings()) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new SpeechError("INVALID_SETTINGS", "语音配置无效。");
-    const patch = value;
-    if (Object.keys(patch).some((key) => !["enabled", "model", "acceleration", "language", "threads"].includes(key))) {
-        throw new SpeechError("INVALID_SETTINGS", "不支持的语音配置项。");
-    }
-    const settings = { ...previous, ...patch };
-    if (typeof settings.enabled !== "boolean" || !speechModel(settings.model)
-        || !["auto", "cpu", "gpu"].includes(settings.acceleration) || !["auto", "zh", "en"].includes(settings.language)
-        || !Number.isInteger(settings.threads) || settings.threads < 1 || settings.threads > 16) {
-        throw new SpeechError("INVALID_SETTINGS", "请选择有效模型、运行设备、语言与 1–16 个 CPU 线程。");
-    }
-    return settings;
-}
-/** Strict canonical WAV; all clients encode this exact shape. No decoder/ffmpeg needed on the host. */
-export function validateSpeechWav(audio) {
-    if (audio.length < 44 + 3200 || audio.length > SPEECH_MAX_WAV_BYTES
-        || audio.toString("ascii", 0, 4) !== "RIFF" || audio.readUInt32LE(4) !== audio.length - 8
-        || audio.toString("ascii", 8, 12) !== "WAVE" || audio.toString("ascii", 12, 16) !== "fmt "
-        || audio.readUInt32LE(16) !== 16 || audio.readUInt16LE(20) !== 1 || audio.readUInt16LE(22) !== 1
-        || audio.readUInt32LE(24) !== SPEECH_SAMPLE_RATE || audio.readUInt32LE(28) !== SPEECH_SAMPLE_RATE * 2
-        || audio.readUInt16LE(32) !== 2 || audio.readUInt16LE(34) !== 16
-        || audio.toString("ascii", 36, 40) !== "data" || audio.readUInt32LE(40) !== audio.length - 44
-        || (audio.length - 44) % 2 !== 0) {
-        throw new SpeechError("INVALID_AUDIO", "请上传 0.1–60 秒、16 kHz 单声道 PCM16 WAV 音频。");
-    }
-    let peak = 0;
-    for (let offset = 44; offset < audio.length; offset += 2)
-        peak = Math.max(peak, Math.abs(audio.readInt16LE(offset)));
-    return { samples: (audio.length - 44) / 2, silent: peak < 160 };
-}
-async function fileHash(file) {
-    const hash = createHash("sha256");
-    for await (const chunk of createReadStream(file))
-        hash.update(chunk);
-    return hash.digest("hex");
-}
-/** A single bounded job per host avoids CPU/RAM amplification. Audio is temporary, never history. */
-export class SpeechService {
-    storage;
-    options;
-    root;
-    models;
-    verified = new Map();
-    verifying = new Map();
-    download = null;
-    downloadAbort = null;
-    active = null;
-    disposed = false;
-    maintenance = false;
-    initialized = new Set();
-    configurationRevision = 0;
-    constructor(storage, configDir, options = {}) {
-        this.storage = storage;
-        this.options = options;
-        this.root = path.join(configDir, "speech");
-        this.models = options.models ?? SPEECH_MODELS;
-    }
-    settings() {
-        try {
-            return parseSpeechSettings(this.storage.getPreference(SPEECH_SETTINGS_KEY, {}));
-        }
-        catch {
-            return defaultSpeechSettings();
-        }
-    }
-    configure(patch) {
-        const settings = parseSpeechSettings(patch, this.settings());
-        this.storage.setPreference(SPEECH_SETTINGS_KEY, settings);
-        this.configurationRevision += 1;
-        return settings;
-    }
-    settingsRevision() { return this.configurationRevision; }
-    acquireMaintenance() {
-        if (this.disposed)
-            throw new SpeechError("UNAVAILABLE", "语音服务已关闭。", 503);
-        if (this.active || this.downloadAbort || this.maintenance)
-            throw new SpeechError("BUSY", "语音识别或模型下载正在进行，请稍后初始化。", 409);
-        this.maintenance = true;
-    }
-    releaseMaintenance() { this.maintenance = false; }
-    /** Explicit admin health check loads the selected model using synthetic silence, without enabling it. */
-    async initializeModel(id, signal, acceleration = this.settings().acceleration) {
-        const model = this.models.find((value) => value.id === id);
-        if (!model)
-            throw new SpeechError("INVALID_MODEL", "模型不存在。");
-        const runtime = await this.runtime();
-        if (!runtime.executable || !await this.modelReady(model))
-            throw new SpeechError("NOT_READY", "请先下载模型并安装语音运行时。", 503);
-        signal.throwIfAborted();
-        const temporary = createManagedTemporary("speech-check", configTemporaryRoot(path.dirname(this.root)));
-        const directory = temporary.directory;
-        try {
-            const wav = Buffer.alloc(8044);
-            wav.write("RIFF");
-            wav.writeUInt32LE(wav.length - 8, 4);
-            wav.write("WAVEfmt ", 8);
-            wav.writeUInt32LE(16, 16);
-            wav.writeUInt16LE(1, 20);
-            wav.writeUInt16LE(1, 22);
-            wav.writeUInt32LE(16000, 24);
-            wav.writeUInt32LE(32000, 28);
-            wav.writeUInt16LE(2, 32);
-            wav.writeUInt16LE(16, 34);
-            wav.write("data", 36);
-            wav.writeUInt32LE(8000, 40);
-            const input = path.join(directory, "check.wav"), output = path.join(directory, "check");
-            await writeFile(input, wav, { mode: 0o600 });
-            const args = ["-m", this.modelPath(model), "-f", input, "-of", output, "-otxt", "-nt", "-l", "en", "-t", String(this.settings().threads)];
-            const cpu = acceleration === "cpu" || runtime.backend === "cpu";
-            try {
-                await this.run(runtime.executable, [...args, ...(cpu ? ["-ng"] : [])], directory, signal, this.options.timeoutMs ?? 120_000);
-            }
-            catch (error) {
-                if (acceleration !== "auto" || cpu || signal.aborted || !(error instanceof SpeechError) || error.code !== "ENGINE_FAILED")
-                    throw error;
-                await this.run(runtime.executable, [...args, "-ng"], directory, signal, this.options.timeoutMs ?? 120_000);
-            }
-            signal.throwIfAborted();
-            if (this.disposed)
-                throw new SpeechError("UNAVAILABLE", "语音服务已关闭。", 503);
-            this.initialized.add(id);
-        }
-        finally {
-            await temporary.closeAsync();
-        }
-    }
-    modelPath(model) { return path.join(this.root, "models", `ggml-${model.id}.bin`); }
-    async modelReady(model) {
-        if (this.verifying.has(model.id))
-            return this.verifying.get(model.id);
-        const promise = this.verifyModel(model);
-        this.verifying.set(model.id, promise);
-        try {
-            return await promise;
-        }
-        finally {
-            this.verifying.delete(model.id);
-        }
-    }
-    async verifyModel(model) {
-        try {
-            const file = this.modelPath(model);
-            const info = await stat(file);
-            if (!info.isFile() || info.size !== model.size)
-                return false;
-            const key = `${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
-            if (this.verified.get(model.id) === key)
-                return true;
-            if (await fileHash(file) !== model.sha256)
-                return false;
-            this.verified.set(model.id, key);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async runtime() {
-        let backend = this.options.backend ?? systemEnvValue("WAND_WHISPER_BACKEND");
-        if (!backend) {
-            try {
-                backend = JSON.parse(await readFile(path.join(this.root, "runtime.json"), "utf8")).backend;
-            }
-            catch { }
-        }
-        if (!["cpu", "metal", "cuda"].includes(backend ?? ""))
-            backend = process.platform === "darwin" ? "metal" : "cpu";
-        const name = process.platform === "win32" ? "whisper-cli.exe" : "whisper-cli";
-        const explicit = this.options.executable ?? systemEnvValue("WAND_WHISPER_BIN");
-        // Explicit bad paths must not silently run another binary. No shell, no request-provided command.
-        const candidates = explicit ? [explicit] : [path.join(this.root, "bin", name),
-            ...(buildChildEnv(true).PATH ?? "").split(path.delimiter).filter(Boolean).map((dir) => path.join(dir, name))];
-        for (const candidate of candidates) {
-            if (!path.isAbsolute(candidate))
-                continue;
-            try {
-                await access(candidate, process.platform === "win32" ? constants.F_OK : constants.X_OK);
-                if ((await stat(candidate)).isFile())
-                    return { executable: candidate, backend: backend };
-            }
-            catch { }
-        }
-        return { executable: null, backend: backend };
-    }
-    async status() {
-        const runtime = await this.runtime();
-        const models = await Promise.all(this.models.map(async (model) => ({ id: model.id, label: model.label,
-            description: model.description, size: model.size, downloaded: await this.modelReady(model) })));
-        const settings = this.settings();
-        const reason = this.disposed ? "语音服务已关闭。" : this.maintenance ? "语音运行时正在初始化，请稍后重试。" : !settings.enabled ? "服务端识别未启用，请在管理设置中启用。"
-            : !runtime.executable ? "服务端尚未安装 whisper.cpp，请在服务器运行语音运行时安装脚本。"
-                : !models.find((model) => model.id === settings.model)?.downloaded ? "服务端模型尚未下载或校验失败，请在管理设置中下载。"
-                    : settings.acceleration === "gpu" && runtime.backend === "cpu" ? "当前运行时是 CPU 版，请改为自动 / CPU 或安装 GPU 版。" : null;
-        return { settings, ready: !reason, reason, runtime: { available: !!runtime.executable, backend: runtime.backend,
-                platform: process.platform, arch: process.arch }, models, download: this.download ? { ...this.download } : null,
-            maxDurationSeconds: SPEECH_MAX_SECONDS, busy: !!this.active || this.maintenance, initialized: this.initialized.has(settings.model) };
-    }
-    cancelDownload() { this.downloadAbort?.abort(); }
-    async startDownload(id) {
-        const model = this.models.find((item) => item.id === id);
-        if (!model)
-            throw new SpeechError("INVALID_MODEL", "模型不存在。");
-        if (this.disposed)
-            throw new SpeechError("UNAVAILABLE", "语音服务已关闭。", 503);
-        if (this.maintenance)
-            throw new SpeechError("BUSY", "语音运行时正在初始化，请稍后下载。", 409);
-        if (this.downloadAbort)
-            throw new SpeechError("DOWNLOAD_BUSY", "已有模型正在下载。", 409);
-        if (await this.modelReady(model))
-            return;
-        // Recheck after asynchronous verification, before reserving the only download slot.
-        if (this.disposed)
-            throw new SpeechError("UNAVAILABLE", "语音服务已关闭。", 503);
-        if (this.downloadAbort)
-            throw new SpeechError("DOWNLOAD_BUSY", "已有模型正在下载。", 409);
-        const abort = new AbortController();
-        this.downloadAbort = abort;
-        this.download = { model: model.id, received: 0, total: model.size, phase: "downloading" };
-        void this.downloadModel(model, abort).finally(() => { if (this.downloadAbort === abort)
-            this.downloadAbort = null; });
-    }
-    async downloadModel(model, abort) {
-        const destination = this.modelPath(model);
-        const partial = `${destination}.part`;
-        const timer = setTimeout(() => abort.abort(), 30 * 60_000);
-        timer.unref();
-        try {
-            await mkdir(path.dirname(destination), { recursive: true, mode: 0o700 });
-            const response = await (this.options.fetch ?? fetch)(speechModelUrl(model), { signal: abort.signal });
-            if (!response.ok || !response.body)
-                throw new Error("download");
-            const declared = response.headers.get("content-length");
-            if (declared && Number(declared) !== model.size) {
-                await response.body.cancel();
-                throw new Error("size");
-            }
-            const file = await open(partial, "w", 0o600);
-            const hash = createHash("sha256");
-            let received = 0;
-            try {
-                for await (const chunk of response.body) {
-                    if (abort.signal.aborted)
-                        throw new Error("cancelled");
-                    received += chunk.length;
-                    if (received > model.size)
-                        throw new Error("size");
-                    hash.update(chunk);
-                    // FileHandle.write may be partial: writeFile writes the entire bounded chunk at current position.
-                    await file.writeFile(chunk);
-                    this.download = { model: model.id, received, total: model.size, phase: "downloading" };
-                }
-            }
-            finally {
-                await file.close();
-            }
-            if (abort.signal.aborted || received !== model.size || hash.digest("hex") !== model.sha256)
-                throw new Error("integrity");
-            await rename(partial, destination);
-            this.verified.delete(model.id);
-            await this.modelReady(model);
-            this.download = null;
-        }
-        catch {
-            await rm(partial, { force: true }).catch(() => { });
-            this.download = { model: model.id, received: 0, total: model.size, phase: "failed", error: "模型下载失败或完整性校验未通过，请检查网络后重试。" };
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    async transcribe(audio, signal) {
-        const { silent } = validateSpeechWav(audio);
-        if (signal?.aborted)
-            throw new SpeechError("CANCELLED", "识别已取消。", 499);
-        if (this.disposed)
-            throw new SpeechError("UNAVAILABLE", "语音服务已关闭。", 503);
-        if (this.active || this.maintenance)
-            throw new SpeechError("BUSY", "服务端正在识别或初始化，请稍后重试。", 429);
-        const abort = new AbortController();
-        this.active = abort;
-        const cancel = () => abort.abort();
-        signal?.addEventListener("abort", cancel, { once: true });
-        let directory = null;
-        let temporary = null;
-        try {
-            const settings = this.settings();
-            const model = this.models.find((item) => item.id === settings.model);
-            const runtime = await this.runtime();
-            if (!settings.enabled || !runtime.executable || !await this.modelReady(model)) {
-                throw new SpeechError("NOT_READY", "服务端语音识别未就绪，请先启用并安装运行时、下载模型。", 503);
-            }
-            if (settings.acceleration === "gpu" && runtime.backend === "cpu")
-                throw new SpeechError("NO_GPU", "当前是 CPU 运行时，请改为自动或 CPU。", 503);
-            if (abort.signal.aborted)
-                throw new SpeechError("CANCELLED", "识别已取消。", 499);
-            let backend = settings.acceleration === "cpu" ? "cpu" : runtime.backend;
-            if (silent)
-                return { text: "", model: model.id, backend };
-            temporary = createManagedTemporary("speech-voice", configTemporaryRoot(path.dirname(this.root)));
-            directory = temporary.directory;
-            const wav = path.join(directory, "audio.wav");
-            await writeFile(wav, audio, { mode: 0o600 });
-            const output = path.join(directory, "transcript");
-            // Whisper's fixed initial vocabulary biases domain words and Simplified Chinese,
-            // without rewriting the transcript or reading any private draft/history as context.
-            const context = settings.language === "en" ? "Wand, code, Git, API."
-                : "Wand, code, Git, API, 代码, 语音识别, 服务端, 客户端, 任务, 工作区。";
-            const args = ["-m", this.modelPath(model), "-f", wav, "-of", output, "-otxt", "-nt", "-l", settings.language, "-t", String(settings.threads), "--prompt", context];
-            const started = Date.now();
-            const timeout = this.options.timeoutMs ?? 120_000;
-            try {
-                await this.run(runtime.executable, [...args, ...(backend === "cpu" ? ["-ng"] : [])], directory, abort.signal, timeout);
-            }
-            catch (error) {
-                if (settings.acceleration !== "auto" || backend === "cpu" || abort.signal.aborted
-                    || !(error instanceof SpeechError) || error.code !== "ENGINE_FAILED")
-                    throw error;
-                // Only local inference is retried, never a message send. Explicit GPU selection does not fallback.
-                backend = "cpu";
-                await rm(`${output}.txt`, { force: true });
-                const remaining = timeout - (Date.now() - started);
-                if (remaining <= 0)
-                    throw new SpeechError("TIMEOUT", "服务端识别超时，请选择较小模型。", 504);
-                await this.run(runtime.executable, [...args, "-ng"], directory, abort.signal, remaining);
-            }
-            const resultFile = `${output}.txt`;
-            if ((await stat(resultFile)).size > 32_768)
-                throw new SpeechError("INVALID_RESULT", "语音识别结果异常。", 502);
-            const text = (await readFile(resultFile, "utf8")).trim();
-            if (text.length > 8_000 || text.includes("\0"))
-                throw new SpeechError("INVALID_RESULT", "语音识别结果异常。", 502);
-            if (abort.signal.aborted)
-                throw new SpeechError("CANCELLED", "识别已取消。", 499);
-            return { text, model: model.id, backend };
-        }
-        catch (error) {
-            if (error instanceof SpeechError)
-                throw error;
-            throw new SpeechError("ENGINE_FAILED", "服务端语音识别失败，请检查运行时、模型与可用磁盘。", 503);
-        }
-        finally {
-            await temporary?.closeAsync();
-            signal?.removeEventListener("abort", cancel);
-            if (this.active === abort)
-                this.active = null;
-        }
-    }
-    run(executable, args, cwd, signal, timeout) {
-        return new Promise((resolve, reject) => {
-            if (signal.aborted) {
-                reject(new SpeechError("CANCELLED", "识别已取消。", 499));
-                return;
-            }
-            const child = spawn(executable, args, { cwd, env: buildChildEnv(false, {
-                    LD_LIBRARY_PATH: systemEnvValue("LD_LIBRARY_PATH"), DYLD_LIBRARY_PATH: systemEnvValue("DYLD_LIBRARY_PATH"),
-                    CUDA_VISIBLE_DEVICES: systemEnvValue("CUDA_VISIBLE_DEVICES"),
-                }), stdio: "ignore", windowsHide: true });
-            try {
-                registerTemporaryChild(cwd, child.pid);
-            }
-            catch {
-                child.on("error", () => { });
-                child.once("close", () => { reject(new SpeechError("ENGINE_FAILED", "临时文件保护失败。", 503)); });
-                child.kill("SIGKILL");
-                return;
-            }
-            let failure = null;
-            let killTimer;
-            const stop = (error) => {
-                failure ??= error;
-                child.kill("SIGTERM");
-                killTimer ??= setTimeout(() => child.kill("SIGKILL"), 1_000);
-                killTimer.unref();
-            };
-            const cancel = () => stop(new SpeechError("CANCELLED", "识别已取消。", 499));
-            signal.addEventListener("abort", cancel, { once: true });
-            const timer = setTimeout(() => stop(new SpeechError("TIMEOUT", "服务端识别超时，请选择较小模型。", 504)), timeout);
-            timer.unref();
-            child.once("error", () => { failure = new SpeechError("ENGINE_FAILED", "无法启动服务端语音运行时，请检查安装。", 503); });
-            child.once("close", (code) => {
-                signal.removeEventListener("abort", cancel);
-                clearTimeout(timer);
-                if (killTimer)
-                    clearTimeout(killTimer);
-                if (failure)
-                    reject(failure);
-                else if (code !== 0)
-                    reject(new SpeechError("ENGINE_FAILED", "服务端识别失败，请尝试 CPU 或较小模型。", 502));
-                else
-                    resolve();
-            });
-        });
-    }
-    dispose() { this.disposed = true; this.downloadAbort?.abort(); this.active?.abort(); }
-}

package/dist/speech-support.d.ts

@@ -1,6 +0,0 @@
-export interface SpeechSupport {
-    supported: boolean;
-    reason: string | null;
-}
-/** Fixed, read-only tool probes; never install anything during status polling. */
-export declare function speechSupport(runtimeAvailable: boolean): Promise<SpeechSupport>;

package/dist/speech-support.js

@@ -1,24 +0,0 @@
-import { systemEnvValue } from "./env-utils.js";
-import { runCommand } from "./run-command.js";
-function available(command, args = ["--version"]) {
-    return runCommand(command, args, { timeout: 5000, maxBuffer: 16_384 }).then((result) => result.ok);
-}
-/** Fixed, read-only tool probes; never install anything during status polling. */
-export async function speechSupport(runtimeAvailable) {
-    if (!["darwin", "linux", "win32"].includes(process.platform)) {
-        return { supported: false, reason: "服务端语音识别仅支持 macOS、Linux 和 Windows。" };
-    }
-    if (runtimeAvailable)
-        return { supported: true, reason: null };
-    if (systemEnvValue("WAND_WHISPER_BIN"))
-        return { supported: false, reason: "配置的语音运行时不可用，请管理员检查 WAND_WHISPER_BIN。" };
-    const tools = [
-        ["Git", available("git")], ["CMake", available("cmake")],
-        ["C++ 编译器", process.platform === "win32" ? available("cl", ["/help"]) : available("c++")],
-        ...(process.platform === "win32" ? [] : [["Make", available("make")]]),
-    ];
-    const results = await Promise.all(tools.map(async ([label, probe]) => await probe ? null : label));
-    const missing = results.filter(Boolean);
-    return missing.length ? { supported: false, reason: `缺少可用的 ${missing.join("、")}，安装后重新打开此页即可启用。` }
-        : { supported: true, reason: null };
-}

package/dist/speech-types.d.ts

@@ -1,52 +0,0 @@
-/** Shared, transport-only speech contract. Never expose executable paths or audio. */
-export type SpeechAcceleration = "auto" | "cpu" | "gpu";
-export type SpeechBackend = "cpu" | "metal" | "cuda";
-export interface SpeechSettings {
-    enabled: boolean;
-    model: string;
-    acceleration: SpeechAcceleration;
-    language: "auto" | "zh" | "en";
-    threads: number;
-}
-export interface SpeechModelStatus {
-    id: string;
-    label: string;
-    description: string;
-    size: number;
-    downloaded: boolean;
-}
-export interface SpeechStatus {
-    settings: SpeechSettings;
-    ready: boolean;
-    reason: string | null;
-    runtime: {
-        available: boolean;
-        backend: SpeechBackend;
-        platform: string;
-        arch: string;
-    };
-    models: SpeechModelStatus[];
-    download: {
-        model: string;
-        received: number;
-        total: number;
-        phase: "downloading" | "failed";
-        error?: string;
-    } | null;
-    maxDurationSeconds: number;
-    busy: boolean;
-    initialized?: boolean;
-}
-export interface SpeechResult {
-    text: string;
-    model: string;
-    backend: SpeechBackend;
-    originalText?: string;
-    optimized?: boolean;
-    optimizationError?: string;
-    employeeId?: string;
-    candidate?: number;
-}
-export declare const SPEECH_SAMPLE_RATE = 16000;
-export declare const SPEECH_MAX_SECONDS = 60;
-export declare const SPEECH_MAX_WAV_BYTES: number;

package/dist/speech-types.js

@@ -1,3 +0,0 @@
-export const SPEECH_SAMPLE_RATE = 16_000;
-export const SPEECH_MAX_SECONDS = 60;
-export const SPEECH_MAX_WAV_BYTES = 44 + SPEECH_SAMPLE_RATE * 2 * SPEECH_MAX_SECONDS;