@hwj123weijian/pi-feishu 0.10.2 → 0.11.0

package/README.md

@@ -155,12 +155,13 @@ pi -e D:\ai_study\pi-feishu
 ### 群聊使用
 
 - **绑定已有群**：把机器人加进现有项目群后，Owner 在群里发送 `/bind` 即可绑定；之后该群获得独立 Pi session，与其他群和主对话互不串上下文。机器人被拉进新群时也会私聊 Owner 提醒绑定。
+- **绑定项目目录**（推荐）：发送 `/bind /path/to/project` 把群锚定到项目目录——群会话的工作目录会切换到该目录，bot 直接读写这个项目；Owner 显式绑定的目录会自动加入 Pi 的项目信任。私聊里说“帮我拉个群 /path/to/project”也可以在建群时一并锚定。
 - **触发方式**：默认在群里 `@机器人 你的问题`。飞书只向 bot 推送 @bot 的群消息；普通消息直接触发需要敏感权限 `im:message.group_msg`。
 - **授权成员**：默认只有 Owner 能使用。Owner 私聊发送 `/allow @张三` 后，张三即可在私聊和已绑定群里与机器人协作；`/deny @张三` 撤销。
 - **分寸感**：未绑定的群里被 @ 时回复绑定引导；非授权成员被 @ 时回复一次“未授权”；其余群内消息完全静默，不会刷屏。
 - **说话人上下文**：群消息发给 Pi 前会加上 `[飞书群聊] 说话人：` 前缀，@ 其他人会被改写成 `@名字`，模型知道在和谁对话。
 
-已知限制：Pi 是单会话进程，多个聊天的任务仍全局串行（排队提示会如实显示位数）；远程命令作用于最近活跃的会话，`/model`、`/thinking`、`/compact` 建议在对应聊天的上一条消息之后紧接着发送。
+已知限制：Pi 是单会话进程，群与群、群与私聊之间共享一个执行引擎，**跨聊天**的任务仍全局串行（排队提示会如实显示位数）。同一聊天内任务运行中继续发消息，会直接并入当前对话（steer），无需排队。远程命令作用于最近活跃的会话，`/model`、`/thinking`、`/compact` 建议在对应聊天的上一条消息之后紧接着发送。
 
 未知命令会返回提示，不会发给 Pi。`/model` 的候选来自本地 Pi 的 scoped models（未配置时为全部已授权模型）；`/model` 无参数时展示当前模型。注意：任何以 `/` 开头的消息都会先被当作命令解析，想发给 Pi 的提问请勿以 `/` 开头。
 

package/package.json

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

package/src/contracts.ts

@@ -9,6 +9,8 @@ export interface FeishuCredentials {
 	allowlist?: string[];
 	/** Display names for allowlisted open IDs, captured from @mentions when authorizing. */
 	allowlistNames?: Record<string, string>;
+	/** Per managed group working directory (easycodeclient-style project binding). */
+	groupDirs?: Record<string, string>;
 }
 
 export interface CredentialStore {
@@ -153,6 +155,11 @@ export interface AgentRunOptions {
 export interface AgentBridge {
 	run(text: string, observer?: AgentProgressObserver, options?: AgentRunOptions): Promise<string>;
 	cancel(reason?: string): void;
+	/**
+	 * 并入当前正在运行的轮次（同聊天追加消息时使用）。
+	 * 仅当确有轮次在跑时返回 true；false 表示当前空闲，调用方应回退到正常排队。
+	 */
+	steer?(text: string): boolean;
 }
 
 export type FeishuGatewayFactory = (credentials: FeishuCredentials) => FeishuGateway;

package/src/controller.ts

@@ -1,3 +1,5 @@
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
 import type {
 	AgentBridge,
 	CredentialStore,
@@ -202,17 +204,36 @@ export class FeishuController {
 		await gateway.sendText(ownerOpenId, welcome).catch(() => undefined);
 	}
 
-	async createGroupChat(name: string): Promise<string> {
+	async createGroupChat(name: string, directory?: string): Promise<string> {
 		const gateway = this.gateway;
 		const ownerOpenId = this.credentials?.ownerOpenId;
 		if (!gateway) throw new CredentialError("飞书尚未连接，请先执行 /feishu start。");
 		if (!ownerOpenId) throw new CredentialError("飞书尚未绑定 Owner，无法创建群聊。");
 		const chatId = await gateway.createGroupChat(name, ownerOpenId);
 		this.managedGroupIds.add(chatId);
-		await this.saveCredentials({ managedGroupIds: [...this.managedGroupIds] });
+		let anchoredLine = "";
+		if (directory) {
+			const resolved = resolve(directory);
+			let isDirectory = false;
+			try {
+				isDirectory = (await stat(resolved)).isDirectory();
+			} catch {
+				isDirectory = false;
+			}
+			if (isDirectory) {
+				await this.saveCredentials({
+					managedGroupIds: [...this.managedGroupIds],
+					groupDirs: { ...(this.credentials?.groupDirs ?? {}), [chatId]: resolved },
+				});
+				anchoredLine = `\n📂 本群已锚定到目录：${resolved}`;
+			}
+		}
+		if (!this.credentials?.groupDirs?.[chatId]) {
+			await this.saveCredentials({ managedGroupIds: [...this.managedGroupIds] });
+		}
 		await gateway.sendText(
 			chatId,
-			`👋 群聊「${name}」已创建，当前绑定的 Pi 飞书机器人已就绪。直接在群内 @机器人即可开始协作。若群内普通消息没有响应，请先 @ 机器人；开通免 @ 权限后可直接发消息。`,
+			`👋 群聊「${name}」已创建，当前绑定的 Pi 飞书机器人已就绪。直接在群内 @机器人即可开始协作。若群内普通消息没有响应，请先 @ 机器人；开通免 @ 权限后可直接发消息。${anchoredLine}`,
 		);
 		await this.sendGroupPermissionReminder(gateway, ownerOpenId, name);
 		return chatId;
@@ -379,9 +400,37 @@ export class FeishuController {
 			await this.runRemoteCommand(gateway, message, reactionId, authorizedText);
 			return;
 		}
+		// 对齐 easycodeclient 的 mid-turn 注入：同聊天的追加消息直接并入正在运行的轮次，
+		// 不排队（跨聊天仍全局串行——Pi 是单会话进程）。
+		if (this.trySteerIntoRunningTurn(gateway, message, reactionId, authorizedText)) return;
 		void this.enqueueAgentTask(gateway, message, authorizedText, reactionId);
 	}
 
+	/** 同聊天已有任务在跑时，把新消息并入该轮次；返回是否成功并入。 */
+	private trySteerIntoRunningTurn(
+		gateway: FeishuGateway,
+		message: FeishuIncomingMessage,
+		reactionId: string,
+		text: string,
+	): boolean {
+		const runningTask = [...this.pendingTasks.values()].find(
+			(entry) => entry.started && !entry.cancelled && entry.chatId === message.chatId,
+		);
+		if (!runningTask) return false;
+		const steered = this.agent.steer?.(buildAgentPrompt(message, text)) ?? false;
+		if (!steered) return false;
+		// 并入后由运行中的任务统一回复；清掉本条消息的已读表情，改用文字确认。
+		void this.clearRead(gateway, message.messageId, reactionId);
+		void gateway
+			.sendText(
+				message.chatId,
+				"✅ 已收到，已并入当前正在处理的对话；回复会更新在上面的回复卡片里。",
+				message.messageId,
+			)
+			.catch(() => undefined);
+		return true;
+	}
+
 	private isAllowlisted(senderOpenId: string): boolean {
 		return this.credentials?.allowlist?.includes(senderOpenId) ?? false;
 	}
@@ -423,19 +472,28 @@ export class FeishuController {
 		await gateway
 			.sendText(
 				message.chatId,
-				"本群还没有绑定到 Pi。Owner 在群里发送 /bind 即可绑定本群：之后群内消息会进入该群专属的独立 Pi 会话。",
+				"本群还没有绑定到 Pi。Owner 在群里发送 /bind 即可绑定本群；也可带目录把群锚定到项目：/bind /path/to/project。",
 				message.messageId,
 			)
 			.catch(() => undefined);
 	}
 
-	/** 把当前群登记为受管群并持久化。 */
+	/** 把当前群登记为受管群并持久化；可同时绑定工作目录（对齐 easycodeclient 的 /bind <路径>）。 */
 	private async bindManagedGroup(gateway: FeishuGateway, message: FeishuIncomingMessage): Promise<void> {
+		const command = parseRemoteCommand(message.text);
+		const dirArg = command?.args.trim();
+		if (dirArg) {
+			await this.bindGroupDirectory(gateway, message, dirArg);
+			return;
+		}
 		if (this.managedGroupIds.has(message.chatId)) {
+			const dir = this.getChatDirectory(message.chatId);
 			await gateway
 				.sendText(
 					message.chatId,
-					"本群已绑定到 Pi，直接 @机器人 即可提问（开通免 @ 权限后无需 @）。",
+					dir
+						? `本群已绑定到 Pi（工作目录：${dir}）。直接 @机器人 即可提问（开通免 @ 权限后无需 @）。`
+						: "本群已绑定到 Pi，直接 @机器人 即可提问（开通免 @ 权限后无需 @）。\n如需把本群锚定到项目目录，发送：/bind /path/to/project",
 					message.messageId,
 				)
 				.catch(() => undefined);
@@ -446,12 +504,55 @@ export class FeishuController {
 		await gateway
 			.sendText(
 				message.chatId,
-				"✅ 本群已绑定到 Pi。下一条群消息会自动创建该群专属的独立 Pi 会话；默认需要 @机器人 触发。",
+				"✅ 本群已绑定到 Pi。下一条群消息会自动创建该群专属的独立 Pi 会话；默认需要 @机器人 触发。\n💡 如需让本群在指定项目目录下工作，发送：/bind /path/to/project",
+				message.messageId,
+			)
+			.catch(() => undefined);
+	}
+
+	/** /bind <目录>：校验目录存在后，把群锚定到该目录（工作目录在会话切换时生效）。 */
+	private async bindGroupDirectory(
+		gateway: FeishuGateway,
+		message: FeishuIncomingMessage,
+		dirArg: string,
+	): Promise<void> {
+		const resolved = resolve(dirArg);
+		let isDirectory = false;
+		try {
+			isDirectory = (await stat(resolved)).isDirectory();
+		} catch {
+			isDirectory = false;
+		}
+		if (!isDirectory) {
+			await gateway
+				.sendText(message.chatId, `❌ 目录不存在或不是文件夹：${resolved}\n用法：/bind /path/to/project`, message.messageId)
+				.catch(() => undefined);
+			return;
+		}
+		this.managedGroupIds.add(message.chatId);
+		await this.saveCredentials({
+			managedGroupIds: [...this.managedGroupIds],
+			groupDirs: { ...(this.credentials?.groupDirs ?? {}), [message.chatId]: resolved },
+		});
+		await gateway
+			.sendText(
+				message.chatId,
+				`✅ 本群已锚定到目录：${resolved}\n下一条群消息会在该目录下的独立 Pi 会话中处理（已有会话也会切换工作目录）。`,
 				message.messageId,
 			)
 			.catch(() => undefined);
 	}
 
+	/** 群绑定的项目目录；未绑定的群返回 undefined（沿用当前 cwd）。 */
+	getChatDirectory(chatId: string): string | undefined {
+		return this.credentials?.groupDirs?.[chatId];
+	}
+
+	/** 所有已绑定的群目录（用于 project trust 自动放行）。 */
+	getBoundDirectories(): string[] {
+		return Object.values(this.credentials?.groupDirs ?? {});
+	}
+
 	/** Controller 自己处理的命令；返回 false 时回落到通用远程命令通道。 */
 	private async runManagedChatCommand(
 		gateway: FeishuGateway,

package/src/credentials.ts

@@ -70,6 +70,7 @@ export function resolveRuntimeCredentials(
 			...(matching?.groupSessions ? { groupSessions: matching.groupSessions } : {}),
 			...(matching?.allowlist ? { allowlist: matching.allowlist } : {}),
 			...(matching?.allowlistNames ? { allowlistNames: matching.allowlistNames } : {}),
+			...(matching?.groupDirs ? { groupDirs: matching.groupDirs } : {}),
 		};
 	}
 	return stored;
@@ -146,6 +147,7 @@ export class FileCredentialStore implements CredentialStore {
 				? { allowlist: value.allowlist.filter((id): id is string => typeof id === "string") }
 				: {}),
 			...(isStringRecord(value.allowlistNames) ? { allowlistNames: value.allowlistNames } : {}),
+			...(isStringRecord(value.groupDirs) ? { groupDirs: value.groupDirs } : {}),
 		};
 	}
 
@@ -185,7 +187,8 @@ function isCredentialRecord(value: unknown): value is FeishuCredentials {
 		(record.managedGroupIds === undefined || Array.isArray(record.managedGroupIds)) &&
 		(record.groupSessions === undefined || isStringRecord(record.groupSessions)) &&
 		(record.allowlist === undefined || Array.isArray(record.allowlist)) &&
-		(record.allowlistNames === undefined || isStringRecord(record.allowlistNames))
+		(record.allowlistNames === undefined || isStringRecord(record.allowlistNames)) &&
+		(record.groupDirs === undefined || isStringRecord(record.groupDirs))
 	);
 }
 

package/src/extension.ts

@@ -1,4 +1,20 @@
-import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type {
+	ExtensionAPI,
+	ExtensionCommandContext,
+	ExtensionContext,
+	ProjectTrustEventResult,
+	ProjectTrustHandler,
+} from "@earendil-works/pi-coding-agent";
+
+/** switchSession/withSession 回调里的新会话上下文；Pi 未从包根导出该类型名，从签名提取。 */
+type SwitchCallback = NonNullable<
+	Parameters<ExtensionCommandContext["switchSession"]>[1] extends infer O | undefined
+		? O extends { withSession?: (ctx: infer C) => unknown }
+			? C
+			: 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";
@@ -30,7 +46,7 @@ interface SharedFeishuState {
 	current: SessionLink | undefined;
 	activeBridge: PiAgentBridge | undefined;
 	latestCommandContext: ExtensionCommandContext | undefined;
-	sendCurrentMessage: ((text: string) => void) | undefined;
+	sendCurrentMessage: ((text: string, options?: { deliverAs?: "steer" | "followUp" }) => void) | undefined;
 	/** Pi 会话文件：p2p 私聊消息归属的主会话（绝不会是群绑定会话）。 */
 	mainSessionFile: string | undefined;
 	/** Pi 进程当前所在的会话文件，随每个事件刷新。 */
@@ -81,6 +97,12 @@ function getSharedState(): SharedFeishuState {
 			});
 		},
 		cancel: (reason) => state.activeBridge?.cancel(reason),
+		steer: (text) => {
+			// 仅当确有飞书轮次在跑时并入：发到当前活跃会话（轮次就在那里），绝不触发会话切换。
+			if (!state.activeBridge || !state.sendCurrentMessage) return false;
+			state.sendCurrentMessage(text, { deliverAs: "steer" });
+			return true;
+		},
 	};
 	const proxyRuntime: PiRuntime = {
 		isIdle: () => state.current?.runtime.isIdle() ?? true,
@@ -180,19 +202,14 @@ async function sendToChatSession(state: SharedFeishuState, chatId: string, promp
 	const context = state.latestCommandContext;
 	if (!context) throw new Error("Pi 会话控制尚未就绪，请先在本地执行一次 /feishu status。");
 
+	const directory = state.controller.getChatDirectory(chatId);
 	state.switchingSession = true;
 	try {
 		const sessionFile = state.controller.getChatSessionFile(chatId);
 		if (sessionFile) {
-			const result = await context.switchSession(sessionFile, {
-				withSession: async (nextContext) => {
-					state.latestCommandContext = nextContext;
-					const currentFile = nextContext.sessionManager.getSessionFile();
-					if (currentFile && currentFile !== sessionFile)
-						await state.controller.setChatSessionFile(chatId, currentFile);
-					await nextContext.sendUserMessage(prompt);
-				},
-			});
+			const result = await switchWithDirectory(context, sessionFile, directory, (nextContext) =>
+				sendAndTrackGroupSession(state, chatId, sessionFile, nextContext, prompt),
+			);
 			if (result.cancelled) throw new Error("切换到飞书群绑定的 Pi 会话已取消。");
 			return;
 		}
@@ -202,6 +219,15 @@ 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 (anchored.cancelled) throw new Error("锚定群会话工作目录已取消。");
+					return;
+				}
 				await nextContext.sendUserMessage(prompt);
 			},
 		});
@@ -211,6 +237,60 @@ async function sendToChatSession(state: SharedFeishuState, chatId: string, promp
 	}
 }
 
+/**
+ * 切换会话并在切换完成后（含目录锚定）执行回调。
+ * Pi 的命令上下文 d.ts 未声明 cwdOverride，但三种运行模式的 switchSession handler
+ * 都会把 options 原样转发给 runtime，而 runtime 完整支持 override（切换后
+ * createRuntime 直接使用 override 后的 cwd）。这里做一次窄化并在切换后校验
+ * cwd 生效——若未来 Pi 改为丢弃该参数，会得到可操作的错误而不是静默串目录。
+ */
+async function switchWithDirectory(
+	context: ExtensionCommandContext,
+	sessionFile: string,
+	directory: string | undefined,
+	withSession: WithSessionCallback,
+): Promise<{ cancelled: boolean }> {
+	if (!directory) {
+		return context.switchSession(sessionFile, { withSession });
+	}
+	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 刷新会话控制。`,
+			);
+		}
+	}
+	return result;
+}
+
+function safeCwd(context: ExtensionContext): string | undefined {
+	try {
+		return context.cwd;
+	} catch {
+		return undefined;
+	}
+}
+
+async function sendAndTrackGroupSession(
+	state: SharedFeishuState,
+	chatId: string,
+	sessionFile: string,
+	nextContext: SwitchCallback,
+	prompt: string,
+): Promise<void> {
+	state.latestCommandContext = nextContext;
+	const currentFile = nextContext.sessionManager.getSessionFile();
+	if (currentFile && currentFile !== sessionFile) await state.controller.setChatSessionFile(chatId, currentFile);
+	await nextContext.sendUserMessage(prompt);
+}
+
 export interface ParsedFeishuCommand {
 	name: FeishuCommandName;
 	args: string;
@@ -386,7 +466,7 @@ export function renderFeishuStatus(status: FeishuStatus, scopeHealth?: string[])
 
 export default function feishuExtension(pi: ExtensionAPI): void {
 	const state = getSharedState();
-	state.sendCurrentMessage = (text) => pi.sendUserMessage(text);
+	state.sendCurrentMessage = (text, options) => pi.sendUserMessage(text, options);
 	let latestContext: ExtensionContext | undefined;
 	let latestCommandContext: ExtensionCommandContext | undefined;
 
@@ -505,25 +585,42 @@ export default function feishuExtension(pi: ExtensionAPI): void {
 		state.activeBridge?.cancel("Pi 会话已关闭。");
 	});
 
+	// 对齐 easycodeclient：Owner 通过 /bind 或建群显式绑定的目录视为受信项目，
+	// 免去切换群会话时的本地信任弹窗。undecided = 不表态，Pi 落回默认流程
+	//（runner 对 undecided 的 handler 会跳过）；handler 用带注解的变量传入，
+	// 内联箭头会让 on() 的重载推断失败。
+	const onProjectTrust: ProjectTrustHandler = (event) => {
+		if (state.controller.getBoundDirectories().includes(event.cwd)) {
+			return { trusted: "yes", remember: true };
+		}
+		return { trusted: "undecided" };
+	};
+	pi.on("project_trust", onProjectTrust);
+
 	pi.registerTool({
 		name: "feishu_create_group",
 		label: "Create Feishu Group",
 		description:
-			"Create a Feishu group chat and invite the currently bound owner. Use when asked to 拉群、建群、创建飞书群 or create a group. This creates only the group (not a local project directory).",
+			"Create a Feishu group chat and invite the currently bound owner. Use when asked to 拉群、建群、创建飞书群 or create a group. Pass `path` when the user mentions a directory (e.g. 拉个群 /path/to/project) to anchor the group's sessions to that working directory; the directory must already exist.",
 		parameters: Type.Object({
 			name: Type.String({ description: "Name for the new Feishu group chat" }),
+			path: Type.Optional(
+				Type.String({ description: "Absolute path of an existing local directory to anchor the group to" }),
+			),
 		}),
 		async execute(_toolCallId, params) {
+			const name = params.name.trim();
 			try {
-				const chatId = await state.controller.createGroupChat(params.name.trim());
+				const chatId = await state.controller.createGroupChat(name, params.path?.trim() || undefined);
+				const anchored = params.path?.trim() ? `，并锚定到目录 ${params.path.trim()}` : "";
 				return {
 					content: [
 						{
 							type: "text",
-							text: `群聊「${params.name.trim()}」已创建，群聊 ID：${chatId}。已邀请当前绑定的飞书用户，并发送群欢迎消息。`,
+							text: `群聊「${name}」已创建，群聊 ID：${chatId}${anchored}。已邀请当前绑定的飞书用户，并发送群欢迎消息。`,
 						},
 					],
-					details: { chatId, name: params.name.trim() },
+					details: { chatId, name },
 				};
 			} catch (error) {
 				return {