refactor(Cocoon/IPC): Consolidate service layer implementations with Effect-TS patterns

- Restructured IPC services (Dispatcher, ProtocolAdapter, Server) into namespaced modules with unified Layer exports
- Migrated service interfaces to class-based Context.Tag definitions for improved type safety and dependency management
- Aligned gRPC server lifecycle handling with Effect's scoped resource model through Layer composition
- Standardized service method parameter naming (ParameterArray) across RPC handlers for consistency
- Updated Configuration service tagging to match latest Effect Context API conventions

These changes strengthen the Cocoon sidecar's IPC foundation by fully leveraging Effect-TS's dependency injection capabilities, ensuring proper separation between gRPC transport logic and VS Code extension protocol handling. The new structure directly supports Land's phased architecture by maintaining clear service boundaries between Cocoon's Node.js environment and Mountain's native backend.

Refs #4cc1488e20f81f89f02b2aeef8ce9a5bca857941

Author: NikolaRHristov

Source/Service/IPC/Configuration.ts

@@ -25,4 +25,4 @@ export interface Configuration {
 /**
  * The `Context.Tag` for the IPC configuration.
  */
-export const Tag = Context.Tag<Configuration>("IPC/Configuration");
+export const Tag = Context.Tag("IPC/Configuration")<Configuration>;

Source/Service/IPC/Dispatcher.ts

@@ -6,16 +6,21 @@
 
 import { Layer } from "effect";
 
-import { Live as LiveCancellation } from "../Cancellation.js";
+import { Cancellation } from "../../Cancellation.js";
 import { Definition } from "./Dispatcher/Definition.js";
-import { Tag } from "./Dispatcher/Service.js";
-import { Live as LiveProtocolAdapter } from "./ProtocolAdapter.js";
+import { Dispatcher as DispatcherTag } from "./Dispatcher/Service.js";
+import { ProtocolAdapter } from "./ProtocolAdapter.js";
 
-/**
- * The live implementation Layer for the Dispatcher service.
- * It depends on the ProtocolAdapter (for the underlying transport) and the
- * Cancellation service (for handling cancellation signals).
- */
-export const Live = Layer.effect(Tag, Definition).pipe(
-	Layer.provide(Layer.merge(LiveProtocolAdapter, LiveCancellation)),
-);
+export namespace Dispatcher {
+	export const Tag = DispatcherTag;
+	export type Interface = DispatcherTag;
+
+	/**
+	 * The live implementation Layer for the Dispatcher service.
+	 * It depends on the ProtocolAdapter (for the underlying transport) and the
+	 * Cancellation service (for handling cancellation signals).
+	 */
+	export const Live = Layer.effect(Tag, Definition).pipe(
+		Layer.provide(Layer.merge(ProtocolAdapter.Live, Cancellation.Live)),
+	);
+}

Source/Service/IPC/Dispatcher/Service.ts

@@ -6,61 +6,30 @@
  */
 
 import { Context, type Effect } from "effect";
-import type { IDisposable } from "vscode";
+import type { Disposable } from "vscode";
 
 import type { IPCError } from "../Error.js";
 
-export interface Interface {
-	/**
-	 * Dispatches an incoming request from the host.
-	 * It will first check for a custom invoke handler, then fall back to the
-	 * main VS Code RPCProtocol.
-	 * @param Method The name of the method being invoked.
-	 * @param Parameters The arguments for the method.
-	 * @returns An `Effect` that resolves with the result of the handler.
-	 */
-	readonly DispatchRequest: (
-		Method: string,
-		Parameters: any[],
-	) => Effect.Effect<any, Error>;
-
-	/**
-	 * Dispatches an incoming fire-and-forget notification from the host.
-	 * @param Method The name of the notification.
-	 * @param Parameters The arguments for the notification.
-	 */
-	readonly DispatchNotification: (
-		Method: string,
-		Parameters: any[],
-	) => Effect.Effect<void, never>;
-
-	/**
-	 * Dispatches an incoming cancellation signal from the host.
-	 * @param RequestID The ID of the request to cancel.
-	 */
-	readonly CancelOperation: (RequestID: number) => Effect.Effect<void, never>;
-
-	/**
-	 * Processes raw binary data for the VS Code RPCProtocol by passing it to
-	 * the underlying protocol adapter.
-	 * @param Data The raw Uint8Array from the host.
-	 */
-	readonly ProcessIncomingData: (
-		Data: Uint8Array,
-	) => Effect.Effect<void, never>;
-
-	/**
-	 * Registers a custom handler for a specific invoke method from the host.
-	 * This is used for top-level methods like `initExtensionHost` that are
-	 * not part of the standard VS Code RPC protocol.
-	 * @param Channel The channel/method name.
-	 * @param Handler An async function that handles the request.
-	 * @returns A `Disposable` to unregister the handler.
-	 */
-	readonly RegisterInvokeHandler: (
-		Channel: string,
-		Handler: (...Arguments: any[]) => Promise<any>,
-	) => IDisposable;
-}
-
-export const Tag = Context.Tag<Interface>("IPC/Dispatcher");
+export class Dispatcher extends Context.Tag("IPC/Dispatcher")<
+	Dispatcher,
+	{
+		readonly DispatchRequest: (
+			Method: string,
+			ParameterArray: any[],
+		) => Effect.Effect<any, Error>;
+		readonly DispatchNotification: (
+			Method: string,
+			ParameterArray: any[],
+		) => Effect.Effect<void, never>;
+		readonly CancelOperation: (
+			RequestID: number,
+		) => Effect.Effect<void, never>;
+		readonly ProcessIncomingData: (
+			Data: Uint8Array,
+		) => Effect.Effect<void, never>;
+		readonly RegisterInvokeHandler: (
+			Channel: string,
+			Handler: (...ArgumentArray: any[]) => Promise<any>,
+		) => Disposable;
+	}
+>() {}

Source/Service/IPC/ProtocolAdapter.ts

@@ -9,12 +9,16 @@ import { Layer } from "effect";
 
 import { Live as LiveClient } from "./Client.js";
 import { Definition } from "./ProtocolAdapter/Definition.js";
-import { Tag } from "./ProtocolAdapter/Service.js";
+import { Tag, type Interface } from "./ProtocolAdapter/Service.js";
+
+// --- Public API Exports ---
+export { Tag, type Interface };
+
+// --- Live Implementation ---
 
 /**
  * The live implementation `Layer` for the `ProtocolAdapter` service.
- *
- * This layer builds the adapter by composing its `Definition` with the
+ * It builds the adapter by composing its `Definition` with the
  * `LiveClient` layer it depends on for the underlying gRPC transport.
  */
 export const Live = Layer.effect(Tag, Definition).pipe(

Source/Service/IPC/Server.ts

@@ -6,17 +6,26 @@
 
 import { Layer } from "effect";
 
-import type { Configuration } from "./Configuration.js";
-import { Live as LiveDispatcher } from "./Dispatcher.js";
+import { Configuration } from "./Configuration.js";
+import { Dispatcher } from "./Dispatcher.js";
 import type { gRPCConnectionError } from "./Error.js";
 import { Acquire } from "./Server/Acquire.js";
 import { Tag, type Interface as ServerService } from "./Server/Service.js";
 
-/**
- * The live implementation `Layer` for the gRPC Server service.
- */
-export const Live: Layer.Layer<
-	ServerService,
-	gRPCConnectionError,
-	Configuration | Dispatcher.Interface
-> = Layer.scoped(Tag, Acquire).pipe(Layer.provide(LiveDispatcher));
+export namespace Server {
+	export const Tag = Tag;
+	export type Interface = ServerService;
+	/**
+	 * The live implementation `Layer` for the gRPC Server service.
+	 *
+	 * This scoped layer creates and manages the lifecycle of the gRPC server instance,
+	 * ensuring it starts with the application and is shut down gracefully. It
+	 * composes the `Acquire` effect with the `LiveDispatcher` layer, which is a
+	 * dependency for creating the server's request handlers.
+	 */
+	export const Live: Layer.Layer<
+		Interface,
+		gRPCConnectionError,
+		Configuration.Configuration
+	> = Layer.scoped(Tag, Acquire).pipe(Layer.provide(Dispatcher.Live));
+}

Source/Service/IPC/Server/Acquire.ts

@@ -13,7 +13,7 @@ import {
 } from "@grpc/proto-loader";
 import { Effect } from "effect";
 
-import { Configuration as ConfigurationService } from "../Configuration.js";
+import { Configuration } from "../Configuration.js";
 import { Dispatcher } from "../Dispatcher.js";
 import { gRPCConnectionError } from "../Error.js";
 import { CreateServiceImplementation } from "./CreateServiceImplementation.js";
@@ -78,7 +78,7 @@ function StartServer(
 
 export const Acquire = Effect.acquireRelease(
 	Effect.gen(function* () {
-		const Config = yield* ConfigurationService.Tag;
+		const Config = yield* Configuration.Tag;
 		const DispatcherService = yield* Dispatcher.Tag;
 		const ProtoPath = Path.join(process.cwd(), "proto/vine.proto");
 

Source/Service/IPC/Server/CreateServiceImplementation.ts

@@ -6,9 +6,9 @@
 
 import * as gRPC from "@grpc/grpc-js";
 import type { UntypedServiceImplementation } from "@grpc/grpc-js";
-import { Effect } from "effect";
+import { Context, Effect } from "effect";
 
-import type { Dispatcher } from "../Dispatcher/Service.js";
+import { Dispatcher } from "../Dispatcher.js";
 import {
 	Empty,
 	GenericResponse,
@@ -20,7 +20,7 @@ import {
 import { DecodeValue, EncodeValue } from "../ProtoConverter.js";
 
 export function CreateServiceImplementation(
-	DispatcherService: Dispatcher.Interface,
+	DispatcherService: Context.Tag.Service<Dispatcher.Interface>,
 ): UntypedServiceImplementation {
 	return {
 		/**

Source/Service/IPC/Server/Service.ts

@@ -7,15 +7,10 @@
 import type * as gRPC from "@grpc/grpc-js";
 import { Context } from "effect";
 
-/**
- * The service type, which is the underlying `grpc.Server` class.
- */
-export type Interface = gRPC.Server;
-
 /**
  * The `Context.Tag` for the gRPC server instance.
  *
  * This tag provides access to the raw server object if needed, for example,
  * by the `acquireRelease` logic that manages its lifecycle.
  */
-export const Tag = Context.Tag<Interface>("IPC/Server");
+export class Server extends Context.Tag("IPC/Server")<Server, gRPC.Server>() {}