Allows plugin to register commands (#44291)

* Pass session into plugin

* Use unknown message type

* Add missing unknown

* use editor services insted of every project

* Fix baseline

* Add plugin test

* Avoid type parameter

* Accept baseline

Author: Kingwl

src/server/editorServices.ts

@@ -411,6 +411,7 @@ namespace ts.server {
         /** @deprecated use serverMode instead */
         syntaxOnly?: boolean;
         serverMode?: LanguageServiceMode;
+        session: Session<unknown> | undefined;
     }
 
     interface OriginalFileInfo { fileName: NormalizedPath; path: Path; }
@@ -795,6 +796,9 @@ namespace ts.server {
         /*@internal*/
         private packageJsonFilesMap: ESMap<Path, FileWatcher> | undefined;
 
+        /*@internal*/
+        readonly session: Session<unknown> | undefined;
+
 
         private performanceEventHandler?: PerformanceEventHandler;
 
@@ -812,6 +816,8 @@ namespace ts.server {
             this.pluginProbeLocations = opts.pluginProbeLocations || emptyArray;
             this.allowLocalPluginLoads = !!opts.allowLocalPluginLoads;
             this.typesMapLocation = (opts.typesMapLocation === undefined) ? combinePaths(getDirectoryPath(this.getExecutingFilePath()), "typesMap.json") : opts.typesMapLocation;
+            this.session = opts.session;
+
             if (opts.serverMode !== undefined) {
                 this.serverMode = opts.serverMode;
                 this.syntaxOnly = this.serverMode === LanguageServiceMode.Syntactic;

src/server/project.ts

@@ -84,6 +84,7 @@ namespace ts.server {
         languageService: LanguageService;
         languageServiceHost: LanguageServiceHost;
         serverHost: ServerHost;
+        session?: Session<unknown>;
         config: any;
     }
 
@@ -1610,7 +1611,8 @@ namespace ts.server {
                     project: this,
                     languageService: this.languageService,
                     languageServiceHost: this,
-                    serverHost: this.projectService.host
+                    serverHost: this.projectService.host,
+                    session: this.projectService.session
                 };
 
                 const pluginModule = pluginModuleFactory({ typescript: ts });
@@ -2119,7 +2121,7 @@ namespace ts.server {
                 /*compileOnSaveEnabled*/ false,
                 /*watchOptions*/ undefined,
                 cachedDirectoryStructureHost,
-                getDirectoryPath(configFileName),
+                getDirectoryPath(configFileName)
             );
         }
 

src/server/session.ts

@@ -775,6 +775,7 @@ namespace ts.server {
                 typesMapLocation: opts.typesMapLocation,
                 syntaxOnly: opts.syntaxOnly,
                 serverMode: opts.serverMode,
+                session: this
             };
             this.projectService = new ProjectService(settings);
             this.projectService.setPerformanceEventHandler(this.performanceEventHandler.bind(this));

src/testRunner/unittests/tsserver/helpers.ts

@@ -423,6 +423,7 @@ namespace ts.projectSystem {
             super({
                 host,
                 logger,
+                session: undefined,
                 cancellationToken,
                 useSingleInferredProject,
                 useInferredProjectPerProjectRoot: false,

src/testRunner/unittests/tsserver/plugins.ts

@@ -1,20 +1,31 @@
 namespace ts.projectSystem {
     describe("unittests:: tsserver:: plugins loading", () => {
+        const testProtocolCommand = "testProtocolCommand";
+        const testProtocolCommandRequest = "testProtocolCommandRequest";
+        const testProtocolCommandResponse = "testProtocolCommandResponse";
+
         function createHostWithPlugin(files: readonly File[]) {
             const host = createServerHost(files);
             const pluginsLoaded: string[] = [];
+            const protocolHandlerRequests: [string, string][] = [];
             host.require = (_initialPath, moduleName) => {
                 pluginsLoaded.push(moduleName);
                 return {
                     module: () => ({
                         create(info: server.PluginCreateInfo) {
+                            info.session?.addProtocolHandler(testProtocolCommand, request => {
+                                protocolHandlerRequests.push([request.command, request.arguments]);
+                                return {
+                                    response: testProtocolCommandResponse
+                                };
+                            });
                             return Harness.LanguageService.makeDefaultProxy(info);
                         }
                     }),
                     error: undefined
                 };
             };
-            return { host, pluginsLoaded };
+            return { host, pluginsLoaded, protocolHandlerRequests };
         }
 
         it("With local plugins", () => {
@@ -51,5 +62,43 @@ namespace ts.projectSystem {
             service.openClientFile(aTs.path);
             assert.deepEqual(pluginsLoaded, expectedToLoad);
         });
+
+        it("With session and custom protocol message", () => {
+            const pluginName = "some-plugin";
+            const expectedToLoad = [pluginName];
+            const aTs: File = { path: "/a.ts", content: `class c { prop = "hello"; foo() { return this.prop; } }` };
+            const tsconfig: File = {
+                path: "/tsconfig.json",
+                content: JSON.stringify({
+                    compilerOptions: {
+                        plugins: [
+                            { name: pluginName }
+                        ]
+                    }
+                })
+            };
+
+            const { host, pluginsLoaded, protocolHandlerRequests } = createHostWithPlugin([aTs, tsconfig, libFile]);
+            const session = createSession(host);
+
+            const service = createProjectService(host, { session });
+            service.openClientFile(aTs.path);
+            assert.deepEqual(pluginsLoaded, expectedToLoad);
+
+            const resp = session.executeCommandSeq({
+                command: testProtocolCommand,
+                arguments: testProtocolCommandRequest
+            });
+
+            assert.strictEqual(protocolHandlerRequests.length, 1);
+            const [command, args] = protocolHandlerRequests[0];
+            assert.strictEqual(command, testProtocolCommand);
+            assert.strictEqual(args, testProtocolCommandRequest);
+
+            const expectedResp: server.HandlerResponse = {
+                response: testProtocolCommandResponse
+            };
+            assert.deepEqual(resp, expectedResp);
+        });
     });
 }

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -9558,6 +9558,7 @@ declare namespace ts.server {
         languageService: LanguageService;
         languageServiceHost: LanguageServiceHost;
         serverHost: ServerHost;
+        session?: Session<unknown>;
         config: any;
     }
     interface PluginModule {
@@ -9949,6 +9950,7 @@ declare namespace ts.server {
         /** @deprecated use serverMode instead */
         syntaxOnly?: boolean;
         serverMode?: LanguageServiceMode;
+        session: Session<unknown> | undefined;
     }
     export interface WatchOptionsAndErrors {
         watchOptions: WatchOptions;