@hwj123weijian/pi-feishu 0.11.0 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hwj123weijian/pi-feishu",
-	"version": "0.11.0",
+	"version": "0.11.2",
 	"description": "Feishu private-chat and managed-group bridge for Pi",
 	"type": "module",
 	"license": "MIT",

package/src/extension.ts

@@ -1,10 +1,13 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
 import type {
 	ExtensionAPI,
 	ExtensionCommandContext,
 	ExtensionContext,
-	ProjectTrustEventResult,
 	ProjectTrustHandler,
 } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { AgentBridge, FeishuStatus, PiModelInfo, PiRuntime, PiRuntimeSnapshot } from "./contracts.js";
 
 /** switchSession/withSession 回调里的新会话上下文；Pi 未从包根导出该类型名，从签名提取。 */
 type SwitchCallback = NonNullable<
@@ -14,9 +17,6 @@ type SwitchCallback = NonNullable<
 			: never
 		: never
 >;
-type WithSessionCallback = (ctx: SwitchCallback) => Promise<void>;
-import { Type } from "typebox";
-import type { AgentBridge, FeishuStatus, PiModelInfo, PiRuntime, PiRuntimeSnapshot } from "./contracts.js";
 import { FeishuController } from "./controller.js";
 import { CredentialError, FileCredentialStore } from "./credentials.js";
 import { SdkFeishuGateway, validateSdkCredentials } from "./gateway.js";
@@ -100,8 +100,13 @@ function getSharedState(): SharedFeishuState {
 		steer: (text) => {
 			// 仅当确有飞书轮次在跑时并入：发到当前活跃会话（轮次就在那里），绝不触发会话切换。
 			if (!state.activeBridge || !state.sendCurrentMessage) return false;
-			state.sendCurrentMessage(text, { deliverAs: "steer" });
-			return true;
+			try {
+				state.sendCurrentMessage(text, { deliverAs: "steer" });
+				return true;
+			} catch {
+				// pi 已失效等场景：并入失败，回落到正常排队。
+				return false;
+			}
 		},
 	};
 	const proxyRuntime: PiRuntime = {
@@ -122,6 +127,8 @@ function getSharedState(): SharedFeishuState {
 					},
 				});
 				return !result.cancelled;
+			} catch (error) {
+				rethrowStaleAsHint(state, error);
 			} finally {
 				state.switchingSession = false;
 			}
@@ -165,6 +172,24 @@ function tryGetSessionFile(context: ExtensionContext): string | undefined {
 	}
 }
 
+/** 缓存的命令上下文已失效（Pi 侧发生过会话替换）时的可操作提示。 */
+export const SESSION_CONTROL_HINT =
+	"本地 Pi 会话控制已过期（本地发生过会话切换）。请在本地 Pi 执行一次 /feishu status 刷新，然后重发这条消息。";
+
+function isStaleCtxError(error: unknown): boolean {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("extension ctx is stale") || message.includes("ctx is stale after session replacement");
+}
+
+/** 把 Pi 的英文 stale 内部错误转译成可操作指引，其余错误原样上抛。 */
+function rethrowStaleAsHint(state: SharedFeishuState, error: unknown): never {
+	if (isStaleCtxError(error)) {
+		state.latestCommandContext = undefined;
+		throw new Error(SESSION_CONTROL_HINT);
+	}
+	throw error instanceof Error ? error : new Error(String(error));
+}
+
 /**
  * p2p 私聊消息永远落在主会话：群消息处理会把 Pi 切进群的会话，
  * 这里负责在下一条私聊到来时切回去，避免把 Owner 的提问发进群会话。
@@ -182,7 +207,7 @@ async function sendToMainSession(state: SharedFeishuState, prompt: string): Prom
 	const context = state.latestCommandContext;
 	if (!context) {
 		// 主会话与当前会话不一致却没有命令上下文：直发会串进群会话，给出可操作的错误更安全。
-		throw new Error("Pi 会话控制尚未就绪，请先在本地执行一次 /feishu status。");
+		throw new Error(SESSION_CONTROL_HINT);
 	}
 	state.switchingSession = true;
 	try {
@@ -193,23 +218,38 @@ async function sendToMainSession(state: SharedFeishuState, prompt: string): Prom
 			},
 		});
 		if (result.cancelled) throw new Error("切回主 Pi 会话已取消。");
+	} catch (error) {
+		rethrowStaleAsHint(state, error);
 	} finally {
 		state.switchingSession = false;
 	}
 }
 
 async function sendToChatSession(state: SharedFeishuState, chatId: string, prompt: string): Promise<void> {
+	const sessionFile = state.controller.getChatSessionFile(chatId);
+	// Pi 侧切换后当前会话可能恰好就是目标群会话：此时无需命令上下文，直接投递。
+	if (sessionFile && sessionFile === state.currentSessionFile && state.sendCurrentMessage) {
+		state.sendCurrentMessage(prompt);
+		return;
+	}
 	const context = state.latestCommandContext;
-	if (!context) throw new Error("Pi 会话控制尚未就绪，请先在本地执行一次 /feishu status。");
+	if (!context) throw new Error(SESSION_CONTROL_HINT);
 
 	const directory = state.controller.getChatDirectory(chatId);
 	state.switchingSession = true;
 	try {
-		const sessionFile = state.controller.getChatSessionFile(chatId);
 		if (sessionFile) {
-			const result = await switchWithDirectory(context, sessionFile, directory, (nextContext) =>
-				sendAndTrackGroupSession(state, chatId, sessionFile, nextContext, prompt),
-			);
+			// Pi 的 TUI switchSession 不透传 cwdOverride，改为把 cwd 写进会话头：
+			// SessionManager.open 切换时从 header 读取 cwd，runtime 随之在新目录重建。
+			if (directory && !(await anchorSessionHeaderCwd(sessionFile, directory))) {
+				throw new Error(`无法把群会话锚定到 ${directory}（会话文件不可写或格式未知）。`);
+			}
+			const result = await context.switchSession(sessionFile, {
+				withSession: (nextContext) => {
+					if (directory) assertAnchoredCwd(nextContext, directory);
+					return sendAndTrackGroupSession(state, chatId, sessionFile, nextContext, prompt);
+				},
+			});
 			if (result.cancelled) throw new Error("切换到飞书群绑定的 Pi 会话已取消。");
 			return;
 		}
@@ -219,11 +259,18 @@ async function sendToChatSession(state: SharedFeishuState, chatId: string, promp
 				state.latestCommandContext = nextContext;
 				const currentFile = nextContext.sessionManager.getSessionFile();
 				if (currentFile) await state.controller.setChatSessionFile(chatId, currentFile);
-				if (directory) {
-					// 新会话默认继承当前 cwd：显式重新锚定到绑定目录，再投递消息。
-					const anchored = await switchWithDirectory(nextContext, currentFile ?? "", directory, (finalContext) => {
-						state.latestCommandContext = finalContext;
-						return finalContext.sendUserMessage(prompt);
+				if (currentFile && directory) {
+					// 新会话默认继承当前 cwd：把会话头 cwd 改写为绑定目录后重新切换一次，
+					// runtime 会以新 cwd 重建，然后才投递消息。
+					if (!(await anchorSessionHeaderCwd(currentFile, directory))) {
+						throw new Error(`无法把群会话锚定到 ${directory}（会话文件不可写或格式未知）。`);
+					}
+					const anchored = await nextContext.switchSession(currentFile, {
+						withSession: (finalContext) => {
+							state.latestCommandContext = finalContext;
+							assertAnchoredCwd(finalContext, directory);
+							return finalContext.sendUserMessage(prompt);
+						},
 					});
 					if (anchored.cancelled) throw new Error("锚定群会话工作目录已取消。");
 					return;
@@ -232,42 +279,54 @@ async function sendToChatSession(state: SharedFeishuState, chatId: string, promp
 			},
 		});
 		if (result.cancelled) throw new Error("创建飞书群专属 Pi 会话已取消。");
+	} catch (error) {
+		rethrowStaleAsHint(state, error);
 	} finally {
 		state.switchingSession = false;
 	}
 }
 
 /**
- * 切换会话并在切换完成后（含目录锚定）执行回调。
- * Pi 的命令上下文 d.ts 未声明 cwdOverride，但三种运行模式的 switchSession handler
- * 都会把 options 原样转发给 runtime，而 runtime 完整支持 override（切换后
- * createRuntime 直接使用 override 后的 cwd）。这里做一次窄化并在切换后校验
- * cwd 生效——若未来 Pi 改为丢弃该参数，会得到可操作的错误而不是静默串目录。
+ * 把会话文件头（JSONL 首行的 session header）里的 cwd 改写为绑定目录。
+ * 群会话空闲时文件不被任何 runtime 持有，重写首行是安全的；下次
+ * SessionManager.open 会以新 cwd 重建 runtime（工具、bash 都在新目录执行）。
+ * 返回 false 表示文件不可读/格式未知，调用方给出可操作错误。
  */
-async function switchWithDirectory(
-	context: ExtensionCommandContext,
-	sessionFile: string,
-	directory: string | undefined,
-	withSession: WithSessionCallback,
-): Promise<{ cancelled: boolean }> {
-	if (!directory) {
-		return context.switchSession(sessionFile, { withSession });
+export async function anchorSessionHeaderCwd(sessionFile: string, directory: string): Promise<boolean> {
+	let raw: string;
+	try {
+		raw = await readFile(sessionFile, "utf8");
+	} catch {
+		return false;
 	}
-	const options = { cwdOverride: directory, withSession };
-	const switcher = context.switchSession as unknown as (
-		path: string,
-		options: { cwdOverride: string; withSession: WithSessionCallback },
-	) => Promise<{ cancelled: boolean }>;
-	const result = await switcher.call(context, sessionFile, options);
-	if (!result.cancelled) {
-		const effectiveCwd = safeCwd(context);
-		if (effectiveCwd && effectiveCwd !== directory) {
-			throw new Error(
-				`群会话未能切换到绑定目录（当前：${effectiveCwd}）。请重启本地 Pi 后重试，或在本地执行 /feishu status 刷新会话控制。`,
-			);
-		}
+	const newlineIndex = raw.indexOf("\n");
+	const firstLine = newlineIndex === -1 ? raw : raw.slice(0, newlineIndex);
+	let header: Record<string, unknown>;
+	try {
+		header = JSON.parse(firstLine) as Record<string, unknown>;
+	} catch {
+		return false;
+	}
+	if (header.type !== "session" || typeof header.cwd !== "string") return false;
+	if (resolvePath(header.cwd) === resolvePath(directory)) return true;
+	header.cwd = directory;
+	const updatedFirstLine = JSON.stringify(header);
+	const updated = newlineIndex === -1 ? updatedFirstLine : updatedFirstLine + raw.slice(newlineIndex);
+	try {
+		await writeFile(sessionFile, updated, "utf8");
+	} catch {
+		return false;
+	}
+	return true;
+}
+
+function assertAnchoredCwd(context: ExtensionContext, directory: string): void {
+	const effective = safeCwd(context);
+	if (effective && resolvePath(effective) !== resolvePath(directory)) {
+		throw new Error(
+			`群会话未能切换到绑定目录（当前：${effective}）。请重启本地 Pi 后重试，或在本地执行 /feishu status 刷新会话控制。`,
+		);
 	}
-	return result;
 }
 
 function safeCwd(context: ExtensionContext): string | undefined {