@andares/pi-toolkits 0.9.1 → 0.9.3

package/README.md

@@ -106,6 +106,8 @@ Enter with `/ask` (press it again to exit). Meant for the case where you only wa
 - `/ask-perm allow allow allow ask` — positional form (`in-read in-write out-read out-write`), enables immediately without a dialog. Missing arguments fall back to the defaults. This is the form autostart uses.
 - `/ask-perm` again — turns it off.
 
+Repeating the argument form with the modes already in force is a **no-op**: no second "ON" notice and no loss of the session grants collected so far. Changing any mode notifies and clears those grants, because they were made under the old policy.
+
 **Defaults**: in-project read/write allowed, outside read allowed, outside write asks.
 
 | Scope | reads | writes / exec |
@@ -307,6 +309,8 @@ No file = feature disabled, zero overhead, silently skipped.
 
 The global list runs first, so a project can override an earlier setting (for example a later `/ask-perm` with different arguments). Use the global file only when you want the same commands in every project; per-project files remain the recommended default.
 
+An **identical command line** declared by both sources runs once: a duplicate is skipped for that replay, so a global `/ask-perm ...` copied into a project does not run (or announce itself) twice. Different commands still both run, which is what keeps a project override working.
+
 **When it runs**:
 
 | session_start reason | Replayed | Why |

package/README.zh-CN.md

@@ -106,6 +106,8 @@ pi -e ./src/index.ts
 - `/ask-perm allow allow allow ask` —— 位置参数形式(`in-read in-write out-read out-write`),不弹窗直接开启;没给全的参数回落到默认值。这也是 autostart 使用的形式
 - 再输入一次 `/ask-perm` —— 关闭
 
+参数形式重复执行、且四项模式与当前一致时是**空操作**:不会再出一条「ON」提示,也不会清掉已经攒下的会话授权。只有模式真的变了才会提示并清空授权——那些授权是按旧策略给的。
+
 **默认值**:项目内读/写全放行,项目外读放行,项目外写询问。
 
 | 作用域 | 读 | 写 / 执行 |
@@ -307,6 +309,8 @@ run = [
 
 全局列表先执行,项目列表后执行,因此项目可以覆盖此前的设置(例如后面再执行一条不同参数的 `/ask-perm`)。只有希望所有项目都用同一套命令时才用全局文件;仍然建议以项目级配置为主。
 
+**完全相同的命令行**若同时出现在两个来源,一次重放里只执行一次:重复项跳过,所以把全局的 `/ask-perm ...` 复制到项目里不会再跑一遍、也不会再提示一遍。不同的命令仍然各跑一次——这正是「项目覆盖全局」得以成立的原因。
+
 **执行时机**:
 
 | session_start reason | 是否重放 | 原因 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andares/pi-toolkits",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Integrated toolkit extension for pi — ask mode (read-only Q&A), session-scoped permission checks, model favorites, prompt stash, third-party code review, session autostart, and a dedicated compaction model",
   "type": "module",
   "license": "MIT",

package/src/features/autostart/autostart.test.ts

@@ -145,7 +145,10 @@ type SessionStartHandler = (
 		cwd: string;
 		isProjectTrusted: () => boolean;
 		ui: { notify: (message: string, type?: string) => void };
-		sessionManager: { buildContextEntries: () => Array<{ type: string }> };
+		sessionManager: {
+			buildContextEntries: () => Array<{ type: string }>;
+			getSessionId: () => string;
+		};
 	},
 ) => Promise<void>;
 
@@ -159,6 +162,7 @@ interface Harness {
 	setTrusted(trusted: boolean): void;
 	/** Simulate a session that already had a conversation (resumed process). */
 	setHistory(entries: Array<{ type: string }>): void;
+	setSessionId(id: string): void;
 	start(reason: string): Promise<void>;
 }
 
@@ -190,6 +194,7 @@ async function makeHarness(
 		{ type: "model_change" },
 		{ type: "thinking_level_change" },
 	];
+	let sessionId = "session-1";
 	let handler: SessionStartHandler = async () => {};
 	const sent: Harness["sent"] = [];
 	const notifications: Harness["notifications"] = [];
@@ -226,6 +231,9 @@ async function makeHarness(
 		setHistory(entries) {
 			history = entries;
 		},
+		setSessionId(id) {
+			sessionId = id;
+		},
 		async start(reason: string) {
 			await handler({ reason }, {
 				cwd,
@@ -235,7 +243,10 @@ async function makeHarness(
 						notifications.push({ message, type });
 					},
 				},
-				sessionManager: { buildContextEntries: () => history },
+				sessionManager: {
+					buildContextEntries: () => history,
+					getSessionId: () => sessionId,
+				},
 			});
 		},
 		cwd,
@@ -286,6 +297,8 @@ describe("registerAutostart", () => {
 	it("replays on new and fork", async () => {
 		const h = await harness('[command]\nrun = ["/ask on"]');
 		await h.start("new");
+		// A fork is a different session, so it replays again.
+		h.setSessionId("forked-session");
 		await h.start("fork");
 		expect(h.sent).toEqual([
 			{ command: "/ask on", options: { expandPromptTemplates: true } },
@@ -302,6 +315,21 @@ describe("registerAutostart", () => {
 		expect(h.notifications).toEqual([]);
 	});
 
+	it("replays once per session even if session_start is emitted twice", async () => {
+		const h = await harness(fullConfig);
+		await h.start("startup");
+		await h.start("startup");
+		expect(h.sent).toHaveLength(2);
+	});
+
+	it("replays again for a new session id", async () => {
+		const h = await harness(fullConfig);
+		await h.start("startup");
+		h.setSessionId("session-2");
+		await h.start("startup");
+		expect(h.sent).toHaveLength(4);
+	});
+
 	it("skips a process started on an existing session (pi -c reports startup)", async () => {
 		const h = await harness(fullConfig);
 		h.setHistory([
@@ -418,6 +446,29 @@ describe("registerAutostart", () => {
 		expect(h.notifications[0]?.type).toBe("warning");
 	});
 
+	it("runs an identical command only once across sources", async () => {
+		const h = await harness(
+			"[command]\nrun = [\"/ask on\"]",
+			false,
+			"[command]\nrun = [\"/ask on\"]",
+		);
+		await h.start("startup");
+		expect(h.sent.map((entry) => entry.command)).toEqual(["/ask on"]);
+	});
+
+	it("still runs different commands from both sources", async () => {
+		const h = await harness(
+			"[command]\nrun = [\"/ask on\", \"/add-dir ../p\"]",
+			false,
+			"[command]\nrun = [\"/ask on\"]",
+		);
+		await h.start("startup");
+		expect(h.sent.map((entry) => entry.command)).toEqual([
+			"/ask on",
+			"/add-dir ../p",
+		]);
+	});
+
 	it("keeps running the project config when the global one is absent", async () => {
 		const h = await harness('[command]\nrun = ["/ask on"]', false, null);
 		await h.start("startup");

package/src/features/autostart/index.ts

@@ -87,6 +87,15 @@ const HISTORY_ENTRY_TYPES: ReadonlySet<string> = new Set([
  * session manager counts as new, which keeps the feature working in hosts where
  * the session surface is unavailable.
  */
+/** Session id, or `undefined` when the host exposes none. */
+function sessionIdOf(ctx: ExtensionContext): string | undefined {
+	try {
+		return ctx.sessionManager.getSessionId();
+	} catch {
+		return undefined;
+	}
+}
+
 function hasConversationHistory(ctx: ExtensionContext): boolean {
 	try {
 		return ctx.sessionManager
@@ -102,6 +111,11 @@ export function registerAutostart(
 	options: AutostartOptions = {},
 ): void {
 	const agentDir = options.agentDir ?? getAgentDir();
+	// One replay per session. The host can emit `session_start` more than once
+	// for the same session (a runtime rebind during startup reports `startup`
+	// again), and replaying on the second emission would announce everything
+	// twice.
+	const replayedSessions = new Set<string>();
 
 	async function readCommands(
 		ctx: ExtensionContext,
@@ -140,6 +154,12 @@ export function registerAutostart(
 		// shouldReplay in autostart.ts for the host-side evidence.
 		if (!shouldReplay(event.reason, hasConversationHistory(ctx))) return;
 
+		const sessionId = sessionIdOf(ctx);
+		if (sessionId !== undefined) {
+			if (replayedSessions.has(sessionId)) return;
+			replayedSessions.add(sessionId);
+		}
+
 		const sources: Source[] = [
 			{
 				path: join(agentDir, GLOBAL_AUTOSTART_FILENAME),
@@ -163,6 +183,13 @@ export function registerAutostart(
 				),
 		);
 
+		// The same line may be declared by both sources (global defaults plus a
+		// project copy). Running an identical command twice in one replay is
+		// never meaningful — a repeated `/ask-perm` would re-notify, and a
+		// repeated `/add-dir` is pure noise — so identical text runs once.
+		// Different commands still both run, which keeps the project's override.
+		const dispatched = new Set<string>();
+
 		for (const source of sources) {
 			const commands = await readCommands(ctx, source);
 			if (commands === undefined || commands.length === 0) continue;
@@ -184,6 +211,8 @@ export function registerAutostart(
 					);
 					continue;
 				}
+				if (dispatched.has(command)) continue;
+				dispatched.add(command);
 				// One failing command must not cancel the rest of the list.
 				try {
 					await pi.sendUserMessage(command, { expandPromptTemplates: true });

package/src/features/permission/index.test.ts

@@ -51,6 +51,7 @@ interface Harness {
 	readonly statuses: Array<[string, string | undefined]>;
 	readonly notes: Array<{ message: string; kind?: string }>;
 	readonly branch: Array<Record<string, unknown>>;
+	setSessionId(id: string): void;
 	evaluate(event: ToolCallEvent): Promise<unknown>;
 	command(args: string): Promise<void>;
 	sessionStart(): Promise<void>;
@@ -62,6 +63,7 @@ function makeHarness(): Harness {
 	const statuses: Harness["statuses"] = [];
 	const notes: Harness["notes"] = [];
 	const branch: Harness["branch"] = [];
+	let sessionId = "session-1";
 	const ctx = {
 		cwd,
 		hasUI: true,
@@ -73,7 +75,10 @@ function makeHarness(): Harness {
 			custom: async () => undefined,
 			select: async () => undefined,
 		},
-		sessionManager: { getBranch: () => branch },
+		sessionManager: {
+			getBranch: () => branch,
+			getSessionId: () => sessionId,
+		},
 	} as unknown as ExtensionContext;
 
 	const captured: ToolGate[] = [];
@@ -110,6 +115,9 @@ function makeHarness(): Harness {
 		statuses,
 		notes,
 		branch,
+		setSessionId(id: string) {
+			sessionId = id;
+		},
 		async evaluate(event) {
 			return gate.evaluate(event, ctx);
 		},
@@ -214,6 +222,25 @@ describe("/ask-perm", () => {
 		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).toBeUndefined();
 	});
 
+	it("keeps the state when the same session emits session_start again", async () => {
+		const h = makeHarness();
+		await h.sessionStart(); // the real first emission
+		await h.command("allow allow allow ask");
+		// A startup rebind reports the same session again; state must survive.
+		await h.sessionStart();
+		expect(asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).kind).toBe(
+			"ask",
+		);
+	});
+
+	it("resets on session_start for a different session", async () => {
+		const h = makeHarness();
+		await h.command("allow allow allow ask");
+		h.setSessionId("session-2");
+		await h.sessionStart();
+		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside"))).toBeUndefined();
+	});
+
 	it("resets on session_start", async () => {
 		const h = makeHarness();
 		await h.command("allow allow allow ask");
@@ -269,15 +296,30 @@ describe("/ask-perm", () => {
 		expect(await h.evaluate(customEvent("mcp"))).toBeUndefined();
 	});
 
-	it("clears session grants when the mode is reconfigured", async () => {
+	it("is idempotent: repeating the same command notifies once and keeps grants", async () => {
 		const h = makeHarness();
 		await h.command("allow allow allow ask");
+		expect(h.notes).toHaveLength(1);
+
 		asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/x"))).request.apply(
 			"allow-session",
 		);
+		await h.command("allow allow allow ask");
+		expect(h.notes).toHaveLength(1);
+		// The grant collected before the repeat is still in force.
 		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).toBeUndefined();
+	});
 
+	it("notifies and clears session grants when the modes actually change", async () => {
+		const h = makeHarness();
 		await h.command("allow allow allow ask");
+		asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/x"))).request.apply(
+			"allow-session",
+		);
+		expect(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).toBeUndefined();
+
+		await h.command("ask allow allow ask");
+		expect(h.notes).toHaveLength(2);
 		expect(asAsk(await h.evaluate(bashEvent("rm -rf /tmp/outside/y"))).kind).toBe("ask");
 	});
 });

package/src/features/permission/index.ts

@@ -31,6 +31,7 @@ import {
 import {
 	formatModes,
 	parsePermissionArgs,
+	sameModes,
 	shortMode,
 } from "./modes.js";
 import { openPermissionPanel } from "./panel.js";
@@ -98,6 +99,10 @@ function toolUnit(
 export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 	let enabled = false;
 	let modes: PermissionModes = { ...DEFAULT_MODES };
+	// Session this state belongs to. A runtime rebind can emit `session_start`
+	// again for the same session; resetting then would wipe a mode that the
+	// autostart replay had just enabled, so only a different session resets.
+	let currentSessionId: string | undefined;
 	const rules = new SessionRules();
 	let rootsCache:
 		| { cwd: string; branchLength: number; roots: string[] }
@@ -110,6 +115,15 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 		rootsCache = undefined;
 	}
 
+	/** Session id, or `undefined` when the host exposes none. */
+	function sessionIdOf(ctx: ExtensionContext): string | undefined {
+		try {
+			return ctx.sessionManager.getSessionId();
+		} catch {
+			return undefined;
+		}
+	}
+
 	function syncStatus(ctx: ExtensionContext): void {
 		if (!enabled) {
 			ctx.ui.setStatus(PERMISSION_STATUS_KEY, undefined);
@@ -232,12 +246,16 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 	// ── Lifecycle ──────────────────────────────────────────────────────────
 
 	pi.on("session_start", (_event, ctx) => {
+		const sessionId = sessionIdOf(ctx);
+		// Same session, repeated emission (a startup rebind): keep the state.
+		if (sessionId !== undefined && sessionId === currentSessionId) {
+			syncStatus(ctx);
+			return;
+		}
+		currentSessionId = sessionId;
 		reset();
 		syncStatus(ctx);
 	});
-	pi.on("session_shutdown", () => {
-		reset();
-	});
 
 	// ── Command ────────────────────────────────────────────────────────────
 
@@ -253,9 +271,16 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 					ctx.ui.notify(`ask-perm: ${parsed.error}`, "error");
 					return;
 				}
+				// Idempotent: the same command may arrive twice in one session start
+				// (both autostart sources declaring it, a duplicated config line, …).
+				// Re-applying an unchanged policy is a no-op — no second "ON" notice,
+				// and no loss of the session grants collected so far.
+				if (enabled && sameModes(modes, parsed.modes)) return;
+
+				const changed = !sameModes(modes, parsed.modes);
 				modes = parsed.modes;
-				// A new policy invalidates grants made under the old one.
-				rules.clear();
+				// A changed policy invalidates grants made under the old one.
+				if (changed) rules.clear();
 				enabled = true;
 				syncStatus(ctx);
 				ctx.ui.notify(
@@ -284,7 +309,9 @@ export function registerPermission(pi: ExtensionAPI, gates: GateHub): void {
 				);
 				return;
 			}
+			// The panel only opens while off, so this always transitions on.
 			modes = chosen;
+			rules.clear();
 			enabled = true;
 			syncStatus(ctx);
 			ctx.ui.notify(

package/src/features/permission/modes.ts

@@ -80,3 +80,13 @@ export function shortMode(mode: TriMode | "allow"): string {
 			return "D";
 	}
 }
+
+/** Structural equality for the four modes. */
+export function sameModes(a: PermissionModes, b: PermissionModes): boolean {
+	return (
+		a.inRead === b.inRead &&
+		a.inWrite === b.inWrite &&
+		a.outRead === b.outRead &&
+		a.outWrite === b.outWrite
+	);
+}