@opensumi/ide-dev-tool 2.27.3-next-1711359673.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  rules: {
+    'no-console': 'off',
+  },
+};

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019-present Alibaba Group Holding Limited, Ant Group Co. Ltd.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/__tests__/mock-injector.test.ts

@@ -0,0 +1,89 @@
+import { Injectable } from '@opensumi/di';
+
+import { createBrowserInjector } from '../src/injector-helper';
+import { createNodeInjector } from '../src/mock-injector';
+import { MockInjector } from '../src/mock-injector';
+
+describe('mock-injector test', () => {
+  let fn1: jest.Mock<any, any>;
+  let fn2: jest.Mock<any, any>;
+
+  @Injectable()
+  class A {
+    log = fn1;
+  }
+
+  beforeEach(() => {
+    fn1 = jest.fn();
+    fn2 = jest.fn();
+  });
+
+  describe('Manually create Injector', () => {
+    let injector: MockInjector;
+
+    beforeEach(() => {
+      injector = new MockInjector();
+    });
+
+    it('Can mock a injected service', () => {
+      injector.mock(A, 'log', fn2);
+
+      const args = [1, '2', true];
+      const a = injector.get(A);
+      a.log(...args);
+
+      expect(fn1).toBeCalledTimes(0);
+      expect(fn2).toBeCalledTimes(1);
+      expect(fn2).toBeCalledWith(...args);
+    });
+
+    it('Can mock a created service', () => {
+      const args = [1, '2', true];
+      const a = injector.get(A);
+
+      injector.mock(A, 'log', fn2);
+      a.log(...args);
+
+      expect(fn1).toBeCalledTimes(0);
+      expect(fn2).toBeCalledTimes(1);
+      expect(fn2).toBeCalledWith(...args);
+    });
+
+    it('Work as expected', () => {
+      const args = [1, '2', true];
+      const a = injector.get(A);
+      a.log(...args);
+
+      expect(fn1).toBeCalledTimes(1);
+      expect(fn1).toBeCalledWith(...args);
+    });
+  });
+
+  describe('User helper to create Injector', () => {
+    it('Can mock service with the Injector created by `createBrowserInjector` method', () => {
+      const injector = createBrowserInjector([]);
+      injector.mock(A, 'log', fn2);
+
+      const args = [1, '2', true];
+      const a = injector.get(A);
+      a.log(...args);
+
+      expect(fn1).toBeCalledTimes(0);
+      expect(fn2).toBeCalledTimes(1);
+      expect(fn2).toBeCalledWith(...args);
+    });
+
+    it('Can mock service with the Injector created by `createNodeInjector` method', () => {
+      const injector = createNodeInjector([]);
+      injector.mock(A, 'log', fn2);
+
+      const args = [1, '2', true];
+      const a = injector.get(A);
+      a.log(...args);
+
+      expect(fn1).toBeCalledTimes(0);
+      expect(fn2).toBeCalledTimes(1);
+      expect(fn2).toBeCalledWith(...args);
+    });
+  });
+});

package/cli/commander/index.js

@@ -0,0 +1,38 @@
+const mri = require('mri');
+
+class Commander {
+  commandMap = new Map();
+  addSubCommand(subCommand, options) {
+    this.commandMap.set(subCommand, options);
+  }
+
+  run() {
+    const argv = mri(process.argv.slice(2));
+
+    const subCommand = argv._[0];
+
+    if (subCommand) {
+      const options = this.commandMap.get(subCommand);
+      if (options && options.handler && typeof options.handler === 'function') {
+        options.handler(argv._.slice(1), argv);
+      }
+      return;
+    }
+
+    const result = [];
+    for (const [name, options] of this.commandMap.entries()) {
+      result.push(`  - ${name}: ${options.help}`);
+    }
+
+    console.log(
+      `
+Usage:
+${result.join('\n')}
+
+Good bye~
+`.trim(),
+    );
+  }
+}
+
+module.exports = Commander;

package/cli/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+const Commander = require('./commander');
+const { rebuild } = require('./rebuild-native');
+
+const commander = new Commander();
+commander.addSubCommand('rebuild', {
+  handler: (_, argv) => {
+    console.log(_);
+    console.log(argv);
+    rebuild(argv);
+  },
+  help: 'rebuild current working directory native modules',
+});
+
+commander.run();

package/cli/rebuild-native.js

@@ -0,0 +1,87 @@
+const { execSync } = require('child_process');
+const os = require('os');
+const { join } = require('path');
+
+const { pathExistsSync, copySync, removeSync } = require('fs-extra');
+
+const nativeModules = [
+  join(process.cwd(), './node_modules/node-pty'),
+  join(process.cwd(), './node_modules/nsfw'),
+  join(process.cwd(), './node_modules/@parcel/watcher'),
+  join(process.cwd(), './node_modules/spdlog'),
+  join(process.cwd(), './node_modules/keytar'),
+];
+
+let commands;
+
+module.exports.rebuild = (argv) => {
+  const target = argv.target || 'node';
+  const arch = argv.arch || os.arch();
+  const force = argv['force-rebuild'] || argv.force;
+  let version;
+
+  if (target === 'electron') {
+    version = argv.electronVersion || require('electron/package.json').version;
+    const distUrl = argv.distUrl || 'https://electronjs.org/headers';
+    console.log('rebuilding native for electron version ' + version);
+    commands = [
+      os.platform() === 'win32' ? 'set HOME=~/.electron-gyp' : 'HOME=~/.electron-gyp',
+      'node-gyp',
+      'rebuild',
+      '--openssl_fips=X',
+      `--target=${version}`,
+      `--arch=${arch}`,
+      `--dist-url=${distUrl}`,
+    ];
+  } else if (target === 'node') {
+    console.log('rebuilding native for node version ' + process.version);
+    version = process.version;
+    commands = ['node-gyp', 'rebuild'];
+  }
+
+  function rebuildModule(modulePath, type, version, arch) {
+    const info = require(join(modulePath, './package.json'));
+    console.log(`rebuilding ${info.name}: ${info.version} for arch ${arch}`);
+    const cache = getBuildCacheDir(modulePath, type, version, arch);
+    console.log(`cache dir ${cache}`);
+    if (pathExistsSync(cache) && !force) {
+      try {
+        console.log('cache found for ' + info.name);
+        removeSync(join(modulePath, 'build'));
+
+        if (process.platform === 'linux') {
+          execSync(`cp -r ${cache} ${join(modulePath, 'build')}`);
+        } else {
+          copySync(cache, join(modulePath, 'build'), { dereference: true, recursive: true });
+        }
+
+        return;
+      } catch (error) {
+        console.log('cache restore error', error);
+        console.log('build from source');
+      }
+    }
+    console.log(`running command ${commands.join(' ')}`);
+    execSync(commands.join(' '), {
+      cwd: modulePath,
+      stdio: 'inherit',
+    });
+    removeSync(cache);
+    copySync(join(modulePath, 'build'), cache, { dereference: true, recursive: true });
+  }
+
+  nativeModules.forEach((path) => {
+    rebuildModule(path, target, version, arch);
+  });
+};
+
+function getBuildCacheDir(modulePath, type, version, arch) {
+  const info = require(join(modulePath, './package.json'));
+  return join(
+    require('os').homedir(),
+    '.sumi-dev',
+    'opensumi_build_cache',
+    `${type}-${version}-${arch}`,
+    info.name + '-' + info.version,
+  );
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@opensumi/ide-dev-tool",
+  "version": "2.27.3-next-1711359673.0",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:opensumi/core.git"
+  },
+  "bin": {
+    "sumi": "./cli/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@types/koa": "^2.14.0",
+    "@types/koa-bodyparser": "^4.3.7",
+    "@types/koa-router": "^7.4.2",
+    "copy-webpack-plugin": "^12.0.2",
+    "css-loader": "^6.9.1",
+    "fork-ts-checker-webpack-plugin": "^9.0.2",
+    "html-webpack-plugin": "^5.6.0",
+    "koa": "^2.15.0",
+    "koa-bodyparser": "^4.3.0",
+    "koa-router": "^10.1.1",
+    "koa-static": "^5.0.0",
+    "less": "^3.9.0",
+    "less-loader": "^12.1.0",
+    "mini-css-extract-plugin": "^2.7.7",
+    "mobx": "^6.12.0",
+    "mobx-react-lite": "^4.0.5",
+    "node-notifier": "^8.0.1",
+    "null-loader": "^4.0.1",
+    "optimize-css-assets-webpack-plugin": "^6.0.1",
+    "react-dom": "^18.2.0",
+    "style-loader": "^3.3.4",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "tsconfig-paths-webpack-plugin": "^4.1.0",
+    "typescript": "4.9.3",
+    "webpack": "^5.90.0",
+    "webpack-cli": "^5.1.4",
+    "webpack-merge": "^5.10.0"
+  },
+  "gitHead": "4f90c6aaf6fa17ef25679ca24c879766663a2440"
+}

package/src/ext-host.js

@@ -0,0 +1,14 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const ide_core_common_1 = require('../../../packages/core-common');
+const ext_process_base_1 = require('../../../packages/extension/lib/hosted/ext.process-base');
+
+const builtinCommands = [
+  {
+    id: 'test:builtinCommand:test',
+    handler: (args) => 'fake token',
+  },
+];
+ext_process_base_1.extProcessInit({
+  builtinCommands,
+  logLevel: ide_core_common_1.LogLevel.Info,
+});

package/src/ext-host.ts

@@ -0,0 +1,16 @@
+import { LogLevel } from '@opensumi/ide-core-common';
+import { IBuiltInCommand, extProcessInit } from '@opensumi/ide-extension/lib/hosted/ext.process-base';
+
+const builtinCommands: IBuiltInCommand[] = [
+  {
+    id: 'test:builtinCommand:test',
+    handler: {
+      handler: (args) => 'fake token',
+    },
+  },
+];
+
+extProcessInit({
+  builtinCommands,
+  logLevel: LogLevel.Info,
+});

package/src/index.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="UTF-8" />
+    <title>OpenSumi IDE</title>
+    <style>
+      html,
+      body {
+        margin: 0;
+        width: 100%;
+        height: 100%;
+      }
+    </style>
+    <script>
+      let savedColors = {};
+      try {
+        savedLayout = JSON.parse(localStorage.getItem('layout') || '{}');
+        savedColors = JSON.parse(localStorage.getItem('theme') || '{}');
+      } catch (err) {}
+      if (savedColors.editorBackground) {
+        document.getElementsByTagName('html')[0].style.backgroundColor = savedColors.editorBackground;
+      }
+    </script>
+  </head>
+  <body>
+    <div id="main"></div>
+  </body>
+</html>

package/src/injector-editor.ts

@@ -0,0 +1,84 @@
+import { MonacoService } from '@opensumi/ide-core-browser/lib/monaco';
+import {
+  EditorCollectionService,
+  EditorComponentRegistry,
+  EmptyDocCacheImpl,
+  IEditorDecorationCollectionService,
+  IEditorDocumentModelContentRegistry,
+  IEditorDocumentModelService,
+  IEditorFeatureRegistry,
+  ILanguageService,
+  ResourceService,
+  WorkbenchEditorService,
+} from '@opensumi/ide-editor/lib/browser';
+import { EditorComponentRegistryImpl } from '@opensumi/ide-editor/lib/browser/component';
+import { EditorDocumentModelServiceImpl } from '@opensumi/ide-editor/lib/browser/doc-model/editor-document-model-service';
+import { EditorDocumentModelContentRegistryImpl } from '@opensumi/ide-editor/lib/browser/doc-model/editor-document-registry';
+import { EditorCollectionServiceImpl } from '@opensumi/ide-editor/lib/browser/editor-collection.service';
+import { EditorDecorationCollectionService } from '@opensumi/ide-editor/lib/browser/editor.decoration.service';
+import { EditorFeatureRegistryImpl } from '@opensumi/ide-editor/lib/browser/feature';
+import { LanguageService } from '@opensumi/ide-editor/lib/browser/language/language.service';
+import { ResourceServiceImpl } from '@opensumi/ide-editor/lib/browser/resource.service';
+import { WorkbenchEditorServiceImpl } from '@opensumi/ide-editor/lib/browser/workbench-editor.service';
+import { IDocPersistentCacheProvider } from '@opensumi/ide-editor/lib/common';
+import { IWorkspaceService } from '@opensumi/ide-workspace';
+import { MockWorkspaceService } from '@opensumi/ide-workspace/lib/common/mocks/workspace-service';
+
+import { TestEditorDocumentProvider } from '../../../packages/editor/__tests__/browser/test-providers';
+import { MockedMonacoService } from '../../../packages/monaco/__mocks__/monaco.service.mock';
+
+import { MockInjector } from './mock-injector';
+export function addEditorProviders(injector: MockInjector) {
+  injector.addProviders(
+    {
+      token: IDocPersistentCacheProvider,
+      useClass: EmptyDocCacheImpl,
+    },
+    {
+      token: IEditorDocumentModelContentRegistry,
+      useClass: EditorDocumentModelContentRegistryImpl,
+    },
+    {
+      token: IEditorDocumentModelService,
+      useClass: EditorDocumentModelServiceImpl,
+    },
+    {
+      token: EditorCollectionService,
+      useClass: EditorCollectionServiceImpl,
+    },
+    {
+      token: WorkbenchEditorService,
+      useClass: WorkbenchEditorServiceImpl,
+    },
+    {
+      token: ResourceService,
+      useClass: ResourceServiceImpl,
+    },
+    {
+      token: EditorComponentRegistry,
+      useClass: EditorComponentRegistryImpl,
+    },
+    {
+      token: IEditorDecorationCollectionService,
+      useClass: EditorDecorationCollectionService,
+    },
+    {
+      token: ILanguageService,
+      useClass: LanguageService,
+    },
+    {
+      token: MonacoService,
+      useClass: MockedMonacoService,
+    },
+    {
+      token: IWorkspaceService,
+      useClass: MockWorkspaceService,
+    },
+    {
+      token: IEditorFeatureRegistry,
+      useClass: EditorFeatureRegistryImpl,
+    },
+  );
+  const editorDocModelRegistry: IEditorDocumentModelContentRegistry = injector.get(IEditorDocumentModelContentRegistry);
+  editorDocModelRegistry.registerEditorDocumentModelContentProvider(TestEditorDocumentProvider);
+}

package/src/injector-helper.ts

@@ -0,0 +1,136 @@
+import { Injectable, Injector } from '@opensumi/di';
+import { ClientApp } from '@opensumi/ide-core-browser/lib/bootstrap/app';
+import { BrowserModule } from '@opensumi/ide-core-browser/lib/browser-module';
+import { IContextKeyService } from '@opensumi/ide-core-browser/lib/context-key';
+import { RecentFilesManager } from '@opensumi/ide-core-browser/lib/quick-open';
+import {
+  CommonServerPath,
+  ConstructorOf,
+  ILogServiceManager,
+  ILogger,
+  ILoggerManagerClient,
+  LogLevel,
+  LogServiceForClientPath,
+  OS,
+  getDebugLogger,
+} from '@opensumi/ide-core-common';
+
+import { MockLogger, MockLoggerManageClient, MockLoggerService } from '../../../packages/core-browser/__mocks__/logger';
+import { useMockStorage } from '../../../packages/core-browser/__mocks__/storage';
+import { MockContextKeyService } from '../../../packages/monaco/__mocks__/monaco.context-key.service';
+
+import { MockInjector } from './mock-injector';
+
+@Injectable()
+class MockMainLayout extends BrowserModule {}
+
+export interface MockClientApp extends ClientApp {
+  injector: MockInjector;
+}
+
+export async function createBrowserApp(
+  modules: Array<ConstructorOf<BrowserModule>>,
+  inj?: MockInjector,
+): Promise<MockClientApp> {
+  const injector = inj || new MockInjector();
+  // 需要依赖前后端模块
+  injector.addProviders(
+    {
+      token: ILoggerManagerClient,
+      useValue: {
+        getLogger() {
+          return getDebugLogger();
+        },
+      },
+    },
+    {
+      token: CommonServerPath,
+      useValue: {
+        getBackendOS: jest.fn(() => OS.Type.OSX),
+      },
+    },
+  );
+  const app = new ClientApp({
+    modules: [MockMainLayout, ...modules],
+    injector,
+    layoutConfig: {},
+  } as any) as MockClientApp;
+  await app.start(document.getElementById('main')!);
+  return app;
+}
+
+@Injectable()
+class MockLogServiceForClient {
+  private level: LogLevel;
+
+  hasDisposeAll = false;
+
+  async setGlobalLogLevel(level) {
+    this.level = level;
+  }
+
+  async getGlobalLogLevel() {
+    return this.level;
+  }
+  async getLevel() {
+    return this.level;
+  }
+  async setLevel(level: LogLevel) {
+    this.level = level;
+  }
+  async verbose() {
+    //
+  }
+  async debug() {}
+  async warn() {}
+  async log() {}
+  async error() {}
+  async critical() {}
+  async dispose() {}
+  async disposeAll() {
+    this.hasDisposeAll = true;
+  }
+}
+
+function getBrowserMockInjector() {
+  const injector = new MockInjector();
+  useMockStorage(injector);
+  injector.addProviders(
+    {
+      token: IContextKeyService,
+      useClass: MockContextKeyService,
+    },
+    {
+      token: RecentFilesManager,
+      useValue: {
+        getMostRecentlyOpenedFiles: () => [],
+      },
+    },
+    {
+      token: LogServiceForClientPath,
+      useClass: MockLogServiceForClient,
+    },
+    {
+      token: ILoggerManagerClient,
+      useClass: MockLoggerManageClient,
+    },
+    {
+      token: ILogServiceManager,
+      useClass: MockLoggerService,
+    },
+    {
+      token: ILogger,
+      useClass: MockLogger,
+    },
+  );
+  return injector;
+}
+
+export function createBrowserInjector(modules: Array<ConstructorOf<BrowserModule>>, inj?: Injector): MockInjector {
+  const injector = inj || getBrowserMockInjector();
+  const app = new ClientApp({ modules, injector } as any);
+  afterAll(() => {
+    app.injector.disposeAll();
+  });
+  return app.injector as MockInjector;
+}

package/src/jest-resolver.js

@@ -0,0 +1,16 @@
+// 关于 resolver 的文档请看: https://jestjs.io/docs/configuration#resolver-string
+
+module.exports = (path, options) =>
+  // Call the defaultResolver, so we leverage its cache, error handling, etc.
+  options.defaultResolver(path, {
+    ...options,
+    // Use packageFilter to process parsed `package.json` before the resolution (see https://www.npmjs.com/package/resolve#resolveid-opts-cb)
+    packageFilter: (pkg) => {
+      if (pkg.name === 'nanoid') {
+        // 一个对于 jest@28 的 workaround，具体原因请见：https://github.com/microsoft/accessibility-insights-web/pull/5421/commits/9ad4e618019298d82732d49d00aafb846fb6bac7
+        delete pkg['exports'];
+        delete pkg['module'];
+      }
+      return pkg;
+    },
+  });

package/src/mock-exports.js

@@ -0,0 +1,26 @@
+// 会使用到的测试文件
+// - packages/debug/__tests__/browser/debug-ansi-handle.test.ts
+//   使用了 styles['code-bold'] 等
+
+const idObj = new Proxy(
+  {
+    mod_selected: 'mod_selected',
+    mod_focused: 'mod_focused',
+    mod_loading: 'mod_loading',
+    mod_cut: 'mod_cut',
+    mod_dragging: 'mod_dragging',
+    mod_dragover: 'mod_dragover',
+    mod_dirty: 'mod_dirty',
+    mod_actived: 'mod_actived',
+  },
+  {
+    get: function getter(target, key) {
+      if (key === '__esModule') {
+        return false;
+      }
+      return target[key] || key;
+    },
+  },
+);
+
+module.exports = idObj;

package/src/mock-injector.ts

@@ -0,0 +1,129 @@
+import { ConstructorOf, CreatorStatus, Injector, InstanceOpts, Token, TokenResult } from '@opensumi/di';
+import { MockLoggerManageClient, MockLoggerService } from '@opensumi/ide-core-browser/__mocks__/logger';
+import { CommandRegistry, ILogServiceManager, ILoggerManagerClient, getDebugLogger } from '@opensumi/ide-core-common';
+import { INodeLogger, NodeModule, ServerApp } from '@opensumi/ide-core-node';
+
+export class MockInjector extends Injector {
+  private mockMap = new Map<Token, [any, any][]>();
+
+  mock<T extends Token, K extends keyof TokenResult<T>>(token: T, method: K, value: TokenResult<T>[K]) {
+    if (this.hasCreated(token)) {
+      const instance = this.get(token);
+      Object.defineProperty(instance, method, {
+        get: () => value,
+        set: (v) => {
+          value = v;
+        },
+        enumerable: true,
+        configurable: true,
+      });
+    } else {
+      const map: [any, any][] = this.mockMap.get(token) || [];
+      map.push([method, value]);
+      this.mockMap.set(token, map);
+    }
+  }
+
+  get<T extends ConstructorOf<any>>(token: T, args?: ConstructorParameters<T>, opts?: InstanceOpts): TokenResult<T>;
+  get<T extends Token>(token: T, opts?: InstanceOpts): TokenResult<T>;
+  get<T>(token: Token, opts?: InstanceOpts): T;
+  get(arg1: any, arg2?: any, arg3?: any) {
+    const instance = super.get(arg1, arg2, arg3);
+    const mockDefs = this.mockMap.get(arg1);
+    if (mockDefs) {
+      for (const mockDef of mockDefs) {
+        const method = mockDef[0];
+        let value = mockDef[1];
+        Object.defineProperty(instance, method, {
+          get: () => value,
+          set: (v) => {
+            value = v;
+          },
+          enumerable: true,
+          configurable: true,
+        });
+        this.mockMap.delete(arg1);
+      }
+    }
+    return instance;
+  }
+
+  private hasCreated(token: Token) {
+    const creator = this.creatorMap.get(token);
+    return creator && creator.status === CreatorStatus.done;
+  }
+
+  public mockCommand(commandId: string, fn?) {
+    const registry = this.get(CommandRegistry) as CommandRegistry;
+    if (registry.getCommand(commandId)) {
+      registry.unregisterCommand(commandId);
+    }
+    registry.registerCommand(
+      {
+        id: commandId,
+      },
+      {
+        execute: (...args) => {
+          if (typeof fn === 'function') {
+            fn(...args);
+          } else if (typeof fn !== 'undefined') {
+            return fn;
+          }
+        },
+      },
+    );
+  }
+
+  public mockService(token: Token, proxyObj: any = {}) {
+    this.addProviders({
+      token,
+      useValue: mockService(proxyObj),
+      override: true,
+    });
+  }
+}
+
+export function mockService<T = any>(target: Partial<T>): any {
+  return new Proxy(target, {
+    get: (t, p) => {
+      if (p === 'hasOwnProperty') {
+        return t[p];
+      }
+      // eslint-disable-next-line no-prototype-builtins
+      if (!t.hasOwnProperty(p)) {
+        t[p] = jest.fn();
+      }
+      return t[p];
+    },
+  });
+}
+
+export function getNodeMockInjector() {
+  const injector = new MockInjector();
+  injector.addProviders(
+    {
+      token: ILoggerManagerClient,
+      useClass: MockLoggerManageClient,
+    },
+    {
+      token: ILogServiceManager,
+      useClass: MockLoggerService,
+    },
+    {
+      token: INodeLogger,
+      useValue: getDebugLogger(),
+    },
+  );
+  return injector;
+}
+
+export function createNodeInjector(modules: Array<ConstructorOf<NodeModule>>, inj?: Injector): MockInjector {
+  const injector = inj || getNodeMockInjector();
+  const app = new ServerApp({ modules, injector } as any);
+
+  afterAll(() => {
+    app.injector.disposeAll();
+  });
+
+  return app.injector as MockInjector;
+}

package/src/mock-log-service.js

@@ -0,0 +1,22 @@
+/* eslint-disable no-console */
+'use strict';
+Object.defineProperty(exports, '__esModule', { value: true });
+class LogServiceClass {
+  constructor(args) {
+    console.log('LogServiceClass args', args);
+  }
+  debug(...args) {
+    console.log('LogServiceClass debug', ...args);
+  }
+  error(...args) {
+    console.log('LogServiceClass error', ...args);
+  }
+  log(...args) {
+    console.log('LogServiceClass log', ...args);
+  }
+  warn(...args) {
+    console.log('LogServiceClass warn', ...args);
+  }
+}
+exports.default = LogServiceClass;
+// # sourceMappingURL=mock-log-service.js.map

package/src/mock-log-service.ts

@@ -0,0 +1,24 @@
+/* eslint-disable no-console */
+import { ILogServiceOptions } from '@opensumi/ide-core-common';
+
+export default class LogServiceClass {
+  constructor(args: ILogServiceOptions) {
+    console.log('LogServiceClass args', args);
+  }
+
+  debug(...args) {
+    console.log('LogServiceClass debug', ...args);
+  }
+
+  error(...args) {
+    console.log('LogServiceClass error', ...args);
+  }
+
+  log(...args) {
+    console.log('LogServiceClass log', ...args);
+  }
+
+  warn(...args) {
+    console.log('LogServiceClass warn', ...args);
+  }
+}

package/src/mock-main.tsx

@@ -0,0 +1,3 @@
+import React from 'react';
+
+export const MainLayout = () => <div></div>;

package/src/server.ts

@@ -0,0 +1,119 @@
+/* eslint-disable no-console */
+import http from 'http';
+import path from 'path';
+
+import Koa from 'koa';
+import KoaRouter from 'koa-router';
+import Static from 'koa-static';
+
+import { Injector, Provider } from '@opensumi/di';
+import { Deferred } from '@opensumi/ide-core-common';
+import { IServerAppOpts, NodeModule, ServerApp } from '@opensumi/ide-core-node';
+import {
+  IExternalFileArgs,
+  IExternalUrlArgs,
+  IRemoteOpenerClient,
+  RemoteOpenerClientToken,
+  RemoteOpenerServiceToken,
+} from '@opensumi/ide-remote-opener/lib/common';
+import { RemoteOpenerServiceImpl } from '@opensumi/ide-remote-opener/lib/node';
+
+export async function startServer(
+  arg1: NodeModule[] | Partial<IServerAppOpts>,
+  options?: {
+    mountStaticPath?: string;
+    injector?: Provider;
+  },
+) {
+  const app = new Koa();
+  const router = new KoaRouter();
+  const deferred = new Deferred<http.Server>();
+
+  router.get('/open', (ctx) => {
+    const openerService: IRemoteOpenerClient = injector.get(RemoteOpenerClientToken);
+    try {
+      console.log('received open request', ctx.query);
+      openerService.openExternal(
+        ctx.query as unknown as IExternalFileArgs | IExternalUrlArgs,
+        ctx.query.clientId as unknown as string,
+      );
+      ctx.body = 'successful';
+    } catch (err: any) {
+      ctx.body = `Error: ${err.message}`;
+    }
+  });
+
+  app.use(router.routes());
+
+  if (options && options.mountStaticPath) {
+    console.log('mount static path:', options.mountStaticPath);
+    app.use(Static(options.mountStaticPath));
+  }
+
+  const injector = new Injector([
+    {
+      token: RemoteOpenerServiceToken,
+      useClass: RemoteOpenerServiceImpl,
+    },
+  ]);
+
+  const port = process.env.PORT || process.env.IDE_SERVER_PORT || 8000;
+  let opts: IServerAppOpts = {
+    webSocketHandler: [
+      // new TerminalHandler(logger),
+    ],
+    injector,
+    use: app.use.bind(app),
+    marketplace: {
+      showBuiltinExtensions: true,
+    },
+    processCloseExitThreshold: 5 * 60 * 1000,
+    terminalPtyCloseThreshold: 5 * 60 * 1000,
+    staticAllowOrigin: '*',
+    staticAllowPath: [
+      path.join(__dirname, '../../../packages/extension'),
+      path.join(__dirname, '../../../tools/extensions'),
+      '/',
+    ],
+    extLogServiceClassPath: path.join(__dirname, './mock-log-service.js'),
+    /**
+     * 集成时可使用自定义的 extHost 入口传入内置 command
+     *  extHost: path.join(__dirname, './ext-host.js') || process.env.EXTENSION_HOST_ENTRY,
+     */
+    extHost:
+      process.env.EXTENSION_HOST_ENTRY || path.join(__dirname, '../../../packages/extension/lib/hosted/ext.process.js'),
+    onDidCreateExtensionHostProcess: (extHostProcess) => {
+      console.log(`Extension host process ${extHostProcess.pid} created`);
+    },
+  };
+
+  if (Array.isArray(arg1)) {
+    opts = {
+      ...opts,
+      modulesInstances: arg1,
+    };
+  } else {
+    opts = {
+      ...opts,
+      ...arg1,
+    };
+  }
+
+  const serverApp = new ServerApp(opts);
+  // server 必须在 ServerApp 实例化后才能创建，因为依赖 app 里收集的中间件
+  const server = http.createServer(app.callback());
+
+  await serverApp.start(server);
+
+  server.on('error', (err) => {
+    deferred.reject(err);
+    console.error('server error: ' + err.message);
+    setTimeout(process.exit, 0, 1);
+  });
+
+  server.listen(port, () => {
+    console.log(`server listen on http://localhost:${port}`);
+    deferred.resolve(server);
+  });
+  return deferred.promise;
+}

package/src/webpack.js

@@ -0,0 +1,423 @@
+const path = require('path');
+
+const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+const fse = require('fs-extra');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+const MiniCssExtractPlugin = require('mini-css-extract-plugin');
+const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
+const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+const webpack = require('webpack');
+const { merge } = require('webpack-merge');
+
+const reactPath = path.resolve(path.join(__dirname, '../../../node_modules/react'));
+const reactDOMPath = path.resolve(path.join(__dirname, '../../../node_modules/react-dom'));
+const tsConfigPath = path.join(__dirname, '../../../tsconfig.json');
+const HOST = process.env.HOST || '0.0.0.0';
+const IDE_FRONT_PORT = process.env.IDE_FRONT_PORT || 8080;
+
+const defaultWorkspace = path.join(__dirname, '../../workspace');
+fse.mkdirpSync(defaultWorkspace);
+
+const withSlash = process.platform === 'win32' ? '/' : '';
+
+const styleLoader =
+  process.env.NODE_ENV === 'production' ? MiniCssExtractPlugin.loader : require.resolve('style-loader');
+
+/**
+ *
+ * @param {string} dir
+ * @param {string} entry
+ * @param {import('webpack').Configuration} extraConfig
+ * @returns {import('webpack').Configuration}
+ */
+exports.createWebpackConfig = function (dir, entry, extraConfig) {
+  console.log('front port', IDE_FRONT_PORT);
+
+  const webpackConfig = merge(
+    {
+      entry,
+      output: {
+        filename: 'bundle.js',
+        path: dir + '/dist',
+      },
+      cache: {
+        type: 'filesystem',
+      },
+      resolve: {
+        extensions: ['.ts', '.tsx', '.js', '.json', '.less'],
+        plugins: [
+          new TsconfigPathsPlugin({
+            configFile: tsConfigPath,
+          }),
+        ],
+        alias: {
+          react: reactPath,
+          'react-dom': reactDOMPath,
+        },
+        fallback: {
+          net: false,
+          path: false,
+          os: false,
+          crypto: false,
+          child_process: false,
+          url: false,
+          fs: false,
+        },
+      },
+      bail: true,
+      mode: 'development',
+      devtool: 'source-map',
+      module: {
+        // https://github.com/webpack/webpack/issues/196#issuecomment-397606728
+        exprContextCritical: false,
+        rules: [
+          {
+            test: /\.tsx?$/,
+            use: [
+              {
+                loader: 'ts-loader',
+                options: {
+                  happyPackMode: true,
+                  transpileOnly: true,
+                  configFile: tsConfigPath,
+                  compilerOptions: {
+                    target: 'es2015',
+                  },
+                },
+              },
+            ],
+          },
+          {
+            test: /\.png$/,
+            type: 'asset/resource',
+          },
+          {
+            test: /\.css$/,
+            use: [styleLoader, 'css-loader'],
+          },
+          {
+            test: /\.module.less$/,
+            use: [
+              styleLoader,
+              {
+                loader: 'css-loader',
+                options: {
+                  importLoaders: 1,
+                  sourceMap: true,
+                  modules: {
+                    localIdentName: '[local]___[hash:base64:5]',
+                  },
+                },
+              },
+              {
+                loader: 'less-loader',
+                options: {
+                  lessOptions: {
+                    javascriptEnabled: true,
+                  },
+                },
+              },
+            ],
+          },
+          {
+            test: /^((?!\.module).)*less$/,
+            use: [
+              styleLoader,
+              {
+                loader: 'css-loader',
+                options: {
+                  importLoaders: 1,
+                },
+              },
+              {
+                loader: 'less-loader',
+                options: {
+                  lessOptions: {
+                    javascriptEnabled: true,
+                  },
+                },
+              },
+            ],
+          },
+          {
+            test: /\.svg$/,
+            type: 'asset/resource',
+            generator: {
+              filename: 'images/[name][ext][query]',
+            },
+          },
+          {
+            test: /\.(woff(2)?|ttf|eot)(\?v=\d+\.\d+\.\d+)?$/,
+            type: 'asset/resource',
+            generator: {
+              filename: 'fonts/[name][ext][query]',
+            },
+          },
+        ],
+      },
+      resolveLoader: {
+        modules: [
+          path.join(__dirname, '../../../node_modules'),
+          path.join(__dirname, '../node_modules'),
+          path.resolve('node_modules'),
+        ],
+        extensions: ['.ts', '.tsx', '.js', '.json', '.less'],
+        mainFields: ['loader', 'main'],
+      },
+      optimization: {
+        nodeEnv: process.env.NODE_ENV,
+        minimize: false,
+      },
+      plugins: [
+        new HtmlWebpackPlugin({
+          template: __dirname + '/index.html',
+        }),
+        new MiniCssExtractPlugin({
+          filename: '[name].[chunkhash:8].css',
+          chunkFilename: '[id].css',
+        }),
+        new webpack.DefinePlugin({
+          'process.env.IS_DEV': JSON.stringify(process.env.NODE_ENV === 'development' ? 1 : 0),
+          'process.env.WORKSPACE_DIR': JSON.stringify(process.env.MY_WORKSPACE || defaultWorkspace),
+          'process.env.SUPPORT_LOAD_WORKSPACE_BY_HASH': JSON.stringify(process.env.SUPPORT_LOAD_WORKSPACE_BY_HASH),
+          'process.env.EXTENSION_DIR': JSON.stringify(path.join(__dirname, '../../extensions')),
+          'process.env.KTLOG_SHOW_DEBUG': JSON.stringify('1'),
+          'process.env.OTHER_EXTENSION_DIR': JSON.stringify(path.join(__dirname, '../../../other')),
+          'process.env.EXTENSION_WORKER_HOST': JSON.stringify(
+            process.env.EXTENSION_WORKER_HOST ||
+              `http://${HOST}:8080/assets` +
+                withSlash +
+                path.join(__dirname, '../../../packages/extension/lib/worker-host.js'),
+          ),
+          'process.env.WS_PATH': JSON.stringify(process.env.WS_PATH || `ws://${HOST}:8000`),
+          'process.env.WEBVIEW_HOST': JSON.stringify(process.env.WEBVIEW_HOST || HOST),
+          'process.env.STATIC_SERVER_PATH': JSON.stringify(process.env.STATIC_SERVER_PATH || `http://${HOST}:8000/`),
+          'process.env.HOST': JSON.stringify(process.env.HOST),
+        }),
+        !process.env.SKIP_TS_CHECKER &&
+          new ForkTsCheckerWebpackPlugin({
+            typescript: {
+              diagnosticOptions: {
+                syntactic: true,
+              },
+              configFile: tsConfigPath,
+            },
+            issue: {
+              include: (issue) => issue.file.includes('src/packages/'),
+              exclude: (issue) => issue.file.includes('__test__'),
+            },
+          }),
+        new NodePolyfillPlugin({
+          includeAliases: ['process', 'Buffer'],
+        }),
+        !process.env.CI && new webpack.ProgressPlugin(),
+        process.env.analysis && new BundleAnalyzerPlugin(),
+      ].filter(Boolean),
+      devServer: {
+        static: {
+          directory: dir + '/dist',
+        },
+        host: HOST,
+        port: IDE_FRONT_PORT,
+        allowedHosts: 'all',
+        devMiddleware: {
+          stats: 'errors-only',
+        },
+        proxy: {
+          '/api': {
+            target: `http://${HOST}:8000`,
+          },
+          '/extension': {
+            target: `http://${HOST}:8000`,
+          },
+          '/assets': {
+            target: `http://${HOST}:8000`,
+          },
+          '/kaitian': {
+            target: `http://${HOST}:8000`,
+          },
+          '/socket.io': {
+            ws: true,
+            target: `ws://${HOST}:8000`,
+          },
+        },
+        open: process.env.SUMI_DEV_OPEN_BROWSER ? true : false,
+        hot: true,
+        client: {
+          overlay: {
+            errors: true,
+            warnings: false,
+            runtimeErrors: false,
+          },
+        },
+      },
+    },
+    extraConfig || {},
+  );
+
+  return webpackConfig;
+};
+
+/**
+ * @returns {import('webpack').Configuration}
+ */
+exports.createWebviewWebpackConfig = (entry, dir, outputPath = '/dist') => {
+  const port = 8899;
+  return {
+    entry,
+    output: {
+      filename: 'webview.js',
+      path: dir + outputPath,
+    },
+    cache: {
+      type: 'filesystem',
+    },
+    resolve: {
+      extensions: ['.ts', '.tsx', '.js', '.json', '.less'],
+      plugins: [
+        new TsconfigPathsPlugin({
+          configFile: tsConfigPath,
+        }),
+      ],
+    },
+    bail: true,
+    mode: 'development',
+    devtool: 'source-map',
+    module: {
+      // https://github.com/webpack/webpack/issues/196#issuecomment-397606728
+      exprContextCritical: false,
+      rules: [
+        {
+          test: /\.tsx?$/,
+          loader: 'ts-loader',
+          options: {
+            happyPackMode: true,
+            transpileOnly: true,
+            configFile: tsConfigPath,
+          },
+        },
+      ],
+    },
+    resolveLoader: {
+      modules: [
+        path.join(__dirname, '../../../node_modules'),
+        path.join(__dirname, '../node_modules'),
+        path.resolve('node_modules'),
+      ],
+      extensions: ['.ts', '.tsx', '.js', '.json', '.less'],
+      mainFields: ['loader', 'main'],
+    },
+    plugins: [
+      new HtmlWebpackPlugin({
+        template: path.dirname(entry) + '/webview.html',
+      }),
+      new NodePolyfillPlugin({
+        includeAliases: ['process', 'Buffer'],
+      }),
+    ],
+    devServer: {
+      static: {
+        directory: dir + '/public',
+      },
+      allowedHosts: 'all',
+      port,
+      host: HOST,
+      open: false,
+      hot: true,
+      client: {
+        overlay: {
+          errors: true,
+          warnings: false,
+          runtimeErrors: false,
+        },
+      },
+    },
+  };
+};
+
+/**
+ * @returns {import('webpack').Configuration}
+ */
+exports.createNodeWebpackConfig = (entry, distDir) => ({
+  entry,
+  target: 'node',
+  output: {
+    filename: 'server.js',
+    path: distDir,
+  },
+  node: false,
+  mode: 'production',
+  optimization: {
+    minimize: false,
+  },
+  cache: {
+    type: 'filesystem',
+  },
+  watch: false,
+  resolve: {
+    modules: [
+      path.join(__dirname, '../../../node_modules'),
+      path.join(__dirname, '../node_modules'),
+      path.resolve('node_modules'),
+    ],
+    extensions: ['.ts', '.tsx', '.js', '.json'],
+    plugins: [
+      new TsconfigPathsPlugin({
+        configFile: tsConfigPath,
+      }),
+    ],
+  },
+  module: {
+    exprContextCritical: false,
+    rules: [
+      {
+        test: /\.tsx?$/,
+        use: [
+          {
+            loader: 'ts-loader',
+            options: {
+              happyPackMode: true,
+              transpileOnly: true,
+              configFile: tsConfigPath,
+              compilerOptions: {
+                target: 'es2016',
+              },
+            },
+          },
+        ],
+      },
+    ],
+  },
+  externals: [
+    function ({ request }, callback) {
+      if (
+        [
+          'node-pty',
+          'oniguruma',
+          '@parcel/watcher',
+          'nsfw',
+          'spdlog',
+          'vm2',
+          'canvas',
+          '@opensumi/vscode-ripgrep',
+          'vertx',
+          'keytar',
+          'tsconfig-paths',
+        ].indexOf(request) !== -1
+      ) {
+        return callback(null, `commonjs ${request}`);
+      }
+      callback();
+    },
+  ],
+  resolveLoader: {
+    extensions: ['.ts', '.tsx', '.js', '.json'],
+    mainFields: ['loader', 'main'],
+    modules: [
+      path.join(__dirname, '../../../node_modules'),
+      path.join(__dirname, '../node_modules'),
+      path.resolve('node_modules'),
+    ],
+  },
+  plugins: [!process.env.CI && new webpack.ProgressPlugin()],
+});