feat: support register external ext api (#3933)

* refactor: replace AppConfig with ExtHostAppConfig

* feat: support register external api to exthost

* refactor: abstract external extension API

* feat: support reguster main thread extender

* fix: fix lint

* fix: missing ExtHostAppConfig for test

Author: hacke2

packages/extension/__tests__/browser/main.thread.extensions.test.ts

@@ -29,6 +29,7 @@ import { MainThreadWebview } from '../../src/browser/vscode/api/main.thread.api.
 import { MainThreadExtensionLog } from '../../src/browser/vscode/api/main.thread.log';
 import { MainThreadStorage } from '../../src/browser/vscode/api/main.thread.storage';
 import { ExtensionNodeServiceServerPath } from '../../src/common';
+import { ExtHostAppConfig } from '../../src/common/ext.process';
 import { MainThreadExtensionLogIdentifier } from '../../src/common/extension-log';
 import { ExtHostAPIIdentifier, MainThreadAPIIdentifier } from '../../src/common/vscode';
 import * as types from '../../src/common/vscode/ext-types';
@@ -69,6 +70,10 @@ describe('MainThreadExtensions Test Suites', () => {
       token: IReporter,
       useClass: DefaultReporter,
     },
+    {
+      token: ExtHostAppConfig,
+      useValue: {},
+    },
   );
   const injector = createBrowserInjector(
     [],

packages/extension/__tests__/hosted/api/vscode/ext.host.test.ts

@@ -10,6 +10,7 @@ import { MainThreadExtensionService } from '../../../../__mocks__/api/mainthread
 import { MainThreadStorage } from '../../../../__mocks__/api/mathread.storage';
 import { mockExtensionProps, mockExtensionProps2 } from '../../../../__mocks__/extensions';
 import { createMockPairRPCProtocol } from '../../../../__mocks__/initRPCProtocol';
+import { ExtHostAppConfig } from '../../../../src/common/ext.process';
 import { ExtHostAPIIdentifier, IExtHostLocalization } from '../../../../src/common/vscode';
 import ExtensionHostServiceImpl from '../../../../src/hosted/ext.host';
 
@@ -23,7 +24,7 @@ describe('Extension process test', () => {
       injector = createBrowserInjector([]);
       injector.addProviders(
         {
-          token: AppConfig,
+          token: ExtHostAppConfig,
           useValue: {
             builtinCommands: [
               {

packages/extension/src/browser/extension-node.service.ts

@@ -4,7 +4,9 @@ import { WSChannelHandler } from '@opensumi/ide-connection/lib/browser';
 import { BaseConnection } from '@opensumi/ide-connection/lib/common/connection';
 import {
   AppConfig,
+  ContributionProvider,
   Deferred,
+  Disposable,
   DisposableStore,
   IApplicationService,
   IExtensionProps,
@@ -21,6 +23,7 @@ import {
 } from '../common';
 import { ActivatedExtensionJSON } from '../common/activator';
 import { AbstractNodeExtProcessService } from '../common/extension.service';
+import { IMainThreadExtenderService, MainThreadExtenderContribution } from '../common/main.thread.extender';
 import { ExtHostAPIIdentifier } from '../common/vscode';
 import { knownProtocols } from '../common/vscode/protocols';
 
@@ -37,7 +40,7 @@ export class NodeExtProcessService implements AbstractNodeExtProcessService<IExt
   private readonly appConfig: AppConfig;
 
   @Autowired(INJECTOR_TOKEN)
-  private readonly injector: Injector;
+  protected readonly injector: Injector;
 
   @Autowired(ExtensionNodeServiceServerPath)
   private readonly extensionNodeClient: IExtensionNodeClientService;
@@ -48,6 +51,12 @@ export class NodeExtProcessService implements AbstractNodeExtProcessService<IExt
   @Autowired(WSChannelHandler)
   private readonly channelHandler: WSChannelHandler;
 
+  @Autowired(IMainThreadExtenderService)
+  private readonly mainThreadExtenderService: IMainThreadExtenderService;
+
+  @Autowired(MainThreadExtenderContribution)
+  private readonly mainThreadExtenderContributionProvider: ContributionProvider<MainThreadExtenderContribution>;
+
   private _apiFactoryDisposables = new DisposableStore();
 
   public ready: Deferred<void> = new Deferred();
@@ -125,9 +134,31 @@ export class NodeExtProcessService implements AbstractNodeExtProcessService<IExt
     this._apiFactoryDisposables.add(apiProxy);
     this._apiFactoryDisposables.add(toDisposable(initNodeThreadAPIProxy(this.protocol, this.injector, this)));
     this._apiFactoryDisposables.add(toDisposable(createSumiAPIFactory(this.protocol, this.injector)));
+    this._apiFactoryDisposables.add(this.createExternalSumiAPIFactory());
     await apiProxy.setup();
   }
 
+  /**
+   * register external main thread class
+   * @returns disposer
+   */
+  private createExternalSumiAPIFactory() {
+    const disposer = new Disposable();
+    // register main thread extender contribution
+    const contributions = this.mainThreadExtenderContributionProvider.getContributions();
+    for (const contribution of contributions) {
+      contribution.registerMainThreadExtender(this.mainThreadExtenderService);
+    }
+    // instantiate this MainThreadExtenderClass
+    const extenders = this.mainThreadExtenderService.getMainThreadExtenders();
+    for (const extender of extenders) {
+      const service = this.injector.get(extender.serviceClass, [this.protocol]);
+      this.protocol.set(extender.identifier, service);
+      disposer.addDispose(service);
+    }
+    return disposer;
+  }
+
   public async getActivatedExtensions(): Promise<ActivatedExtensionJSON[]> {
     const proxy = await this.getProxy();
     return await proxy.$getActivatedExtensions();

packages/extension/src/browser/index.ts

@@ -19,6 +19,11 @@ import {
   AbstractViewExtProcessService,
   AbstractWorkerExtProcessService,
 } from '../common/extension.service';
+import {
+  IMainThreadExtenderService,
+  MainThreadExtenderContribution,
+  MainThreadExtenderService,
+} from '../common/main.thread.extender';
 
 import { ActivationEventServiceImpl } from './activation.service';
 import { ExtCommandManagementImpl as ExtCommandManagementImpl } from './extension-command-management';
@@ -37,7 +42,7 @@ import { VSCodeContributesService, VSCodeContributesServiceToken } from './vscod
 
 @Injectable()
 export class ExtensionModule extends BrowserModule {
-  contributionProvider = [RequireInterceptorContribution];
+  contributionProvider = [RequireInterceptorContribution, MainThreadExtenderContribution];
   providers: Provider[] = [
     {
       token: ExtensionService,
@@ -93,6 +98,10 @@ export class ExtensionModule extends BrowserModule {
       token: SumiContributionsServiceToken,
       useClass: SumiContributionsService,
     },
+    {
+      token: IMainThreadExtenderService,
+      useClass: MainThreadExtenderService,
+    },
     ExtensionCommandContribution,
     ExtensionClientAppContribution,
     BrowserRequireInterceptorContribution,

packages/extension/src/common/ext.process.ts

@@ -0,0 +1,56 @@
+import type { SumiApiExtenders } from './sumi';
+import type { CommandHandler } from './vscode';
+import type { ConstructorOf, Injector } from '@opensumi/di';
+import type { ILogService, LogLevel } from '@opensumi/ide-core-common';
+import type Stream from 'stream';
+
+export interface IBuiltInCommand {
+  id: string;
+  handler: CommandHandler;
+}
+
+export interface CustomChildProcess {
+  stdin: Stream.Writable;
+  stdout: Stream.Readable;
+  kill: () => void;
+}
+
+export interface CustomChildProcessModule {
+  spawn(command: string, args: string | string[], options: any): CustomChildProcess;
+}
+
+export const ExtHostAppConfig = Symbol('ExtHostAppConfig');
+export interface ExtHostAppConfig {
+  /**
+   * exthost log service class
+   */
+  LogServiceClass?: ConstructorOf<ILogService>;
+  /**
+   * 插件日志自定义实现路径
+   */
+  extLogServiceClassPath?: string;
+  logDir?: string;
+  logLevel?: LogLevel;
+  builtinCommands?: IBuiltInCommand[];
+  customDebugChildProcess?: CustomChildProcessModule;
+  /**
+   * 集成方自定义 vscode.version 版本
+   * 设置该参数可能会导致插件运行异常
+   * @type {string} 插件版本号
+   * @memberof ExtHostAppConfig
+   */
+  customVSCodeEngineVersion?: string;
+  /**
+   * control rpcProtocol message timeout
+   * default -1，it means disable
+   */
+  rpcMessageTimeout?: number;
+  /**
+   * register external sumi extension api
+   */
+  sumiApiExtenders?: SumiApiExtenders;
+}
+
+export interface ExtProcessConfig extends ExtHostAppConfig {
+  injector?: Injector;
+}

packages/extension/src/common/main.thread.extender.ts

@@ -0,0 +1,39 @@
+import { Injectable } from '@opensumi/di';
+import { IRPCProtocol, ProxyIdentifier } from '@opensumi/ide-connection';
+import { Disposable, IDisposable } from '@opensumi/ide-core-common';
+
+export interface IMainThreadExtender<T = any> {
+  identifier: ProxyIdentifier<T>;
+  serviceClass: new (rpcProtocol: IRPCProtocol) => T;
+}
+
+export const IMainThreadExtenderService = Symbol('IMainThreadExtenderService');
+export interface IMainThreadExtenderService<T = any> {
+  registerMainThreadExtender(extender: IMainThreadExtender<T>): IDisposable;
+  getMainThreadExtenders(): IMainThreadExtender<T>[];
+}
+
+export const MainThreadExtenderContribution = Symbol('MainThreadExtenderContribution');
+
+export interface MainThreadExtenderContribution {
+  registerMainThreadExtender(registry: IMainThreadExtenderService): void;
+}
+
+@Injectable()
+export class MainThreadExtenderService<T> implements IMainThreadExtenderService<T> {
+  private readonly registry: IMainThreadExtender<T>[] = [];
+
+  registerMainThreadExtender(extender: IMainThreadExtender) {
+    this.registry.push(extender);
+    return Disposable.create(() => {
+      const index = this.registry.indexOf(extender);
+      if (index !== -1) {
+        this.registry.splice(index, 1);
+      }
+    });
+  }
+
+  getMainThreadExtenders() {
+    return this.registry;
+  }
+}

packages/extension/src/common/sumi/index.ts

@@ -1,4 +1,9 @@
-import { createExtHostContextProxyIdentifier, createMainContextProxyIdentifier } from '@opensumi/ide-connection';
+import {
+  IRPCProtocol,
+  ProxyIdentifier,
+  createExtHostContextProxyIdentifier,
+  createMainContextProxyIdentifier,
+} from '@opensumi/ide-connection';
 
 import { IExtHostChatAgents, IMainThreadChatAgents } from './chat-agents';
 import { IExtHostCommon, IMainThreadCommon } from './common';
@@ -27,3 +32,23 @@ export const ExtHostSumiAPIIdentifier = {
   ExtHostIDEWindow: createExtHostContextProxyIdentifier<IExtHostIDEWindow>('ExtHostIDEWindow'),
   ExtHostChatAgents: createExtHostContextProxyIdentifier<IExtHostChatAgents>('ExtHostChatAgents'),
 };
+
+/**
+ * sumi API extender
+ */
+export abstract class SumiApiExtender<T = any> {
+  constructor(protected rpcProtocol: IRPCProtocol) {}
+  /**
+   * create rpc service when main thread could call
+   */
+  createRPCService?: () => [identifier: ProxyIdentifier<T>, service: T];
+  /**
+   * api factory
+   * can use rpc service to call main thread
+   */
+  createApiFactory: (service?: T) => any;
+}
+
+export interface SumiApiExtenders extends Record<string, any> {
+  [api: string]: new (rpcProtocol: IRPCProtocol) => SumiApiExtender;
+}

packages/extension/src/hosted/api/sumi/ext.host.api.impl.ts

@@ -1,8 +1,8 @@
 import { IRPCProtocol } from '@opensumi/ide-connection';
-import { IReporter, REPORT_HOST, ReporterService } from '@opensumi/ide-core-common';
+import { IReporter, REPORT_HOST, ReporterService, isFunction } from '@opensumi/ide-core-common';
 
 import { IExtensionHostService, IExtensionWorkerHost, WorkerHostAPIIdentifier } from '../../../common';
-import { ExtHostSumiAPIIdentifier } from '../../../common/sumi';
+import { ExtHostSumiAPIIdentifier, SumiApiExtenders } from '../../../common/sumi';
 import { ExtHostAPIIdentifier, IExtensionDescription } from '../../../common/vscode';
 import { ExtensionHostEditorService } from '../vscode/editor/editor.host';
 
@@ -21,6 +21,7 @@ export function createAPIFactory(
   extensionService: IExtensionHostService | IExtensionWorkerHost,
   type: string,
   reporterEmitter: IReporter,
+  sumiApiExtenders: SumiApiExtenders = {},
 ) {
   if (type === 'worker') {
     rpcProtocol.set(WorkerHostAPIIdentifier.ExtWorkerHostExtensionService, extensionService);
@@ -58,6 +59,20 @@ export function createAPIFactory(
     new ExtHostChatAgents(rpcProtocol),
   ) as ExtHostChatAgents;
 
+  const externalSumiApis = Object.keys(sumiApiExtenders).reduce((acc, key) => {
+    const SumiApiExtender = sumiApiExtenders[key];
+    const extender = new SumiApiExtender(rpcProtocol);
+    let rpcService;
+    // register external api rpc protocol
+    if (isFunction(extender.createRPCService)) {
+      const [identifier, service] = extender.createRPCService();
+      rpcService = service;
+      rpcProtocol.set(identifier, service);
+    }
+    acc[key] = extender.createApiFactory(rpcService);
+    return acc;
+  }, {});
+
   return (extension: IExtensionDescription) => {
     const reporter = new ReporterService(reporterEmitter, {
       extensionId: extension.extensionId,
@@ -75,6 +90,7 @@ export function createAPIFactory(
       commands: createCommandsApiFactory(extHostCommands, extHostEditors, extension),
       toolbar: createToolbarAPIFactory(extension, extHostToolbar),
       chat: createChatApiFactory(extension, extHostChatAgents),
+      ...externalSumiApis,
     };
   };
 }

packages/extension/src/hosted/api/vscode/debug/ext.host.debug.ts

@@ -7,6 +7,7 @@ import {
   IDebuggerContribution,
 } from '@opensumi/ide-debug';
 
+import { CustomChildProcessModule } from '../../../../common/ext.process';
 import {
   IExtHostCommands,
   IExtHostDebugService,
@@ -25,7 +26,6 @@ import {
   Uri,
 } from '../../../../common/vscode/ext-types';
 import { Breakpoint } from '../../../../common/vscode/models';
-import { CustomChildProcessModule } from '../../../ext.process-base';
 
 import { IDebugConfigurationProvider } from './common';
 import { resolveDebugAdapterExecutable } from './extension-debug-adapter-excutable-resolver';

packages/extension/src/hosted/api/vscode/debug/extension-debug-adapter-starter.ts

@@ -4,7 +4,7 @@ import net from 'net';
 
 import { DebugAdapterForkExecutable, DebugStreamConnection } from '@opensumi/ide-debug';
 
-import { CustomChildProcess, CustomChildProcessModule } from '../../../ext.process-base';
+import { CustomChildProcess, CustomChildProcessModule } from '../../../../common/ext.process';
 
 import { DirectDebugAdapter } from './abstract-debug-adapter-session';