@dyyz1993/pi-coding-agent 0.74.24 → 0.74.25

package/dist/extensions/file-snapshot/index.ts

@@ -0,0 +1,131 @@
+import type { ExtensionAPI, ExtensionContext, SessionTreeEvent, TurnEndEvent } from "@dyyz1993/pi-coding-agent";
+
+export default function fileSnapshot(pi: ExtensionAPI) {
+	const channel = pi.registerChannel("file-snapshot");
+
+	channel.onReceive(async (msg) => {
+		const ctx = msg.context as ExtensionContext;
+		const mgr = ctx.fileSnapshotManager;
+		if (!mgr) {
+			return { error: "fileSnapshotManager not available" };
+		}
+
+		switch (msg.method) {
+			case "snapshot.list": {
+				const snapshots = mgr.getModifiedFiles({});
+				return snapshots;
+			}
+			case "snapshot.rollback": {
+				const { snapshotId, files } = msg.params as {
+					sessionId: string;
+					snapshotId: string;
+					files?: string[];
+				};
+				const result = await mgr.restoreFiles(ctx.cwd, {
+					targetEntryId: snapshotId,
+					files,
+					entries: ctx.sessionManager.getEntries() as import("@dyyz1993/pi-coding-agent").SessionEntry[],
+					appendEntry: (type: string, data: unknown) => {
+						return pi.appendEntry(type, data) ?? undefined;
+					},
+				});
+				return {
+					ok: true,
+					restoredFiles: [...result.restored, ...result.deleted],
+				};
+			}
+			case "snapshot.unrevert": {
+				const { snapshotId } = msg.params as {
+					sessionId: string;
+					snapshotId: string;
+				};
+				const entries = ctx.sessionManager.getEntries() as import("@dyyz1993/pi-coding-agent").SessionEntry[];
+				for (const entry of entries) {
+					if (entry.type !== "custom") continue;
+					const custom = entry as { customType: string; data: { rolledBackToLeaf: string; preRollbackTreeHash: string | null } };
+					if (custom.customType === "unrevert-point" && custom.data.rolledBackToLeaf === snapshotId) {
+						const restoreResult = await mgr.restoreFiles(ctx.cwd, {
+							snapshotHash: custom.data.preRollbackTreeHash ?? undefined,
+							entries,
+							appendEntry: (type: string, data: unknown) => {
+								return pi.appendEntry(type, data) ?? undefined;
+							},
+						});
+						return {
+							ok: true,
+							restoredFiles: [...restoreResult.restored, ...restoreResult.deleted],
+						};
+					}
+				}
+				return { ok: false, error: "Unrevert point not found" };
+			}
+			case "snapshot.get": {
+				const { snapshotId } = msg.params as { sessionId: string; snapshotId: string };
+				const data = mgr.getSnapshotAtEntry(snapshotId);
+				if (!data) return null;
+				const diff = data.diff ?? { added: [], modified: [], deleted: [] };
+				return {
+					id: snapshotId,
+					stepIndex: data.turnIndex,
+					treeHash: data.snapshotTreeHash,
+					diff,
+					files: Object.fromEntries([
+						...diff.added.map((f) => [f, "added"]),
+						...diff.modified.map((f) => [f, "modified"]),
+						...diff.deleted.map((f) => [f, "deleted"]),
+					]),
+					rolledBack: false,
+				};
+			}
+			case "snapshot.restoreByHash": {
+				const { snapshotTreeHash, files } = msg.params as {
+					snapshotTreeHash: string;
+					files?: string[];
+				};
+				const result = await mgr.restoreFiles(ctx.cwd, {
+					snapshotHash: snapshotTreeHash,
+					files,
+					entries: ctx.sessionManager.getEntries() as import("@dyyz1993/pi-coding-agent").SessionEntry[],
+					appendEntry: (type: string, data: unknown) => {
+						return pi.appendEntry(type, data) ?? undefined;
+					},
+				});
+				return {
+					restored: [...result.restored, ...result.deleted],
+				};
+			}
+			default:
+				return { error: `Unknown method: ${msg.method}` };
+		}
+	});
+
+	pi.on("session_start", async (_event: unknown, ctx: ExtensionContext) => {
+		const mgr = ctx.fileSnapshotManager;
+		if (!mgr) return;
+		await mgr.initialize(ctx.cwd);
+	});
+
+	pi.on("turn_end", async (event: TurnEndEvent, ctx: ExtensionContext) => {
+		const mgr = ctx.fileSnapshotManager;
+		if (!mgr) return;
+		mgr.onTurnEnd(ctx.cwd, event.turnIndex, (type, data) => {
+			return pi.appendEntry(type, data, { display: false }) ?? undefined;
+		});
+	});
+
+	pi.on("session_tree", async (event: SessionTreeEvent, ctx: ExtensionContext) => {
+		if (event.skipFiles) return;
+		const mgr = ctx.fileSnapshotManager;
+		if (!mgr) return;
+
+		await mgr.restoreFiles(ctx.cwd, {
+			targetEntryId: event.newLeafId ?? undefined,
+			preview: event.preview,
+			currentLeafId: event.oldLeafId,
+			entries: ctx.sessionManager.getEntries() as import("@dyyz1993/pi-coding-agent").SessionEntry[],
+			appendEntry: (type: string, data: unknown) => {
+				return pi.appendEntry(type, data) ?? undefined;
+			},
+		});
+	});
+}

package/dist/extensions/file-time-guard/README.md

@@ -0,0 +1,133 @@
+# File Time Guard
+
+防止 AI 在文件被外部修改后覆盖用户更改的安全扩展。
+
+## 功能
+
+- ✅ 记录文件读取时的元数据（mtime、ctime、size）
+- ✅ 写入前检查文件是否被外部修改
+- ✅ 三种检查模式：block（阻止）、warn（警告）、ignore（忽略）
+- ✅ 支持忽略特定路径（如 `node_modules/`、`.git/`）
+- ✅ 会话隔离，不同会话独立追踪
+- ✅ 提供 `/file-time-status` 命令查看追踪状态
+
+## 使用场景
+
+### 场景 1：阻止覆盖外部修改
+
+```bash
+# AI 读取文件
+pi
+
+# 在另一个终端打开编辑器修改文件
+vim src/index.ts
+
+# AI 尝试写入，被拦截并提示
+ERROR: 文件已被外部修改: src/index.ts
+请重新读取文件
+```
+
+### 场景 2：仅警告不阻止
+
+```bash
+pi --file-time-check-mode warn
+
+# AI 写入文件时显示警告，但允许操作
+警告: 文件已被外部修改: src/index.ts
+```
+
+### 场景 3：完全禁用
+
+```bash
+pi --disable-file-time-check
+# 或
+export OPENCODE_DISABLE_FILETIME_CHECK=true
+```
+
+## 配置选项
+
+### 命令行 Flag
+
+| Flag | 类型 | 默认值 | 说明 |
+|------|------|---------|------|
+| `--file-time-check-mode` | string | `block` | 检查模式：`block`/`warn`/`ignore` |
+| `--disable-file-time-check` | boolean | `false` | 禁用文件时间戳检查 |
+
+### 环境变量
+
+```bash
+export OPENCODE_DISABLE_FILETIME_CHECK=true
+```
+
+### 检查模式说明
+
+- **block**: 阻止写入，显示错误提示
+- **warn**: 允许写入，显示警告信息
+- **ignore**: 不检查，直接写入
+
+## 默认忽略路径
+
+以下路径默认被忽略，不会被检查：
+
+- `node_modules/**`
+- `.git/**`
+- `dist/**`
+- `build/**`
+
+## 命令
+
+### `/file-time-status`
+
+查看当前会话的文件追踪状态：
+
+```
+文件时间戳检查: 启用
+检查模式: block
+已追踪文件: 5
+
+已追踪文件:
+  /path/to/file1.ts
+  /path/to/file2.ts
+```
+
+## 工作原理
+
+1. **读取文件**：记录文件元数据（mtime、ctime、size）和读取时间
+2. **写入文件**：对比当前文件元数据与记录的值
+3. **检测修改**：如果任意一项不匹配，认为文件被外部修改
+4. **执行操作**：根据检查模式决定是阻止、警告还是忽略
+
+### 检查规则
+
+文件被认为"被修改"当且仅当满足以下任意一个条件：
+
+- `mtime`（修改时间）改变
+- `ctime`（元数据改变时间）改变
+- `size`（文件大小）改变
+
+## 技术实现
+
+- 使用 `tool_call` 事件拦截 `read`/`write`/`edit` 工具
+- 基于 `sessionID` 实现会话隔离
+- 使用 `Map<SessionID, Map<FilePath, FileStamp>>` 存储追踪数据
+- 依赖 `minimatch` 实现路径忽略模式匹配
+- 利用现有的 `withFileMutationQueue()` 实现并发保护
+
+## 兼容性
+
+- ✅ 与其他扩展兼容（如 `file-lock-guard`、`protected-paths`）
+- ✅ 不修改核心工具代码
+- ✅ 可通过 flag 环境变量动态配置
+
+## 注意事项
+
+1. 仅追踪通过 `read` 工具读取的文件
+2. 必须先读取文件才能写入（block 模式下）
+3. 会话结束时自动清理追踪记录
+4. 忽略路径不会被追踪或检查
+
+## 相关扩展
+
+- **file-lock-guard**: 文件并发写入保护
+- **protected-paths**: 阻止写入敏感路径
+- **file-snapshot**: 文件快照和恢复功能

package/dist/extensions/file-time-guard/config.ts

@@ -0,0 +1,13 @@
+export interface FileTimeGuardConfig {
+	enabled: boolean;
+	checkMode: "block" | "warn" | "ignore";
+	ignorePatterns: string[];
+	sessionTimeout: number;
+}
+
+export const DEFAULT_CONFIG: FileTimeGuardConfig = {
+	enabled: true,
+	checkMode: "block",
+	ignorePatterns: ["node_modules/**", ".git/**", "dist/**", "build/**"],
+	sessionTimeout: 30 * 60 * 1000,
+};

package/dist/extensions/file-time-guard/index.ts

@@ -0,0 +1,171 @@
+import type { ExtensionAPI } from "@dyyz1993/pi-coding-agent";
+import { stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { minimatch } from "minimatch";
+import { DEFAULT_CONFIG, type FileTimeGuardConfig } from "./config.js";
+
+interface FileStamp {
+	readTime: number;
+	mtime: number;
+	ctime: number;
+	size: number;
+}
+
+const fileRecords = new Map<string, Map<string, FileStamp>>();
+
+export default function (pi: ExtensionAPI) {
+	const config: FileTimeGuardConfig = { ...DEFAULT_CONFIG };
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (!config.enabled) return;
+
+		const sessionId = ctx.sessionManager.getSessionId();
+		if (!sessionId) return;
+
+		fileRecords.set(sessionId, new Map());
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		const sessionId = ctx.sessionManager.getSessionId();
+		if (sessionId) {
+			fileRecords.delete(sessionId);
+		}
+	});
+
+	pi.on("tool_call", async (event, ctx) => {
+		if (!config.enabled) return;
+
+		const sessionId = ctx.sessionManager.getSessionId();
+		if (!sessionId) return;
+
+		const records = fileRecords.get(sessionId);
+		if (!records) return;
+
+		if (event.toolName === "read") {
+			const relativePath = (event.input as { path: string }).path;
+			const absolutePath = resolve(ctx.cwd, relativePath);
+
+			if (shouldIgnorePath(absolutePath)) return;
+
+			try {
+				const stats = await stat(absolutePath);
+
+				records.set(absolutePath, {
+					readTime: Date.now(),
+					mtime: stats.mtimeMs,
+					ctime: stats.ctimeMs,
+					size: stats.size,
+				});
+			} catch (err) {
+				console.debug("[file-time-guard] file stat failed:", err instanceof Error ? err.message : err);
+			}
+		}
+
+		if (event.toolName === "write" || event.toolName === "edit") {
+			const relativePath = (event.input as { path: string }).path;
+			const absolutePath = resolve(ctx.cwd, relativePath);
+
+			if (shouldIgnorePath(absolutePath)) return;
+
+			const record = records.get(absolutePath);
+
+			if (!record) {
+				if (config.checkMode === "block") {
+					ctx.ui.notify(
+						`文件未读取过: ${relativePath}\n请先读取文件再修改`,
+						"error",
+					);
+					return { block: true, reason: "文件未读取过" };
+				}
+				if (config.checkMode === "warn") {
+					ctx.ui.notify(
+						`警告: 文件未读取过: ${relativePath}`,
+						"warning",
+					);
+				}
+				return;
+			}
+
+			try {
+				const currentStats = await stat(absolutePath);
+
+				const isModified =
+					currentStats.mtimeMs !== record.mtime ||
+					currentStats.ctimeMs !== record.ctime ||
+					currentStats.size !== record.size;
+
+				if (isModified) {
+					if (config.checkMode === "block") {
+						ctx.ui.notify(
+							`文件已被外部修改: ${relativePath}\n请重新读取文件`,
+							"error",
+						);
+						return { block: true, reason: "文件已被外部修改" };
+					}
+					if (config.checkMode === "warn") {
+						ctx.ui.notify(
+							`警告: 文件已被外部修改: ${relativePath}`,
+							"warning",
+						);
+					}
+				}
+			} catch (err) {
+				console.debug("[file-time-guard] current file stat failed:", err instanceof Error ? err.message : err);
+			}
+		}
+	});
+
+	function shouldIgnorePath(path: string): boolean {
+		for (const pattern of config.ignorePatterns) {
+			if (minimatch(path, pattern)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	pi.registerCommand("file-time-status", {
+		description: "查看文件时间戳检查状态",
+		handler: async (_args, ctx) => {
+			const sessionId = ctx.sessionManager.getSessionId();
+			if (!sessionId) {
+				ctx.ui.notify("无活动会话", "info");
+				return;
+			}
+
+			const records = fileRecords.get(sessionId);
+			if (!records) {
+				ctx.ui.notify("会话无文件记录", "info");
+				return;
+			}
+
+			const count = records.size;
+			const lines = [
+				`文件时间戳检查: ${config.enabled ? "启用" : "禁用"}`,
+				`检查模式: ${config.checkMode}`,
+				`已追踪文件: ${count}`,
+			];
+
+			if (count > 0 && count <= 10) {
+				lines.push("\n已追踪文件:");
+				for (const [path] of Array.from(records.entries())) {
+					lines.push(`  ${path}`);
+				}
+			}
+
+			ctx.ui.notify(lines.join("\n"), "info");
+		},
+	});
+
+	pi.registerFlag("file-time-check-mode", {
+		description: "文件时间戳检查模式 (block/warn/ignore)",
+		type: "string",
+		default: "block",
+	});
+
+	pi.registerFlag("disable-file-time-check", {
+		description: "禁用文件时间戳检查",
+		type: "boolean",
+		default: false,
+	});
+}

package/dist/extensions/hooks-engine/index.ts

@@ -0,0 +1,117 @@
+/**
+ * Hooks Engine Extension
+ *
+ * Executes hooks defined in AgentConfig.hooks.
+ * Hooks are stored as JSON in event.variables["agentHooks"].
+ *
+ * Supported events: tool_call, tool_result, agent_start, agent_end
+ * Supported hook types: command (spawn process), prompt (inject text)
+ *
+ * Command hooks: exit code 2 = block operation, 0 = allow
+ * Prompt hooks: text injected into the conversation
+ */
+
+import type { ExtensionAPI, AgentHook, AgentHooks } from "@dyyz1993/pi-coding-agent";
+import { spawn } from "node:child_process";
+
+const EVENT_MAP: Record<string, string> = {
+	tool_call: "on_tool_start",
+	tool_result: "on_tool_complete",
+	agent_start: "on_agent_start",
+	agent_end: "on_agent_complete",
+	session_start: "on_session_start",
+	session_shutdown: "on_session_end",
+};
+
+function parseHooks(raw: string | undefined): AgentHooks | null {
+	if (!raw) return null;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+
+function matchesCondition(condition: string | undefined, event: Record<string, unknown>): boolean {
+	if (!condition) return true;
+	const toolName = (event.toolName as string) ?? "";
+	const parts = condition.split("|").map(s => s.trim());
+	return parts.includes(toolName);
+}
+
+async function executeCommand(command: string, event: Record<string, unknown>, timeout = 5000): Promise<number> {
+	return new Promise((resolve) => {
+		const toolName = (event.toolName as string) ?? "";
+		const input = event.input ?? {};
+		const env: Record<string, string> = {
+			...process.env as Record<string, string>,
+			PI_HOOK_TOOL: toolName,
+			PI_HOOK_EVENT: JSON.stringify(input),
+		};
+
+		const proc = spawn("sh", ["-c", command], {
+			env,
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+
+		const timer = setTimeout(() => {
+			proc.kill("SIGTERM");
+			resolve(0);
+		}, timeout);
+
+		proc.on("close", (code) => {
+			clearTimeout(timer);
+			resolve(code ?? 0);
+		});
+
+		proc.on("error", () => {
+			clearTimeout(timer);
+			resolve(0);
+		});
+	});
+}
+
+export default function hooksEngine(pi: ExtensionAPI): void {
+	const subscribe = (eventName: string) => {
+		const hookKey = EVENT_MAP[eventName];
+		if (!hookKey) return;
+
+		pi.on(eventName, async (event: Record<string, unknown>) => {
+			const vars = event.variables as Record<string, string> | undefined;
+			if (!vars?.agentHooks) return undefined;
+
+			const hooks = parseHooks(vars.agentHooks);
+			if (!hooks) return undefined;
+
+			const eventHooks = hooks[hookKey] ?? hooks["*"] ?? [];
+			if (eventHooks.length === 0) return undefined;
+
+			const results: string[] = [];
+
+			for (const hook of eventHooks) {
+				if (!matchesCondition(hook.if, event)) continue;
+
+				if (hook.type === "command") {
+					const code = await executeCommand(hook.command, event);
+					if (code === 2) {
+						return {
+							block: true,
+							reason: `[hook] Operation blocked by hook: ${hook.command}`,
+						};
+					}
+				} else if (hook.type === "prompt") {
+					results.push(hook.prompt);
+				}
+			}
+
+			if (results.length > 0) {
+			}
+
+			return undefined;
+		});
+	};
+
+	for (const eventName of Object.keys(EVENT_MAP)) {
+		subscribe(eventName);
+	}
+}

package/dist/extensions/lsp/lsp/client/file-tracker.ts

@@ -0,0 +1,70 @@
+export interface FileTrackerOptions {
+	maxOpenFiles?: number;
+	now?: () => number;
+}
+
+export interface FileTracker {
+	open(filePath: string, onClose: (file: string) => void): void;
+	getOpenFiles(): string[];
+	getIdleFiles(idleMs: number): string[];
+	closeAll(onClose: (file: string) => void): void;
+}
+
+interface TrackedFile {
+	filePath: string;
+	lastAccess: number;
+}
+
+export function createFileTracker(options: FileTrackerOptions = {}): FileTracker {
+	const maxOpenFiles = options.maxOpenFiles ?? 30;
+	const now = options.now ?? (() => Date.now());
+	const files = new Map<string, TrackedFile>();
+	const order: string[] = [];
+
+	return {
+		open(filePath: string, onClose: (file: string) => void): void {
+			if (files.has(filePath)) {
+				const entry = files.get(filePath)!;
+				entry.lastAccess = now();
+				const idx = order.indexOf(filePath);
+				if (idx !== -1) {
+					order.splice(idx, 1);
+				}
+				order.push(filePath);
+				return;
+			}
+
+			while (order.length >= maxOpenFiles) {
+				const evicted = order.shift()!;
+				files.delete(evicted);
+				onClose(evicted);
+			}
+
+			files.set(filePath, { filePath, lastAccess: now() });
+			order.push(filePath);
+		},
+
+		getOpenFiles(): string[] {
+			return [...order];
+		},
+
+		getIdleFiles(idleMs: number): string[] {
+			const threshold = now() - idleMs;
+			const idle: string[] = [];
+			for (const entry of files.values()) {
+				if (entry.lastAccess < threshold) {
+					idle.push(entry.filePath);
+				}
+			}
+			return idle;
+		},
+
+		closeAll(onClose: (file: string) => void): void {
+			for (const filePath of order) {
+				onClose(filePath);
+			}
+			files.clear();
+			order.length = 0;
+		},
+	};
+}