pi-web-ui 0.28.2 → 0.29.0

package/dist/server/process-utils.js

@@ -0,0 +1,86 @@
+/**
+ * process-utils — 跨平台进程工具：监听端口快照、进程树查杀、进程名查询。
+ * 后台任务面板（bgServers）用它们检测/停止 agent 在后台拉起的服务。
+ * 从 agent-service.ts 抽出，行为保持不变。全平台 best-effort：失败静默。
+ */
+/**
+ * Snapshot currently LISTENING TCP ports → owning pid. Windows: netstat;
+ * POSIX: lsof. Used to detect servers the agent started in the background
+ * (the bash tool itself exits, leaving e.g. `npm run dev &` listening).
+ */
+export async function snapshotListeningPorts() {
+    const m = new Map();
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            const out = await new Promise((resolve, reject) => execFile("netstat", ["-ano", "-p", "tcp"], { windowsHide: true, timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/)) {
+                const p = line.trim().split(/\s+/);
+                // TCP 0.0.0.0:5173 0.0.0.0:0 LISTENING 12345
+                if (p.length >= 5 && p[0] === "TCP" && p[3] === "LISTENING") {
+                    const port = Number(p[1].split(":").pop());
+                    const pid = Number(p[4]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+        else {
+            const out = await new Promise((resolve, reject) => execFile("lsof", ["-iTCP", "-sTCP:LISTEN", "-P", "-n"], { timeout: 8000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            for (const line of out.split(/\r?\n/).slice(1)) {
+                const p = line.trim().split(/\s+/);
+                if (p.length >= 9) {
+                    // NAME column tail: "*:5173 (LISTEN)" or "[::1]:5173 (LISTEN)"
+                    const mm = (p[p.length - 1] ?? "").match(/(\d+)\)?\s*$/);
+                    const port = mm ? Number(mm[1]) : NaN;
+                    const pid = Number(p[1]);
+                    if (Number.isFinite(port) && Number.isFinite(pid))
+                        m.set(port, pid);
+                }
+            }
+        }
+    }
+    catch {
+        // best effort — snapshot failure just means no tracking this round
+    }
+    return m;
+}
+/** Kill a pid and its whole process tree (cross-platform). */
+export function killPidTree(pid) {
+    try {
+        if (process.platform === "win32") {
+            void import("node:child_process").then(({ spawn }) => {
+                spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
+                    stdio: "ignore",
+                    detached: true,
+                    windowsHide: true,
+                }).unref();
+            });
+        }
+        else {
+            process.kill(-pid, "SIGKILL");
+        }
+    }
+    catch {
+        // already dead
+    }
+}
+/** Best-effort process name for a pid (tasklist on win32, ps on POSIX).
+ *  Returns undefined when the process is gone or the lookup fails. */
+export async function lookupProcessName(pid) {
+    try {
+        const { execFile } = await import("node:child_process");
+        if (process.platform === "win32") {
+            const out = await new Promise((resolve, reject) => execFile("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], { windowsHide: true, timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+            // CSV: "node.exe","12345",...
+            const m = out.match(/"([^"]+)"/);
+            return m ? m[1] : undefined;
+        }
+        const out = await new Promise((resolve, reject) => execFile("ps", ["-o", "comm=", "-p", String(pid)], { timeout: 4000 }, (err, stdout) => (err ? reject(err) : resolve(stdout))));
+        const name = out.trim();
+        return name || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/server/protocol-version.js

@@ -0,0 +1,11 @@
+/**
+ * Wire-protocol version. Bump whenever a protocol change would make an old
+ * browser tab talk to a newer server (or vice versa) in a broken way — the
+ * classic symptom is "UI is new, WS handling is old" after an in-place app
+ * update before the auto-restart completes.
+ *
+ * Lives OUTSIDE protocol.ts (which must stay pure types). The frontend keeps
+ * its own copy in web/src/protocol-version.ts; scripts/check-protocol-sync.mjs
+ * verifies the two never drift.
+ */
+export const PROTOCOL_VERSION = 1;

package/dist/server/scm.js

@@ -0,0 +1,298 @@
+/**
+ * Read-only git queries backing the source-control panel.
+ *
+ * Replaces the old hidden-PTY + text-scraping approach: every query is a
+ * plain `execFile("git", …)` — no shell, no prompts, no echo, no sentinel
+ * parsing. Output is parsed into structured JSON on the server; the client
+ * just renders it.
+ */
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+/** Per-command timeout / output cap — a stuck repo must not hang the panel. */
+const GIT_TIMEOUT_MS = 15_000;
+const MAX_GIT_OUTPUT = 16 * 1024 * 1024;
+/** Run one git command; throws Error with a readable message on failure. */
+async function git(cwd, args) {
+    try {
+        const { stdout } = await exec("git", ["-c", "core.quotepath=false", ...args], {
+            cwd,
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: MAX_GIT_OUTPUT,
+            windowsHide: true,
+        });
+        return stdout;
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === "ENOENT")
+            throw new Error("未找到 git 命令——请确认已安装 Git 并在 PATH 中");
+        if (e.killed)
+            throw new Error("git 命令超时");
+        const detail = (e.stderr ?? e.message ?? "").trim().split("\n")[0];
+        throw new Error(detail || "git 命令失败");
+    }
+}
+/** Absolute path of the repo's git dir (handles worktrees/submodules), or
+ *  null when cwd isn't inside a repository. */
+export async function gitDirOf(cwd) {
+    try {
+        const { stdout } = await exec("git", ["rev-parse", "--absolute-git-dir"], {
+            cwd,
+            timeout: 5_000,
+            windowsHide: true,
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** True when the error is "this directory isn't a git repository". */
+export function isNotRepoError(err) {
+    return /not a git repository/i.test(err instanceof Error ? err.message : String(err));
+}
+/* ------------------------------------------------------------------ */
+/* parsers                                                             */
+/* ------------------------------------------------------------------ */
+/** Undo git's C-style quoting for unusual file names ("a\tb" → a<TAB>b).
+ *  core.quotepath=false already handles non-ASCII; this covers control chars. */
+function unquotePath(s) {
+    if (!s.startsWith('"'))
+        return s;
+    const inner = s.endsWith('"') ? s.slice(1, -1) : s.slice(1);
+    return inner.replace(/\\(.)/g, (_m, c) => {
+        switch (c) {
+            case "n": return "\n";
+            case "t": return "\t";
+            case "r": return "\r";
+            case "b": return "\b";
+            case "a": return "\a";
+            case "f": return "\f";
+            case "v": return "\v";
+            case "\\": return "\\";
+            case '"': return '"';
+            default: return c;
+        }
+    });
+}
+function parseStatusHeader(rest) {
+    const out = {
+        branch: "HEAD",
+        detached: false,
+        upstream: null,
+        ahead: 0,
+        behind: 0,
+        upstreamGone: false,
+    };
+    let branchPart = rest;
+    let flags = "";
+    const bi = rest.indexOf(" [");
+    if (bi >= 0) {
+        branchPart = rest.slice(0, bi);
+        flags = rest.slice(bi + 2);
+        if (flags.endsWith("]"))
+            flags = flags.slice(0, -1);
+    }
+    if (branchPart === "HEAD (no branch)" || branchPart === "HEAD") {
+        out.detached = true;
+    }
+    else {
+        if (branchPart.startsWith("No commits yet on "))
+            branchPart = branchPart.slice("No commits yet on ".length);
+        const up = branchPart.indexOf("...");
+        if (up >= 0) {
+            out.branch = branchPart.slice(0, up);
+            out.upstream = branchPart.slice(up + 3);
+        }
+        else {
+            out.branch = branchPart;
+        }
+    }
+    if (flags) {
+        for (const part of flags.split(",")) {
+            const p = part.trim();
+            const m = p.match(/^(ahead|behind) (\d+)$/);
+            if (m) {
+                if (m[1] === "ahead")
+                    out.ahead = Number(m[2]);
+                else
+                    out.behind = Number(m[2]);
+            }
+            else if (p === "gone") {
+                out.upstreamGone = true;
+            }
+        }
+    }
+    return out;
+}
+function parseStatusFiles(text) {
+    const out = [];
+    for (const rawLine of text.split("\n")) {
+        const line = rawLine.trimEnd();
+        if (!line || line.startsWith("## "))
+            continue;
+        if (line.length >= 3) {
+            let path = line.slice(3);
+            const arrow = path.indexOf(" -> "); // rename: "R  old -> new"
+            if (arrow >= 0)
+                path = path.slice(arrow + 4);
+            out.push({ path: unquotePath(path), x: line[0], y: line[1] });
+        }
+    }
+    return out;
+}
+function parseBranches(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const parts = line.split("\t");
+        if (parts.length < 2)
+            continue;
+        const ref = parts[0];
+        const isHead = parts[1] === "*";
+        if (ref.startsWith("refs/heads/")) {
+            out.push({ name: ref.slice("refs/heads/".length), current: isHead });
+        }
+        else if (ref.startsWith("refs/remotes/")) {
+            const short = ref.slice("refs/remotes/".length);
+            // Skip the "origin/HEAD -> origin/main" symlink.
+            if (short.endsWith("/HEAD"))
+                continue;
+            const slash = short.indexOf("/");
+            out.push({
+                name: short,
+                current: false,
+                remote: slash > 0 ? short.slice(0, slash) : true,
+            });
+        }
+    }
+    return out;
+}
+/** Parse `git log --graph --pretty=format:%H%x09…` preserving graph prefixes. */
+function parseCommitHistory(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const tab = line.indexOf("\t");
+        if (tab < 0)
+            continue; // connector-only graph line
+        const prefixAndHash = line.slice(0, tab);
+        const match = prefixAndHash.match(/([0-9a-f]{7,40})$/i);
+        if (!match || match.index === undefined)
+            continue;
+        const fields = line.slice(tab + 1).split("\t");
+        // An empty decoration field removes the final tab — four fields is a
+        // valid undecorated commit.
+        if (fields.length < 4)
+            continue;
+        out.push({
+            hash: match[1],
+            shortHash: fields[0],
+            author: fields[1],
+            date: fields[2],
+            subject: fields[3],
+            decorations: fields[4] ?? "",
+            graph: prefixAndHash.slice(0, match.index),
+        });
+    }
+    return out;
+}
+/** Parse `git diff --numstat` output: "12\t3\tpath" → { path: [add, del] }. */
+function parseNumStat(text) {
+    const stats = {};
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        const tab1 = line.indexOf("\t");
+        const tab2 = tab1 < 0 ? -1 : line.indexOf("\t", tab1 + 1);
+        if (tab2 < 0)
+            continue;
+        let add = Number(line.slice(0, tab1));
+        let del = Number(line.slice(tab1 + 1, tab2));
+        if (!Number.isFinite(add))
+            add = 0; // binary file → "-"
+        if (!Number.isFinite(del))
+            del = 0;
+        const path = unquotePath(line.slice(tab2 + 1).trim());
+        const prev = stats[path];
+        stats[path] = [
+            (prev?.[0] ?? 0) + add,
+            (prev?.[1] ?? 0) + del,
+        ];
+    }
+    return stats;
+}
+/* ------------------------------------------------------------------ */
+/* queries                                                             */
+/* ------------------------------------------------------------------ */
+const HISTORY_ARGS = [
+    "log",
+    "--all",
+    "--graph",
+    "--decorate=short",
+    "--date=short",
+    "--pretty=format:%H%x09%h%x09%an%x09%ad%x09%s%x09%D",
+    "-n",
+    "120",
+];
+/** Commit graph for the history tab — fetched lazily so the common
+ *  "changes" view never pays for it on huge repos. */
+export async function scmHistory(cwd) {
+    return parseCommitHistory(await git(cwd, HISTORY_ARGS));
+}
+/** Status refresh payload (status + branches + numstat) — parallel. */
+export async function scmStatus(cwd) {
+    const [statusText, branchText, statText, cachedStatText] = await Promise.all([
+        git(cwd, ["status", "--porcelain=v1", "-b", "--find-renames"]),
+        git(cwd, [
+            "for-each-ref",
+            "refs/heads",
+            "refs/remotes",
+            "--format=%(refname)%09%(HEAD)",
+        ]),
+        git(cwd, ["diff", "--numstat"]),
+        git(cwd, ["diff", "--cached", "--numstat"]),
+    ]);
+    const header = parseStatusHeader(statusText.split("\n").find((l) => l.startsWith("## "))?.slice(3) ?? "");
+    // Worktree + staged line counts, merged per path.
+    const merged = {};
+    for (const [path, pair] of Object.entries(parseNumStat(statText))) {
+        merged[path] = pair;
+    }
+    for (const [path, pair] of Object.entries(parseNumStat(cachedStatText))) {
+        const prev = merged[path];
+        merged[path] = [(prev?.[0] ?? 0) + pair[0], (prev?.[1] ?? 0) + pair[1]];
+    }
+    return {
+        notRepo: false,
+        branch: header.branch,
+        detached: header.detached,
+        upstream: header.upstream,
+        ahead: header.ahead,
+        behind: header.behind,
+        upstreamGone: header.upstreamGone,
+        files: parseStatusFiles(statusText),
+        branches: parseBranches(branchText),
+        stats: merged,
+    };
+}
+/** Staged + worktree diffs for one file (empty strings when no diff). */
+export async function scmFileDiff(cwd, path) {
+    const [staged, worktree] = await Promise.all([
+        git(cwd, ["diff", "--cached", "--no-color", "--no-ext-diff", "--", path]).catch(() => ""),
+        git(cwd, ["diff", "--no-color", "--no-ext-diff", "--", path]).catch(() => ""),
+    ]);
+    return { staged, worktree };
+}
+/** Full patch of one commit (`git show`). */
+export async function scmCommitDetail(cwd, hash) {
+    return git(cwd, [
+        "show",
+        "--no-color",
+        "--no-ext-diff",
+        "--find-renames",
+        "--format=fuller",
+        "--stat",
+        "--patch",
+        hash,
+    ]);
+}

package/dist/server/settings-service.js

@@ -0,0 +1,268 @@
+/**
+ * Settings service — 从 agent-service.ts 抽出（系统提示词 / 技能插件开关 /
+ * 目标审查提示词 / 预设 / 视觉桥偏好）。设置持久化在 client-state.json 按客户端隔离。
+ *
+ * 经 SettingsHost 回调与 ClientSession 解耦：本模块只管「设置状态 + 面板推送 +
+ * 预设存取 + 何时需要 reload」，真正动 runtime 的 session.reload() 走宿主回调
+ * （reloadSession 里还会刷新斜杠命令目录）。
+ */
+import { basename } from "node:path";
+import { extensionKey } from "./client-state.js";
+import { findVisionModels, SYSTEM_PROMPT } from "./vision-bridge.js";
+export class SettingsService {
+    host;
+    settings;
+    presets;
+    knownSkills = new Map();
+    knownExtensions = new Map();
+    /** 流式中改了需要 reload 的设置 → agent_end 后延迟应用（防拆毁运行中 run）。 */
+    pendingReload = false;
+    constructor(host) {
+        this.host = host;
+        this.settings = host.stateStore.getSettings(host.clientId);
+        this.presets = host.stateStore.getPresets(host.clientId);
+    }
+    get current() {
+        return this.settings;
+    }
+    get reviewPrefs() {
+        return {
+            reviewPrompt: this.settings.reviewPrompt,
+            reviewDisabledSkills: this.settings.reviewDisabledSkills,
+        };
+    }
+    hasPendingReload() {
+        return this.pendingReload;
+    }
+    consumePendingReload() {
+        const v = this.pendingReload;
+        this.pendingReload = false;
+        return v;
+    }
+    push() {
+        const disabledSkills = new Set(this.settings.disabledSkills);
+        const reviewDisabledSkills = new Set(this.settings.reviewDisabledSkills);
+        const disabledExts = new Set(this.settings.disabledExtensions);
+        try {
+            // Refresh the cache with the CURRENTLY loaded set (post-filter).
+            for (const s of this.host.getSession().resourceLoader.getSkills().skills) {
+                this.knownSkills.set(s.name, {
+                    name: s.name,
+                    description: s.description,
+                    enabled: true,
+                });
+            }
+            for (const e of this.host.getSession().resourceLoader.getExtensions().extensions) {
+                const id = extensionKey(e);
+                const p = e.sourceInfo?.path ?? e.path;
+                this.knownExtensions.set(id, {
+                    id,
+                    name: e.sourceInfo?.origin === "package" && e.sourceInfo.source
+                        ? e.sourceInfo.source
+                        : basename(p),
+                    path: p,
+                    enabled: true,
+                });
+            }
+        }
+        catch {
+            // Session not ready yet — keep whatever we already know.
+        }
+        // Disabled entries are filtered out of the loader — keep them in the
+        // panel (with the last-known description) so they can be re-enabled.
+        for (const name of this.settings.disabledSkills) {
+            if (!this.knownSkills.has(name)) {
+                this.knownSkills.set(name, { name, description: "", enabled: false });
+            }
+        }
+        for (const id of this.settings.disabledExtensions) {
+            if (!this.knownExtensions.has(id)) {
+                this.knownExtensions.set(id, {
+                    id,
+                    name: id.startsWith("npm:") ? id : basename(id),
+                    path: "",
+                    enabled: false,
+                });
+            }
+        }
+        const skills = [...this.knownSkills.values()]
+            .map((s) => ({ ...s, enabled: !disabledSkills.has(s.name) }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const reviewSkills = [...this.knownSkills.values()]
+            .map((s) => ({ ...s, enabled: !reviewDisabledSkills.has(s.name) }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const extensions = [...this.knownExtensions.values()]
+            .map((e) => ({ ...e, enabled: !disabledExts.has(e.id) }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        this.host.emit({
+            type: "settings_state",
+            settings: {
+                promptMode: this.settings.promptMode,
+                customSystemPrompt: this.settings.customSystemPrompt,
+                visionBridgeEnabled: this.settings.visionBridgeEnabled,
+                visionBridgeModel: this.settings.visionBridgeModel,
+                visionBridgePromptMode: this.settings.visionBridgePromptMode,
+                visionBridgePrompt: this.settings.visionBridgePrompt,
+                reviewPrompt: this.settings.reviewPrompt,
+                reviewDisabledSkills: [...this.settings.reviewDisabledSkills],
+                // The built-in prompts, so the replace-mode editors can prefill the
+                // text they would otherwise replace (empty until the resource-loader
+                // has run once for the system prompt).
+                defaultSystemPrompt: this.host.effectiveDefaultSystemPrompt(),
+                visionBridgeDefaultPrompt: SYSTEM_PROMPT,
+                visionModels: this.collectVisionModels(),
+                disabledSkills: [...this.settings.disabledSkills],
+                disabledExtensions: [...this.settings.disabledExtensions],
+                skills,
+                reviewSkills,
+                extensions,
+                presets: this.presets.map((p) => ({ ...p })),
+            },
+        });
+    }
+    /** Vision-capable configured models, for the settings-panel picker. */
+    collectVisionModels() {
+        try {
+            return findVisionModels(this.host.getSession().modelRuntime).map((m) => ({
+                provider: m.provider,
+                id: m.id,
+                label: m.label,
+            }));
+        }
+        catch {
+            // Session not ready yet — the picker stays empty until next push.
+            return [];
+        }
+    }
+    /** Persist + apply a partial settings update (prompt text/mode, toggles). */
+    async set(partial) {
+        const needsReload = partial.promptMode !== undefined ||
+            partial.customSystemPrompt !== undefined ||
+            partial.disabledSkills !== undefined ||
+            partial.disabledExtensions !== undefined;
+        if (partial.promptMode !== undefined)
+            this.settings.promptMode = partial.promptMode;
+        if (partial.customSystemPrompt !== undefined) {
+            this.settings.customSystemPrompt = partial.customSystemPrompt;
+        }
+        if (partial.disabledSkills !== undefined) {
+            this.settings.disabledSkills = partial.disabledSkills;
+        }
+        if (partial.disabledExtensions !== undefined) {
+            this.settings.disabledExtensions = partial.disabledExtensions;
+        }
+        if (partial.visionBridgeEnabled !== undefined) {
+            this.settings.visionBridgeEnabled = partial.visionBridgeEnabled;
+        }
+        if (partial.visionBridgeModel !== undefined) {
+            this.settings.visionBridgeModel = partial.visionBridgeModel ?? null;
+        }
+        if (partial.visionBridgePromptMode !== undefined) {
+            this.settings.visionBridgePromptMode = partial.visionBridgePromptMode;
+        }
+        if (partial.visionBridgePrompt !== undefined) {
+            this.settings.visionBridgePrompt = partial.visionBridgePrompt;
+        }
+        if (partial.reviewPrompt !== undefined) {
+            this.settings.reviewPrompt = partial.reviewPrompt;
+        }
+        if (partial.reviewDisabledSkills !== undefined) {
+            this.settings.reviewDisabledSkills = partial.reviewDisabledSkills;
+        }
+        this.host.stateStore.saveSettings(this.host.clientId, this.settings);
+        this.push();
+        if (needsReload)
+            await this.applyRuntime();
+    }
+    /** Save the CURRENT settings as a named preset (overwrites if exists). */
+    async savePreset(name) {
+        const n = name.trim();
+        if (!n) {
+            this.host.emit({ type: "notice", level: "error", text: "预设名称不能为空" });
+            return;
+        }
+        const preset = {
+            name: n,
+            promptMode: this.settings.promptMode,
+            customSystemPrompt: this.settings.customSystemPrompt,
+            disabledSkills: [...this.settings.disabledSkills],
+            disabledExtensions: [...this.settings.disabledExtensions],
+            reviewPrompt: this.settings.reviewPrompt,
+            reviewDisabledSkills: [...this.settings.reviewDisabledSkills],
+        };
+        const existing = this.presets.findIndex((p) => p.name === n);
+        if (existing >= 0)
+            this.presets[existing] = preset;
+        else
+            this.presets.push(preset);
+        this.host.stateStore.savePresets(this.host.clientId, this.presets);
+        this.push();
+    }
+    /** Replace the current settings with the named preset and apply it. */
+    async applyPreset(name) {
+        const p = this.presets.find((x) => x.name === name);
+        if (!p) {
+            this.host.emit({ type: "notice", level: "error", text: `预设不存在：${name}` });
+            return;
+        }
+        this.settings = {
+            promptMode: p.promptMode,
+            customSystemPrompt: p.customSystemPrompt,
+            disabledSkills: [...p.disabledSkills],
+            disabledExtensions: [...p.disabledExtensions],
+            reviewPrompt: p.reviewPrompt ?? this.settings.reviewPrompt,
+            reviewDisabledSkills: [
+                ...(p.reviewDisabledSkills ?? this.settings.reviewDisabledSkills),
+            ],
+            // Presets don't capture vision-bridge prefs — keep the current ones.
+            visionBridgeEnabled: this.settings.visionBridgeEnabled,
+            visionBridgeModel: this.settings.visionBridgeModel,
+            visionBridgePromptMode: this.settings.visionBridgePromptMode,
+            visionBridgePrompt: this.settings.visionBridgePrompt,
+        };
+        this.host.stateStore.saveSettings(this.host.clientId, this.settings);
+        this.push();
+        await this.applyRuntime();
+    }
+    /** Remove a named preset. */
+    async deletePreset(name) {
+        this.presets = this.presets.filter((p) => p.name !== name);
+        this.host.stateStore.savePresets(this.host.clientId, this.presets);
+        this.push();
+    }
+    /**
+     * Make settings changes effective in the running runtime. The resource-loader
+     * overrides read this.settings at call time, so a reload re-applies them.
+     * Reloading mid-stream would tear down the in-flight run — defer instead.
+     */
+    async applyRuntime() {
+        if (this.host.isDisposed())
+            return;
+        if (this.host.isStreaming()) {
+            this.pendingReload = true;
+            this.host.emit({
+                type: "notice",
+                level: "info",
+                text: "当前回复进行中，设置将在回复结束后自动应用",
+            });
+            return;
+        }
+        await this.applyReload();
+    }
+    /** session.reload() + refresh the slash-command catalog + push state. */
+    async applyReload() {
+        try {
+            await this.host.reloadSession();
+            this.push();
+            this.host.flushSnapshot();
+            this.host.emit({ type: "notice", level: "info", text: "设置已应用" });
+        }
+        catch (err) {
+            this.host.emit({
+                type: "notice",
+                level: "error",
+                text: `设置应用失败：${err.message}`,
+            });
+        }
+    }
+}