@co0ontty/wand 4.85.1 → 4.87.0-beta.gd2f0f8f

package/dist/local-model-setup.js

@@ -0,0 +1,248 @@
+import { existsSync } from "node:fs";
+import { mkdir, mkdtemp, readFile, rm } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { DecisionError } from "./decision-types.js";
+import { LAYA_FILES, LAYA_REPOSITORY, layaFileUrl } from "./laya-model-manifest.js";
+import { ModelFileStore } from "./model-file-store.js";
+import { runModelSetup } from "./model-setup-process.js";
+import { speechModel } from "./speech-models.js";
+import { systemEnvValue } from "./env-utils.js";
+/** Deployment jobs only; existing inference owners retain their protocols, rate limits and capabilities. */
+export class LocalModelSetupService {
+    deps;
+    files;
+    root;
+    manifest;
+    operations = new Map();
+    jobs = new Map();
+    sequence = 0;
+    disposed = false;
+    constructor(deps) {
+        this.deps = deps;
+        this.files = new ModelFileStore(deps.fetch);
+        this.root = path.join(deps.configDir, "local-models", "laya");
+        this.manifest = deps.layaFiles ?? LAYA_FILES;
+    }
+    supported() { return (this.deps.supportedLaya ?? (() => process.platform === "darwin" && process.arch === "arm64"))(); }
+    managedModel() { return path.join(this.root, "model"); }
+    async layaModel() {
+        const current = this.deps.decisionConfig().modelPath;
+        if (current && path.isAbsolute(current) && await this.files.ready(current, this.manifest))
+            return { modelPath: current, downloaded: true };
+        const managed = this.managedModel();
+        return { modelPath: managed, downloaded: await this.files.ready(managed, this.manifest) };
+    }
+    async python() {
+        const current = this.deps.decisionConfig().pythonPath;
+        if (current && path.isAbsolute(current) && existsSync(current))
+            return current;
+        try {
+            const receipt = JSON.parse(await readFile(path.join(this.root, "runtime.json"), "utf8"));
+            if (receipt.layaVersion === "0.3.0" && receipt.mlxVersion === "0.32.2" && typeof receipt.pythonPath === "string"
+                && receipt.pythonPath.startsWith(path.join(this.root, "environments") + path.sep) && existsSync(receipt.pythonPath))
+                return receipt.pythonPath;
+        }
+        catch { }
+        return null;
+    }
+    async status() {
+        const [model, python, speech] = await Promise.all([this.layaModel(), this.python(), this.deps.speech.status()]);
+        const decision = this.deps.decisions.status();
+        const supported = this.supported();
+        const operation = this.operations.get("laya") ?? null;
+        const selected = speech.models.find((value) => value.id === speech.settings.model);
+        return {
+            laya: { kind: "laya", label: "LAYA 本地决策", supported,
+                reason: !supported ? "LAYA-MLX 当前仅支持 Apple Silicon macOS / Metal；不是聊天或授权模型。"
+                    : !model.downloaded ? "模型尚未下载或完整性校验失败。" : !python ? "独立 Python/MLX 运行时尚未初始化。" : null,
+                enabled: decision.enabled, model: LAYA_REPOSITORY, modelSize: this.manifest.reduce((sum, file) => sum + file.size, 0),
+                downloaded: model.downloaded, runtimeAvailable: !!python, initialized: decision.state === "ready", busy: this.jobs.has("laya") || decision.queued > 0 || decision.state === "loading",
+                operation: operation ? { ...operation } : null },
+            speech: { kind: "speech", label: "服务端语音识别", supported: ["darwin", "linux", "win32"].includes(process.platform), reason: speech.reason,
+                enabled: speech.settings.enabled, model: speech.settings.model, modelSize: selected?.size ?? 0,
+                downloaded: selected?.downloaded ?? false, runtimeAvailable: speech.runtime.available, initialized: speech.initialized === true,
+                busy: speech.busy || this.jobs.has("speech"), operation: this.operations.has("speech") ? { ...this.operations.get("speech") } : null },
+        };
+    }
+    parse(kind, raw) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw))
+            throw new DecisionError("INVALID_REQUEST", "模型操作参数无效。");
+        const body = raw;
+        if (Object.keys(body).some((key) => !["model", "backend"].includes(key))
+            || (body.model !== undefined && typeof body.model !== "string")
+            || (body.backend !== undefined && !["auto", "cpu", "metal", "cuda"].includes(body.backend))) {
+            throw new DecisionError("INVALID_REQUEST", "仅允许选择固定模型与受支持的后端；不接受命令、路径或URL。");
+        }
+        if (kind === "laya" && ((body.model && body.model !== LAYA_REPOSITORY) || body.backend !== undefined))
+            throw new DecisionError("INVALID_MODEL", "LAYA 使用固定多语言 MLX 模型。");
+        if (kind === "speech" && body.model !== undefined && !speechModel(body.model))
+            throw new DecisionError("INVALID_MODEL", "未知语音模型。");
+        if (body.backend === "metal" && process.platform !== "darwin")
+            throw new DecisionError("UNSUPPORTED", "Metal 仅适用于 macOS。");
+        return body;
+    }
+    start(kind, action, raw) {
+        if (this.disposed)
+            throw new DecisionError("UNAVAILABLE", "模型管理已关闭。", 503);
+        if (kind === "laya" && !this.supported())
+            throw new DecisionError("UNSUPPORTED", "LAYA-MLX 需要 Apple Silicon macOS 与 Metal。", 409);
+        const input = this.parse(kind, raw);
+        if (this.jobs.has(kind))
+            throw new DecisionError("BUSY", "该模型已有安装任务，请等待或取消。", 409);
+        if (kind === "laya")
+            this.deps.decisions.assertConfigurable();
+        if (kind === "speech" && action === "initialize")
+            this.deps.speech.acquireMaintenance();
+        const abort = new AbortController(), id = ++this.sequence;
+        this.operations.set(kind, { id, action, phase: "verifying", message: "检查已安装资源，不覆盖既有环境", received: 0, total: null });
+        const promise = this.work(kind, action, input, abort, id).catch(() => { }).finally(() => {
+            if (kind === "speech" && action === "initialize")
+                this.deps.speech.releaseMaintenance();
+            if (this.jobs.get(kind)?.abort === abort)
+                this.jobs.delete(kind);
+        });
+        this.jobs.set(kind, { abort, promise });
+        // Failure is represented by operation status. Always observe the background promise.
+        void promise;
+    }
+    update(kind, id, patch) {
+        const current = this.operations.get(kind);
+        if (current?.id === id)
+            this.operations.set(kind, { ...current, ...patch });
+    }
+    async work(kind, action, input, abort, id) {
+        const timer = setTimeout(() => abort.abort(), this.deps.timeoutMs ?? 30 * 60_000);
+        timer.unref();
+        const signal = abort.signal;
+        const phase = (value, message) => this.update(kind, id, { phase: value, message });
+        try {
+            if (kind === "laya") {
+                let model = await this.layaModel();
+                signal.throwIfAborted();
+                if (action === "download") {
+                    phase("downloading", "下载固定多语言 LAYA 模型与 tokenizer（不下载聊天模型）");
+                    await this.files.download(model.modelPath, this.manifest, layaFileUrl, signal, (received, total) => this.update(kind, id, { received, total }));
+                }
+                else {
+                    if (!model.downloaded)
+                        throw new Error("请先下载并校验 LAYA 模型，再初始化运行环境。");
+                    let python = await this.python();
+                    signal.throwIfAborted();
+                    if (python) {
+                        phase("verifying", "检查已配置 Python 的 LAYA / MLX 版本与 Metal 能力，不修改该环境");
+                        const compatible = await this.checkRuntime(python, signal);
+                        signal.throwIfAborted();
+                        if (!compatible)
+                            python = null;
+                    }
+                    if (!python) {
+                        phase("runtime", "安装独立 LAYA / MLX 环境，需服务器具备 Python 3.11+；不修改系统 Python");
+                        await mkdir(path.join(this.root, "environments"), { recursive: true, mode: 0o700 });
+                        const environment = path.join(this.root, "environments", `setup-${id}-${Date.now()}`);
+                        try {
+                            await (this.deps.run ?? runModelSetup)(process.execPath, [this.installer("install-laya-runtime.js"), "--dir", this.root, "--environment", environment, "--events"], this.deps.configDir, signal, (name, message) => phase(name === "verifying" ? "verifying" : "runtime", message));
+                        }
+                        catch (error) {
+                            await rm(environment, { recursive: true, force: true }).catch(() => { });
+                            throw error;
+                        }
+                        const receipt = JSON.parse(await readFile(path.join(this.root, "runtime.json"), "utf8"));
+                        python = typeof receipt.pythonPath === "string" && receipt.pythonPath.startsWith(path.join(this.root, "environments") + path.sep) && existsSync(receipt.pythonPath)
+                            ? receipt.pythonPath : null;
+                        if (!python)
+                            throw new Error("独立运行时校验未通过。请检查 Python 3.11+、PyPI 网络、Metal 和磁盘空间。");
+                    }
+                    signal.throwIfAborted();
+                    model = await this.layaModel();
+                    if (!model.downloaded)
+                        throw new Error("LAYA 模型校验失败，请重新下载。");
+                    const current = this.deps.decisionConfig();
+                    if (current.pythonPath !== python || current.modelPath !== model.modelPath) {
+                        this.deps.configureDecision({ enabled: current.enabled, pythonPath: python, modelPath: model.modelPath });
+                    }
+                    phase("initializing", "加载并检查 LAYA 模型，未自动启用、派工或授予任何工具权限");
+                    await this.deps.decisions.initialize(signal);
+                }
+            }
+            else {
+                const selected = input.model ?? this.deps.speech.settings().model;
+                if (action === "download") {
+                    phase("downloading", "下载并校验语音模型");
+                    await this.deps.speech.startDownload(selected);
+                    while (true) {
+                        signal.throwIfAborted();
+                        const status = await this.deps.speech.status();
+                        if (status.download?.phase === "failed")
+                            throw new Error(status.download.error || "语音模型下载失败。");
+                        if (!status.download || status.download.phase !== "downloading")
+                            break;
+                        this.update(kind, id, { received: status.download.received, total: status.download.total });
+                        await new Promise((resolve, reject) => {
+                            const cancelled = () => { clearTimeout(delay); reject(new Error("Cancelled")); };
+                            const delay = setTimeout(() => { signal.removeEventListener("abort", cancelled); resolve(); }, 250);
+                            signal.addEventListener("abort", cancelled, { once: true });
+                        });
+                    }
+                }
+                else {
+                    const status = await this.deps.speech.status();
+                    signal.throwIfAborted();
+                    const backend = input.backend === "auto" || !input.backend ? process.platform === "darwin" ? "metal" : "cpu" : input.backend;
+                    if (!status.models.find((value) => value.id === selected)?.downloaded)
+                        throw new Error("请先下载所选语音模型，再初始化。");
+                    if (!status.runtime.available || (input.backend && input.backend !== "auto" && status.runtime.backend !== backend)) {
+                        if (systemEnvValue("WAND_WHISPER_BIN"))
+                            throw new Error("服务器使用自定义语音运行时，请由管理员核对环境配置；不会覆盖它。");
+                        phase("runtime", "安装固定 whisper.cpp 运行时（需 Git、CMake、C++工具链；CUDA需已安装Toolkit）");
+                        await mkdir(path.join(this.deps.configDir, "speech"), { recursive: true, mode: 0o700 });
+                        const work = await mkdtemp(path.join(this.deps.configDir, "speech", ".setup-work-"));
+                        try {
+                            await (this.deps.run ?? runModelSetup)(process.execPath, [this.installer("install-speech-runtime.js"), "--dir", path.join(this.deps.configDir, "speech"), "--backend", backend, "--work-dir", work, "--events"], this.deps.configDir, signal, (name, message) => phase(name === "verifying" ? "verifying" : "runtime", message));
+                        }
+                        finally {
+                            await rm(work, { recursive: true, force: true }).catch(() => { });
+                        }
+                    }
+                    phase("initializing", "加载所选语音模型并用合成静音检查，未启用识别或重启服务");
+                    await this.deps.speech.initializeModel(selected, signal);
+                }
+            }
+            signal.throwIfAborted();
+            phase("completed", action === "download" ? "模型下载及完整性校验完成；可继续初始化" : "运行时和模型初始化检查完成；启用状态保持不变");
+        }
+        catch (error) {
+            const cancelled = signal.aborted;
+            const message = cancelled ? "安装任务已取消，完整文件保留，可重试" : error instanceof DecisionError || (error instanceof Error && /请先|校验|自定义|独立/.test(error.message))
+                ? error.message : "安装或初始化失败，请检查网络、编译工具/Python版本、磁盘空间和平台能力，再重试。";
+            this.update(kind, id, { phase: cancelled ? "cancelled" : "failed", message, ...(cancelled ? {} : { error: message }) });
+            if (kind === "speech" && action === "download" && cancelled)
+                this.deps.speech.cancelDownload();
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    async checkRuntime(python, signal) {
+        if (this.deps.checkRuntime)
+            return this.deps.checkRuntime(python, signal);
+        try {
+            await runModelSetup(python, ["-c", "import importlib.metadata as m; import mlx.core as mx; import laya_mlx; assert m.version('laya-mlx') == '0.3.0'; assert m.version('mlx') == '0.32.2'; assert mx.metal.is_available()"], this.deps.configDir, signal, () => { }, 30_000);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    installer(name) { return fileURLToPath(new URL(`../scripts/${name}`, import.meta.url)); }
+    cancel(kind) { this.jobs.get(kind)?.abort.abort(); }
+    setLayaEnabled(enabled) {
+        if (this.jobs.has("laya"))
+            throw new DecisionError("BUSY", "LAYA 安装任务进行中，请稍后修改。", 409);
+        if (enabled && !this.supported())
+            throw new DecisionError("UNSUPPORTED", "当前平台不支持 LAYA-MLX。", 409);
+        this.deps.configureDecision({ ...this.deps.decisionConfig(), enabled });
+    }
+    dispose() { this.disposed = true; for (const job of this.jobs.values())
+        job.abort.abort(); }
+}

package/dist/local-model-types.d.ts

@@ -0,0 +1,34 @@
+import type { SpeechBackend } from "./speech-types.js";
+export type LocalModelKind = "laya" | "speech";
+export type ModelSetupPhase = "downloading" | "verifying" | "runtime" | "initializing" | "completed" | "failed" | "cancelled";
+export interface ModelSetupOperation {
+    id: number;
+    action: "download" | "initialize";
+    phase: ModelSetupPhase;
+    message: string;
+    received: number;
+    total: number | null;
+    error?: string;
+}
+export interface LocalModelStatus {
+    kind: LocalModelKind;
+    label: string;
+    supported: boolean;
+    reason: string | null;
+    enabled: boolean;
+    model: string;
+    modelSize: number;
+    downloaded: boolean;
+    runtimeAvailable: boolean;
+    initialized: boolean;
+    busy: boolean;
+    operation: ModelSetupOperation | null;
+}
+export interface LocalModelsStatus {
+    laya: LocalModelStatus;
+    speech: LocalModelStatus;
+}
+export interface ModelSetupInput {
+    model?: string;
+    backend?: "auto" | SpeechBackend;
+}

package/dist/local-model-types.js

@@ -0,0 +1 @@
+export {};

package/dist/message-truncator.d.ts

@@ -25,6 +25,8 @@ export interface BlockWindowedMessages extends WindowedMessages {
  * 超出的会话才按下面的预算从尾部切：客户端先翻这条 turn 的头部块，再按 turn 往前翻。
  */
 export declare const MESSAGE_FIRST_PAINT_BYTES: number;
+/** Explicit small-page clients may narrow, never enlarge, the transport budget. */
+export declare function messageWindowByteBudget(value: unknown): number;
 /** 每个块在客户端是否「默认收起」（思考块 + 默认收起的工具卡片，与传输截断同一口径）。 */
 export declare function collapsedBlockFlags(content: ContentBlock[], cardDefaults: CardExpandDefaults): boolean[];
 /**
@@ -44,7 +46,7 @@ export declare function contentTransportBytes(content: ContentBlock[], cardDefau
  *
  * 返回吸附后的起点；起点越界时回退到 0（整条 turn 入窗，保证窗口不为空）。
  */
-export declare function alignedBlockStart(content: ContentBlock[], cardDefaults: CardExpandDefaults, rawStart: number, forwardLimit?: number): number;
+export declare function alignedBlockStart(content: ContentBlock[], cardDefaults: CardExpandDefaults, rawStart: number, forwardLimit?: number, maxSnapBackBytes?: number): number;
 /** [0, end) 里用户可感知的块数（默认收起的工具 / 思考块不计入）。 */
 export declare function visibleBlockCount(content: ContentBlock[], cardDefaults: CardExpandDefaults, end: number): number;
 /**
@@ -56,7 +58,7 @@ export declare function visibleBlockCount(content: ContentBlock[], cardDefaults:
  * 另外叠加一层载荷上限 —— 否则一段长工具调用会把预算吃光，把用户自己的提示词挤出首屏，
  * 一条提示词的会话也会莫名出现「更早消息」。
  */
-export declare function blockWindowMessagesForTransport(all: ConversationTurn[] | undefined, cardDefaults: CardExpandDefaults, blockBudget?: number, byteBudget?: number): BlockWindowedMessages;
+export declare function blockWindowMessagesForTransport(all: ConversationTurn[] | undefined, cardDefaults: CardExpandDefaults, blockBudget?: number, byteBudget?: number, strictByteBudget?: boolean): BlockWindowedMessages;
 /**
  * 块级翻页：取某条 turn 的 content[start, end) 这一段（已做 transport 截断）。
  * 客户端滚动到顶、且当前最旧 turn 仍有更早块时调用，end = 客户端当前 leadingBlockOffset。

package/dist/message-truncator.js

@@ -26,6 +26,13 @@ const MESSAGE_BLOCK_WINDOW = 60;
  * 超出的会话才按下面的预算从尾部切：客户端先翻这条 turn 的头部块，再按 turn 往前翻。
  */
 export const MESSAGE_FIRST_PAINT_BYTES = 1024 * 1024;
+/** Explicit small-page clients may narrow, never enlarge, the transport budget. */
+export function messageWindowByteBudget(value) {
+    const parsed = typeof value === "string" && /^\d+$/.test(value) ? Number(value) : value;
+    return typeof parsed === "number" && Number.isSafeInteger(parsed) && parsed > 0
+        ? Math.min(MESSAGE_FIRST_PAINT_BYTES, Math.max(16 * 1024, parsed))
+        : MESSAGE_FIRST_PAINT_BYTES;
+}
 /**
  * 吸附回退的额外载荷上限：折叠段往回吃掉的体积超过它就改为跳过整段，
  * 而不是把整段拉进首屏（窗口的目标是压住首屏载荷，吸附不能反过来把它撑大）。
@@ -171,7 +178,7 @@ function collapsedRunEnd(collapsed, index) {
  *
  * 返回吸附后的起点；起点越界时回退到 0（整条 turn 入窗，保证窗口不为空）。
  */
-export function alignedBlockStart(content, cardDefaults, rawStart, forwardLimit = content.length) {
+export function alignedBlockStart(content, cardDefaults, rawStart, forwardLimit = content.length, maxSnapBackBytes = MAX_BLOCK_SNAP_BACK_BYTES) {
     const total = content.length;
     const start = Math.min(Math.max(rawStart, 0), total);
     if (start <= 0 || total === 0)
@@ -196,12 +203,19 @@ export function alignedBlockStart(content, cardDefaults, rawStart, forwardLimit
         cursor = next;
     }
     const snapBackBytes = contentTransportBytes(content.slice(cursor, start), cardDefaults);
-    if (snapBackBytes <= MAX_BLOCK_SNAP_BACK_BYTES)
+    if (snapBackBytes <= maxSnapBackBytes)
         return cursor;
     // 折叠段太长：不再往回吃，跳到该段之后，保证首屏载荷不因吸附膨胀。
     const skipped = collapsed[cursor] ? collapsedRunEnd(collapsed, cursor) : cursor;
-    if (skipped >= total)
-        return 0;
+    if (skipped >= total) {
+        if (maxSnapBackBytes >= MAX_BLOCK_SNAP_BACK_BYTES)
+            return 0;
+        // Opted-in small pages must not absorb an entire huge closed timeline.
+        // Keep a boundary tool_result paired with its call, even if that single
+        // semantic unit is larger than the soft byte budget.
+        const head = content[start];
+        return head?.type === "tool_result" ? useIndexById.get(head.tool_use_id) ?? start : start;
+    }
     // 跳不到更晚的位置（只可能还是往回吃）或超过本页末尾时保持原切点。
     if (skipped <= start || skipped >= forwardLimit)
         return start;
@@ -227,7 +241,7 @@ export function visibleBlockCount(content, cardDefaults, end) {
  * 另外叠加一层载荷上限 —— 否则一段长工具调用会把预算吃光，把用户自己的提示词挤出首屏，
  * 一条提示词的会话也会莫名出现「更早消息」。
  */
-export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget = MESSAGE_BLOCK_WINDOW, byteBudget = MESSAGE_FIRST_PAINT_BYTES) {
+export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget = MESSAGE_BLOCK_WINDOW, byteBudget = MESSAGE_FIRST_PAINT_BYTES, strictByteBudget = false) {
     const turns = all ?? [];
     const total = turns.length;
     if (total === 0) {
@@ -280,7 +294,7 @@ export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget =
     // 最旧入窗 turn 的切点吸附到干净边界：不切开折叠的工具段，也不留下无头 tool_result。
     const headContent = turns[startTurn].content;
     const startOffset = leadingBlockOffset > 0
-        ? alignedBlockStart(headContent, cardDefaults, leadingBlockOffset)
+        ? alignedBlockStart(headContent, cardDefaults, leadingBlockOffset, headContent.length, strictByteBudget ? Math.min(MAX_BLOCK_SNAP_BACK_BYTES, byteBudget) : MAX_BLOCK_SNAP_BACK_BYTES)
         : 0;
     const windowedTurns = [];
     for (let i = startTurn; i < total; i++) {

package/dist/missions.js

@@ -187,12 +187,15 @@ export class Missions {
     ingest(event) {
         if (!event.sessionId || event.sessionId === "__system__")
             return;
-        const snapshot = this.sessions.getLatest(event.sessionId);
-        if (!snapshot)
-            return;
+        // Most PTY output belongs to no mission. Check the indexed ownership first
+        // instead of projecting a session (and reading its workspace/completion) for
+        // every unrelated output batch.
         const attempt = this.storage.getMissionAttemptBySession(event.sessionId);
         if (!attempt)
             return;
+        const snapshot = this.sessions.getLatest(event.sessionId);
+        if (!snapshot)
+            return;
         const state = activityState(snapshot, event);
         const updatedAt = nowIso();
         this.storage.saveMissionAttempt({

package/dist/model-file-store.d.ts

@@ -0,0 +1,13 @@
+import type { ModelFile } from "./laya-model-manifest.js";
+/** Fixed manifests only. No URL/path from a client is passed to this utility. */
+export declare class ModelFileStore {
+    private readonly fetcher;
+    private readonly verified;
+    private readonly pending;
+    constructor(fetcher?: typeof fetch);
+    ready(root: string, files: readonly ModelFile[]): Promise<boolean>;
+    private filePath;
+    private fileReady;
+    private verify;
+    download(root: string, files: readonly ModelFile[], url: (file: ModelFile) => string, signal: AbortSignal, progress: (received: number, total: number) => void): Promise<void>;
+}

package/dist/model-file-store.js

@@ -0,0 +1,108 @@
+import { createHash, randomBytes } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, open, rename, rm, stat } from "node:fs/promises";
+import path from "node:path";
+/** Fixed manifests only. No URL/path from a client is passed to this utility. */
+export class ModelFileStore {
+    fetcher;
+    verified = new Map();
+    pending = new Map();
+    constructor(fetcher = fetch) {
+        this.fetcher = fetcher;
+    }
+    async ready(root, files) {
+        return (await Promise.all(files.map((file) => this.fileReady(root, file)))).every(Boolean);
+    }
+    filePath(root, file) {
+        if (!file.path || path.isAbsolute(file.path) || file.path.split(/[\\/]/).some((part) => !part || part === "." || part === ".."))
+            throw new Error("Invalid fixed model manifest");
+        return path.join(root, file.path);
+    }
+    async fileReady(root, file) {
+        const target = this.filePath(root, file);
+        const key = `${target}:${file.sha256}`;
+        const existing = this.pending.get(key);
+        if (existing)
+            return existing;
+        const result = this.verify(target, file, key);
+        this.pending.set(key, result);
+        try {
+            return await result;
+        }
+        finally {
+            this.pending.delete(key);
+        }
+    }
+    async verify(target, file, key) {
+        try {
+            const info = await stat(target);
+            if (!info.isFile() || info.size !== file.size)
+                return false;
+            const signature = `${info.size}:${info.mtimeMs}:${info.ctimeMs}`;
+            if (this.verified.get(key) === signature)
+                return true;
+            const hash = createHash("sha256");
+            for await (const chunk of createReadStream(target))
+                hash.update(chunk);
+            if (hash.digest("hex") !== file.sha256)
+                return false;
+            this.verified.set(key, signature);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async download(root, files, url, signal, progress) {
+        const total = files.reduce((sum, file) => sum + file.size, 0);
+        let completed = 0;
+        for (const file of files) {
+            signal.throwIfAborted();
+            if (await this.fileReady(root, file)) {
+                completed += file.size;
+                progress(completed, total);
+                continue;
+            }
+            signal.throwIfAborted();
+            const target = this.filePath(root, file);
+            const partial = `${target}.${randomBytes(6).toString("hex")}.part`;
+            try {
+                await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
+                const response = await this.fetcher(url(file), { signal });
+                if (!response.ok || !response.body)
+                    throw new Error("Model download failed");
+                const length = response.headers.get("content-length");
+                if (length && Number(length) !== file.size) {
+                    await response.body.cancel();
+                    throw new Error("Model size mismatch");
+                }
+                const output = await open(partial, "wx", 0o600);
+                let received = 0;
+                const hash = createHash("sha256");
+                try {
+                    for await (const chunk of response.body) {
+                        signal.throwIfAborted();
+                        received += chunk.length;
+                        if (received > file.size)
+                            throw new Error("Model too large");
+                        hash.update(chunk);
+                        await output.writeFile(chunk);
+                        progress(completed + received, total);
+                    }
+                }
+                finally {
+                    await output.close();
+                }
+                signal.throwIfAborted();
+                if (received !== file.size || hash.digest("hex") !== file.sha256)
+                    throw new Error("Model hash mismatch");
+                await rename(partial, target);
+                completed += file.size;
+                progress(completed, total);
+            }
+            finally {
+                await rm(partial, { force: true, maxRetries: 3, retryDelay: 100 }).catch(() => { });
+            }
+        }
+    }
+}

package/dist/model-groups.js

@@ -73,7 +73,7 @@ export function normalizeModelGroups(value) {
                 throw new Error("组内必须是具体模型 ID，不能嵌套分组或使用默认值。");
             }
             if (isOpenRouterFreeSelector(trimmed) && provider !== "pi")
-                throw new Error("免费模型仅属于 one 的 Agent。");
+                throw new Error("免费模型仅属于 Pi。");
             if (free && !trimmed.startsWith(`${OPENROUTER_FREE_PROVIDER}/`))
                 throw new Error("免费分组只能包含免费池中的模型。");
             return trimmed;
@@ -113,7 +113,7 @@ export function resolveModelGroupModels(groups, provider, selector, options = {}
     const value = modelSelectorWithoutAutoAssign(selector);
     if (value === OPENROUTER_FREE_SELECTOR) {
         if (provider !== "pi")
-            throw new Error("免费分组仅属于 one 的 Agent。");
+            throw new Error("免费分组仅属于 Pi。");
         return [value];
     }
     const group = findModelGroup(groups, provider, value, options);

package/dist/model-setup-process.d.ts

@@ -0,0 +1,2 @@
+/** Runs one fixed deployment command. Only whitelisted server code constructs executable/args. */
+export declare function runModelSetup(executable: string, args: string[], cwd: string, signal: AbortSignal, progress: (phase: string, message: string) => void, timeoutMs?: number): Promise<void>;

package/dist/model-setup-process.js

@@ -0,0 +1,80 @@
+import { spawn } from "node:child_process";
+import { buildChildEnv, systemEnvValue } from "./env-utils.js";
+/** Runs one fixed deployment command. Only whitelisted server code constructs executable/args. */
+export function runModelSetup(executable, args, cwd, signal, progress, timeoutMs = 20 * 60_000) {
+    return new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error("Model setup cancelled"));
+            return;
+        }
+        const grouped = process.platform !== "win32";
+        const child = spawn(executable, args, { cwd, detached: grouped, windowsHide: true, stdio: ["ignore", "pipe", "pipe"],
+            env: buildChildEnv(false, {
+                HTTPS_PROXY: systemEnvValue("HTTPS_PROXY"), HTTP_PROXY: systemEnvValue("HTTP_PROXY"), NO_PROXY: systemEnvValue("NO_PROXY"),
+                WAND_LAYA_PYTHON_BIN: systemEnvValue("WAND_LAYA_PYTHON_BIN"),
+            }) });
+        let failed = false, buffer = "", kill;
+        const terminate = () => {
+            failed = true;
+            const stop = (hard) => {
+                if (grouped && child.pid) {
+                    try {
+                        process.kill(-child.pid, hard ? "SIGKILL" : "SIGTERM");
+                    }
+                    catch { }
+                }
+                else if (child.pid) {
+                    const cleanup = spawn("taskkill", ["/pid", String(child.pid), "/T", "/F"], { env: buildChildEnv(false), windowsHide: true, stdio: "ignore" });
+                    cleanup.on("error", () => { try {
+                        child.kill();
+                    }
+                    catch { } });
+                }
+            };
+            stop(false);
+            kill ??= setTimeout(() => stop(true), 1_000);
+            kill.unref();
+        };
+        const timer = setTimeout(terminate, timeoutMs);
+        timer.unref();
+        signal.addEventListener("abort", terminate, { once: true });
+        // Compiler/Python diagnostics may contain proxy credentials or local paths: discard, never echo.
+        child.stderr.resume();
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 16_384)
+                buffer = buffer.slice(-4096);
+            let end;
+            while ((end = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, end);
+                buffer = buffer.slice(end + 1);
+                if (!line.startsWith("[wand-model] "))
+                    continue;
+                try {
+                    const value = JSON.parse(line.slice(13));
+                    if (["runtime", "verifying", "completed"].includes(value.phase) && typeof value.message === "string" && value.message.length < 240)
+                        progress(value.phase, value.message);
+                }
+                catch { }
+            }
+        });
+        child.once("error", () => { failed = true; });
+        child.once("close", (code) => {
+            if (failed && grouped && child.pid) {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                catch { }
+            }
+            clearTimeout(timer);
+            if (kill)
+                clearTimeout(kill);
+            signal.removeEventListener("abort", terminate);
+            if (failed || code !== 0)
+                reject(new Error("Model runtime setup failed"));
+            else
+                resolve();
+        });
+    });
+}

package/dist/models.js

@@ -61,7 +61,7 @@ const QODER_FALLBACK_MODELS = [
     { id: "ultimate", label: "Ultimate" },
 ];
 const PI_FALLBACK_MODELS = [
-    { id: "default", label: "跟随 one 的 Agent 默认", alias: true },
+    { id: "default", label: "跟随 Pi 默认", alias: true },
 ];
 /**
  * Gemini CLI 没有列模型的子命令，只能给出稳定别名（`packages/core/src/config/models.ts`
@@ -799,7 +799,7 @@ export function parsePiRpcModels(stdout) {
     return [
         {
             id: "default",
-            label: "跟随 one 的 Agent 默认",
+            label: "跟随 Pi 默认",
             alias: true,
             ...(union.length ? { reasoningEfforts: union } : {}),
         },
@@ -832,7 +832,7 @@ export function parsePiModels(stdout) {
     if (!discovered.length)
         return cloneModels(PI_FALLBACK_MODELS);
     return [
-        { id: "default", label: "跟随 one 的 Agent 默认", alias: true },
+        { id: "default", label: "跟随 Pi 默认", alias: true },
         ...discovered,
     ];
 }