@rexvane/piweb 0.3.20 → 0.3.21

package/src/components/update/CopyCommand.tsx

@@ -0,0 +1,34 @@
+"use client";
+
+import { useState } from "react";
+import { useI18n } from "@/i18n";
+import { copyText } from "@/lib/clipboard";
+
+/** 要用户自己在终端执行的命令：等宽显示 + 复制按钮（设置行和右下角提示条共用） */
+export function CopyCommand({ command }: { command: string }) {
+	const { t } = useI18n();
+	const [copied, setCopied] = useState<"" | "ok" | "fail">("");
+	return (
+		<span className="flex min-w-0 items-center gap-1.5">
+			<code
+				className="min-w-0 flex-1"
+				style={{ fontFamily: "var(--font-mono)", fontSize: 11, color: "var(--dsw-label-primary)", whiteSpace: "nowrap", overflowX: "auto" }}
+			>
+				{command}
+			</code>
+			<button
+				type="button"
+				className="btn-outline flex-none"
+				style={{ height: 22, padding: "0 8px", fontSize: 11, color: copied === "fail" ? "var(--dsw-danger)" : undefined }}
+				onClick={() => {
+					void copyText(command).then((ok) => {
+						setCopied(ok ? "ok" : "fail");
+						setTimeout(() => setCopied(""), 1500);
+					});
+				}}
+			>
+				{copied === "ok" ? t.updateCopied : copied === "fail" ? t.copyFailed : t.copy}
+			</button>
+		</span>
+	);
+}

package/src/components/update/UpdateNotice.tsx

@@ -0,0 +1,130 @@
+"use client";
+
+/**
+ * 右下角的更新提示条：每次服务启动提醒一次（按启动标识记在 localStorage，刷新、多开标签页不重复）。
+ *
+ * 只列启动检查时就有新版本的那几项：
+ * - 能直接更新的点「更新」，按 PiWeb → Pi 的顺序逐个装（同一时间只能有一个更新在跑）；
+ * - Windows 上的 npm 安装 PiWeb 不能替换运行中的自己，给命令和复制按钮；
+ * - 装好后提示手动重启，进程不自己重启。
+ * 状态和设置里的版本行共用（update-store），在哪边点都一样。
+ */
+import { useEffect, useState } from "react";
+import { CopyCommand } from "@/components/update/CopyCommand";
+import { loadUpdates, runUpdate, UPDATE_TARGETS, useUpdates, type TargetUpdate, type UpdateTarget } from "@/components/update/update-store";
+import { useI18n } from "@/i18n";
+
+/** 已经关掉过的那次启动的标识 */
+export const UPDATE_NOTICE_KEY = "piweb.updateNotice";
+
+const LABEL: Record<UpdateTarget, string> = { piweb: "PiWeb", pi: "Pi" };
+
+export function UpdateNotice() {
+	const { t } = useI18n();
+	const updates = useUpdates();
+	/** 读过 localStorage 之后才知道这次启动是否已经关掉过（服务端渲染没有 localStorage） */
+	const [dismissed, setDismissed] = useState<string | null | undefined>(undefined);
+	/** 启动检查时就有新版本的项：提示条只管这些，之后它们变成更新中 / 已更新 / 失败也留在条里 */
+	const [offered, setOffered] = useState<UpdateTarget[] | null>(null);
+
+	useEffect(() => {
+		try {
+			setDismissed(localStorage.getItem(UPDATE_NOTICE_KEY));
+		} catch {
+			setDismissed(null);
+		}
+		void loadUpdates();
+	}, []);
+
+	useEffect(() => {
+		if (offered === null && updates.loaded) setOffered(UPDATE_TARGETS.filter((target) => updates.targets[target].phase === "available"));
+	}, [offered, updates]);
+
+	if (dismissed === undefined || !offered?.length || !updates.startId || dismissed === updates.startId) return null;
+	const startId = updates.startId;
+	const items = offered.map((target) => ({ target, ...updates.targets[target] }));
+	const updatable = items.filter((item) => !item.command && (item.phase === "available" || item.phase === "error"));
+	const updating = items.some((item) => item.phase === "updating");
+	const anyUpdated = items.some((item) => item.phase === "updated");
+	const dismiss = () => {
+		try {
+			localStorage.setItem(UPDATE_NOTICE_KEY, startId);
+		} catch {
+			/* 存不下就只关这一页 */
+		}
+		setDismissed(startId);
+	};
+	const updateAll = async () => {
+		// 一个一个来：服务端同一时间只允许一个更新；前一个失败（比如有会话在跑）就停下
+		for (const item of updatable) {
+			if (!(await runUpdate(item.target))) break;
+		}
+	};
+	const title = updating ? t.updateNoticeUpdatingTitle : anyUpdated && !updatable.length ? t.updateNoticeDoneTitle : t.updateNoticeTitle;
+
+	return (
+		<div
+			role="status"
+			className="pointer-events-auto flex flex-col gap-2 rounded-xl px-3 py-2.5"
+			style={{ fontSize: 12.5, background: "var(--dsw-glass-popover)", border: "0.5px solid var(--dsw-border-l2)", boxShadow: "var(--dsw-elevation-soft)", borderLeft: "3px solid var(--dsw-accent)" }}
+			data-testid="update-notice"
+		>
+			<span style={{ fontWeight: 600, color: "var(--dsw-label-primary)" }}>{title}</span>
+			{items.map((item) => (
+				<div key={item.target} className="flex flex-col gap-1">
+					<span className="flex items-center gap-1.5" style={{ color: "var(--dsw-label-secondary)" }}>
+						<span style={{ color: "var(--dsw-label-primary)" }}>{LABEL[item.target]}</span>
+						<ItemStatus item={item} />
+					</span>
+					{item.command && item.phase === "available" ? (
+						<span className="flex flex-col gap-1">
+							<span style={{ fontSize: 11.5, color: "var(--dsw-label-tertiary)" }}>{t.updateRunCommandHint}</span>
+							<CopyCommand command={item.command} />
+						</span>
+					) : null}
+				</div>
+			))}
+			{anyUpdated && !updating ? <span style={{ fontSize: 11.5, color: "var(--dsw-label-tertiary)" }}>{t.updateRestartHint}</span> : null}
+			{!updating ? (
+				<div className="flex justify-end gap-2">
+					<button type="button" className="btn-outline" style={{ height: 26, padding: "0 12px", fontSize: 12 }} onClick={dismiss}>
+						{anyUpdated || !updatable.length ? t.updateNoticeOk : t.updateNoticeLater}
+					</button>
+					{updatable.length ? (
+						<button type="button" className="btn-primary-white" style={{ height: 26, padding: "0 12px", fontSize: 12 }} onClick={() => void updateAll()}>
+							{t.updateNoticeUpdate}
+						</button>
+					) : null}
+				</div>
+			) : null}
+		</div>
+	);
+}
+
+function ItemStatus({ item }: { item: TargetUpdate }) {
+	const { t } = useI18n();
+	if (item.phase === "updating") {
+		return (
+			<span className="flex items-center gap-1.5" style={{ color: "var(--dsw-label-tertiary)" }}>
+				<span className="h-3 w-3 flex-none animate-spin rounded-full border-2 border-current border-t-transparent" />
+				{t.updatingNow}
+			</span>
+		);
+	}
+	if (item.phase === "updated") return <span style={{ color: "var(--dsw-success)" }}>{t.updateNoticeUpdated.replace("{v}", item.latest)}</span>;
+	if (item.phase === "error") {
+		// npm / 构建的报错可能很长：只露三行，完整内容放在悬停提示里
+		return (
+			<span className="line-clamp-3 min-w-0 break-all" style={{ color: "var(--dsw-danger)" }} title={item.error}>
+				{item.busy ? t.updateBusy : `${t.updateFailed}: ${item.error}`}
+			</span>
+		);
+	}
+	return <span>{versionChange(item, t.updateCommits)}</span>;
+}
+
+/** 「0.3.18 → 0.3.20」；Git 检出版本号没变、只有新提交时写提交数 */
+export function versionChange(item: Pick<TargetUpdate, "current" | "latest" | "behind">, commitsText: string): string {
+	if (item.latest === item.current && item.behind > 0) return commitsText.replace("{n}", String(item.behind));
+	return `${item.current} → ${item.latest}`;
+}

package/src/components/update/update-store.ts

@@ -0,0 +1,155 @@
+import { useSyncExternalStore } from "react";
+
+/**
+ * 更新状态的前端单例：设置里的两行「PiWeb 版本 / Pi 版本」和右下角提示条共用一份，
+ * 在一处点了更新，另一处同步显示进度和结果。
+ *
+ * 页面打开时取一次启动检查的结果（GET /api/update，服务启动时已经在查），
+ * 不用先点「检查更新」就知道有没有新版本。
+ */
+
+export type UpdateTarget = "piweb" | "pi";
+export type UpdatePhase = "idle" | "checking" | "available" | "updating" | "latest" | "updated" | "error";
+
+export interface TargetUpdate {
+	phase: UpdatePhase;
+	current: string;
+	latest: string;
+	/** Git 检出：main 上落后的提交数（版本号没变时用它说明「有新提交」） */
+	behind: number;
+	/** 要用户自己执行的命令（Windows 上的 npm 安装 PiWeb 不能替换运行中的自己）；空串表示能直接更新 */
+	command: string;
+	error: string;
+	/** 失败是因为有会话正在运行（409） */
+	busy: boolean;
+}
+
+export interface UpdateState {
+	/** 启动检查的结果取回来了（成功或失败都算） */
+	loaded: boolean;
+	/** 本次服务启动的标识，提示条按它做到「每次启动提醒一次」；关掉启动检查时为 null */
+	startId: string | null;
+	targets: Record<UpdateTarget, TargetUpdate>;
+}
+
+export const UPDATE_TARGETS: readonly UpdateTarget[] = ["piweb", "pi"];
+
+interface CheckData {
+	current: string;
+	latest: string;
+	canUpdate: boolean;
+	behind?: number;
+	command?: string;
+	updatedTo?: string;
+}
+
+const blank = (): TargetUpdate => ({ phase: "idle", current: "", latest: "", behind: 0, command: "", error: "", busy: false });
+const initial = (): UpdateState => ({ loaded: false, startId: null, targets: { piweb: blank(), pi: blank() } });
+
+let state: UpdateState = initial();
+let loading: Promise<void> | null = null;
+const listeners = new Set<() => void>();
+
+function emit(): void {
+	for (const listener of listeners) listener();
+}
+
+function patch(target: UpdateTarget, next: Partial<TargetUpdate>): void {
+	state = { ...state, targets: { ...state.targets, [target]: { ...state.targets[target], ...next } } };
+	emit();
+}
+
+function fromCheck(check: CheckData): Partial<TargetUpdate> {
+	const base = { current: check.current, behind: check.behind ?? 0, error: "", busy: false };
+	if (check.updatedTo) return { ...base, phase: "updated", latest: check.updatedTo, command: "" };
+	if (check.canUpdate) return { ...base, phase: "available", latest: check.latest, command: check.command ?? "" };
+	return { ...base, phase: "latest", latest: check.latest, command: "" };
+}
+
+class UpdateRequestError extends Error {
+	busy: boolean;
+	constructor(message: string, busy: boolean) {
+		super(message);
+		this.busy = busy;
+	}
+}
+
+async function post(target: UpdateTarget, action: "check" | "update") {
+	const response = await fetch("/api/update", {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ target, action }),
+	});
+	const json = await response.json();
+	if (!json.success) throw new UpdateRequestError(String(json.error ?? response.status), response.status === 409);
+	return json.data;
+}
+
+function failure(error: unknown): Partial<TargetUpdate> {
+	return { phase: "error", error: error instanceof Error ? error.message : String(error), busy: error instanceof UpdateRequestError && error.busy };
+}
+
+/** 取启动检查的结果；每个页面只取一次（设置面板反复开关不重复请求） */
+export function loadUpdates(): Promise<void> {
+	loading ??= (async () => {
+		try {
+			const response = await fetch("/api/update", { cache: "no-store" });
+			const json = await response.json();
+			if (!json.success) throw new Error(String(json.error));
+			const targets = { ...state.targets };
+			for (const target of UPDATE_TARGETS) {
+				const result = json.data?.results?.[target];
+				// 已经手动查过 / 正在更新的不覆盖；启动检查失败的项留在 idle，照旧手动检查
+				if (targets[target].phase !== "idle" || !result || "error" in result) continue;
+				targets[target] = { ...targets[target], ...fromCheck(result) };
+			}
+			state = { loaded: true, startId: json.data?.startId ?? null, targets };
+		} catch {
+			state = { ...state, loaded: true };
+		}
+		emit();
+	})();
+	return loading;
+}
+
+export async function checkUpdate(target: UpdateTarget): Promise<void> {
+	patch(target, { phase: "checking", error: "", busy: false });
+	try {
+		patch(target, fromCheck(await post(target, "check")));
+	} catch (error) {
+		patch(target, failure(error));
+	}
+}
+
+/** 更新一项；成功返回 true。装好后要用户手动重启，进程不自己重启 */
+export async function runUpdate(target: UpdateTarget): Promise<boolean> {
+	patch(target, { phase: "updating", error: "", busy: false });
+	try {
+		const data = await post(target, "update");
+		patch(target, { phase: "updated", latest: data?.version || state.targets[target].latest, command: "" });
+		return true;
+	} catch (error) {
+		patch(target, failure(error));
+		return false;
+	}
+}
+
+function subscribe(listener: () => void): () => void {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+
+const getState = () => state;
+
+export function useUpdates(): UpdateState {
+	return useSyncExternalStore(subscribe, getState, getState);
+}
+
+/** 仅供测试：回到页面刚打开时的状态 */
+export function resetUpdates(): void {
+	state = initial();
+	loading = null;
+	emit();
+}

package/src/hooks/usePiWeb.ts

@@ -4,6 +4,7 @@
  * 中央状态：会话列表轮询、当前会话 SSE 订阅、事件折叠（快照→增量）、命令发送。
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { pollEventStream, usesEventPolling } from "@/lib/chat/event-stream";
 import { createEventBatcher, type EventBatcher } from "@/lib/event-batcher";
 import type {
 	GrowthConsentRequest,
@@ -194,6 +195,9 @@ export const foldPiWebEvent = (state: PiWebState, evt: WebEvent): PiWebState =>
 				tools: { active: evt.active, all: evt.all.map((n) => ({ name: n })) },
 			};
 			return s;
+		case "context_breakdown":
+			if (s.snapshot) s.snapshot = { ...s.snapshot, contextBreakdown: evt.breakdown };
+			return s;
 		case "resources":
 			if (s.snapshot) {
 				s.snapshot = {
@@ -350,7 +354,7 @@ export function usePiWeb() {
 	const [orderBy, setOrderByState] = useState<"updated" | "manual">("updated");
 	const [resyncNonce, setResyncNonce] = useState(0);
 	const [snapshotEpoch, setSnapshotEpoch] = useState(0);
-	const esRef = useRef<EventSource | null>(null);
+	const esRef = useRef<{ close(): void } | null>(null);
 	const promptRequestsRef = useRef(new Set<string>());
 	const presetRestoreAttemptRef = useRef<string | null>(null);
 	const presetRestorePromiseRef = useRef<Promise<void> | null>(null);
@@ -674,38 +678,21 @@ export function usePiWeb() {
 			? { ...current, connected: false }
 			: { ...emptyState(savedToolPreset()), connected: false });
 		let retryDelayMs = 2000;
+		const eventsUrl = `/api/agent/${currentId}/events`;
 		const connect = () => {
-			const es = new EventSource(`/api/agent/${currentId}/events`);
-			esRef.current = es;
-			es.onopen = () => {
-				retryDelayMs = 2000;
-				setState((s) => ({ ...s, connected: true }));
-			};
-			es.onerror = () => {
-				setState((s) => ({ ...s, connected: false }));
-				if (esRef.current !== es) return;
-				// 网络断开时浏览器自己会重连，并带上 Last-Event-ID 让服务端从环形缓冲续放
-				// （只补漏掉的几条事件）。这时手动重建就等于丢掉续传、每次都拉一份全量快照。
-				if (es.readyState !== EventSource.CLOSED) return;
-				// 浏览器对非 200 响应会永久放弃自动重连：这里手动兜底，关掉后延迟重建，
-				// 重建时会拿到全新快照。
-				es.close();
-				esRef.current = null;
-				const delay = retryDelayMs;
-				retryDelayMs = Math.min(retryDelayMs * 2, 30_000);
-				retryTimer = setTimeout(() => {
-					if (esRef.current === null) connect();
-				}, delay);
-			};
 			// 流式事件按帧合并：token 速率再高也只每 16ms 渲染一次（见 event-batcher）
 			const batcher = createEventBatcher<WebEvent>({
 				flush: (events) => setState((s) => events.reduce((acc, evt) => foldPiWebEvent(acc, evt), s)),
 			});
 			batcherRef.current = batcher;
-			es.onmessage = (e) => {
+			const onOpen = () => {
+				retryDelayMs = 2000;
+				setState((s) => ({ ...s, connected: true }));
+			};
+			const onMessage = (data: string) => {
 				let parsed: any;
 				try {
-					parsed = JSON.parse(e.data);
+					parsed = JSON.parse(data);
 				} catch {
 					// 单帧损坏（代理截断等）只丢弃该帧，不能让 EventSource 回调抛异常
 					return;
@@ -737,6 +724,36 @@ export function usePiWeb() {
 					batcher.push(parsed as WebEvent);
 				}
 			};
+			// Cloudflare 快速隧道不支持 SSE（流被攒成 128KB 一块，快照永远收不全）：改用长轮询，
+			// 失败退避、Last-Event-ID 续传都在 pollEventStream 里
+			if (usesEventPolling(window.location.hostname)) {
+				esRef.current = pollEventStream(eventsUrl, {
+					onOpen,
+					onMessage,
+					onError: () => setState((s) => ({ ...s, connected: false })),
+				});
+				return;
+			}
+			const es = new EventSource(eventsUrl);
+			esRef.current = es;
+			es.onopen = onOpen;
+			es.onerror = () => {
+				setState((s) => ({ ...s, connected: false }));
+				if (esRef.current !== es) return;
+				// 网络断开时浏览器自己会重连，并带上 Last-Event-ID 让服务端从环形缓冲续放
+				// （只补漏掉的几条事件）。这时手动重建就等于丢掉续传、每次都拉一份全量快照。
+				if (es.readyState !== EventSource.CLOSED) return;
+				// 浏览器对非 200 响应会永久放弃自动重连：这里手动兜底，关掉后延迟重建，
+				// 重建时会拿到全新快照。
+				es.close();
+				esRef.current = null;
+				const delay = retryDelayMs;
+				retryDelayMs = Math.min(retryDelayMs * 2, 30_000);
+				retryTimer = setTimeout(() => {
+					if (esRef.current === null) connect();
+				}, delay);
+			};
+			es.onmessage = (e) => onMessage(e.data);
 		};
 		let retryTimer: ReturnType<typeof setTimeout> | undefined;
 		connect();

package/src/i18n.tsx

@@ -323,6 +323,9 @@ const zh = {
 	contextCompacted: "Compacted Data",
 	contextAutoCompactBuffer: "Auto-Compact Buffer",
 	contextFreeSpace: "Free Space",
+	contextColdHint: "会话还没启动，System Prompt 和工具定义要启动后才算得出",
+	contextCountNow: "现在统计",
+	contextCounting: "统计中…",
 	// 统计条
 	turns: "轮次",
 	toolCalls: "工具调用",
@@ -532,9 +535,9 @@ const zh = {
 	trustAlways: "总是信任",
 	trustNever: "从不信任",
 	versionPiweb: "PiWeb 版本",
-	versionPiwebDesc: "本 Web 应用的版本，点击打开仓库",
+	versionPiwebDesc: "本 Web 应用的版本；启动时自动检查，有新版本在这里直接更新（点版本号打开仓库）",
 	versionPi: "Pi 版本",
-	versionPiDesc: "pi 智能体内核的版本，点击打开仓库",
+	versionPiDesc: "pi 智能体内核的版本；启动时自动检查，有新版本在这里直接更新（点版本号打开仓库）",
 	checkUpdate: "检查更新",
 	checkingUpdate: "检查中…",
 	upToDate: "已是最新",
@@ -543,6 +546,18 @@ const zh = {
 	updatedTo: "已更新到 {v}，重启 PiWeb 后生效",
 	updateFailed: "更新失败",
 	updateManualHint: "先停止 piweb，再执行上面的命令（Windows 无法替换运行中的安装目录）",
+	updateCopied: "已复制",
+	updateBusy: "有会话正在运行，等它结束再更新",
+	updateCommits: "main 新增 {n} 个提交",
+	updateNoticeTitle: "有新版本",
+	updateNoticeUpdatingTitle: "正在更新…",
+	updateNoticeDoneTitle: "更新完成",
+	updateNoticeUpdate: "更新",
+	updateNoticeLater: "稍后",
+	updateNoticeOk: "知道了",
+	updateNoticeUpdated: "已更新到 {v}",
+	updateRunCommandHint: "先停掉 piweb，再在终端运行：",
+	updateRestartHint: "重启 PiWeb 后生效：在运行 piweb 的终端按 Ctrl+C，再重新运行 piweb",
 	skillsDesc: "关闭后技能不会出现在系统提示中，仅可通过 /skill:名称 手动调用",
 	confirmDeleteSkill: "确定删除技能“{name}”吗？将删除其所在技能目录，不可恢复。",
 	deleteSkillHint: "删除技能目录",
@@ -653,6 +668,26 @@ const zh = {
 	viewerNotInSnapshot: "此文件不在快照里（超过 1MB 或被排除），显示磁盘上的当前内容",
 	viewerLoadFailed: "加载失败",
 	viewerEmpty: "从左侧树里选择一个文件",
+	// 流式输出
+	streamStyleTitle: "流式输出样式",
+	streamStyleDesc: "回答逐字出现的方式；改完立刻生效，正在流出的回答也一并换",
+	streamStyleSmooth: "平滑",
+	streamStyleSmoothDesc: "匀速长出，不跳字",
+	streamStyleTypewriter: "打字机",
+	streamStyleTypewriterDesc: "固定节奏逐字敲出",
+	streamStyleFade: "渐显",
+	streamStyleFadeDesc: "整词推进，段落柔和淡入",
+	streamStyleInstant: "即时",
+	streamStyleInstantDesc: "立即显示，不做平滑",
+	streamSpeedTitle: "推进速度",
+	streamSpeedDesc: "平滑 / 打字机 / 渐显的节奏快慢；即时样式不受影响",
+	streamSpeed1: "慢",
+	streamSpeed2: "较慢",
+	streamSpeed3: "标准",
+	streamSpeed4: "快",
+	streamSpeed5: "极快",
+	streamCaretTitle: "打字光标",
+	streamCaretDesc: "流式期间在文字末尾显示闪烁光标",
 } as const;
 
 type Dict = { [K in keyof typeof zh]: string };
@@ -971,6 +1006,9 @@ const en: Dict = {
 	contextCompacted: "Compacted Data",
 	contextAutoCompactBuffer: "Auto-Compact Buffer",
 	contextFreeSpace: "Free Space",
+	contextColdHint: "Session not started yet — System Prompt and tool definitions are counted once it starts",
+	contextCountNow: "Count now",
+	contextCounting: "Counting…",
 	turns: "turns",
 	toolCalls: "tool calls",
 	cost: "cost",
@@ -1175,9 +1213,9 @@ const en: Dict = {
 	trustAlways: "Always trust",
 	trustNever: "Never trust",
 	versionPiweb: "PiWeb version",
-	versionPiwebDesc: "Version of this web app; click to open the repo",
+	versionPiwebDesc: "Version of this web app; checked at startup and updatable right here (click the version to open the repo)",
 	versionPi: "Pi version",
-	versionPiDesc: "Version of the pi agent engine; click to open the repo",
+	versionPiDesc: "Version of the pi agent engine; checked at startup and updatable right here (click the version to open the repo)",
 	checkUpdate: "Check for updates",
 	checkingUpdate: "Checking…",
 	upToDate: "Up to date",
@@ -1186,6 +1224,18 @@ const en: Dict = {
 	updatedTo: "Updated to {v}; restart PiWeb to apply",
 	updateFailed: "Update failed",
 	updateManualHint: "Stop piweb, then run the command above (Windows cannot replace a running installation)",
+	updateCopied: "Copied",
+	updateBusy: "A session is running; update after it finishes",
+	updateCommits: "{n} new commits on main",
+	updateNoticeTitle: "Update available",
+	updateNoticeUpdatingTitle: "Updating…",
+	updateNoticeDoneTitle: "Update installed",
+	updateNoticeUpdate: "Update",
+	updateNoticeLater: "Later",
+	updateNoticeOk: "Got it",
+	updateNoticeUpdated: "Updated to {v}",
+	updateRunCommandHint: "Stop piweb, then run in a terminal:",
+	updateRestartHint: "Restart PiWeb to apply: press Ctrl+C in the terminal running piweb, then run piweb again",
 	skillsDesc: "Disabled skills are hidden from the system prompt and only callable via /skill:name",
 	confirmDeleteSkill: "Delete skill \"{name}\"? Its skill directory will be removed and cannot be recovered.",
 	deleteSkillHint: "Delete the skill directory",
@@ -1295,6 +1345,26 @@ const en: Dict = {
 	viewerNotInSnapshot: "Not in the snapshot (over 1MB or excluded); showing the current content from disk",
 	viewerLoadFailed: "Failed to load",
 	viewerEmpty: "Pick a file from the tree on the left",
+	// Streaming text
+	streamStyleTitle: "Streaming text",
+	streamStyleDesc: "How the answer appears while it arrives; applies to the stream already running",
+	streamStyleSmooth: "Smooth",
+	streamStyleSmoothDesc: "Even pace, no jumps",
+	streamStyleTypewriter: "Typewriter",
+	streamStyleTypewriterDesc: "Fixed cadence, character by character",
+	streamStyleFade: "Fade in",
+	streamStyleFadeDesc: "Whole words, paragraphs fade in",
+	streamStyleInstant: "Instant",
+	streamStyleInstantDesc: "Show immediately, no smoothing",
+	streamSpeedTitle: "Streaming speed",
+	streamSpeedDesc: "Cadence for Smooth / Typewriter / Fade in; Instant ignores it",
+	streamSpeed1: "Slow",
+	streamSpeed2: "Relaxed",
+	streamSpeed3: "Standard",
+	streamSpeed4: "Fast",
+	streamSpeed5: "Fastest",
+	streamCaretTitle: "Typing caret",
+	streamCaretDesc: "Blinking caret at the end of the text while streaming",
 };
 
 const dicts: Record<string, Dict> = { zh, en };

package/src/instrumentation-node.ts

@@ -12,6 +12,9 @@ export async function registerNode() {
 	const { authEnabled } = await import("./lib/web-auth");
 	if (authEnabled()) (await import("./lib/web-launch-token")).publishLaunchToken();
 
+	// 每次启动检查一次 PiWeb / pi 有没有新版本：不等结果，查到了在终端打一行，页面右下角也会提醒
+	void (await import("./lib/update/startup-check")).ensureStartupCheck().catch(() => {});
+
 	const { remoteBlocked, remoteLanEnabled, startLan } = await import("./lib/remote/supervisor");
 	if (!remoteLanEnabled()) return;