@rexvane/piweb 0.3.17 → 0.3.19

package/src/lib/remote/supervisor.ts

@@ -0,0 +1,482 @@
+/**
+ * 「远程连接」内置插件的控制面。它管两个监听：
+ *
+ *   1. 局域网入口 —— 手机排版注入代理，绑 0.0.0.0。默认就该有，手机连同一个 WiFi 就能用。
+ *   2. 公网入口 —— cloudflared 快速隧道，指向局域网入口。由设置页的按钮开关。
+ *
+ * 引擎（隧道实现）刻意做成可替换的：`startPublic` 只依赖「起一个进程 + 从输出里抓到
+ * https 地址」这两件事，换 ngrok / frp 时改这一个函数即可。
+ *
+ * 状态挂 globalThis：Next 的热重载会重新求值模块，不能把监听弄丢或重复起。
+ */
+import { spawn, type ChildProcess } from "node:child_process";
+import fs from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import os from "node:os";
+import path from "node:path";
+import { authEnabled } from "../web-auth";
+import { agentDir } from "../web-secret";
+import { createMobileProxy, MOBILE_FIT_CSS, MOBILE_FIT_JS } from "./mobile-proxy";
+
+export const PLUGIN_ID = "builtin-remote";
+export const DEFAULT_LAN_PORT = 30142;
+/** cloudflared 快速隧道给的地址长这样 */
+const PUBLIC_URL_PATTERN = /https:\/\/[a-z0-9][a-z0-9-]*\.trycloudflare\.com/;
+const TUNNEL_TIMEOUT_MS = 45_000;
+/** 拿到地址后等它就绪的上限：快速隧道的域名要十几秒才在全球 DNS 生效 */
+const TUNNEL_READY_TIMEOUT_MS = 60_000;
+const TUNNEL_READY_POLL_MS = 2_500;
+
+/**
+ * 从 cloudflared 的输出里抓公网地址，**只认第一个**。
+ *
+ * 为什么必须只认第一个：隧道域名是绑在隧道上的，一次运行期内不该变。
+ * cloudflared 在重连等情况下的输出里可能再出现一个地址，若跟着换，
+ * 用户手里那条链接会当场失效，旧域名还会留在 Host 白名单里没人摘。
+ */
+export function createUrlCatcher(pattern: RegExp = PUBLIC_URL_PATTERN) {
+	let captured: string | null = null;
+	let buffer = "";
+	return {
+		/** 返回新捕获到的地址；已经捕获过、或这次还没匹配到，都返回 null */
+		feed(chunk: string): string | null {
+			if (captured) return null;
+			// 累积再匹配：子进程的 chunk 边界不保证落在行边界上，
+			// 逐块匹配会把一个被切断的地址整条漏掉。
+			buffer += chunk;
+			const match = pattern.exec(buffer);
+			if (!match) {
+				// 只留尾巴，够覆盖一个被切断的地址即可，避免缓冲无限增长
+				if (buffer.length > 4096) buffer = buffer.slice(-4096);
+				return null;
+			}
+			captured = match[0];
+			buffer = "";
+			return captured;
+		},
+		get url(): string | null {
+			return captured;
+		},
+	};
+}
+
+/**
+ * 探一次隧道是否真的可用。
+ *
+ * 只看 DNS 不够：域名解析出来之后边缘还可能要几秒才把请求转到这条隧道上。
+ * 所以这里发一次 HEAD，把「能连上并拿到 HTTP 响应」当作就绪标准；
+ * 4xx 也算就绪（说明请求已经打到我们的上游了），只有连不上/DNS 失败才算没就绪。
+ */
+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);
+		});
+		request.on("timeout", () => { request.destroy(); resolve(false); });
+		request.on("error", () => resolve(false));
+		request.end();
+	});
+}
+
+/** 等隧道真的能连上；等不到也返回（地址已经拿到，用户至少能看到它） */
+async function waitForTunnelReady(url: string, keepGoing: () => boolean): Promise<boolean> {
+	const deadline = Date.now() + TUNNEL_READY_TIMEOUT_MS;
+	for (;;) {
+		if (!keepGoing()) return false;
+		if (await probeTunnel(url)) return true;
+		if (Date.now() >= deadline) return false;
+		await new Promise((resolve) => setTimeout(resolve, TUNNEL_READY_POLL_MS));
+	}
+}
+
+export type TunnelEngine = "cloudflared";
+
+export interface LanState {
+	running: boolean;
+	port: number | null;
+	urls: string[];
+	error: string | null;
+}
+
+export interface PublicState {
+	running: boolean;
+	url: string | null;
+	/** 地址已可访问。快速隧道拿到地址后还要十几秒域名才在全球 DNS 生效 */
+	ready: boolean;
+	engine: TunnelEngine | null;
+	/** 引擎二进制是否可用；不可用时 UI 应给出安装提示而不是「启动失败」 */
+	engineAvailable: boolean;
+	error: string | null;
+}
+
+/** 不允许开入口的原因：没开认证 / 开发模式（Next 开发工具端点不能暴露出去） */
+export type RemoteBlocked = "auth" | "dev";
+
+export interface RemoteStatus {
+	plugin: typeof PLUGIN_ID;
+	/** PiWeb 自己的端口（局域网入口的转发目标） */
+	targetPort: number;
+	/** 非空时两个入口都不许开，UI 应置灰按钮并说明原因 */
+	blocked: RemoteBlocked | null;
+	lan: LanState;
+	public: PublicState;
+}
+
+interface SupervisorState {
+	lan: { server: http.Server; port: number } | null;
+	tunnel: { child: ChildProcess; url: string | null; ready: boolean } | null;
+	/** 正在启动中的那一次：并发调用复用它，不能起两个监听 / 两个 cloudflared */
+	lanStarting?: Promise<LanState> | null;
+	publicStarting?: Promise<PublicState> | null;
+	lanError: string | null;
+	publicError: string | null;
+	enginePath: string | null;
+	engineChecked: boolean;
+}
+
+/**
+ * 入口能不能开。两个入口都会把 PiWeb 交给本机以外的设备，所以：
+ *  - 没开认证绝不能开（直接 `next start`、或显式 PI_WEB_AUTH=0 时，开出去就是一个免密 shell）；
+ *  - 开发模式不能开（认证保护不了 Next 开发工具端点，启动器也拒绝非本机开发模式）。
+ */
+export function remoteBlocked(env: Record<string, string | undefined> = process.env): RemoteBlocked | null {
+	if (!authEnabled(env)) return "auth";
+	if (env.NODE_ENV === "development") return "dev";
+	return null;
+}
+
+const STATE_KEY = "piweb:remote-supervisor";
+
+/**
+ * 把隧道域名并进 Host 白名单。
+ *
+ * 必须是动态的：快速隧道的域名每次启动都变，没法在启动前写进环境变量。
+ * isSafeHost 每次请求现读 process.env，所以同进程内改了立刻生效，不用重启。
+ */
+export function allowTunnelHost(url: string): void {
+	let hostname: string;
+	try {
+		hostname = new URL(url).hostname.toLowerCase();
+	} catch {
+		return;
+	}
+	const current = (process.env.PI_WEB_TRUSTED_HOSTS ?? "")
+		.split(",")
+		.map((part) => part.trim().toLowerCase())
+		.filter(Boolean);
+	if (!current.includes(hostname)) current.push(hostname);
+	process.env.PI_WEB_TRUSTED_HOSTS = current.join(",");
+}
+
+/** 隧道停了就把域名从白名单摘掉：不要给一个已经没人管的域名留后门 */
+export function disallowTunnelHost(url: string | null): void {
+	if (!url) return;
+	let hostname: string;
+	try {
+		hostname = new URL(url).hostname.toLowerCase();
+	} catch {
+		return;
+	}
+	const remaining = (process.env.PI_WEB_TRUSTED_HOSTS ?? "")
+		.split(",")
+		.map((part) => part.trim().toLowerCase())
+		.filter((part) => part && part !== hostname);
+	process.env.PI_WEB_TRUSTED_HOSTS = remaining.join(",");
+}
+
+function state(): SupervisorState {
+	const store = globalThis as Record<PropertyKey, unknown>;
+	const key = Symbol.for(STATE_KEY);
+	const existing = store[key] as SupervisorState | undefined;
+	if (existing) return existing;
+	const created: SupervisorState = { lan: null, tunnel: null, lanError: null, publicError: null, enginePath: null, engineChecked: false };
+	store[key] = created;
+	return created;
+}
+
+/** PiWeb 自己的监听端口：启动器显式给的优先 */
+export function piwebPort(env: Record<string, string | undefined> = process.env): number {
+	for (const raw of [env.PIWEB_PORT, env.PORT]) {
+		const value = Number(raw);
+		if (Number.isInteger(value) && value >= 1 && value <= 65535) return value;
+	}
+	return 30141;
+}
+
+function isOff(value: string | undefined): boolean {
+	const flag = (value ?? "").trim().toLowerCase();
+	return flag === "0" || flag === "false" || flag === "off" || flag === "no";
+}
+
+/**
+ * 局域网入口是否随服务启动。默认开 —— 「不开启也默认局域网可用」就是这个开关。
+ * 设 PIWEB_REMOTE_LAN=0 关掉。
+ */
+export function remoteLanEnabled(env: Record<string, string | undefined> = process.env): boolean {
+	return !isOff(env.PIWEB_REMOTE_LAN);
+}
+
+export function remoteLanPort(env: Record<string, string | undefined> = process.env): number {
+	const value = Number(env.PIWEB_REMOTE_LAN_PORT);
+	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())) {
+		for (const entry of entries ?? []) {
+			if (entry.family === "IPv4" && !entry.internal && !entry.address.startsWith("169.254.")) out.push(entry.address);
+		}
+	}
+	return out;
+}
+
+export function remoteStatus(): RemoteStatus {
+	const current = state();
+	const lanPort = current.lan?.port ?? null;
+	return {
+		plugin: PLUGIN_ID,
+		targetPort: piwebPort(),
+		blocked: remoteBlocked(),
+		lan: {
+			running: Boolean(current.lan),
+			port: lanPort,
+			urls: lanPort ? lanAddresses().map((address) => `http://${address}:${lanPort}`) : [],
+			error: current.lanError,
+		},
+		public: {
+			running: Boolean(current.tunnel),
+			url: current.tunnel?.url ?? null,
+			ready: Boolean(current.tunnel?.ready),
+			engine: current.tunnel ? "cloudflared" : null,
+			engineAvailable: current.engineChecked ? current.enginePath !== null : true,
+			error: current.publicError,
+		},
+	};
+}
+
+/** PiWeb 自己管的引擎位置（与 web-secret 同一批状态文件放在 agent 目录下） */
+export function managedEnginePath(): string {
+	return path.join(agentDir(), "web-bin", process.platform === "win32" ? "cloudflared.exe" : "cloudflared");
+}
+
+/**
+ * 引擎查找顺序：
+ *   1. PIWEB_CLOUDFLARED（显式指定绝对路径）
+ *   2. PiWeb 自己管的位置（「一键安装」就放这儿）
+ *   3. PATH 上的 cloudflared
+ * 都没找到时返回 PATH 上的名字，让 spawn 报 ENOENT —— startPublic 会翻译成安装提示。
+ */
+function resolveTunnelEngine(): string {
+	const explicit = process.env.PIWEB_CLOUDFLARED?.trim();
+	if (explicit) return explicit;
+	const managed = managedEnginePath();
+	try {
+		if (fs.existsSync(managed)) return managed;
+	} catch {
+		/* 读不了就当没有 */
+	}
+	return "cloudflared";
+}
+
+/** 探测隧道引擎是否可用（结果缓存） */
+export function tunnelEngine(): string | null {
+	const current = state();
+	if (current.engineChecked) return current.enginePath;
+	current.engineChecked = true;
+	current.enginePath = resolveTunnelEngine();
+	return current.enginePath;
+}
+
+export function markEngineMissing(): void {
+	const current = state();
+	current.engineChecked = true;
+	current.enginePath = null;
+}
+
+/** 起局域网入口；已经在跑（或正在起）就复用。targetPort 默认转发回 PiWeb 自己，测试可改成别的上游。 */
+export function startLan(port = remoteLanPort(), host = "0.0.0.0", targetPort = piwebPort()): Promise<LanState> {
+	const current = state();
+	if (current.lan) return Promise.resolve(remoteStatus().lan);
+	if (current.lanStarting) return current.lanStarting;
+	const starting = listenLan(port, host, targetPort).finally(() => {
+		if (current.lanStarting === starting) current.lanStarting = null;
+	});
+	current.lanStarting = starting;
+	return starting;
+}
+
+async function listenLan(port: number, host: string, targetPort: number): Promise<LanState> {
+	const current = state();
+	current.lanError = null;
+	const server = createMobileProxy({
+		targetPort,
+		css: MOBILE_FIT_CSS,
+		js: MOBILE_FIT_JS,
+		log: (message) => console.warn(message),
+	});
+	try {
+		await new Promise<void>((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(port, host, resolve);
+		});
+	} catch (error) {
+		current.lanError = error instanceof Error ? error.message : String(error);
+		server.close();
+		return remoteStatus().lan;
+	}
+	current.lan = { server, port };
+	return remoteStatus().lan;
+}
+
+export async function stopLan(): Promise<void> {
+	const current = state();
+	const lan = current.lan;
+	current.lan = null;
+	if (!lan) return;
+	lan.server.closeAllConnections?.();
+	await new Promise<void>((resolve) => lan.server.close(() => resolve()));
+}
+
+/**
+ * 起公网隧道；已在跑（或正在起）就复用。
+ * 「正在起」必须算进来：起局域网入口、等 cloudflared 吐地址都要 await，连点两下若各自 spawn，
+ * 先起的那个会变成没人管的孤儿进程，它的域名还留在 Host 白名单里。
+ */
+export function startPublic(): Promise<PublicState> {
+	const current = state();
+	if (current.tunnel) return Promise.resolve(remoteStatus().public);
+	if (current.publicStarting) return current.publicStarting;
+	const starting = spawnTunnel().finally(() => {
+		if (current.publicStarting === starting) current.publicStarting = null;
+	});
+	current.publicStarting = starting;
+	return starting;
+}
+
+/** 把一条隧道彻底收掉：摘白名单、清状态、杀进程（只动传进来的这一条） */
+function dropTunnel(child: ChildProcess): void {
+	const current = state();
+	const active = current.tunnel;
+	if (active?.child === child) {
+		disallowTunnelHost(active.url);
+		current.tunnel = null;
+	}
+	if (child.exitCode === null && !child.killed) child.kill();
+}
+
+async function spawnTunnel(): Promise<PublicState> {
+	const current = state();
+	current.publicError = null;
+
+	// 公网入口转发到局域网入口，所以局域网入口必须在跑
+	if (!current.lan) await startLan();
+	const lan = remoteStatus().lan;
+	if (!lan.running || lan.port === null) {
+		current.publicError = lan.error ?? "局域网入口没能启动，公网入口无从转发";
+		return remoteStatus().public;
+	}
+
+	const binary = tunnelEngine();
+	if (!binary) {
+		current.publicError = "找不到 cloudflared";
+		return remoteStatus().public;
+	}
+
+	const child = spawn(binary, ["tunnel", "--no-autoupdate", "--url", `http://127.0.0.1:${lan.port}`], {
+		stdio: ["ignore", "pipe", "pipe"],
+		windowsHide: true,
+	});
+	current.tunnel = { child, url: null, ready: false };
+
+	await new Promise<void>((resolve) => {
+		let settled = false;
+		const finish = (error?: string) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			if (error) current.publicError = error;
+			resolve();
+		};
+		const timer = setTimeout(() => {
+			// 不收掉的话进程还活着、状态一直是「运行中」却永远没有地址
+			dropTunnel(child);
+			finish("启动隧道超时：cloudflared 没有在 45 秒内给出地址");
+		}, TUNNEL_TIMEOUT_MS);
+		const catcher = createUrlCatcher();
+		const scan = (chunk: Buffer) => {
+			const url = catcher.feed(chunk.toString("utf8"));
+			if (!url || !current.tunnel) return;
+			current.tunnel.url = url;
+			// 域名必须先放行再算启动成功，否则第一次访问必然被 Host 校验挡成 403
+			allowTunnelHost(url);
+			// 抓到就够了，摘掉监听：既避免后续输出改动已生效的地址，也不白占着流
+			child.stdout?.off("data", scan);
+			child.stderr?.off("data", scan);
+			finish();
+		};
+		child.stdout?.on("data", scan);
+		child.stderr?.on("data", scan);
+		child.once("error", (error: NodeJS.ErrnoException) => {
+			// spawn 失败时不一定还有 exit 事件：这里不清状态，界面会永远显示「运行中」
+			dropTunnel(child);
+			if (error.code === "ENOENT") {
+				markEngineMissing();
+				finish("找不到 cloudflared：请先安装它（https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/）");
+				return;
+			}
+			finish(error.message);
+		});
+		child.once("exit", (code) => {
+			const active = current.tunnel;
+			if (active?.child === child) {
+				disallowTunnelHost(active.url);
+				current.tunnel = null;
+				finish(`cloudflared 退出了（code ${code ?? "?"}）`);
+			} else {
+				finish();
+			}
+		});
+	});
+
+	// 地址拿到了，但快速隧道的域名还要十几秒才在全球 DNS 生效。
+	// 不等它就直接报「就绪」，用户一复制地址打开就是打不开 —— 那才是真的像坏了。
+	const tunnel = current.tunnel;
+	if (tunnel?.url) {
+		const ready = await waitForTunnelReady(tunnel.url, () => current.tunnel === tunnel);
+		if (current.tunnel === tunnel) tunnel.ready = ready;
+	}
+	return remoteStatus().public;
+}
+
+export async function stopPublic(): Promise<void> {
+	const current = state();
+	const tunnel = current.tunnel;
+	current.tunnel = null;
+	if (!tunnel) return;
+	// 先摘域名再杀进程：别给一个已经没人管的域名留后门
+	disallowTunnelHost(tunnel.url);
+	await new Promise<void>((resolve) => {
+		tunnel.child.once("exit", () => resolve());
+		tunnel.child.kill();
+		// 进程已经死了或杀不掉时不要卡住调用方
+		setTimeout(resolve, 3_000).unref();
+	});
+}
+
+export async function stopAll(): Promise<void> {
+	await stopPublic();
+	await stopLan();
+}
+
+/** 仅供测试 */
+export function resetRemoteSupervisor(): void {
+	const store = globalThis as Record<PropertyKey, unknown>;
+	store[Symbol.for(STATE_KEY)] = {
+		lan: null, tunnel: null, lanError: null, publicError: null, enginePath: null, engineChecked: false,
+	} satisfies SupervisorState;
+}

package/src/lib/security-service.ts

@@ -4,8 +4,8 @@
  * - 项目信任（settings.json 的 defaultProjectTrust：ask/always/never）
  * pi 没有 OS 级沙箱与审批系统——不做假开关。
  */
-import fs from "node:fs/promises";
 import path from "node:path";
+import { invalidateJsonFile, readJsonObject } from "./agent-config";
 import { getAgentDir, getSettingsManager, reloadAllLoaders, reloadSettingsManagers, syncProjectTrust } from "./pi";
 import { reloadSessionsForCwd } from "./agent-manager";
 import { flushSettingsOrThrow, withSettingsWriteLock } from "./settings-write-lock";
@@ -13,16 +13,9 @@ import { flushSettingsOrThrow, withSettingsWriteLock } from "./settings-write-lo
 export type ProjectTrust = "ask" | "always" | "never";
 
 export async function getSecurity(): Promise<{ defaultProjectTrust: ProjectTrust }> {
-	let raw: string;
-	try {
-		raw = await fs.readFile(path.join(getAgentDir(), "settings.json"), "utf8");
-	} catch (error) {
-		if ((error as NodeJS.ErrnoException).code === "ENOENT") return { defaultProjectTrust: "ask" };
-		throw error;
-	}
-	const parsed: unknown = JSON.parse(raw.replace(/^\uFEFF/, ""));
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("settings.json must contain a JSON object");
-	const trust = (parsed as { defaultProjectTrust?: unknown }).defaultProjectTrust;
+	// 统一缓存：settings.json 在信任判定 / 会话创建 / 快照里被读很多次
+	const parsed = await readJsonObject(path.join(getAgentDir(), "settings.json"));
+	const trust = parsed.defaultProjectTrust;
 	return { defaultProjectTrust: trust === "always" || trust === "never" ? trust : "ask" };
 }
 
@@ -37,6 +30,8 @@ export async function setProjectTrust(value: ProjectTrust): Promise<void> {
 		// SDK 自己持有跨进程锁，只落修改字段；flush 不抛写错，必须显式 drainErrors。
 		manager.setDefaultProjectTrust(value);
 		await flushSettingsOrThrow(manager);
+		// 刚写过的文件必须重新读盘再验：(mtime, ctime, size, ino) 校验戳有可能与旧值相同
+		invalidateJsonFile(path.join(getAgentDir(), "settings.json"));
 		if ((await getSecurity()).defaultProjectTrust !== value) {
 			throw new Error("defaultProjectTrust was not persisted");
 		}

package/src/lib/session-import/claude.ts

@@ -91,6 +91,17 @@ function assistantBlocks(content: unknown): ImportedBlock[] {
 	}));
 }
 
+/**
+ * Claude 的 stop_reason → pi 的 stopReason（与 pi-ai 的 anthropic 映射一致）。
+ * 拆开的记录每行都带整条回复的 stop_reason（思考那行也写着 tool_use），所以以合并后的内容为准：
+ * 有工具调用就是 toolUse。原样写进去的 tool_use / end_turn pi 不认，界面会把中途的说明当成最终回答。
+ */
+function stopReasonOf(content: ImportedBlock[], raw: unknown): { stopReason: string; errorMessage?: string } {
+	if (raw === "refusal" || raw === "sensitive") return { stopReason: "error", errorMessage: `Claude stopped with: ${raw}` };
+	if (content.some((block) => block.type === "toolCall")) return { stopReason: "toolUse" };
+	return { stopReason: raw === "max_tokens" ? "length" : "stop" };
+}
+
 /** user 行可能同时含文本与工具结果：文本进用户消息，工具结果单列 */
 function splitUserContent(content: unknown): { text: ImportedBlock[]; results: Array<{ toolCallId: string; content: ImportedBlock[]; isError: boolean }> } {
 	const text: Array<ImportedBlock | null> = [];
@@ -163,6 +174,14 @@ export const claudeSource: ImportSourceModule = {
 		let projectPath = summary.projectPath;
 		let model = summary.model;
 		let provider: string | undefined;
+		/**
+		 * Claude Code 把一次回复按内容块拆成多行（思考、正文、每个工具调用各一行），共用 message.id，
+		 * 每行还带着整条回复的 usage。必须合并回一条：拆开后并行调用变成 assistant[A] → assistant[B]，
+		 * pi-ai 会给 A 补一条 "No result provided"，后面真正的 A 结果就成了孤儿，接着聊直接 400；usage 也会重复计 N 次。
+		 * 流式时工具边跑边出结果，同一 id 的行之间会夹着 tool_result，所以按 id 跨位置合并。
+		 */
+		const assistantById = new Map<string, Extract<ImportedMessage, { role: "assistant" }>>();
+		const rawStopById = new Map<string, unknown>();
 
 		for (const record of eachJsonLine(text)) {
 			if (record.isSidechain === true) {
@@ -178,28 +197,31 @@ export const claudeSource: ImportSourceModule = {
 
 			if (record.type === "assistant") {
 				const content = assistantBlocks(message.content);
-				if (!content.length) continue;
+				const id = typeof message.id === "string" && message.id ? message.id : undefined;
+				const existing = id ? assistantById.get(id) : undefined;
+				if (!content.length && !existing) continue;
 				const usage = message.usage as Record<string, unknown> | undefined;
-				entries.push({
-					type: "message",
-					message: {
-						role: "assistant",
-						content,
-						timestamp,
-						...(typeof message.model === "string" ? { model: message.model } : {}),
-						...(typeof message.stop_reason === "string" && message.stop_reason ? { stopReason: message.stop_reason } : {}),
-						...(usage
-							? {
-									usage: {
-										input: Number(usage.input_tokens) || 0,
-										output: Number(usage.output_tokens) || 0,
-										cacheRead: Number(usage.cache_read_input_tokens) || 0,
-										cacheWrite: Number(usage.cache_creation_input_tokens) || 0,
-									},
-								}
-							: {}),
-					},
-				});
+				const target = existing ?? { role: "assistant" as const, content: [], timestamp };
+				target.content.push(...content);
+				if (typeof message.model === "string") target.model = message.model;
+				// 同一回复的每行 usage 相同（后面的行只会更完整）：取最后一行，只记一次
+				if (usage) {
+					target.usage = {
+						input: Number(usage.input_tokens) || 0,
+						output: Number(usage.output_tokens) || 0,
+						cacheRead: Number(usage.cache_read_input_tokens) || 0,
+						cacheWrite: Number(usage.cache_creation_input_tokens) || 0,
+					};
+				}
+				if (id && message.stop_reason != null) rawStopById.set(id, message.stop_reason);
+				const { stopReason, errorMessage } = stopReasonOf(target.content, id ? rawStopById.get(id) : message.stop_reason);
+				target.stopReason = stopReason;
+				if (errorMessage) target.errorMessage = errorMessage;
+				else delete target.errorMessage;
+				if (!existing) {
+					entries.push({ type: "message", message: target });
+					if (id) assistantById.set(id, target);
+				}
 				continue;
 			}
 
@@ -209,6 +231,8 @@ export const claudeSource: ImportSourceModule = {
 				const keepText = textBlocks.filter((block) => block.type !== "text");
 				if (plain && !isSynthetic(plain.trim()) && !/^Caveat:/i.test(plain.trim())) {
 					entries.push({ type: "message", message: { role: "user", content: [...keepText, { type: "text", text: plain }], timestamp } as ImportedMessage });
+					// 真人发了新消息，之前的回复已经结束：不要再把后面的行合并到它前面去
+					assistantById.clear();
 				} else if (plain) {
 					synthetic += 1;
 				}