@hydranium/glsp-server 1.0.0-next.31 → 1.0.0-next.315

package/src/node/start-glsp-server.ts

@@ -15,15 +15,61 @@ import {
    createAppModule,
    defaultSocketLaunchOptions
 } from '@eclipse-glsp/server/node.js';
-import { Container, type ContainerModule } from 'inversify';
-import type { Logger } from '@hydranium/protocol';
-import { Deferred } from '@hydranium/langium';
+import { Container, ContainerModule, injectable } from 'inversify';
+import { Deferred, describeError, describeErrorWithStack, sendByMethodName, type Logger } from '@hydranium/protocol';
 import type * as net from 'node:net';
-import type { IntegratedServer } from '@hydranium/core';
+import { createMessageConnection, SocketMessageReader, SocketMessageWriter } from 'vscode-jsonrpc/node';
+import {
+   initializeWorkspaceWithoutLsp,
+   type IntegratedServer,
+   type ServerSharedServicesMinimal,
+   type WorkspaceFolderInput
+} from '@hydranium/core';
+import { dropNotificationsToGoneClient } from '../launcher/drop-notifications-to-gone-client.js';
+import { createGlspConnectionLogger } from '../launcher/glsp-connection-logger.js';
 import { createGlspFrameworkOverrides } from '../launcher/glsp-framework-overrides.js';
 import { createGlspServerOverrides } from '../launcher/glsp-server-overrides.js';
+import { HydraniumTypes } from '../state/hydranium-shared-core-services.js';
 import type { LspConnectionLike } from '@hydranium/core/node';
 
+/**
+ * The default socket launcher of {@link startGlspServer}: GLSP's own,
+ * with each connection built from this package's copy of `vscode-jsonrpc`, so a
+ * framework error thrown in a handler keeps its code. The connection sends
+ * GLSP's typed messages by method name, since GLSP builds them from its copy.
+ */
+@injectable()
+export class HydraniumGlspSocketServerLauncher extends SocketServerLauncher {
+   protected override createConnection(socket: net.Socket): ReturnType<SocketServerLauncher['createConnection']> {
+      return dropNotificationsToGoneClient(
+         sendByMethodName(
+            createMessageConnection(
+               new SocketMessageReader(socket),
+               new SocketMessageWriter(socket),
+               createGlspConnectionLogger(this.logger)
+            )
+         ),
+         this.logger
+      );
+   }
+}
+
+/**
+ * Binds GLSP's own `SocketServerLauncher` token to
+ * {@link HydraniumGlspSocketServerLauncher}. {@link startGlspServer} loads it
+ * before the adopter's `appModules`, so an adopter replaces the launcher with
+ * `rebind`; a second `bind` makes the resolve ambiguous and the start throws.
+ * A replacement extends {@link HydraniumGlspSocketServerLauncher}: GLSP's own
+ * launcher builds its connection from GLSP's copy, so framework errors lose
+ * their code, and GLSP's typed messages throw where its packages nest
+ * separate copies.
+ */
+export function createGlspSocketLauncherModule(): ContainerModule {
+   return new ContainerModule(bind => {
+      bind(SocketServerLauncher).to(HydraniumGlspSocketServerLauncher);
+   });
+}
+
 /**
  * Options for {@link startGlspServer}.
  *
@@ -65,12 +111,20 @@ export interface GlspServerOptions {
    /**
     * Additional Inversify modules to load on the app container AFTER GLSP's
     * own app module (via `createAppModule`, which binds `InjectionContainer`
-    * plus the GLSP-version-specific app bindings) and the framework overrides
+    * plus the GLSP-version-specific app bindings), the framework overrides
     * that route GLSP's logger and logger factory through the adopter logger
-    * and add the shared Tracer. Adopters wire language-services bindings
-    * (e.g. their own shared-services symbol) here.
+    * and add the shared Tracer, and {@link createGlspSocketLauncherModule}.
+    * Adopters wire language-services bindings (e.g. their own shared-services
+    * symbol) here, and replace the launcher with `rebind`.
     */
    readonly appModules?: ReadonlyArray<ContainerModule>;
+   /**
+    * Workspace root(s) to initialize — a filesystem path or a `URI`. Required
+    * when no LSP head is composed, refused beside one: see
+    * `initializeWorkspaceWithoutLsp`. The shared services are the ones
+    * `HydraniumGlspAppModule` binds in {@link appModules}.
+    */
+   readonly workspace?: WorkspaceFolderInput | ReadonlyArray<WorkspaceFolderInput>;
    /**
     * Optional LSP connection used to register a port-discovery request
     * handler. When both `lspConnection` and `portCommand` are set, the
@@ -105,12 +159,14 @@ export interface GlspServerOptions {
 /**
  * Live GLSP server handle returned by {@link startGlspServer}.
  *
- * - {@link IntegratedServer.started} resolves once the GLSP socket is
- *   listening AND (if configured) the port-discovery handler has been
- *   registered on the LSP connection.
- * - {@link IntegratedServer.stopped} resolves once GLSP's
- *   `SocketServerLauncher.start` promise settles (i.e. the underlying
- *   `net.Server` has closed).
+ * - {@link IntegratedServer.started} resolves once the workspace is up,
+ *   where the launcher brings it up, AND the GLSP socket is listening AND
+ *   (if configured) the port-discovery handler has been registered on the
+ *   LSP connection. It rejects, and nothing listens, when the bring-up fails.
+ * - {@link IntegratedServer.stopped} settles as GLSP's
+ *   `SocketServerLauncher.start` promise does (i.e. once the underlying
+ *   `net.Server` has closed), or resolves once a failed bring-up has
+ *   rejected `started`.
  * - {@link port} is `undefined` until `started` resolves.
  */
 export interface StartedGlspServer extends IntegratedServer {
@@ -120,17 +176,22 @@ export interface StartedGlspServer extends IntegratedServer {
 /**
  * Start a GLSP socket head. Builds the GLSP app container with framework-
  * default `Logger` / `LoggerFactory` bindings, layers adopter modules,
- * resolves {@link SocketServerLauncher}, configures the adopter
+ * resolves the launcher bound to {@link SocketServerLauncher}, by default
+ * {@link HydraniumGlspSocketServerLauncher}, configures the adopter
  * {@link ServerModule}, and starts listening.
  *
  * **GLSP launcher coupling.** GLSP's {@link SocketServerLauncher} owns the
- * `net.Server` and per-connection `MessageConnection` construction;
+ * `net.Server` and each connection's server instance;
  * the framework wrapper composes ABOVE that launcher rather than replacing
  * it. The framework's own `startSocketServer`
  * helper is NOT used here — it's designed for stdio/raw-JSON-RPC heads
  * (data-server's pattern), not GLSP's Inversify-driven per-connection
  * server-instance model. Bridging the two would lose GLSP's action-handler
  * registry plumbing.
+ *
+ * **Without an LSP head the launcher brings the workspace up, then
+ * listens**, as `startSocketServer` does: a diagram loaded before the
+ * bring-up starts keeps its cross-file edges missing for good.
  */
 export function startGlspServer(options: GlspServerOptions): StartedGlspServer {
    const launchOptions: SocketLaunchOptions = {
@@ -150,20 +211,30 @@ export function startGlspServer(options: GlspServerOptions): StartedGlspServer {
    const glspAppModule = createAppModule({ ...launchOptions, consoleLog: false, fileLog: false });
 
    const appContainer = new Container();
-   appContainer.load(glspAppModule, createGlspFrameworkOverrides(options.createLogger), ...(options.appModules ?? []));
+   appContainer.load(
+      glspAppModule,
+      createGlspFrameworkOverrides(options.createLogger),
+      createGlspSocketLauncherModule(),
+      ...(options.appModules ?? [])
+   );
 
-   const launcher = appContainer.resolve<SocketServerLauncher>(SocketServerLauncher);
+   const launcher = appContainer.get<SocketServerLauncher>(SocketServerLauncher);
    // Passed as an additional module rather than folded into the app container:
    // the launcher loads these into the per-connection SERVER container, which is
-   // the only tier where the adopter's `ServerModule` binding of `GLSPServer`
-   // can be rebound.
+   // the tier where each connection gets a server of its own.
    launcher.configure(options.serverModule, createGlspServerOverrides());
 
    const started = new Deferred<void>();
+   const stopped = new Deferred<void>();
    const portHandle: { port: number | undefined } = { port: undefined };
 
-   try {
-      const stoppedPromise = Promise.resolve(launcher.start(launchOptions));
+   const listen = (): void => {
+      // `start` creates the `net.Server` and listens, so the listeners below
+      // attach to it synchronously after the call, before any event fires.
+      Promise.resolve(launcher.start(launchOptions)).then(
+         () => stopped.resolve(),
+         (error: unknown) => stopped.reject(error)
+      );
 
       // GLSP's `SocketServerLauncher.netServer` field is `protected`; we
       // access it via property indexing. The alternative is to fork the
@@ -177,7 +248,7 @@ export function startGlspServer(options: GlspServerOptions): StartedGlspServer {
             if (options.lspConnection && options.portCommand) {
                options.lspConnection.onRequest(options.portCommand, () => portHandle.port);
             }
-            lifecycle?.info(`[GlspServer] Ready to accept new client requests on port: ${address.port}`);
+            lifecycle?.info(`[GlspServer] Ready to accept new client requests on ${address.address} port: ${address.port}`);
             started.resolve();
          } else {
             const message = address === null ? 'address is null' : `bound to non-TCP "${String(address)}"`;
@@ -187,28 +258,50 @@ export function startGlspServer(options: GlspServerOptions): StartedGlspServer {
          }
       });
       netServer.on('error', (err: Error) => {
-         lifecycle?.error(`[GlspServer] Error: ${err.message}`);
+         lifecycle?.error(`[GlspServer] Error: ${describeErrorWithStack(err)}`);
          started.reject(err);
       });
       if (options.onClientConnection) {
          netServer.on('connection', options.onClientConnection);
       }
+   };
 
-      return {
-         get port() {
-            return portHandle.port;
-         },
-         started: started.promise,
-         stopped: stoppedPromise
-      };
-   } catch (error) {
-      lifecycle?.error('Error in GLSP server launcher:', error);
-      return {
-         get port() {
-            return portHandle.port;
-         },
-         started: Promise.reject(error),
-         stopped: Promise.resolve()
-      };
-   }
+   // The workspace manager logs a failed initialization itself; a refused
+   // `workspace` throws before `initializing` is set.
+   let initializing = false;
+   const begin = async (): Promise<void> => {
+      const shared = appContainer.isBound(HydraniumTypes.SharedCoreServices)
+         ? appContainer.get<ServerSharedServicesMinimal>(HydraniumTypes.SharedCoreServices)
+         : undefined;
+      if (shared === undefined) {
+         throw new Error(
+            '[hydranium] startGlspServer found no shared services in its app container. Add `new HydraniumGlspAppModule({ shared })` to `appModules`.'
+         );
+      }
+      const initialization = initializeWorkspaceWithoutLsp(shared, options.workspace);
+      initializing = true;
+      await initialization;
+      initializing = false;
+      listen();
+   };
+   begin().catch((error: unknown) => {
+      if (initializing) {
+         lifecycle?.debug(`[GlspServer] Startup failed: the workspace did not initialize. ${describeError(error)}`);
+      } else {
+         lifecycle?.error(`[GlspServer] Startup failed: ${describeErrorWithStack(error)}`);
+      }
+      started.reject(error);
+      stopped.resolve();
+   });
+   // `started` is always observed internally, as `startStdioServer`'s is, so a
+   // caller that closes early and ignores it cannot crash the process.
+   void started.promise.catch(() => undefined);
+
+   return {
+      get port() {
+         return portHandle.port;
+      },
+      started: started.promise,
+      stopped: stopped.promise
+   };
 }