pi-smart-voice-notify 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.2.3] - 2026-03-13
+
+### Added
+- Integration with `pi-permission-system:permission-request` event channel for permission request notifications
+- Automatic cancellation of permission reminders when approval/denial is received from the permission system
+- Deduplication to prevent duplicate notifications when permission system events precede tool_call events
+- New test coverage for permission system event integration
+
+### Changed
+- Refactored to use shared `toRecord` utility from `pi-permission-system`, removing duplicate implementation
+
 ## [0.2.2] - 2026-03-12
 
 ### Changed

package/package.json

@@ -1,61 +1,61 @@
-{
-  "name": "pi-smart-voice-notify",
-  "version": "0.2.2",
-  "description": "Windows-optimized smart voice, sound, and desktop notifications for Pi coding agent.",
-  "type": "module",
-  "main": "./index.ts",
-  "exports": {
-    ".": "./index.ts"
-  },
-  "files": [
-    "index.ts",
-    "src",
-    "config/config.example.json",
-    "assets",
-    "README.md",
-    "CHANGELOG.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "build": "npx --yes -p typescript@5.7.3 -p @types/node@20.17.57 tsc -p tsconfig.json --noEmit",
-    "lint": "npm run build",
-    "test": "node --experimental-strip-types --test src/abortable-command.test.ts src/reminder-playback.test.ts src/index.test.ts",
-    "check": "npm run build && npm run test"
-  },
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "voice-notify",
-    "windows",
-    "desktop-notification"
-  ],
-  "author": "MasuRii",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/MasuRii/pi-smart-voice-notify.git"
-  },
-  "homepage": "https://github.com/MasuRii/pi-smart-voice-notify#readme",
-  "bugs": {
-    "url": "https://github.com/MasuRii/pi-smart-voice-notify/issues"
-  },
-  "engines": {
-    "node": ">=24"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "pi": {
-    "extensions": [
-      "./index.ts"
-    ]
-  },
-  "peerDependencies": {
-    "@mariozechner/pi-coding-agent": "*",
-    "@mariozechner/pi-tui": "*"
-  },
-  "dependencies": {
-    "node-notifier": "^10.0.1"
-  }
-}
+{
+  "name": "pi-smart-voice-notify",
+  "version": "0.2.3",
+  "description": "Windows-optimized smart voice, sound, and desktop notifications for Pi coding agent.",
+  "type": "module",
+  "main": "./index.ts",
+  "exports": {
+    ".": "./index.ts"
+  },
+  "files": [
+    "index.ts",
+    "src",
+    "config/config.example.json",
+    "assets",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "npx --yes -p typescript@5.7.3 -p @types/node@20.17.57 tsc -p tsconfig.json --noEmit",
+    "lint": "npm run build",
+    "test": "node --experimental-strip-types --test src/abortable-command.test.ts src/reminder-playback.test.ts src/index.test.ts",
+    "check": "npm run build && npm run test"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "voice-notify",
+    "windows",
+    "desktop-notification"
+  ],
+  "author": "MasuRii",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MasuRii/pi-smart-voice-notify.git"
+  },
+  "homepage": "https://github.com/MasuRii/pi-smart-voice-notify#readme",
+  "bugs": {
+    "url": "https://github.com/MasuRii/pi-smart-voice-notify/issues"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  },
+  "dependencies": {
+    "node-notifier": "^10.0.1"
+  }
+}

package/src/index.test.ts

@@ -26,6 +26,9 @@ type PermissionForwardingWatcherController = ReturnType<PermissionForwardingWatc
 type ForwardedPermissionRequestEvent = Parameters<PermissionForwardingWatcherOptions["onRequest"]>[0];
 type ForwardedPermissionResolutionEvent = Parameters<PermissionForwardingWatcherOptions["onResolve"]>[0];
 type PermissionForwardingWatcherConfig = Parameters<PermissionForwardingWatcherController["start"]>[0];
+type EventBusHandler = (payload: unknown) => void;
+
+const PERMISSION_SYSTEM_EVENT_CHANNEL = "pi-permission-system:permission-request";
 
 const EMPTY_AVAILABILITY: TTSAvailability = {
 	"espeak-ng": false,
@@ -35,9 +38,31 @@ const EMPTY_AVAILABILITY: TTSAvailability = {
 	sapi: false,
 };
 
+class FakeEventBus {
+	private readonly handlers = new Map<string, EventBusHandler[]>();
+
+	public on(channel: string, handler: EventBusHandler): () => void {
+		const existing = this.handlers.get(channel) ?? [];
+		existing.push(handler);
+		this.handlers.set(channel, existing);
+		return () => {
+			const current = this.handlers.get(channel) ?? [];
+			this.handlers.set(channel, current.filter((entry) => entry !== handler));
+		};
+	}
+
+	public emit(channel: string, payload: unknown): void {
+		for (const handler of this.handlers.get(channel) ?? []) {
+			handler(payload);
+		}
+	}
+}
+
 class FakePi {
 	private readonly handlers = new Map<string, EventHandler[]>();
 
+	public readonly events = new FakeEventBus();
+
 	public on(eventName: string, handler: EventHandler): void {
 		const existing = this.handlers.get(eventName) ?? [];
 		existing.push(handler);
@@ -223,6 +248,32 @@ function permissionEvent(toolCallId: string): { block: boolean; reason: string;
 	};
 }
 
+function permissionSystemEvent(
+	state: "waiting" | "approved" | "denied",
+	requestId: string,
+	overrides: Partial<{
+		source: "tool_call" | "skill_input" | "skill_read";
+		message: string;
+		toolCallId: string;
+		toolName: string;
+		skillName: string;
+		path: string;
+		agentName: string | null;
+	}> = {},
+): Record<string, unknown> {
+	return {
+		requestId,
+		state,
+		source: overrides.source ?? "tool_call",
+		message: overrides.message ?? "Current agent requested tool 'write'. Allow this call?",
+		toolCallId: overrides.toolCallId,
+		toolName: overrides.toolName,
+		skillName: overrides.skillName,
+		path: overrides.path,
+		agentName: overrides.agentName ?? null,
+	};
+}
+
 function forwardedPermissionRequest(
 	requestId: string,
 	requesterAgentName = "Delegate Alpha",
@@ -287,6 +338,62 @@ async function tickAndFlush(milliseconds: number): Promise<void> {
 	await flushAsyncWork();
 }
 
+test("permission-system waiting events trigger a permission notification and cancel on resolution", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness();
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-wait", {
+			toolCallId: "call-wait",
+			toolName: "write_file",
+		}),
+	);
+	await flushAsyncWork();
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
+
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("approved", "permission-wait", {
+			toolCallId: "call-wait",
+			toolName: "write_file",
+		}),
+	);
+	await flushAsyncWork();
+	await tickAndFlush(1_000);
+
+	assert.equal(countReminderCalls(ttsCalls), 0);
+});
+
+test("permission-system waiting events do not duplicate a later blocked tool_call notification", async (t) => {
+	disableFocusDetection(t);
+	useMockClock(t);
+
+	const { ctx, pi, ttsCalls } = createHarness();
+
+	await pi.emit("session_start", {}, ctx);
+	await flushAsyncWork();
+	pi.events.emit(
+		PERMISSION_SYSTEM_EVENT_CHANNEL,
+		permissionSystemEvent("waiting", "permission-dedupe", {
+			toolCallId: "call-dedupe",
+			toolName: "write_file",
+		}),
+	);
+	await flushAsyncWork();
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
+
+	await pi.emit("tool_call", permissionEvent("call-dedupe"), ctx);
+	await flushAsyncWork();
+
+	assert.equal(immediateNotificationCalls(ttsCalls).length, 1);
+});
+
 test("tool_execution_start only cancels the resolved permission reminder flow", async (t) => {
 	disableFocusDetection(t);
 	useMockClock(t);

package/src/index.ts

@@ -246,6 +246,67 @@ function forwardedPermissionReminderKey(requestId: string): ReminderKey {
 		: defaultReminderKey("permission");
 }
 
+const PERMISSION_SYSTEM_EVENT_CHANNEL = "pi-permission-system:permission-request";
+type PermissionSystemEventState = "waiting" | "approved" | "denied";
+type PermissionSystemEventSource = "tool_call" | "skill_input" | "skill_read";
+
+interface PermissionSystemEvent {
+	requestId: string;
+	state: PermissionSystemEventState;
+	source: PermissionSystemEventSource;
+	message: string;
+	toolCallId?: string;
+	toolName?: string;
+	skillName?: string;
+	path?: string;
+	agentName?: string | null;
+}
+
+function normalizeOptionalString(value: unknown): string | undefined {
+	if (typeof value !== "string") {
+		return undefined;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : undefined;
+}
+
+function readPermissionSystemEvent(value: unknown): PermissionSystemEvent | null {
+	const record = toRecord(value);
+	const requestId = normalizeOptionalString(record.requestId);
+	const state = normalizeOptionalString(record.state);
+	const source = normalizeOptionalString(record.source);
+	const message = normalizeOptionalString(record.message);
+	if (!requestId || !message) {
+		return null;
+	}
+	if (state !== "waiting" && state !== "approved" && state !== "denied") {
+		return null;
+	}
+	if (source !== "tool_call" && source !== "skill_input" && source !== "skill_read") {
+		return null;
+	}
+
+	return {
+		requestId,
+		state,
+		source,
+		message,
+		toolCallId: normalizeOptionalString(record.toolCallId),
+		toolName: normalizeOptionalString(record.toolName),
+		skillName: normalizeOptionalString(record.skillName),
+		path: normalizeOptionalString(record.path),
+		agentName: typeof record.agentName === "string" ? record.agentName : null,
+	};
+}
+
+function permissionSystemReminderKey(event: PermissionSystemEvent): ReminderKey {
+	if (event.toolCallId) {
+		return permissionReminderKey(event.toolCallId);
+	}
+
+	return `permission:request:${event.requestId}`;
+}
+
 export default function smartVoiceNotifyExtension(
 	pi: ExtensionAPI,
 	dependencies: SmartVoiceNotifyDependencies = {},
@@ -1021,6 +1082,57 @@ export default function smartVoiceNotifyExtension(
 		);
 	};
 
+	pi.events.on(PERMISSION_SYSTEM_EVENT_CHANNEL, (payload: unknown) => {
+		const event = readPermissionSystemEvent(payload);
+		if (!event) {
+			return;
+		}
+		if (!config.enabled || !config.enablePermissionNotification) {
+			return;
+		}
+		if (!activeSessionContext) {
+			logger.debug("permission_system.notification_skipped", {
+				reason: "missing_session_context",
+				requestId: event.requestId,
+				state: event.state,
+				source: event.source,
+			});
+			return;
+		}
+
+		const reminderKey = permissionSystemReminderKey(event);
+		if (event.state === "waiting") {
+			if (event.toolCallId) {
+				pendingPermissionToolCallIds.add(event.toolCallId);
+				rememberScopedToolCallId(event.toolCallId, blockedPermissionToolCallIds);
+			}
+			logger.debug("permission_system.wait_detected", {
+				requestId: event.requestId,
+				toolCallId: event.toolCallId ?? null,
+				toolName: event.toolName ?? null,
+				skillName: event.skillName ?? null,
+				source: event.source,
+			});
+			triggerNotification("permission", activeSessionContext, {
+				reason: event.message,
+				reminderKey,
+			});
+			return;
+		}
+
+		if (event.toolCallId) {
+			pendingPermissionToolCallIds.delete(event.toolCallId);
+		}
+		cancelReminderActivityForKey(reminderKey, "permission_system_wait_resolved", {
+			requestId: event.requestId,
+			toolCallId: event.toolCallId ?? null,
+			toolName: event.toolName ?? null,
+			skillName: event.skillName ?? null,
+			state: event.state,
+			source: event.source,
+		});
+	});
+
 	const applySetting = (draft: VoiceNotifyConfig, id: string, value: string): void => {
 		switch (id) {
 			case "enabled":