feat(Wind): Implement MessageChannel for extension host IPC

Add proper MessageChannel implementation in Preload and Install.ts to handle VS Code's extension host protocol. The acquire() method now creates a MessageChannel pair, posts port2 to window for acquirePort() to pick up, and implements a minimal handshake (Ready/Initialized) to prevent VS Code from hanging for 60s.

Also add stub for utilityProcessWorker.createWorker returning a never-resolving Promise to prevent destructure crashes in watcherClient, and implement readFileStream listener to stream file data using VSBuffer. Add IPC logging for stub channels.

These changes enable the extension host to initialize properly while awaiting full Cocoon sidecar integration.

Author: NikolaRHristov

Source/Function/DevLog.ts

@@ -16,15 +16,45 @@
  * localStorage.setItem("LAND_DEV_LOG", "config,folder");
  * ```
  *
- * ## Tags
- * - `vfs`       — file stat, read, write, readdir
- * - `ipc`       — TauriMainProcessService channel routing
- * - `config`    — ResolveConfiguration, environment paths
- * - `lifecycle` — preload, polyfills, workbench loading
- * - `storage`   — storage getItems/updateItems
- * - `exthost`   — extension host starter
- * - `folder`    — folder picker, workspace navigation
- * - `bootstrap` — Effect-TS bootstrap stages
+ * ## Tags — Mountain (Rust) + Wind/Sky (TypeScript)
+ *
+ * | Tag           | Scope                                               |
+ * |---------------|-----------------------------------------------------|
+ * | `vfs`         | File stat, read, write, readdir, mkdir, delete, copy|
+ * | `ipc`         | IPC routing: invoke dispatch, channel calls          |
+ * | `config`      | Configuration get/set, env paths, workbench config   |
+ * | `lifecycle`   | Startup, shutdown, phases, window events             |
+ * | `storage`     | Storage get/set/delete, items, optimize              |
+ * | `folder`      | Folder picker, workspace navigation                  |
+ * | `exthost`     | Extension host: create, start, kill, exit info       |
+ * | `extensions`  | Extension scanning, activation, management           |
+ * | `terminal`    | Terminal/PTY: create, sendText, profiles, shell      |
+ * | `search`      | Search: findFiles, findInFiles                       |
+ * | `themes`      | Theme: list, get active, set                         |
+ * | `window`      | Window: focus, maximize, minimize, fullscreen        |
+ * | `nativehost`  | OS integration: process, devtools, shell             |
+ * | `clipboard`   | Clipboard: read/write text, buffer, image            |
+ * | `commands`    | Command registry: execute, getAll                    |
+ * | `model`       | Text model: open, close, get, updateContent          |
+ * | `output`      | Output channels: create, append, show                |
+ * | `notification`| Notifications: show, progress                        |
+ * | `progress`    | Progress: begin, end, report                         |
+ * | `quickinput`  | Quick input: showQuickPick, showInputBox             |
+ * | `workingcopy` | Working copy: dirty state                            |
+ * | `workspaces`  | Workspace: folders, recent, enter                    |
+ * | `keybinding`  | Keybindings: add, remove, lookup                     |
+ * | `label`       | Label service: getBase, getUri                       |
+ * | `history`     | Navigation history: push, goBack, goForward          |
+ * | `decorations` | Decorations: get, set, clear                         |
+ * | `textfile`    | Text file operations: read, write, save              |
+ * | `update`      | Update service: check, download, apply               |
+ * | `encryption`  | Encryption: encrypt, decrypt                         |
+ * | `menubar`     | Menubar updates                                      |
+ * | `url`         | URL handler: registerExternalUriOpener               |
+ * | `grpc`        | gRPC/Vine: server, client, connections               |
+ * | `cocoon`      | Cocoon sidecar: spawn, health, handshake             |
+ * | `bootstrap`   | Effect-TS bootstrap stages                           |
+ * | `preload`     | Preload: globals, polyfills, ipcRenderer             |
  */
 
 let CachedTags: string[] | null = null;

Source/Function/Install/Function/Install.ts

@@ -77,7 +77,38 @@ export default async function Install(): Promise<void> {
 			},
 			webFrame: { setZoomLevel: () => {} },
 			webUtils: { getPathForFile: (file: File) => file.name },
-			ipcMessagePort: { acquire: () => {} },
+			ipcMessagePort: {
+				acquire: (ResponseChannel: string, Nonce: string) => {
+					console.log(
+						`[Wind] MessagePort acquire: ${ResponseChannel}, nonce=${Nonce}`,
+					);
+					const { port1, port2 } = new MessageChannel();
+					window.postMessage(Nonce, "*", [port2]);
+					port1.start();
+					let Done = false;
+					port1.onmessage = (Event: MessageEvent) => {
+						if (Done) return;
+						const Data = Event.data;
+						const Length =
+							Data instanceof ArrayBuffer
+								? Data.byteLength
+								: Data instanceof Uint8Array
+									? Data.byteLength
+									: 0;
+						if (Length > 1) {
+							Done = true;
+							console.log(
+								"[Wind] Extension host: received init data, sending Initialized",
+							);
+							port1.postMessage(new Uint8Array([1]));
+						}
+					};
+					setTimeout(() => {
+						console.log("[Wind] Extension host: sending Ready");
+						port1.postMessage(new Uint8Array([2]));
+					}, 50);
+				},
+			},
 		};
 
 		// Attach to window

Source/Preload.ts

@@ -186,16 +186,62 @@ const ipcRenderer = {
 
 const ipcMessagePort = {
 	acquire: (responseChannel: string, nonce: string) => {
-		// FUTURE: Implement proper MessageChannel for VSCode SharedProcessWorker
 		console.log(
-			`[Preload] MessagePort acquire requested: ${responseChannel}, ${nonce}`,
+			`[Preload] MessagePort acquire: ${responseChannel}, nonce=${nonce}`,
 		);
 
-		// For now, signal that ports are not available
-		// This will need proper implementation for full VSCode compatibility
+		// Create an in-memory MessageChannel.
+		// port2 is posted to the window so acquirePort() (ipc.mp.ts) picks it up
+		// via its window 'message' listener (filters e.data === nonce && e.ports[0]).
+		// port1 implements a minimal extension host handshake so VS Code
+		// does not hang for 60 s waiting for Ready / Initialized.
+		const { port1, port2 } = new MessageChannel();
+
+		// acquirePort() filters: e.data === nonce && e.source === window
+		window.postMessage(nonce, "*", [port2]);
+
+		port1.start();
+
+		let HandshakeComplete = false;
+
+		port1.onmessage = (Event: MessageEvent) => {
+			if (HandshakeComplete) {
+				// After handshake, silently drop extension-host protocol
+				// messages (activate, executeCommand, etc.) until
+				// a real Cocoon relay is wired.
+				return;
+			}
+
+			// The first large message from VS Code is the init data
+			// (JSON-encoded IExtensionHostInitData wrapped in VSBuffer).
+			// Any message with byteLength > 1 is init data; single-byte
+			// messages are control (Ready=2, Initialized=1, Terminate=3).
+			const Data = Event.data;
+			const Length =
+				Data instanceof ArrayBuffer
+					? Data.byteLength
+					: Data instanceof Uint8Array
+						? Data.byteLength
+						: typeof Data === "object" && Data?.byteLength
+							? Data.byteLength
+							: 0;
+
+			if (Length > 1) {
+				HandshakeComplete = true;
+				console.log(
+					"[Preload] Extension host: received init data, sending Initialized",
+				);
+				// MessageType.Initialized → byte 1
+				port1.postMessage(new Uint8Array([1]));
+			}
+		};
+
+		// Send Ready after a tick so VS Code's onMessage listener is registered.
+		// MessageType.Ready → byte 2
 		setTimeout(() => {
-			ipcRenderer.send(responseChannel, nonce);
-		}, 0);
+			console.log("[Preload] Extension host: sending Ready");
+			port1.postMessage(new Uint8Array([2]));
+		}, 50);
 	},
 };
 

Source/Service/TauriMainProcessService.ts

@@ -135,7 +135,14 @@ const StubChannels: Record<string, Record<string, unknown>> = {
 		},
 	},
 	sharedProcess: {},
-	utilityProcessWorker: { createWorker: undefined },
+	utilityProcessWorker: {
+		// createWorker returns a never-resolving promise to prevent
+		// destructure crash in watcherClient/utilityProcessWorkerWorkbenchService.
+		// Without a real utility process, the watcher and other workers
+		// simply never initialize (non-blocking — Mountain handles file watching).
+		createWorker: new Promise(() => {}),
+		disposeWorker: undefined,
+	},
 	// Channels with no desktop equivalent in Tauri
 	meteredConnection: {},
 	webContentExtractor: {},
@@ -203,6 +210,7 @@ class TauriChannel implements IChannel {
 		// Stub channels (not yet wired to Mountain)
 		const Stubs = StubChannels[this.ChannelName];
 		if (Stubs !== undefined) {
+			DevLog("ipc", `stub: ${this.ChannelName}.${Command}`);
 			const StubValue = Stubs[Command];
 			if (StubValue !== undefined) {
 				return StubValue as T;
@@ -297,10 +305,50 @@ class TauriChannel implements IChannel {
 		return undefined as T;
 	}
 
-	listen<T>(_Event: string, _Arg?: unknown): VSCodeEvent<T> {
-		// Event subscriptions — return a no-op event for now.
-		// These should be wired to Tauri event listeners (AppHandle.emit)
-		// when Mountain emits sky:// events.
+	listen<T>(Event: string, Arg?: unknown): VSCodeEvent<T> {
+		DevLog("ipc", `listen: ${this.ChannelName}.${Event}`);
+
+		// readFileStream: import real VSBuffer from VS Code's buffer.js
+		// (relative path resolves from /Static/Application/vs/platform/ipc/electron-browser/).
+		if (
+			FileSystemChannels.has(this.ChannelName) &&
+			Event === "readFileStream"
+		) {
+			return ((Listener: (DataOrErrorOrEnd: unknown) => void) => {
+				const Params =
+					Arg !== undefined ? (Array.isArray(Arg) ? Arg : [Arg]) : [];
+
+				Promise.all([
+					import("../../../base/common/buffer.js") as Promise<{
+						VSBuffer: { wrap(buffer: Uint8Array): unknown };
+					}>,
+					InvokeMountain(`${this.RoutePrefix}:readFile`, Params),
+				])
+					.then(([{ VSBuffer }, Result]) => {
+						const Raw = Result as
+							| { buffer: number[] }
+							| number[]
+							| null
+							| undefined;
+						if (Raw !== null && Raw !== undefined) {
+							const Arr = Array.isArray(Raw)
+								? Raw
+								: (Raw as { buffer: number[] }).buffer;
+							if (Array.isArray(Arr)) {
+								Listener(VSBuffer.wrap(new Uint8Array(Arr)));
+							}
+						}
+						Listener("end" as unknown);
+					})
+					.catch((Err) => {
+						Listener(Err);
+					});
+
+				return { dispose: () => {} };
+			}) as unknown as VSCodeEvent<T>;
+		}
+
+		// Other events — return no-op for now.
 		return (() => ({ dispose: () => {} })) as unknown as VSCodeEvent<T>;
 	}
 }