feat(Cocoon): Implement core extension host services and user command workflow

- Added `ProcessUserData` command effect with structured error handling, demonstrating Effect-TS integration for extension workflows
- Established core service layers (`ApiFactory`, `RequireInterceptor`, `ExtensionHost`) using Effect-TS Layer system to compose VS Code API surface
- Implemented service definitions for 30+ VS Code API areas (Commands, LanguageFeatures, Documents) with gRPC IPC to Mountain backend
- Introduced type-safe RPC handlers for language features like Hover providers, ensuring compatibility with `vine.proto` contracts
- Configured process patching and module interception to secure extension environment while maintaining VS Code compatibility

This foundational work enables Cocoon's Node.js extension host (Path A MVP) to provide full VS Code API compatibility while delegating privileged operations to Mountain via gRPC. Services are built as pure Effect layers, aligning with Land's declarative architecture and preparing for future Grove integration.

Author: NikolaRHristov

Source/Command/ProcessUserData.ts

@@ -0,0 +1,58 @@
+/**
+ * @module ProcessUserData (Command)
+ * @description The main module for the 'ProcessUserData' command.
+ *
+ * This orchestrates the entire workflow of getting text from the active
+ * editor, sending it to a backend service for processing, and then
+ * displaying the result to the user.
+ */
+
+import { Effect, pipe } from "effect";
+
+import { InvokeProcessingService } from "../../Service/Mountain/InvokeProcessingService.js";
+import { GetActiveTextEditor } from "../../Service/Window/GetActiveTextEditor.js";
+import {
+	ShowErrorMessage,
+	ShowInformationMessage,
+} from "../../Service/Window/mod.js";
+import { ActiveEditorNotFoundError, ProcessingServiceError } from "./Error.js";
+import { GetDocumentText } from "./GetDocumentText.js";
+
+/**
+ * An `Effect` that encapsulates the entire workflow for processing user data
+ * from the active text editor, demonstrating declarative, type-safe error
+ * handling.
+ */
+export const ProcessUserData = pipe(
+	Effect.gen(function* (_) {
+		// Safely get the active editor, which may not exist.
+		const MaybeEditor = yield* _(GetActiveTextEditor);
+
+		// Convert the Option into an Effect that fails with our specific error if empty.
+		const Editor = yield* _(
+			MaybeEditor,
+			Effect.mapError(() => new ActiveEditorNotFoundError()),
+		);
+
+		// If the above succeeds, the workflow proceeds.
+		const TextContent = yield* _(GetDocumentText(Editor.document));
+		const ProcessingResult = yield* _(InvokeProcessingService(TextContent));
+		yield* _(
+			ShowInformationMessage(
+				`Processing complete: ${ProcessingResult.Id}`,
+			),
+		);
+	}),
+	// Declaratively handle all known, tagged failure cases for this workflow.
+	Effect.catchTags({
+		ActiveEditorNotFoundError: (Error) => ShowErrorMessage(Error.message),
+		ProcessingServiceError: (Error) => ShowErrorMessage(Error.message),
+	}),
+	// Catch any other unexpected error that might have occurred, safely handling
+	// the error type.
+	Effect.catchAll((Error) =>
+		ShowErrorMessage(
+			`An unexpected error occurred: ${Error instanceof Error ? Error.message : String(Error)}`,
+		),
+	),
+);

Source/Core.ts

@@ -0,0 +1,33 @@
+// --- Creating a single, composed layer for all core services ---
+
+import { Layer } from "effect";
+
+import { Live as LiveApiFactory } from "./ApiFactory/mod.js";
+import { Live as LiveExtensionHost } from "./ExtensionHost/mod.js";
+import { Live as LiveExtensionPaths } from "./ExtensionPath/mod.js";
+import { Live as LiveRequireInterceptor } from "./RequireInterceptor/mod.js";
+
+/**
+ * @module Core
+ * @description This is the aggregator module for all core services of the Cocoon
+ * extension host. These services are fundamental to the runtime's operation,
+ * managing the extension lifecycle, API creation, and module loading.
+ */
+
+// --- Re-exporting the full public API (Tag, Interface, Live Layer) for each core service ---
+
+export * as ApiFactory from "./ApiFactory/mod.js";
+export * as ExtensionHost from "./ExtensionHost/mod.js";
+export * as ExtensionPaths from "./ExtensionPath/mod.js";
+export * as RequireInterceptor from "./RequireInterceptor/mod.js";
+
+/**
+ * A single, composed layer that provides all core services of the extension host.
+ * This simplifies the process of building the final application layer in `Index.ts`.
+ */
+export const CoreServicesLayer = Layer.mergeAll(
+	LiveApiFactory,
+	LiveExtensionHost,
+	LiveExtensionPaths,
+	LiveRequireInterceptor,
+);

Source/Core/APIFactory.ts

@@ -0,0 +1,77 @@
+/**
+ * @module ApiFactory
+ * @description The main module for the `ApiFactory` service, which is
+ * responsible for creating sandboxed `vscode` API objects for extensions.
+ */
+
+import { Context, Effect, Layer } from "effect";
+import type { IExtensionDescription } from "vs/platform/extensions/common/extensions.js";
+import type * as Vscode from "vscode";
+
+import * as Service from "../../Service/mod.js";
+import { CreateApiFactory } from "./CreateApiFactory.js";
+
+/**
+ * The interface for the `ApiFactory` service.
+ */
+export interface Interface {
+	/**
+	 * Creates a new, sandboxed `vscode` API object for a specific extension.
+	 * @param Extension The full description of the extension requesting the API.
+	 * @returns A frozen `vscode` API object tailored for the extension.
+	 */
+	readonly Create: (Extension: IExtensionDescription) => typeof Vscode;
+}
+
+/**
+ * The `Context.Tag` for the `ApiFactory` service.
+ */
+export const Tag = Context.Tag<Interface>("ApiFactory");
+
+/**
+ * The live implementation `Layer` for the `ApiFactory` service.
+ *
+ * This layer has a comprehensive dependency graph, as it requires every
+ * underlying service that contributes to the final `vscode` API object. It
+ * injects all of these services into the `CreateApiFactory` function to
+ * construct the final service implementation.
+ */
+export const Live = Layer.effect(
+	Tag,
+	Effect.gen(function* (_) {
+		// --- Inject all necessary services ---
+		const LogService = yield* _(Service.Log.Tag);
+		const ProposedApiService = yield* _(Service.ProposedApi.Tag);
+		const DeprecationService = yield* _(Service.ApiDeprecation.Tag);
+		const CommandsService = yield* _(Service.Commands.Tag);
+		const WorkspaceService = yield* _(Service.Workspace.Tag);
+		const WindowService = yield* _(Service.Window.Tag);
+		const LanguageFeaturesService = yield* _(Service.LanguageFeatures.Tag);
+		const DebugService = yield* _(Service.Debug.Tag);
+		const TasksService = yield* _(Service.Tasks.Tag);
+		const ExtensionService = yield* _(Service.Extension.Tag);
+		const WebviewPanelService = yield* _(Service.WebviewPanel.Tag);
+		const CustomEditorService = yield* _(Service.CustomEditor.Tag);
+		const TreeViewService = yield* _(Service.TreeView.Tag);
+		const StatusBarService = yield* _(Service.StatusBar.Tag);
+		// Add other services here as they are implemented.
+
+		// --- Construct the factory with all its dependencies ---
+		return CreateApiFactory(
+			LogService,
+			ProposedApiService,
+			DeprecationService,
+			CommandsService,
+			WorkspaceService,
+			WindowService,
+			LanguageFeaturesService,
+			DebugService,
+			TasksService,
+			ExtensionService,
+			WebviewPanelService,
+			CustomEditorService,
+			TreeViewService,
+			StatusBarService,
+		);
+	}),
+);

Source/Core/ESMInterceptor.ts

@@ -0,0 +1,20 @@
+/**
+ * @module EsmInterceptor (Core)
+ * @description The main module for the EsmInterceptor service, which installs a
+ * Node.js loader hook to intercept `import 'vscode'` statements.
+ */
+
+import { Layer } from "effect";
+
+import { Live as LiveLog } from "../../Service/Log.js";
+import { Live as LiveApiFactory } from "../ApiFactory/mod.js";
+import { Definition } from "./Definition.js";
+import { Tag } from "./Service.js";
+
+/**
+ * The live implementation layer for the EsmInterceptor service.
+ * It depends on the ApiFactory and logging services.
+ */
+export const Live = Layer.effect(Tag, Definition).pipe(
+	Layer.provide(Layer.merge(LiveApiFactory, LiveLog)),
+);

Source/Core/ExtensionHost.ts

@@ -0,0 +1,25 @@
+/**
+ * @module ExtensionHost (Core)
+ * @description The main module for the Extension Host service, which manages the
+ * entire lifecycle of extensions.
+ */
+
+import { Layer } from "effect";
+
+import { InitDataService } from "../../Service/InitData.js";
+import { Live as LiveIpc } from "../../Service/Ipc/mod.js";
+import { Live as LiveLog } from "../../Service/Log.js";
+import { Live as LiveApiFactory } from "../ApiFactory/mod.js";
+import { Definition } from "./Definition.js";
+import { Tag } from "./Service.js";
+
+/**
+ * The live implementation layer for the ExtensionHost service.
+ * It depends on the ApiFactory, logging, IPC, and initialization data services.
+ */
+export const Live = Layer.effect(Tag, Definition).pipe(
+	Layer.provide(LiveApiFactory),
+	Layer.provide(LiveLog),
+	Layer.provide(LiveIpc),
+	Layer.provide(Layer.succeed(InitDataService, {} as any)), // Placeholder for real init data
+);

Source/Core/ExtensionHost/Definition.ts

@@ -9,7 +9,7 @@ import { ExtensionDescriptionRegistry } from "vs/workbench/services/extensions/c
 import { InitDataService } from "../../Service/InitData.js";
 import { IpcProvider } from "../../Service/Ipc.js";
 import { LogProvider } from "../../Service/Log.js";
-import { ApiFactoryProvider } from "../ApiFactory.js";
+import { ApiFactoryProvider } from "../APIFactory.js";
 import { type Interface } from "./Service.js";
 import type { ActivatedExtension } from "./State.js";
 

Source/Core/ExtensionPath.ts

@@ -0,0 +1,32 @@
+/**
+ * @module ExtensionPaths (Core)
+ * @description The main module for the ExtensionPaths service, which maps file URIs
+ * to their owner extension.
+ */
+
+import { Context, Effect, Layer } from "effect";
+
+import { InitDataService } from "../../Service/InitData.js";
+import { Definition } from "./Definition.js";
+
+/**
+ * The interface for the ExtensionPaths service is the class definition itself.
+ */
+export type Interface = Definition;
+
+/**
+ * The Context.Tag for the ExtensionPaths service.
+ */
+export const Tag = Context.Tag<Interface>("Core/ExtensionPaths");
+
+/**
+ * The live implementation layer for the ExtensionPaths service.
+ * It depends on the InitDataService to get the list of all installed extensions.
+ */
+export const Live = Layer.effect(
+	Tag,
+	Effect.map(
+		InitDataService,
+		(InitData) => new Definition(InitData.extensions),
+	),
+);

Source/Core/ExtensionPath/Definition.ts

@@ -0,0 +1,63 @@
+/**
+ * @module Definition (ExtensionPaths)
+ * @description The class implementation for the ExtensionPaths service.
+ */
+
+import { URI } from "vs/base/common/uri.js";
+import {
+	ExtensionIdentifier,
+	type IExtensionDescription,
+} from "vs/platform/extensions/common/extensions.js";
+
+interface ExtensionPathsEntry {
+	readonly Path: string;
+	readonly Identifier: ExtensionIdentifier;
+}
+
+/**
+ * A service that maintains an index of installed extension paths, allowing for
+ * quick, synchronous lookups from a file URI to its owner extension.
+ * This is a critical dependency for the `RequireInterceptor`.
+ */
+export class Definition {
+	private readonly Paths: readonly ExtensionPathsEntry[];
+
+	constructor(Extensions: readonly IExtensionDescription[]) {
+		const mutablePaths: ExtensionPathsEntry[] = [];
+		for (const Extension of Extensions) {
+			if (Extension.extensionLocation) {
+				mutablePaths.push({
+					Path: URI.revive(Extension.extensionLocation).fsPath,
+					Identifier: Extension.identifier,
+				});
+			}
+		}
+
+		// Sort by path length, longest first. This is crucial to ensure that if
+		// one extension's folder is inside another's, the more specific
+		// (longer) path is matched first.
+		mutablePaths.sort((a, b) => b.Path.length - a.Path.length);
+		this.Paths = mutablePaths;
+	}
+
+	/**
+	 * Finds the extension description that corresponds to a given file URI by
+	 * checking if the URI's path is a substring of any known extension path.
+	 *
+	 * @param Uri - The file URI to look up.
+	 * @returns A minimal `IExtensionDescription` containing the identifier if a
+	 *   match is found, otherwise `undefined`.
+	 */
+	public FindSubstr(Uri: URI): IExtensionDescription | undefined {
+		const FilePath = Uri.fsPath;
+		for (const Entry of this.Paths) {
+			if (FilePath.startsWith(Entry.Path)) {
+				// Return a minimal description, as this is all the interceptor needs.
+				return {
+					identifier: Entry.Identifier,
+				} as IExtensionDescription;
+			}
+		}
+		return undefined;
+	}
+}

Source/Core/HostKindPicker.ts

@@ -0,0 +1,19 @@
+/**
+ * @module HostKindPicker (Core)
+ * @description This module provides the HostKindPicker service, which determines if
+ * an extension is compatible with the Cocoon (Node.js) extension host.
+ */
+
+import { Layer } from "effect";
+
+import { Live as LiveLog } from "../../Service/Log.js";
+import { Definition } from "./Definition.js";
+import { Tag } from "./Service.js";
+
+export { Tag, type Interface } from "./Service.js";
+
+/**
+ * The live implementation Layer for the HostKindPicker service.
+ * It depends on the Log service for reporting its decisions.
+ */
+export const Live = Layer.effect(Tag, Definition).pipe(Layer.provide(LiveLog));

Source/Core/NodeModuleShim.ts

@@ -0,0 +1,20 @@
+/**
+ * @module NodeModuleShim (Core)
+ * @description Provides the NodeModuleShim service, which intercepts requests for
+ * built-in Node.js modules, blocking some and providing safe shims for others.
+ */
+
+import { Layer } from "effect";
+
+import { Live as LiveLog } from "../../Service/Log.js";
+import { Definition } from "./Definition.js";
+import { Tag } from "./Service.js";
+
+export { Tag, type Interface } from "./Service.js";
+export * from "./Error.js";
+
+/**
+ * The live implementation Layer for the NodeModuleShim service.
+ * It depends on the Log service for reporting interception events.
+ */
+export const Live = Layer.effect(Tag, Definition).pipe(Layer.provide(LiveLog));