Address code review feedback for Tasks panel IPC

- Remove unused `scope` feature from IPC protocol (YAGNI)
- Remove redundant array spreads in TasksPanel
- Make TaskDetails extend TaskActions to reduce duplication
- Remove handler fallback in TasksPanel (keep requests/commands separate)
- Add notification subscription support to useIpc hook
- Add tests for onNotification feature
- Remove redundant individual exports from tasks/api.ts (export as group only)

Author: EhabY

package.json

@@ -537,7 +537,7 @@
 	"extensionPack": [
 		"ms-vscode-remote.remote-ssh"
 	],
-	"packageManager": "pnpm@10.27.0",
+	"packageManager": "pnpm@10.28.2",
 	"engines": {
 		"vscode": "^1.95.0",
 		"node": ">= 20"

packages/shared/src/ipc/protocol.ts

@@ -10,23 +10,20 @@
 /** Request definition: params P, response R */
 export interface RequestDef<P = void, R = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom types for inference - not present at runtime */
 	readonly _types?: { params: P; response: R };
 }
 
 /** Command definition: params P, no response */
 export interface CommandDef<P = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom type for inference - not present at runtime */
 	readonly _types?: { params: P };
 }
 
 /** Notification definition: data D (extension to webview) */
 export interface NotificationDef<D = void> {
 	readonly method: string;
-	readonly scope?: string;
 	/** @internal Phantom type for inference - not present at runtime */
 	readonly _types?: { data: D };
 }
@@ -36,25 +33,20 @@ export interface NotificationDef<D = void> {
 /** Define a request with typed params and response */
 export function defineRequest<P = void, R = void>(
 	method: string,
-	scope?: string,
 ): RequestDef<P, R> {
-	return { method, scope } as RequestDef<P, R>;
+	return { method } as RequestDef<P, R>;
 }
 
 /** Define a fire-and-forget command */
-export function defineCommand<P = void>(
-	method: string,
-	scope?: string,
-): CommandDef<P> {
-	return { method, scope } as CommandDef<P>;
+export function defineCommand<P = void>(method: string): CommandDef<P> {
+	return { method } as CommandDef<P>;
 }
 
 /** Define a push notification (extension to webview) */
 export function defineNotification<D = void>(
 	method: string,
-	scope?: string,
 ): NotificationDef<D> {
-	return { method, scope } as NotificationDef<D>;
+	return { method } as NotificationDef<D>;
 }
 
 // --- Wire format ---
@@ -63,7 +55,6 @@ export function defineNotification<D = void>(
 export interface IpcRequest<P = unknown> {
 	readonly requestId: string;
 	readonly method: string;
-	readonly scope?: string;
 	readonly params?: P;
 }
 

packages/shared/src/tasks/api.ts

@@ -17,20 +17,18 @@ import {
 
 import type { Task, TaskDetails, TaskLogEntry, TaskTemplate } from "./types";
 
-// --- Requests ---
-
 export interface InitResponse {
 	tasks: Task[];
 	templates: TaskTemplate[];
 	baseUrl: string;
 	tasksSupported: boolean;
 }
 
-export const init = defineRequest<void, InitResponse>("init");
-export const getTasks = defineRequest<void, Task[]>("getTasks");
-export const getTemplates = defineRequest<void, TaskTemplate[]>("getTemplates");
-export const getTask = defineRequest<{ taskId: string }, Task>("getTask");
-export const getTaskDetails = defineRequest<{ taskId: string }, TaskDetails>(
+const init = defineRequest<void, InitResponse>("init");
+const getTasks = defineRequest<void, Task[]>("getTasks");
+const getTemplates = defineRequest<void, TaskTemplate[]>("getTemplates");
+const getTask = defineRequest<{ taskId: string }, Task>("getTask");
+const getTaskDetails = defineRequest<{ taskId: string }, TaskDetails>(
 	"getTaskDetails",
 );
 
@@ -39,31 +37,25 @@ export interface CreateTaskParams {
 	prompt: string;
 	presetId?: string;
 }
-export const createTask = defineRequest<CreateTaskParams, Task>("createTask");
-
-export const deleteTask = defineRequest<{ taskId: string }, void>("deleteTask");
-export const pauseTask = defineRequest<{ taskId: string }, void>("pauseTask");
-export const resumeTask = defineRequest<{ taskId: string }, void>("resumeTask");
+const createTask = defineRequest<CreateTaskParams, Task>("createTask");
 
-// --- Commands ---
+const deleteTask = defineRequest<{ taskId: string }, void>("deleteTask");
+const pauseTask = defineRequest<{ taskId: string }, void>("pauseTask");
+const resumeTask = defineRequest<{ taskId: string }, void>("resumeTask");
 
-export const viewInCoder = defineCommand<{ taskId: string }>("viewInCoder");
-export const viewLogs = defineCommand<{ taskId: string }>("viewLogs");
-export const downloadLogs = defineCommand<{ taskId: string }>("downloadLogs");
-export const sendTaskMessage = defineCommand<{
+const viewInCoder = defineCommand<{ taskId: string }>("viewInCoder");
+const viewLogs = defineCommand<{ taskId: string }>("viewLogs");
+const downloadLogs = defineCommand<{ taskId: string }>("downloadLogs");
+const sendTaskMessage = defineCommand<{
 	taskId: string;
 	message: string;
 }>("sendTaskMessage");
 
-// --- Notifications ---
-
-export const taskUpdated = defineNotification<Task>("taskUpdated");
-export const tasksUpdated = defineNotification<Task[]>("tasksUpdated");
-export const logsAppend = defineNotification<TaskLogEntry[]>("logsAppend");
-export const refresh = defineNotification<void>("refresh");
-export const showCreateForm = defineNotification<void>("showCreateForm");
-
-// --- Grouped export ---
+const taskUpdated = defineNotification<Task>("taskUpdated");
+const tasksUpdated = defineNotification<Task[]>("tasksUpdated");
+const logsAppend = defineNotification<TaskLogEntry[]>("logsAppend");
+const refresh = defineNotification<void>("refresh");
+const showCreateForm = defineNotification<void>("showCreateForm");
 
 export const TasksApi = {
 	// Requests

packages/shared/src/tasks/types.ts

@@ -44,12 +44,10 @@ export type LogsStatus = "ok" | "not_available" | "error";
 /**
  * Full details for a selected task, including logs and action availability.
  */
-export interface TaskDetails {
+export interface TaskDetails extends TaskActions {
 	task: Task;
 	logs: TaskLogEntry[];
 	logsStatus: LogsStatus;
-	canResume: boolean;
-	canPause: boolean;
 }
 
 export interface TaskActions {

packages/tasks/src/hooks/useTasksApi.ts

@@ -9,44 +9,32 @@
  * ```
  */
 
-import {
-	createTask as createTaskDef,
-	deleteTask as deleteTaskDef,
-	downloadLogs as downloadLogsDef,
-	getTask as getTaskDef,
-	getTaskDetails as getTaskDetailsDef,
-	getTasks as getTasksDef,
-	getTemplates as getTemplatesDef,
-	init as initDef,
-	pauseTask as pauseTaskDef,
-	resumeTask as resumeTaskDef,
-	sendTaskMessage as sendTaskMessageDef,
-	viewInCoder as viewInCoderDef,
-	viewLogs as viewLogsDef,
-	type CreateTaskParams,
-} from "@repo/shared";
+import { TasksApi, type CreateTaskParams } from "@repo/shared";
 import { useIpc } from "@repo/webview-shared/react";
 
 export function useTasksApi() {
 	const { request, command } = useIpc();
 
 	return {
 		// Requests
-		init: () => request(initDef),
-		getTasks: () => request(getTasksDef),
-		getTemplates: () => request(getTemplatesDef),
-		getTask: (taskId: string) => request(getTaskDef, { taskId }),
-		getTaskDetails: (taskId: string) => request(getTaskDetailsDef, { taskId }),
-		createTask: (params: CreateTaskParams) => request(createTaskDef, params),
-		deleteTask: (taskId: string) => request(deleteTaskDef, { taskId }),
-		pauseTask: (taskId: string) => request(pauseTaskDef, { taskId }),
-		resumeTask: (taskId: string) => request(resumeTaskDef, { taskId }),
+		init: () => request(TasksApi.init),
+		getTasks: () => request(TasksApi.getTasks),
+		getTemplates: () => request(TasksApi.getTemplates),
+		getTask: (taskId: string) => request(TasksApi.getTask, { taskId }),
+		getTaskDetails: (taskId: string) =>
+			request(TasksApi.getTaskDetails, { taskId }),
+		createTask: (params: CreateTaskParams) =>
+			request(TasksApi.createTask, params),
+		deleteTask: (taskId: string) => request(TasksApi.deleteTask, { taskId }),
+		pauseTask: (taskId: string) => request(TasksApi.pauseTask, { taskId }),
+		resumeTask: (taskId: string) => request(TasksApi.resumeTask, { taskId }),
 
 		// Commands
-		viewInCoder: (taskId: string) => command(viewInCoderDef, { taskId }),
-		viewLogs: (taskId: string) => command(viewLogsDef, { taskId }),
-		downloadLogs: (taskId: string) => command(downloadLogsDef, { taskId }),
+		viewInCoder: (taskId: string) => command(TasksApi.viewInCoder, { taskId }),
+		viewLogs: (taskId: string) => command(TasksApi.viewLogs, { taskId }),
+		downloadLogs: (taskId: string) =>
+			command(TasksApi.downloadLogs, { taskId }),
 		sendTaskMessage: (taskId: string, message: string) =>
-			command(sendTaskMessageDef, { taskId, message }),
+			command(TasksApi.sendTaskMessage, { taskId, message }),
 	};
 }

packages/webview-shared/src/index.ts

@@ -3,7 +3,6 @@ export interface WebviewMessage {
 	method: string;
 	params?: unknown;
 	requestId?: string;
-	scope?: string;
 }
 
 // VS Code state API

packages/webview-shared/src/react/useIpc.ts

@@ -7,7 +7,7 @@ import { useEffect, useRef } from "react";
 
 import { postMessage } from "../api";
 
-import type { IpcResponse } from "@repo/shared";
+import type { IpcNotification, IpcResponse } from "@repo/shared";
 
 interface PendingRequest {
 	resolve: (value: unknown) => void;
@@ -20,10 +20,10 @@ const DEFAULT_TIMEOUT_MS = 30000;
 export interface UseIpcOptions {
 	/** Request timeout in ms (default: 30000) */
 	timeoutMs?: number;
-	/** Scope for message routing */
-	scope?: string;
 }
 
+type NotificationHandler = (data: unknown) => void;
+
 /**
  * Hook for type-safe IPC with the extension.
  *
@@ -32,11 +32,21 @@ export interface UseIpcOptions {
  * const ipc = useIpc();
  * const tasks = await ipc.request(getTasks);  // Type: Task[]
  * ipc.command(viewInCoder, { taskId: "123" }); // Fire-and-forget
+ *
+ * // Subscribe to notifications
+ * useEffect(() => {
+ *   return ipc.onNotification(tasksUpdated, (tasks) => {
+ *     setTasks(tasks);  // tasks is typed as Task[]
+ *   });
+ * }, []);
  * ```
  */
 export function useIpc(options: UseIpcOptions = {}) {
-	const { timeoutMs = DEFAULT_TIMEOUT_MS, scope } = options;
+	const { timeoutMs = DEFAULT_TIMEOUT_MS } = options;
 	const pendingRequests = useRef<Map<string, PendingRequest>>(new Map());
+	const notificationHandlers = useRef<Map<string, Set<NotificationHandler>>>(
+		new Map(),
+	);
 
 	// Cleanup on unmount
 	useEffect(() => {
@@ -46,27 +56,43 @@ export function useIpc(options: UseIpcOptions = {}) {
 				req.reject(new Error("Component unmounted"));
 			}
 			pendingRequests.current.clear();
+			notificationHandlers.current.clear();
 		};
 	}, []);
 
-	// Handle responses
+	// Handle responses and notifications
 	useEffect(() => {
 		const handler = (event: MessageEvent) => {
-			const msg = event.data as IpcResponse | undefined;
-			if (!msg || typeof msg.requestId !== "string" || !("success" in msg)) {
+			const msg = event.data as IpcResponse | IpcNotification | undefined;
+
+			if (!msg || typeof msg !== "object") {
 				return;
 			}
 
-			const pending = pendingRequests.current.get(msg.requestId);
-			if (!pending) return;
+			// Response handling (has requestId + success)
+			if ("requestId" in msg && "success" in msg) {
+				const pending = pendingRequests.current.get(msg.requestId);
+				if (!pending) return;
+
+				clearTimeout(pending.timeout);
+				pendingRequests.current.delete(msg.requestId);
 
-			clearTimeout(pending.timeout);
-			pendingRequests.current.delete(msg.requestId);
+				if (msg.success) {
+					pending.resolve(msg.data);
+				} else {
+					pending.reject(new Error(msg.error || "Request failed"));
+				}
+				return;
+			}
 
-			if (msg.success) {
-				pending.resolve(msg.data);
-			} else {
-				pending.reject(new Error(msg.error || "Request failed"));
+			// Notification handling (has type, no requestId)
+			if ("type" in msg && !("requestId" in msg)) {
+				const handlers = notificationHandlers.current.get(msg.type);
+				if (handlers) {
+					for (const h of handlers) {
+						h(msg.data);
+					}
+				}
 			}
 		};
 
@@ -78,7 +104,6 @@ export function useIpc(options: UseIpcOptions = {}) {
 	function request<P, R>(
 		definition: {
 			method: string;
-			scope?: string;
 			_types?: { params: P; response: R };
 		},
 		...args: P extends void ? [] : [params: P]
@@ -102,7 +127,6 @@ export function useIpc(options: UseIpcOptions = {}) {
 
 			postMessage({
 				method: definition.method,
-				scope: scope ?? definition.scope,
 				requestId,
 				params,
 			});
@@ -111,15 +135,51 @@ export function useIpc(options: UseIpcOptions = {}) {
 
 	/** Send command without waiting (fire-and-forget) */
 	function command<P>(
-		definition: { method: string; scope?: string; _types?: { params: P } },
+		definition: { method: string; _types?: { params: P } },
 		...args: P extends void ? [] : [params: P]
 	): void {
 		postMessage({
 			method: definition.method,
-			scope: scope ?? definition.scope,
 			params: args[0],
 		});
 	}
 
-	return { request, command };
+	/**
+	 * Subscribe to push notifications from the extension.
+	 * Returns an unsubscribe function that should be called on cleanup.
+	 *
+	 * @example
+	 * ```tsx
+	 * useEffect(() => {
+	 *   return ipc.onNotification(tasksUpdated, (tasks) => {
+	 *     setTasks(tasks);
+	 *   });
+	 * }, []);
+	 * ```
+	 */
+	function onNotification<D>(
+		definition: { method: string; _types?: { data: D } },
+		callback: (data: D) => void,
+	): () => void {
+		const method = definition.method;
+		let handlers = notificationHandlers.current.get(method);
+		if (!handlers) {
+			handlers = new Set();
+			notificationHandlers.current.set(method, handlers);
+		}
+		handlers.add(callback as NotificationHandler);
+
+		// Return unsubscribe function
+		return () => {
+			const h = notificationHandlers.current.get(method);
+			if (h) {
+				h.delete(callback as NotificationHandler);
+				if (h.size === 0) {
+					notificationHandlers.current.delete(method);
+				}
+			}
+		};
+	}
+
+	return { request, command, onNotification };
 }