Re-Sync

Author: NikolaRHristov

Source/Cocoon.ts

@@ -0,0 +1,142 @@
+/**
+ * @module Cocoon
+ * @description The main entry point for the Cocoon Node.js extension host.
+ *
+ * This file orchestrates the entire application lifecycle:
+ * 1. Sets up the Node.js environment by patching module paths.
+ * 2. Defines the main application workflow as a declarative `Effect`.
+ * 3. Composes all service layers (`Core`, `IPC`, `Service`) into a single application layer.
+ * 4. Executes the main Effect, which includes performing a handshake with Mountain,
+ *    initializing all services with data from the host, and activating extensions.
+ */
+
+import * as Path from "path";
+import { Barrier, Context, Effect, Layer, Scope } from "effect";
+import type { IExtensionHostInitData } from "vs/workbench/services/extensions/common/extensionHostProtocol.js";
+
+import { CoreServiceLayer } from "./Core.js";
+import { ExtensionHost } from "./Core/ExtensionHost.js";
+import { RequireInterceptor } from "./Core/RequireInterceptor.js";
+import { RunProcessPatch } from "./PatchProcess.js";
+import { AllServiceLayer } from "./Service.js";
+import { InitDataLayer } from "./Service/InitData.js";
+import { IPCProvider, Live as LiveIPC } from "./Service/IPC.js";
+
+// --- Pre-initialization Steps ---
+// Add the bundled VS Code module path to Node's search paths. This allows
+// imports like `vs/base/common/uri.js` to resolve correctly.
+const VSCodeOutputDirectory =
+	process.env["VSCODE_OUT_DIR"] ??
+	Path.resolve(__dirname, "../../../Dependency/VSCode/out");
+(module as any).paths.unshift(VSCodeOutputDirectory);
+
+// --- Application Logic ---
+
+/**
+ * An Effect that represents the full initialization of all services *after*
+ * the handshake with Mountain is complete and the init data has been received.
+ */
+const FullApplicationInitialization = Effect.gen(function* (_) {
+	const Interceptor = yield* _(RequireInterceptor.Tag);
+	yield* _(Interceptor.Install());
+	yield* _(Effect.logInfo("Node.js require() interceptor installed."));
+
+	// Now that the environment is fully set up, we can activate extensions.
+	const Host = yield* _(ExtensionHost.Tag);
+	// The '*' event signifies activating all extensions marked for startup.
+	yield* _(
+		Host.ActivateById("*" as any, { startup: true, activationEvent: "*" }),
+	);
+
+	yield* _(Effect.logInfo("Startup extensions activated."));
+});
+
+/**
+ * The main application workflow, described as a single declarative Effect.
+ */
+const Main = Effect.gen(function* (_) {
+	const InitializationBarrier = yield* _(Barrier.make());
+
+	// 1. Apply all low-level process patches (e.g., console piping, termination hooks).
+	yield* _(RunProcessPatch);
+
+	// 2. Get the IPC provider.
+	const IPC = yield* _(IPCProvider.Tag);
+
+	// 3. Register the handler that will be called by Mountain to kick off initialization.
+	IPC.RegisterInvokeHandler(
+		"initExtensionHost",
+		(initializationData: IExtensionHostInitData) =>
+			Effect.gen(function* (_) {
+				yield* _(
+					Effect.logInfo(
+						"Received 'initExtensionHost' data from Mountain.",
+					),
+				);
+
+				// Compose the final application layer, providing the received init data.
+				const ApplicationLayer = AllServiceLayer.pipe(
+					Layer.provide(CoreServiceLayer),
+					Layer.provide(InitDataLayer(initializationData)),
+				);
+
+				// Provide the full layer to our initialization Effect and run it.
+				yield* _(
+					Effect.provide(
+						FullApplicationInitialization,
+						ApplicationLayer,
+					),
+				);
+
+				// Signal that initialization is complete.
+				yield* _(Barrier.succeed(InitializationBarrier, undefined));
+				return "initialized"; // Acknowledge completion back to Mountain.
+			}).pipe(Effect.runPromise),
+	);
+
+	// 4. Send the 'Ready' signal to Mountain, indicating we are ready for init data.
+	yield* _(IPC.SendNotification("$initialHandshake", []));
+	yield* _(Effect.logInfo("Cocoon is ready. Sent handshake to Mountain."));
+
+	// 5. Wait for the `initExtensionHost` handler to open the barrier.
+	yield* _(Barrier.await(InitializationBarrier));
+	yield* _(Effect.logInfo("Cocoon is fully initialized and operational."));
+
+	// 6. Keep the process alive indefinitely.
+	yield* _(Effect.never);
+}).pipe(
+	// Global error handler for the entire application.
+	Effect.catchAllCause((cause) =>
+		Effect.logFatal("Cocoon main process failed.", cause),
+	),
+);
+
+// --- Application Layer Composition ---
+
+/**
+ * A configuration object for the IPC layer.
+ */
+const ApplicationConfiguration = {
+	MountainAddress: process.env["MOUNTAIN_ADDR"] || "localhost:50051",
+	CocoonAddress: process.env["COCOON_ADDR"] || "localhost:50052",
+};
+
+/**
+ * The base Layer for the application, providing the IPC connection.
+ * Other layers will be built on top of this.
+ */
+const CocoonBaseLayer = LiveIPC(ApplicationConfiguration);
+
+// --- Run the Application ---
+
+// We create a master Scope for the application. When this scope is closed (e.g., on SIGTERM),
+// all finalizers from our `Layer.scoped` resources (like the gRPC client/server)
+// will be executed, ensuring a graceful shutdown.
+const ApplicationWithScope = Scope.make().pipe(
+	Effect.flatMap((scope) =>
+		Effect.provide(Main, CocoonBaseLayer).pipe(Scope.extend(scope)),
+	),
+);
+
+// Fork the entire application into the background.
+Effect.runFork(ApplicationWithScope);

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 {
+	ShowErrorMessage,
+	ShowInformationMessage,
+} from "../../Service/Window.js";
+import { ActiveEditorNotFoundError } from "./ProcessUserData/Error.js";
+import { GetActiveTextEditor } from "./ProcessUserData/GetActiveTextEditor.js";
+import { GetDocumentText } from "./ProcessUserData/GetDocumentText.js";
+import { InvokeProcessingService } from "./ProcessUserData/InvokeProcessingService.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 globalThis.Error ? Error.message : String(Error)}`,
+		),
+	),
+);

Source/Command/ProcessUserData/Error.ts

@@ -0,0 +1,26 @@
+/**
+ * @module Error (ProcessUserData)
+ * @description Defines custom, tagged errors for the ProcessUserData command workflow.
+ */
+
+import { Data } from "effect";
+
+export class ActiveEditorNotFoundError extends Data.TaggedError(
+	"ActiveEditorNotFoundError",
+)<{}> {
+	message = "No active text editor found. Please open a file to process.";
+}
+
+export class ProcessingServiceError extends Data.TaggedError(
+	"ProcessingServiceError",
+)<{
+	readonly cause: unknown;
+}> {
+	get message() {
+		const causeMessage =
+			this.cause instanceof Error
+				? this.cause.message
+				: String(this.cause);
+		return `Failed to connect to the processing service: ${causeMessage}`;
+	}
+}

Source/Command/ProcessUserData/GetActiveTextEditor.ts

@@ -0,0 +1,20 @@
+/**
+ * @module GetActiveTextEditor
+ * @description An Effect that retrieves the active VS Code text editor by
+ * delegating to the Window service.
+ */
+
+import { Effect, Option } from "effect";
+import type * as vscode from "vscode";
+
+import { Window } from "../../Service/Window.js";
+
+/**
+ * An Effect that safely retrieves the active text editor.
+ * @returns An `Effect` that resolves to an `Option<vscode.TextEditor>`, which
+ * will be `None` if no editor is active, and `Some` otherwise.
+ */
+export const GetActiveTextEditor = Effect.gen(function* (_) {
+	const WindowService = yield* _(Window.Tag);
+	return Option.fromNullable(WindowService.activeTextEditor);
+});

Source/Command/ProcessUserData/GetDocumentText.ts

@@ -0,0 +1,18 @@
+/**
+ * @module GetDocumentText
+ * @description An Effect that retrieves the full text content of a document.
+ */
+
+import { Effect } from "effect";
+import type * as VSCode from "vscode";
+
+/**
+ * An Effect that gets the full text content of a given document.
+ * @param Document The `vscode.TextDocument` to read from.
+ * @returns An `Effect` that synchronously resolves to the document's text content.
+ */
+export function GetDocumentText(
+	Document: VSCode.TextDocument,
+): Effect.Effect<string> {
+	return Effect.sync(() => Document.getText());
+}

Source/Command/ProcessUserData/InvokeProcessingService.ts

@@ -0,0 +1,35 @@
+/**
+ * @module InvokeProcessingService
+ * @description An Effect that sends text to a backend service for processing.
+ * This version uses the internal IPC service instead of a direct `fetch`.
+ */
+
+import { Effect } from "effect";
+
+import { IPC } from "../../Service/IPC.js";
+import { ProcessingServiceError } from "./Error.js";
+
+interface ProcessingResult {
+	ID: string;
+	Status: "Success";
+}
+
+/**
+ * An Effect that makes an RPC call to a backend service.
+ * @param TextContent The text to be processed.
+ * @returns An `Effect` that resolves to the result from the service,
+ *   or fails with a `ProcessingServiceError`.
+ */
+export function InvokeProcessingService(
+	TextContent: string,
+): Effect.Effect<ProcessingResult, ProcessingServiceError> {
+	return Effect.gen(function* (_) {
+		const IPCService = yield* _(IPC.Tag);
+		return yield* _(
+			IPCService.SendRequest<ProcessingResult>("$processText", [
+				TextContent,
+			]),
+			Effect.mapError((cause) => new ProcessingServiceError({ cause })),
+		);
+	});
+}

Source/Core.ts

@@ -0,0 +1,40 @@
+/**
+ * @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.
+ */
+
+import { Layer } from "effect";
+
+import { Live as LiveAPIFactory } from "./Core/APIFactory.js";
+import { Live as LiveESMInterceptor } from "./Core/ESMInterceptor.js";
+import { Live as LiveExtensionHost } from "./Core/ExtensionHost.js";
+import { Live as LiveExtensionPath } from "./Core/ExtensionPath.js";
+import { Live as LiveHostKindPicker } from "./Core/HostKindPicker.js";
+import { Live as LiveNodeModuleShim } from "./Core/NodeModuleShim.js";
+import { Live as LiveRequireInterceptor } from "./Core/RequireInterceptor.js";
+
+// --- Re-exporting the full public API (Tag, Interface, Live Layer) for each core service ---
+
+export * as APIFactory from "./Core/APIFactory.js";
+export * as ESMInterceptor from "./Core/ESMInterceptor.js";
+export * as ExtensionHost from "./Core/ExtensionHost.js";
+export * as ExtensionPath from "./Core/ExtensionPath.js";
+export * as HostKindPicker from "./Core/HostKindPicker.js";
+export * as NodeModuleShim from "./Core/NodeModuleShim.js";
+export * as RequireInterceptor from "./Core/RequireInterceptor.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 `Cocoon.ts`.
+ */
+export const CoreServiceLayer = Layer.mergeAll(
+	LiveAPIFactory,
+	LiveESMInterceptor,
+	LiveExtensionHost,
+	LiveExtensionPath,
+	LiveHostKindPicker,
+	LiveNodeModuleShim,
+	LiveRequireInterceptor,
+);