@opensumi/ide-core-node 2.21.13 → 2.22.0

package/src/bootstrap/inner-providers.ts

@@ -0,0 +1,42 @@
+import { Injector } from '@opensumi/di';
+import {
+  IReporter,
+  DefaultReporter,
+  IReporterService,
+  ReporterService,
+  ReporterMetadata,
+  REPORT_HOST,
+} from '@opensumi/ide-core-common';
+import {
+  HashCalculateServiceImpl,
+  IHashCalculateService,
+} from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
+
+import { INodeLogger, NodeLogger } from '../logger/node-logger';
+
+export function injectInnerProviders(injector: Injector) {
+  injector.addProviders(
+    {
+      token: INodeLogger,
+      useClass: NodeLogger,
+    },
+    {
+      token: IReporter,
+      useClass: DefaultReporter,
+    },
+    {
+      token: IReporterService,
+      useClass: ReporterService,
+    },
+    {
+      token: ReporterMetadata,
+      useValue: {
+        host: REPORT_HOST.NODE,
+      },
+    },
+    {
+      token: IHashCalculateService,
+      useClass: HashCalculateServiceImpl,
+    },
+  );
+}

package/src/bootstrap/shell-path.ts

@@ -0,0 +1,116 @@
+import { spawn } from 'child_process';
+
+import { isWindows, stripAnsi } from '@opensumi/ide-core-common';
+
+// 成功过一次后，取 PATH 的超时时间
+const MAX_WAIT_AFTER_SUCCESS = 3 * 1000;
+
+// Shell 执行的最大超时时间
+// 即使 getShellPath 已经返回，在这个时间之内执行成功后还是会更新缓存，供下一次调用使用
+const SHELL_TIMEOUT = 30 * 1000;
+
+let shellPath = process.env.PATH;
+const isJestTest = process.env.IS_JEST_TEST;
+let updating: Promise<void> | undefined;
+
+// 至少成功过一次
+let hasSuccess = false;
+
+// 某些用户的配置初始化时间较长，提前开始
+// 测试环境下不执行，让测试快一点
+if (!isJestTest) {
+  updateShellPath();
+}
+
+function parseEnv(env: string) {
+  env = env.split('_SHELL_ENV_DELIMITER_')[1];
+  const ret: { [key: string]: string } = {};
+  const lines = stripAnsi(env).split('\n').filter(Boolean);
+  for (const line of lines) {
+    const [key, ...values] = line.split('=');
+    ret[key] = values.join('=');
+  }
+  return ret;
+}
+
+async function createUpdateShellPathPromise(): Promise<void> {
+  let pid: number;
+  const timer = setTimeout(() => {
+    if (pid) {
+      try {
+        process.kill(pid);
+      } catch (error) {
+        // ignore
+      }
+    }
+  }, SHELL_TIMEOUT);
+
+  try {
+    shellPath = await new Promise((resolve, reject) => {
+      const buf: Buffer[] = [];
+      const proc = spawn(
+        '/bin/bash',
+        ['-ilc', 'echo -n "_SHELL_ENV_DELIMITER_"; env; echo -n "_SHELL_ENV_DELIMITER_"; exit;'],
+        {
+          stdio: ['ignore', 'pipe', 'pipe'],
+          detached: true, // 在有些场景 zsh 会卡住， detached 后正常
+        },
+      );
+      proc.on('error', (err) => {
+        reject(err);
+      });
+      proc.stdout.on('data', (chunk) => {
+        buf.push(chunk);
+      });
+      proc.stderr.on('data', (chunk) => {
+        // reject(chunk.toString());
+      });
+      proc.on('close', () => {
+        clearTimeout(timer);
+
+        if (buf.length) {
+          resolve(parseEnv(Buffer.concat(buf).toString()).PATH);
+        } else {
+          reject(new Error('Fail to get env.'));
+        }
+      });
+      proc.unref();
+      pid = proc.pid;
+    });
+    hasSuccess = true;
+  } catch (err) {
+    // console.error('shell path error:', err);
+  }
+}
+
+function updateShellPath(): Promise<void> {
+  // 确保每次只有一个进程运行
+  // macOS 实测多个进程同时运行时，耗时成倍增加 <1s -> 6-10s
+  if (!updating) {
+    updating = createUpdateShellPathPromise().finally(() => {
+      updating = undefined;
+    });
+  }
+  return updating;
+}
+
+export async function getShellPath(): Promise<string | undefined> {
+  if (isWindows) {
+    return process.env['PATH'];
+  }
+  // 触发一次更新
+  await Promise.race([
+    updateShellPath(),
+    new Promise<void>((resolve) => {
+      // 第一次等待时间长一些，尽量拿到正确的 PATH
+      setTimeout(
+        () => {
+          resolve(undefined);
+        },
+        hasSuccess ? MAX_WAIT_AFTER_SUCCESS : SHELL_TIMEOUT,
+      );
+    }),
+  ]);
+  // 不管有没有更新成功，都返回当前的最新结果
+  return shellPath;
+}

package/src/common-module/common.server.ts

@@ -0,0 +1,9 @@
+import { Injectable } from '@opensumi/di';
+import { ICommonServer, OS, OperatingSystem } from '@opensumi/ide-core-common';
+
+@Injectable()
+export class CommonServer implements ICommonServer {
+  async getBackendOS(): Promise<OperatingSystem> {
+    return OS.type();
+  }
+}

package/src/common-module/credential.server.ts

@@ -0,0 +1,92 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+import { Injectable, Autowired } from '@opensumi/di';
+import { IChunkedPassword, INativeCredentialService, isWindows } from '@opensumi/ide-core-common';
+
+import { AppConfig } from '../types';
+
+@Injectable()
+export class CredentialService implements INativeCredentialService {
+  private static readonly MAX_PASSWORD_LENGTH = 2500;
+  private static readonly PASSWORD_CHUNK_SIZE = CredentialService.MAX_PASSWORD_LENGTH - 100;
+
+  @Autowired(AppConfig)
+  private readonly appConfig: AppConfig;
+
+  async setPassword(service: string, account: string, password: string): Promise<void> {
+    const keytar = await this.withKeytar();
+    if (isWindows && password.length > CredentialService.MAX_PASSWORD_LENGTH) {
+      let index = 0;
+      let chunk = 0;
+      let hasNextChunk = true;
+      while (hasNextChunk) {
+        const passwordChunk = password.substring(index, index + CredentialService.PASSWORD_CHUNK_SIZE);
+        index += CredentialService.PASSWORD_CHUNK_SIZE;
+        hasNextChunk = password.length - index > 0;
+
+        const content: IChunkedPassword = {
+          content: passwordChunk,
+          hasNextChunk,
+        };
+
+        await keytar.setPassword(service, chunk ? `${account}-${chunk}` : account, JSON.stringify(content));
+        chunk++;
+      }
+    } else {
+      await keytar.setPassword(service, account, password);
+    }
+  }
+
+  async deletePassword(service: string, account: string) {
+    const keytar = await this.withKeytar();
+    const didDelete = await keytar.deletePassword(service, account);
+    return didDelete;
+  }
+
+  async getPassword(service: string, account: string) {
+    const keytar = await this.withKeytar();
+    const password = await keytar.getPassword(service, account);
+    if (password) {
+      try {
+        let { content, hasNextChunk }: IChunkedPassword = JSON.parse(password);
+        if (!content || !hasNextChunk) {
+          return password;
+        }
+
+        let index = 1;
+        while (hasNextChunk) {
+          const nextChunk = await keytar.getPassword(service, `${account}-${index++}`);
+          const result: IChunkedPassword = JSON.parse(nextChunk!);
+          content += result.content;
+          hasNextChunk = result.hasNextChunk;
+        }
+
+        return content;
+      } catch (_e) {
+        return password;
+      }
+    }
+    return null;
+  }
+
+  async findPassword(service: string) {
+    const keytar = await this.withKeytar();
+    const password = await keytar.findPassword(service);
+    if (password) {
+      return password;
+    }
+    return null;
+  }
+
+  async findCredentials(service: string): Promise<Array<{ account: string; password: string }>> {
+    const keytar = await this.withKeytar();
+    return keytar.findCredentials(service);
+  }
+
+  private async withKeytar(): Promise<typeof import('keytar')> {
+    if (this.appConfig.disableKeytar) {
+      throw new Error('keytar has been disabled via --disable-keytar option');
+    }
+    // @ts-ignore
+    return await import('keytar');
+  }
+}

package/src/common-module/crypto.server.ts

@@ -0,0 +1,50 @@
+import crypto from 'crypto';
+
+import { Injectable } from '@opensumi/di';
+import { INativeCryptoService } from '@opensumi/ide-core-common';
+
+@Injectable()
+export class CryptoService implements INativeCryptoService {
+  private static SECRET_KEY = 'CryptoService';
+  private static IV_LENGTH = 16;
+  private static SALT_LENGTH = 64;
+  private static TAG_LENGTH = 16;
+  private static ALGORITHM = 'aes-256-gcm';
+  private static TAG_POSITION: number = CryptoService.SALT_LENGTH + CryptoService.IV_LENGTH;
+  private static ENCRYPTED_POSITION: number = CryptoService.TAG_POSITION + CryptoService.TAG_LENGTH;
+
+  private getKey(salt: string | Buffer) {
+    return crypto.pbkdf2Sync(CryptoService.SECRET_KEY, salt, 100000, 32, 'sha512');
+  }
+
+  async encrypt(password: string) {
+    const iv = crypto.randomBytes(CryptoService.IV_LENGTH);
+    const salt = crypto.randomBytes(CryptoService.SALT_LENGTH);
+
+    const key = this.getKey(salt);
+
+    const cipher = crypto.createCipheriv(CryptoService.ALGORITHM, key, iv);
+    const encrypted = Buffer.concat([cipher.update(password, 'utf8'), cipher.final()]);
+
+    const tag = (cipher as any).getAuthTag();
+
+    return Buffer.concat([salt, iv, tag, encrypted]).toString('hex');
+  }
+
+  async decrypt(hash: string) {
+    const stringValue = Buffer.from(String(hash), 'hex');
+
+    const salt = stringValue.slice(0, CryptoService.SALT_LENGTH);
+    const iv = stringValue.slice(CryptoService.SALT_LENGTH, CryptoService.TAG_POSITION);
+    const tag = stringValue.slice(CryptoService.TAG_POSITION, CryptoService.ENCRYPTED_POSITION);
+    const encrypted = stringValue.slice(CryptoService.ENCRYPTED_POSITION);
+
+    const key = this.getKey(salt);
+
+    const decipher = crypto.createDecipheriv(CryptoService.ALGORITHM, key, iv);
+
+    (decipher as any).setAuthTag(tag);
+
+    return decipher.update(encrypted) + decipher.final('utf8');
+  }
+}

package/src/common-module/index.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@opensumi/di';
+import {
+  ICommonServer,
+  CommonServerPath,
+  INativeCredentialService,
+  KeytarServicePath,
+  INativeCryptoService,
+  CryptoServicePath,
+} from '@opensumi/ide-core-common';
+
+import { HashCalculateContribution } from '../hash-calculate/hash-calculate.contribution';
+import { NodeModule } from '../node-module';
+
+import { CommonServer } from './common.server';
+import { CredentialService } from './credential.server';
+import { CryptoService } from './crypto.server';
+
+@Injectable()
+export class ServerCommonModule extends NodeModule {
+  providers = [
+    HashCalculateContribution,
+    {
+      token: ICommonServer,
+      useClass: CommonServer,
+    },
+    {
+      token: INativeCredentialService,
+      useClass: CredentialService,
+    },
+    {
+      token: INativeCryptoService,
+      useClass: CryptoService,
+    },
+  ];
+  backServices = [
+    {
+      servicePath: CommonServerPath,
+      token: ICommonServer,
+    },
+    {
+      servicePath: KeytarServicePath,
+      token: INativeCredentialService,
+    },
+    {
+      servicePath: CryptoServicePath,
+      token: INativeCryptoService,
+    },
+  ];
+}

package/src/connection.ts

@@ -0,0 +1,142 @@
+import http from 'http';
+import net from 'net';
+
+import ws from 'ws';
+
+import { Injector, InstanceCreator, ClassCreator, FactoryCreator } from '@opensumi/di';
+import { WSChannel, initRPCService, RPCServiceCenter } from '@opensumi/ide-connection';
+import { createWebSocketConnection } from '@opensumi/ide-connection/lib/common/message';
+import {
+  WebSocketServerRoute,
+  WebSocketHandler,
+  CommonChannelHandler,
+  commonChannelPathHandler,
+  createSocketConnection,
+} from '@opensumi/ide-connection/lib/node';
+
+import { INodeLogger } from './logger/node-logger';
+import { NodeModule } from './node-module';
+import { IServerAppOpts } from './types';
+
+export { RPCServiceCenter };
+
+export function createServerConnection2(
+  server: http.Server,
+  injector,
+  modulesInstances,
+  handlerArr: WebSocketHandler[],
+  serverAppOpts: IServerAppOpts,
+) {
+  const logger = injector.get(INodeLogger);
+  const socketRoute = new WebSocketServerRoute(server, logger);
+  const channelHandler = new CommonChannelHandler('/service', logger, {
+    pathMatchOptions: serverAppOpts.pathMatchOptions,
+    wsServerOptions: serverAppOpts.wsServerOptions,
+  });
+
+  // 事件由 connection 的时机来触发
+  commonChannelPathHandler.register('RPCService', {
+    handler: (connection: WSChannel, clientId: string) => {
+      logger.log(`New RPC connection ${clientId}`);
+
+      const serviceCenter = new RPCServiceCenter(undefined, logger);
+      const serviceChildInjector = bindModuleBackService(injector, modulesInstances, serviceCenter, clientId);
+
+      const serverConnection = createWebSocketConnection(connection);
+      connection.messageConnection = serverConnection;
+      serviceCenter.setConnection(serverConnection);
+
+      connection.onClose(() => {
+        serviceCenter.removeConnection(serverConnection);
+        serviceChildInjector.disposeAll();
+
+        logger.log(`Remove RPC connection ${clientId}`);
+      });
+    },
+    dispose: () => {},
+  });
+
+  socketRoute.registerHandler(channelHandler);
+  if (handlerArr) {
+    for (const handler of handlerArr) {
+      socketRoute.registerHandler(handler);
+    }
+  }
+  socketRoute.init();
+}
+
+export function createNetServerConnection(server: net.Server, injector, modulesInstances) {
+  const logger = injector.get(INodeLogger);
+  const serviceCenter = new RPCServiceCenter(undefined, logger);
+  const serviceChildInjector = bindModuleBackService(
+    injector,
+    modulesInstances,
+    serviceCenter,
+    process.env.CODE_WINDOW_CLIENT_ID as string,
+  );
+
+  server.on('connection', (connection) => {
+    const serverConnection = createSocketConnection(connection);
+    serviceCenter.setConnection(serverConnection);
+
+    connection.on('close', () => {
+      serviceCenter.removeConnection(serverConnection);
+      serviceChildInjector.disposeAll();
+    });
+  });
+
+  return serviceCenter;
+}
+
+export function bindModuleBackService(
+  injector: Injector,
+  modules: NodeModule[],
+  serviceCenter: RPCServiceCenter,
+  clientId?: string,
+) {
+  const { createRPCService } = initRPCService(serviceCenter);
+
+  const childInjector = injector.createChild();
+  for (const module of modules) {
+    if (module.backServices) {
+      for (const service of module.backServices) {
+        if (service.token) {
+          const serviceToken = service.token;
+
+          if (!injector.creatorMap.has(serviceToken)) {
+            continue;
+          }
+
+          const creator = injector.creatorMap.get(serviceToken) as InstanceCreator;
+
+          if ((creator as FactoryCreator).useFactory) {
+            const serviceFactory = (creator as FactoryCreator).useFactory;
+            childInjector.addProviders({
+              token: serviceToken,
+              useValue: serviceFactory(childInjector),
+            });
+          } else {
+            const serviceClass = (creator as ClassCreator).useClass;
+            childInjector.addProviders({
+              token: serviceToken,
+              useClass: serviceClass,
+            });
+          }
+          const serviceInstance = childInjector.get(serviceToken);
+
+          if (serviceInstance.setConnectionClientId && clientId) {
+            serviceInstance.setConnectionClientId(clientId);
+          }
+          const servicePath = service.servicePath;
+          const createService = createRPCService(servicePath, serviceInstance);
+
+          if (!serviceInstance.rpcClient) {
+            serviceInstance.rpcClient = [createService];
+          }
+        }
+      }
+    }
+  }
+
+  return childInjector;
+}

package/src/hash-calculate/hash-calculate.contribution.ts

@@ -0,0 +1,19 @@
+import { Autowired } from '@opensumi/di';
+import { Domain } from '@opensumi/ide-core-common/lib/di-helper';
+import { IHashCalculateService } from '@opensumi/ide-core-common/lib/hash-calculate/hash-calculate';
+
+import { ServerAppContribution } from '../types';
+
+@Domain(ServerAppContribution)
+export class HashCalculateContribution implements ServerAppContribution {
+  @Autowired(IHashCalculateService)
+  private readonly hashCalculateService: IHashCalculateService;
+
+  async initialize() {
+    try {
+      await this.hashCalculateService.initialize();
+    } catch (err) {
+      throw new Error(`hashCalculateService init fail: \n ${err.message}`);
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+// 输出所有 common 里面会有的内容
+export * from '@opensumi/ide-core-common';
+
+export * from './connection';
+
+export * from './bootstrap';
+
+export * from './logger/node-logger';
+
+export * from './common-module';
+
+export * from './types';

package/src/logger/node-logger.ts

@@ -0,0 +1,68 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { ILogServiceManager, SupportLogNamespace, ILogService, LogLevel } from '@opensumi/ide-core-common';
+
+export type INodeLogger = ILogService;
+export const INodeLogger = Symbol('INodeLogger');
+
+@Injectable()
+export class NodeLogger implements INodeLogger {
+  @Autowired(ILogServiceManager)
+  private loggerManger: ILogServiceManager;
+
+  private logger: ILogService;
+
+  constructor() {
+    this.logger = this.loggerManger.getLogger(SupportLogNamespace.Node);
+  }
+
+  error(...args) {
+    return this.logger.error(...args);
+  }
+
+  warn(...args) {
+    return this.logger.warn(...args);
+  }
+
+  log(...args) {
+    return this.logger.log(...args);
+  }
+  debug(...args) {
+    return this.logger.debug(...args);
+  }
+
+  verbose(...args) {
+    return this.logger.verbose(...args);
+  }
+
+  critical(...args) {
+    return this.logger.critical(...args);
+  }
+
+  dispose() {
+    return this.logger.dispose();
+  }
+
+  setOptions(options) {
+    return this.logger.setOptions(options);
+  }
+
+  sendLog(level: LogLevel, message: string) {
+    return this.logger.sendLog(level, message);
+  }
+
+  drop() {
+    return this.logger.drop();
+  }
+
+  flush() {
+    return this.logger.flush();
+  }
+
+  getLevel() {
+    return this.logger.getLevel();
+  }
+
+  setLevel(level: LogLevel) {
+    return this.logger.setLevel(level);
+  }
+}

package/src/node-module.ts

@@ -0,0 +1,3 @@
+import { BasicModule } from '@opensumi/ide-core-common';
+
+export abstract class NodeModule extends BasicModule {}