@rexvane/piweb 0.3.19 → 0.3.21

package/src/lib/chat/event-stream.ts

@@ -0,0 +1,113 @@
+/**
+ * 会话事件的长轮询通道（浏览器端）。
+ *
+ * Cloudflare 快速隧道（远程连接的公网入口）不支持 SSE：流式响应被攒成 128KB 一块才转发，
+ * 不满一块的尾巴一直卡着——打开会话等不到完整快照（一直转圈），聊天也不流式。
+ * 隧道下改成一次次短请求：服务端把这一批事件发完就结束响应（结束时隧道一定吐干净），
+ * 浏览器带着 Last-Event-ID 立刻再来一次，漏掉的事件由服务端从环形缓冲补发。
+ * 线上格式仍是 SSE 文本，服务端两种模式共用一套写法。
+ */
+
+/** 只有快速隧道需要轮询；局域网、本机、用户自己的反向代理都照旧走 SSE */
+export function usesEventPolling(hostname: string): boolean {
+	return hostname.toLowerCase().endsWith(".trycloudflare.com");
+}
+
+export interface SseFrame {
+	id?: string;
+	event?: string;
+	data: string;
+}
+
+/** 解析一段完整的 SSE 文本（只认本项目用到的 id / event / data，注释行跳过） */
+export function parseSseText(text: string): SseFrame[] {
+	const frames: SseFrame[] = [];
+	for (const block of text.split(/\r?\n\r?\n/)) {
+		const frame: SseFrame = { data: "" };
+		const data: string[] = [];
+		for (const line of block.split(/\r?\n/)) {
+			if (!line || line.startsWith(":")) continue;
+			const colon = line.indexOf(":");
+			const field = colon === -1 ? line : line.slice(0, colon);
+			let value = colon === -1 ? "" : line.slice(colon + 1);
+			if (value.startsWith(" ")) value = value.slice(1);
+			if (field === "data") data.push(value);
+			else if (field === "id") frame.id = value;
+			else if (field === "event") frame.event = value;
+		}
+		if (!data.length) continue;
+		frame.data = data.join("\n");
+		frames.push(frame);
+	}
+	return frames;
+}
+
+export interface EventPollHandlers {
+	/** 一次请求成功返回（断开后恢复时也会再调） */
+	onOpen(): void;
+	onMessage(data: string): void;
+	/** 一次请求失败；之后按退避自动重试 */
+	onError(): void;
+}
+
+export interface EventPollOptions {
+	fetch?: typeof fetch;
+	/** 第 n 次连续失败后等多久再试 */
+	backoffMs?: (failures: number) => number;
+}
+
+const defaultBackoff = (failures: number) => Math.min(2000 * 2 ** (failures - 1), 30_000);
+
+export function pollEventStream(url: string, handlers: EventPollHandlers, { fetch: fetchImpl = fetch, backoffMs = defaultBackoff }: EventPollOptions = {}): { close(): void } {
+	const controller = new AbortController();
+	let closed = false;
+	let lastEventId: string | undefined;
+	let open = false;
+	let failures = 0;
+	const pollUrl = `${url}${url.includes("?") ? "&" : "?"}poll=1`;
+
+	const sleep = (ms: number) => new Promise<void>((resolve) => {
+		const timer = setTimeout(resolve, ms);
+		controller.signal.addEventListener("abort", () => { clearTimeout(timer); resolve(); }, { once: true });
+	});
+
+	void (async () => {
+		while (!closed) {
+			let frames: SseFrame[];
+			try {
+				const response = await fetchImpl(pollUrl, {
+					headers: lastEventId ? { "Last-Event-ID": lastEventId } : {},
+					cache: "no-store",
+					signal: controller.signal,
+				});
+				if (!response.ok) throw new Error(`events poll failed (${response.status})`);
+				frames = parseSseText(await response.text());
+			} catch {
+				if (closed) return;
+				open = false;
+				handlers.onError();
+				failures += 1;
+				await sleep(backoffMs(failures));
+				continue;
+			}
+			if (closed) return;
+			failures = 0;
+			if (!open) {
+				open = true;
+				handlers.onOpen();
+			}
+			for (const frame of frames) {
+				if (closed) return;
+				handlers.onMessage(frame.data);
+				if (frame.id !== undefined) lastEventId = frame.id;
+			}
+		}
+	})();
+
+	return {
+		close() {
+			closed = true;
+			controller.abort();
+		},
+	};
+}

package/src/lib/chat/stream-settings.ts

@@ -0,0 +1,192 @@
+/**
+ * 流式文字输出偏好：显示样式 / 推进速度 / 打字光标。
+ *
+ * 存 localStorage（piweb.streamStyle / piweb.streamSpeed / piweb.streamCaret），
+ * 模块级订阅：设置面板一改，正在流的那条回答在下一帧就换样式，不必重开会话；
+ * 跨标签页由 storage 事件同步。
+ *
+ * 推进量是纯函数 nextRevealEnd(target, shownLength, settings)：给定目标文本、已显示长度和偏好，
+ * 算出这一帧该显示到哪。不变量是「显示内容始终是目标前缀、单调增长、最终追平」——
+ * 见 tests/stream-settings.test.ts。
+ */
+
+export type StreamStyle = "smooth" | "instant" | "typewriter" | "fade";
+
+export interface StreamSettings {
+	/** 文字出现的方式 */
+	style: StreamStyle;
+	/** 推进速度档位 1..5（3 = 标准） */
+	speed: number;
+	/** 打字光标：流式期间在文字末尾闪烁 */
+	caret: boolean;
+}
+
+/** 设置面板里的展示顺序（即时排在最后：它是「不要平滑」的退路） */
+export const STREAM_STYLES: readonly StreamStyle[] = ["smooth", "typewriter", "fade", "instant"];
+export const STREAM_SPEED_MIN = 1;
+export const STREAM_SPEED_MAX = 5;
+export const DEFAULT_STREAM_SETTINGS: StreamSettings = { style: "smooth", speed: 3, caret: false };
+
+const KEY = {
+	style: "piweb.streamStyle",
+	speed: "piweb.streamSpeed",
+	caret: "piweb.streamCaret",
+} as const;
+
+/** 每帧间隔（约 60fps 起步）：档位越高越密 */
+const STEP_MS = [24, 20, 16, 12, 8];
+/** 平滑 / 渐显：每帧推进「积压 / 该值」，值越大追赶越缓、手感越匀（突发不再狂奔） */
+const SMOOTH_DIVISOR = [14, 10, 7, 5, 3];
+/** 平滑 / 渐显：每帧至少推进的字符数，保证收尾时也能走完 */
+const SMOOTH_MIN_CHARS = [1, 1, 1, 2, 3];
+/** 平滑 / 渐显：每帧至多推进的字符数——大块突发被摊到更多帧里缓缓出现，不会一口吞掉 */
+const SMOOTH_MAX_CHARS = [140, 110, 90, 70, 50];
+/** 打字机：每帧固定敲出的字符数 */
+const TYPEWRITER_CHARS = [1, 2, 3, 5, 8];
+/** 打字机也要有底线：积压超过约 1.5 秒的量就跟着加速，不出现「回答完了字还在爬」 */
+const TYPEWRITER_CATCHUP_DIVISOR = 90;
+
+export function isStreamStyle(value: string | null | undefined): value is StreamStyle {
+	return value === "smooth" || value === "instant" || value === "typewriter" || value === "fade";
+}
+
+export function clampStreamSpeed(value: number): number {
+	if (!Number.isFinite(value)) return DEFAULT_STREAM_SETTINGS.speed;
+	return Math.max(STREAM_SPEED_MIN, Math.min(STREAM_SPEED_MAX, Math.round(value)));
+}
+
+/** 这一档速度下每帧的间隔（毫秒） */
+export function streamStepMs(speed: number): number {
+	return STEP_MS[clampStreamSpeed(speed) - 1];
+}
+
+function readStored(): StreamSettings {
+	try {
+		const style = localStorage.getItem(KEY.style);
+		const speed = Number.parseInt(localStorage.getItem(KEY.speed) ?? "", 10);
+		const caret = localStorage.getItem(KEY.caret);
+		return {
+			style: isStreamStyle(style) ? style : DEFAULT_STREAM_SETTINGS.style,
+			speed: Number.isFinite(speed) ? clampStreamSpeed(speed) : DEFAULT_STREAM_SETTINGS.speed,
+			caret: caret === null ? DEFAULT_STREAM_SETTINGS.caret : caret === "1" || caret === "true",
+		};
+	} catch {
+		// 隐私模式 / localStorage 不可用：这一份内存偏好照样生效
+		return DEFAULT_STREAM_SETTINGS;
+	}
+}
+
+export function loadStreamSettings(): StreamSettings {
+	if (typeof window === "undefined") return DEFAULT_STREAM_SETTINGS;
+	return readStored();
+}
+
+function persist(settings: StreamSettings): void {
+	if (typeof window === "undefined") return;
+	try {
+		localStorage.setItem(KEY.style, settings.style);
+		localStorage.setItem(KEY.speed, String(settings.speed));
+		localStorage.setItem(KEY.caret, settings.caret ? "1" : "0");
+	} catch {
+		/* 配额满 / 被禁用：内存里已经生效 */
+	}
+}
+
+let cached: StreamSettings | null = null;
+const listeners = new Set<() => void>();
+let storageBound = false;
+
+/** useSyncExternalStore 的 getSnapshot：同一份引用，只有真改了才换（否则会无限重渲染） */
+export function getStreamSettings(): StreamSettings {
+	if (!cached) cached = loadStreamSettings();
+	return cached;
+}
+
+/** 服务端 / 水合首帧没有 localStorage，给默认值 */
+export function getServerStreamSettings(): StreamSettings {
+	return DEFAULT_STREAM_SETTINGS;
+}
+
+function bindStorage(): void {
+	if (storageBound || typeof window === "undefined") return;
+	storageBound = true;
+	window.addEventListener("storage", (event) => {
+		if (event.key !== null && event.key !== KEY.style && event.key !== KEY.speed && event.key !== KEY.caret) return;
+		cached = loadStreamSettings();
+		for (const listener of listeners) listener();
+	});
+}
+
+export function subscribeStreamSettings(listener: () => void): () => void {
+	listeners.add(listener);
+	bindStorage();
+	return () => {
+		listeners.delete(listener);
+	};
+}
+
+/** 改一项并持久化，返回合并后的完整偏好；正在流的回答下帧就用新值 */
+export function setStreamSettings(patch: Partial<StreamSettings>): StreamSettings {
+	const current = getStreamSettings();
+	const next: StreamSettings = {
+		style: isStreamStyle(patch.style) ? patch.style : current.style,
+		speed: patch.speed === undefined ? current.speed : clampStreamSpeed(patch.speed),
+		caret: patch.caret === undefined ? current.caret : patch.caret === true,
+	};
+	cached = next;
+	persist(next);
+	for (const listener of listeners) listener();
+	return next;
+}
+
+/**
+ * 不在 UTF-16 代理对中间切：切在中间会渲染成一个替换字符（半个 emoji）。
+ * 端点越界时按文本长度收口。
+ */
+export function safeSliceEnd(text: string, end: number): number {
+	if (end <= 0) return 0;
+	if (end >= text.length) return text.length;
+	const high = text.charCodeAt(end - 1);
+	const low = text.charCodeAt(end);
+	if (high >= 0xd800 && high <= 0xdbff && low >= 0xdc00 && low <= 0xdfff) return Math.min(end + 1, text.length);
+	return end;
+}
+
+/**
+ * 渐显：只在整词处停 —— 从 end 往回找到最近的分隔符，切在它后面；
+ * 这一段里没有分隔符（正在敲的词）就照常长，否则会停在原地走不完。
+ */
+function snapToWordEnd(target: string, from: number, end: number): number {
+	if (end >= target.length) return target.length;
+	for (let i = end - 1; i >= from; i -= 1) {
+		if (/\s/.test(target[i])) return i + 1;
+	}
+	return end;
+}
+
+/**
+ * 这一帧显示到哪个下标（返回值 = 目标文本前缀长度）。
+ * - instant：不排队，直接追平；
+ * - smooth：自适应 —— 积压越多推得越快，但每帧有上限：大块突发被摊到多帧缓缓出现；
+ * - typewriter：固定节奏逐字，但积压过大时跟着加速（上限约 1.5 秒的落后量）；
+ * - fade：在 smooth 的基础上按整词推进。
+ */
+export function nextRevealEnd(target: string, shownLength: number, settings: StreamSettings): number {
+	const total = target.length;
+	if (settings.style === "instant") return total;
+	const backlog = total - shownLength;
+	if (backlog <= 0) return total;
+	const level = clampStreamSpeed(settings.speed) - 1;
+	let end: number;
+	if (settings.style === "typewriter") {
+		end = shownLength + Math.max(TYPEWRITER_CHARS[level], Math.ceil(backlog / TYPEWRITER_CATCHUP_DIVISOR));
+	} else {
+		end = shownLength + Math.min(
+			SMOOTH_MAX_CHARS[level],
+			Math.max(SMOOTH_MIN_CHARS[level], Math.ceil(backlog / SMOOTH_DIVISOR[level])),
+		);
+	}
+	if (end > total) end = total;
+	if (settings.style === "fade") end = snapToWordEnd(target, shownLength, end);
+	return safeSliceEnd(target, end);
+}

package/src/lib/remote/mobile-proxy.ts

@@ -79,7 +79,11 @@ export interface MobileProxyOptions {
 }
 
 export function createMobileProxy({ targetPort, targetHost = "127.0.0.1", css = null, js = null, log = () => {} }: MobileProxyOptions): http.Server {
-	return http.createServer((req, res) => {
+	// 转回 PiWeb 的这一跳必须直连。设了 NODE_USE_ENV_PROXY=1 时，Node 默认的 globalAgent 会把它交给
+	// HTTP_PROXY，代理再按原样转发的 Host（局域网地址:入口端口）连回本入口——自己转给自己，直到本机端口耗尽，
+	// 手机和公网隧道只能看到 502。自建的 Agent 不读代理环境变量；参数照抄 Node 的 globalAgent。
+	const agent = new http.Agent({ keepAlive: true, scheduling: "lifo", timeout: 5000 });
+	const server = http.createServer((req, res) => {
 		// 保留原 Host / Origin 原样转发：PiWeb 的 isSafeHost 与 isSafeOrigin 都要看它们，
 		// 改写成回环反而会让写操作被判成跨源。
 		const headers: http.OutgoingHttpHeaders = { ...req.headers };
@@ -89,7 +93,7 @@ export function createMobileProxy({ targetPort, targetHost = "127.0.0.1", css =
 			headers["accept-encoding"] = "identity";
 		}
 
-		const upstream = http.request({ host: targetHost, port: targetPort, method: req.method, path: req.url ?? "/", headers }, (up) => {
+		const upstream = http.request({ host: targetHost, port: targetPort, method: req.method, path: req.url ?? "/", headers, agent }, (up) => {
 			const type = String(up.headers["content-type"] ?? "");
 			if (!styled || !type.includes("text/html")) {
 				res.writeHead(up.statusCode ?? 502, up.headers);
@@ -146,4 +150,6 @@ export function createMobileProxy({ targetPort, targetHost = "127.0.0.1", css =
 		});
 		req.pipe(upstream);
 	});
+	server.on("close", () => agent.destroy());
+	return server;
 }

package/src/lib/remote/supervisor.ts

@@ -66,14 +66,15 @@ export function createUrlCatcher(pattern: RegExp = PUBLIC_URL_PATTERN) {
  *
  * 只看 DNS 不够：域名解析出来之后边缘还可能要几秒才把请求转到这条隧道上。
  * 所以这里发一次 HEAD，把「能连上并拿到 HTTP 响应」当作就绪标准；
- * 4xx 也算就绪（说明请求已经打到我们的上游了），只有连不上/DNS 失败才算没就绪。
+ * 4xx 也算就绪（说明请求已经打到我们的上游了）。5xx 不算：边缘还没接上这条隧道时 Cloudflare 自己回
+ * 530（错误 1033），上游连不上时回 502——它们也是 HTTP 响应，当成就绪就会让界面显示「就绪」而手机打开是错误页。
  */
 function probeTunnel(url: string): Promise<boolean> {
 	return new Promise((resolve) => {
 		const target = new URL(url);
 		const request = https.request({ host: target.hostname, path: "/api/health", method: "HEAD", timeout: 8_000 }, (response) => {
 			response.resume();
-			resolve(true);
+			resolve((response.statusCode ?? 0) < 500);
 		});
 		request.on("timeout", () => { request.destroy(); resolve(false); });
 		request.on("error", () => resolve(false));
@@ -224,15 +225,24 @@ export function remoteLanPort(env: Record<string, string | undefined> = process.
 	return Number.isInteger(value) && value >= 1 && value <= 65535 ? value : DEFAULT_LAN_PORT;
 }
 
-/** 所有非回环 IPv4 —— 手机该用哪个地址，UI 直接列出来 */
-export function lanAddresses(): string[] {
-	const out: string[] = [];
-	for (const entries of Object.values(os.networkInterfaces())) {
+/** 虚拟机、WSL、容器的虚拟网卡：地址也是私网段，但同一 WiFi 的手机连不到，排到最后 */
+const VIRTUAL_ADAPTER = /vmware|virtualbox|vboxnet|vethernet|hyper-v|wsl|docker|^br-|^veth/i;
+
+/**
+ * 所有非回环 IPv4 —— 手机该用哪个地址，UI 直接列出来，真实网卡排在前面。
+ * 198.18.0.0/15 是测试保留段，Clash / Mihomo 等代理的 TUN 网卡用它，手机永远连不上，直接不列。
+ */
+export function lanAddresses(interfaces: NodeJS.Dict<os.NetworkInterfaceInfo[]> = os.networkInterfaces()): string[] {
+	const real: string[] = [];
+	const virtual: string[] = [];
+	for (const [name, entries] of Object.entries(interfaces)) {
 		for (const entry of entries ?? []) {
-			if (entry.family === "IPv4" && !entry.internal && !entry.address.startsWith("169.254.")) out.push(entry.address);
+			if (entry.family !== "IPv4" || entry.internal || entry.address.startsWith("169.254.")) continue;
+			if (/^198\.1[89]\./.test(entry.address)) continue;
+			(VIRTUAL_ADAPTER.test(name) ? virtual : real).push(entry.address);
 		}
 	}
-	return out;
+	return [...real, ...virtual];
 }
 
 export function remoteStatus(): RemoteStatus {

package/src/lib/types.ts

@@ -116,6 +116,8 @@ export type WebEvent =
 	| { type: "traj"; entry: TrajEntry; ts: number }
 	| { type: "name"; name: string; ts: number }
 	| { type: "tools"; active: string[]; all: string[]; toolPreset?: ToolPreset; customActiveTools?: string[] | null; ts: number }
+	/** 上下文分项变了（会话启动、工具 / 资源重载、压缩之后）：替换快照里的 contextBreakdown */
+	| { type: "context_breakdown"; breakdown: ContextBreakdown; ts: number }
 	| {
 			/** 资源（扩展/技能/模板/命令）重载后的新清单；前端据此刷新 / 菜单与设置面板 */
 			type: "resources";
@@ -248,6 +250,11 @@ export interface ContextBreakdown {
 	compacted: number;
 	/** auto-compact 预留（compaction.reserveTokens 设置值；未启用为 0） */
 	autoCompactBuffer: number;
+	/**
+	 * 会话还没启动（只浏览历史不冷启动 agent）：systemPrompt / systemTools / customTools 拿不到、为 0，
+	 * 其余几项照常统计。前端据此提示并提供「现在统计」（prepare 启动会话）。
+	 */
+	cold?: boolean;
 }
 
 /** SSE 连接建立时先发的完整快照 */

package/src/lib/update/startup-check.ts

@@ -0,0 +1,117 @@
+/**
+ * 启动时检查一次更新：PiWeb 和 pi 各查一次，结果留在内存里给设置页和右下角提示条用，
+ * 有新版本时在终端打一行。离线、registry 不通都不吭声——设置里还能手动检查。
+ *
+ * 状态挂 globalThis：instrumentation 和路由是不同的 bundle，模块级变量不共享（同 remote/supervisor）。
+ * 每次服务启动换一个 startId，页面据此做到「每次启动提醒一次」。
+ * 手动检查、更新成功后改写这份缓存：刷新页面不会又显示「更新到 vX」。
+ * PI_WEB_UPDATE_CHECK=0 关掉启动检查（不联网），设置里手动检查不受影响。
+ */
+import { randomUUID } from "node:crypto";
+import { checkForUpdate, type UpdateCheck, type UpdateTarget } from "../update-service";
+
+/** 一项的结果：检查结果（更新过就带上 updatedTo），或检查失败的原因 */
+export type StartupResult = (UpdateCheck & { updatedTo?: string }) | { error: string };
+
+export interface StartupUpdates {
+	/** 本次服务启动的标识；关掉启动检查时为 null */
+	startId: string | null;
+	results: Partial<Record<UpdateTarget, StartupResult>>;
+}
+
+interface StartupState {
+	startId: string;
+	results: Partial<Record<UpdateTarget, StartupResult>>;
+	pending: Promise<void> | null;
+	started: boolean;
+}
+
+interface StartupOptions {
+	check?: (target: UpdateTarget) => Promise<UpdateCheck>;
+	log?: (line: string) => void;
+	env?: Record<string, string | undefined>;
+}
+
+const STATE_KEY = "piweb.update.startup";
+const TARGETS: readonly UpdateTarget[] = ["piweb", "pi"];
+const LABEL: Record<UpdateTarget, string> = { piweb: "PiWeb", pi: "Pi" };
+
+function state(): StartupState {
+	const store = globalThis as Record<PropertyKey, unknown>;
+	const key = Symbol.for(STATE_KEY);
+	const existing = store[key] as StartupState | undefined;
+	if (existing) return existing;
+	const created: StartupState = { startId: randomUUID(), results: {}, pending: null, started: false };
+	store[key] = created;
+	return created;
+}
+
+export function startupCheckEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return env.PI_WEB_UPDATE_CHECK !== "0";
+}
+
+/** 终端里那一行；没有新版本时为 null */
+export function updateNoticeLine(results: StartupUpdates["results"]): string | null {
+	const parts: string[] = [];
+	let manual: string | undefined;
+	for (const target of TARGETS) {
+		const result = results[target];
+		if (!result || "error" in result || !result.canUpdate) continue;
+		// Git 检出版本号没变、只是 main 上有新提交时，写提交数而不是「0.3.20 → 0.3.20」
+		parts.push(result.latest === result.current && result.behind ? `${LABEL[target]}（main 新增 ${result.behind} 个提交）` : `${LABEL[target]} ${result.current} → ${result.latest}`);
+		if (!result.selfUpdate && result.command) manual = result.command;
+	}
+	if (!parts.length) return null;
+	const line = `[更新] 有新版本：${parts.join("、")}。打开 设置 → 通用 点「更新」`;
+	return manual ? `${line}；PiWeb 要先停掉 piweb 再运行：${manual}` : line;
+}
+
+/**
+ * 启动检查（只跑一次）；返回检查完之后的状态快照。关掉时返回 null，不联网。
+ * instrumentation 在启动时调它，GET /api/update 也调它（页面先到时由页面触发，结果一样只查一次）。
+ */
+export async function ensureStartupCheck({ check = checkForUpdate, log = console.log, env = process.env }: StartupOptions = {}): Promise<StartupUpdates | null> {
+	if (!startupCheckEnabled(env)) return null;
+	const current = state();
+	if (!current.started) {
+		current.started = true;
+		current.pending = (async () => {
+			await Promise.all(TARGETS.map(async (target) => {
+				try {
+					const result = await check(target);
+					// 检查期间已经手动更新过的项不覆盖
+					if (!current.results[target]) current.results[target] = result;
+				} catch (error) {
+					if (!current.results[target]) current.results[target] = { error: error instanceof Error ? error.message : String(error) };
+				}
+			}));
+			const line = updateNoticeLine(current.results);
+			if (line) log(line);
+		})();
+	}
+	await current.pending;
+	return snapshot();
+}
+
+function snapshot(): StartupUpdates {
+	const current = state();
+	return { startId: current.startId, results: { ...current.results } };
+}
+
+/** 手动检查的结果覆盖缓存 */
+export function recordCheck(target: UpdateTarget, check: UpdateCheck): void {
+	state().results[target] = check;
+}
+
+/** 更新成功：记下装好的版本，页面刷新后显示「已更新，重启生效」而不是又让人更新一次 */
+export function markUpdated(target: UpdateTarget, version: string): void {
+	const current = state();
+	const previous = current.results[target];
+	const base = previous && !("error" in previous) ? previous : { current: "", latest: version, canUpdate: false, selfUpdate: true };
+	current.results[target] = { ...base, latest: version || base.latest, canUpdate: false, updatedTo: version || base.latest };
+}
+
+/** 仅供测试：清掉挂在 globalThis 上的状态 */
+export function resetStartupCheck(): void {
+	delete (globalThis as Record<PropertyKey, unknown>)[Symbol.for(STATE_KEY)];
+}

package/src/lib/update-service.ts

@@ -5,7 +5,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import { installPiUpdate, PI_PACKAGE, prepareRelease } from "../../scripts/release.mjs";
+import { installPiUpdate, PI_AI_PACKAGE, PI_PACKAGE, prepareRelease } from "../../scripts/release.mjs";
 import { assertInstallation, readProductionBuild } from "../../scripts/build-output.mjs";
 import { runCommand } from "../../scripts/process-runner.mjs";
 import { isNewer } from "./semver";
@@ -153,14 +153,34 @@ export function createUpdateService({ root = APP_ROOT, run = runCommand, version
 		return { ...readProductionBuild(installation, ".next"), version, needsRestart: true };
 	}
 
+	/**
+	 * 只换 npm 成品包里的 pi 依赖：成品包没有 devDependencies，跑不了 typecheck / 构建，也不需要——
+	 * pi 两个包都在 serverExternalPackages 里，运行时从这里的 node_modules 加载，重启即用上新版。
+	 * Windows 也能做：运行中的服务没加载 pi 的原生模块，pi 目录也不是服务的工作目录，不会 EBUSY。
+	 * 图标不用同步：成品包自带 public/provider-icons，清单也和 pi 版本无关。
+	 */
+	async function installPiIntoPackage(installation: string, assertIdle: () => Promise<void>): Promise<UpdateResult> {
+		await assertIdle();
+		await run("npm", ["install", "--save-exact", `${PI_PACKAGE}@latest`, `${PI_AI_PACKAGE}@latest`, "--omit=dev", "--no-audit", "--no-fund"], {
+			cwd: installation, env: commandEnv, timeoutMs: 600_000,
+		});
+		await assertIdle();
+		assertInstallation(installation);
+		const version = await readPackageVersion(path.join(installation, "node_modules", PI_PACKAGE, "package.json"));
+		return { ...readProductionBuild(installation, ".next"), version, needsRestart: true };
+	}
+
 	async function runUpdate(target: UpdateTarget, { assertIdle = async () => {} }: { assertIdle?: () => Promise<void> } = {}): Promise<UpdateResult> {
 		assertTarget(target);
 		if (updateRunning) throw new UpdateBusyError("an update is already running");
 		updateRunning = true;
 		try {
 			const installation = await checkedRoot();
-			// npm 安装：装发布好的成品即可——不需要 Git，也不需要本地构建（成品包自带 .next）。
-			if (target === "piweb" && isNpmInstall(installation)) return await installFromRegistry(installation, assertIdle);
+			// npm 安装：装发布好的成品即可——不需要 Git，也不需要本地构建（成品包自带 .next）；
+			// 单独更新 pi 只换依赖，同样不重建。
+			if (isNpmInstall(installation)) {
+				return target === "piweb" ? await installFromRegistry(installation, assertIdle) : await installPiIntoPackage(installation, assertIdle);
+			}
 			let version = "";
 			const release = await prepareRelease({
 				root: installation, env, run,

package/.next/server/chunks/131.js

@@ -1 +0,0 @@
-"use strict";exports.id=131,exports.ids=[131],exports.modules={6512:(a,b,c)=>{c.d(b,{Kt:()=>f,W8:()=>e});let d=["off","minimal","low","medium","high","xhigh","max"];function e(a){return a.reasoning?d.filter(b=>{let c=a.thinkingLevelMap?.[b];return null!==c&&("xhigh"!==b&&"max"!==b||void 0!==c)}):["off"]}function f(a,b){let c=e(a);if(c.includes(b))return b;let f=d.indexOf(b);if(-1===f)return c[0]??"off";for(let a=f;a<d.length;a++){let b=d[a];if(c.includes(b))return b}for(let a=f-1;a>=0;a--){let b=d[a];if(c.includes(b))return b}return c[0]??"off"}}};