@opensumi/ide-debug 2.21.6 → 2.21.7-next-1670485458.0

package/src/common/constants.ts

@@ -0,0 +1,81 @@
+import { DEBUG_CONSOLE_CONTAINER_ID, DEBUG_CONTAINER_ID } from '@opensumi/ide-core-browser/lib/common/container-id';
+import { RawContextKey } from '@opensumi/ide-core-browser/lib/raw-context-key';
+
+import { DebugState } from './debug-session';
+
+export { DEBUG_CONSOLE_CONTAINER_ID, DEBUG_CONTAINER_ID };
+
+export const DEBUG_MEMORY_SCHEME = 'vscode-debug-memory';
+
+export const DEBUG_WATCH_ID = 'debug-watch';
+export const DEBUG_THREAD_ID = 'debug-thread';
+export const DEBUG_VARIABLES_ID = 'debug-variable';
+export const DEBUG_BREAKPOINTS_ID = 'debug-breakpoints';
+export const DEBUG_WELCOME_ID = 'debug-welcome';
+export const DEBUG_STACK_ID = 'debug-stack';
+export const DEBUG_FLOATING_CLICK_WIDGET = 'debug.overlayWidget.floatingClickWidget';
+export const DEBUG_SCHEME = 'debug';
+
+export const CONTEXT_DEBUG_STOPPED_KEY = 'debugStopped';
+export const CONTEXT_IN_DEBUG_MODE_KEY = 'inDebugMode';
+export const CONTEXT_DEBUG_TYPE_KEY = 'debugType';
+
+export const CONTEXT_DEBUG_TYPE = new RawContextKey<string>('debugType', undefined);
+export const CONTEXT_DEBUG_CONFIGURATION_TYPE = new RawContextKey<string>('debugConfigurationType', undefined);
+export const CONTEXT_DEBUG_STATE = new RawContextKey<keyof typeof DebugState>('debugState', 'Inactive');
+export const CONTEXT_DEBUG_UX_KEY = 'debugUx';
+export const CONTEXT_DEBUG_UX = new RawContextKey<string>(CONTEXT_DEBUG_UX_KEY, 'default');
+export const CONTEXT_IN_DEBUG_MODE = new RawContextKey<boolean>('inDebugMode', false);
+export const CONTEXT_IN_DEBUG_REPL = new RawContextKey<boolean>('inDebugRepl', false);
+export const CONTEXT_IN_DEBUG_CONSOLE = new RawContextKey<boolean>('inDebugConsole', false);
+export const CONTEXT_BREAKPOINT_WIDGET_VISIBLE = new RawContextKey<boolean>('breakpointWidgetVisible', false);
+export const CONTEXT_IN_BREAKPOINT_WIDGET = new RawContextKey<boolean>('inBreakpointWidget', false);
+export const CONTEXT_BREAKPOINTS_FOCUSED = new RawContextKey<boolean>('breakpointsFocused', true);
+export const CONTEXT_WATCH_EXPRESSIONS_FOCUSED = new RawContextKey<boolean>('watchExpressionsFocused', true);
+export const CONTEXT_WATCH_EXPRESSIONS_EXIST = new RawContextKey<boolean>('watchExpressionsExist', false);
+export const CONTEXT_VARIABLES_FOCUSED = new RawContextKey<boolean>('variablesFocused', true);
+export const CONTEXT_EXPRESSION_SELECTED = new RawContextKey<boolean>('expressionSelected', false);
+export const CONTEXT_BREAKPOINT_INPUT_FOCUSED = new RawContextKey<boolean>('breakpointInputFocused', false);
+export const CONTEXT_CALLSTACK_ITEM_TYPE = new RawContextKey<string>('callStackItemType', undefined);
+export const CONTEXT_CALLSTACK_SESSION_IS_ATTACH = new RawContextKey<boolean>('callStackSessionIsAttach', false);
+export const CONTEXT_CALLSTACK_ITEM_STOPPED = new RawContextKey<boolean>('callStackItemStopped', false);
+export const CONTEXT_CALLSTACK_SESSION_HAS_ONE_THREAD = new RawContextKey<boolean>(
+  'callStackSessionHasOneThread',
+  false,
+);
+export const CONTEXT_WATCH_ITEM_TYPE = new RawContextKey<string>('watchItemType', undefined);
+export const CONTEXT_BREAKPOINT_ITEM_TYPE = new RawContextKey<string>('breakpointItemType', undefined);
+export const CONTEXT_BREAKPOINT_ACCESS_TYPE = new RawContextKey<string>('breakpointAccessType', undefined);
+export const CONTEXT_BREAKPOINT_SUPPORTS_CONDITION = new RawContextKey<boolean>('breakpointSupportsCondition', false);
+export const CONTEXT_LOADED_SCRIPTS_SUPPORTED = new RawContextKey<boolean>('loadedScriptsSupported', false);
+export const CONTEXT_LOADED_SCRIPTS_ITEM_TYPE = new RawContextKey<string>('loadedScriptsItemType', undefined);
+export const CONTEXT_FOCUSED_SESSION_IS_ATTACH = new RawContextKey<boolean>('focusedSessionIsAttach', false);
+export const CONTEXT_STEP_BACK_SUPPORTED = new RawContextKey<boolean>('stepBackSupported', false);
+export const CONTEXT_RESTART_FRAME_SUPPORTED = new RawContextKey<boolean>('restartFrameSupported', false);
+export const CONTEXT_STACK_FRAME_SUPPORTS_RESTART = new RawContextKey<boolean>('stackFrameSupportsRestart', false);
+export const CONTEXT_JUMP_TO_CURSOR_SUPPORTED = new RawContextKey<boolean>('jumpToCursorSupported', false);
+export const CONTEXT_STEP_INTO_TARGETS_SUPPORTED = new RawContextKey<boolean>('stepIntoTargetsSupported', false);
+export const CONTEXT_BREAKPOINTS_EXIST = new RawContextKey<boolean>('breakpointsExist', false);
+export const CONTEXT_DEBUGGERS_AVAILABLE = new RawContextKey<boolean>('debuggersAvailable', false);
+export const CONTEXT_DEBUG_PROTOCOL_VARIABLE_MENU_CONTEXT = new RawContextKey<string>(
+  'debugProtocolVariableMenuContext',
+  undefined,
+);
+export const CONTEXT_SET_VARIABLE_SUPPORTED = new RawContextKey<boolean>('debugSetVariableSupported', false);
+export const CONTEXT_BREAK_WHEN_VALUE_CHANGES_SUPPORTED = new RawContextKey<boolean>(
+  'breakWhenValueChangesSupported',
+  false,
+);
+export const CONTEXT_BREAK_WHEN_VALUE_IS_ACCESSED_SUPPORTED = new RawContextKey<boolean>(
+  'breakWhenValueIsAccessedSupported',
+  false,
+);
+export const CONTEXT_BREAK_WHEN_VALUE_IS_READ_SUPPORTED = new RawContextKey<boolean>(
+  'breakWhenValueIsReadSupported',
+  false,
+);
+export const CONTEXT_VARIABLE_EVALUATE_NAME_PRESENT = new RawContextKey<boolean>('variableEvaluateNamePresent', false);
+export const CONTEXT_EXCEPTION_WIDGET_VISIBLE = new RawContextKey<boolean>('exceptionWidgetVisible', false);
+export const CONTEXT_MULTI_SESSION_REPL = new RawContextKey<boolean>('multiSessionRepl', false);
+export const CONTEXT_MULTI_SESSION_DEBUG = new RawContextKey<boolean>('multiSessionDebug', false);
+export const CONTEXT_CAN_VIEW_MEMORY = new RawContextKey<boolean>('canViewMemory', undefined);

package/src/common/debug-breakpoint.ts

@@ -0,0 +1,43 @@
+import { URI } from '@opensumi/ide-core-common';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol';
+
+export interface ISourceBreakpoint {
+  id: string;
+  enabled: boolean;
+  uri: string;
+  raw: DebugProtocol.SourceBreakpoint;
+  logMessage?: string;
+  message?: string;
+  status: Map<string, DebugProtocol.Breakpoint>;
+}
+
+export interface IRuntimeBreakpoint extends ISourceBreakpoint {
+  status: Map<string, DebugProtocol.Breakpoint>;
+}
+
+export type TSourceBrekpointProperties = keyof Pick<
+  DebugProtocol.SourceBreakpoint,
+  'condition' | 'hitCondition' | 'logMessage'
+>;
+
+export interface BreakpointChangeData {
+  context: TSourceBrekpointProperties;
+  value: string;
+}
+
+export type DebugBreakpointWidgetContext = {
+  [context in TSourceBrekpointProperties]?: string;
+};
+
+export interface BreakpointsChangeEvent {
+  affected: URI[];
+  added: IDebugBreakpoint[];
+  removed: IDebugBreakpoint[];
+  changed: IDebugBreakpoint[];
+  /**
+   * 标识后端调试状态已更新，这是纯视图更新。
+   */
+  statusUpdated?: boolean;
+}
+
+export type IDebugBreakpoint = ISourceBreakpoint | IRuntimeBreakpoint;

package/src/common/debug-configuration.ts

@@ -0,0 +1,68 @@
+export type DebugViewLocation = 'default' | 'left' | 'right' | 'bottom';
+/**
+ * 调试适配器进程配置.
+ */
+export interface DebugConfiguration {
+  /**
+   * 调试适配器进程类型.
+   */
+  type: string;
+
+  /**
+   * 调试适配器进程名称
+   */
+  name: string;
+
+  /**
+   * 拓展属性
+   */
+  [key: string]: any;
+
+  /**
+   * 调试适配器进程请求类型
+   */
+  request: string;
+
+  /**
+   * 如果noDebug为true，则启动请求应启动程序而不启用调试
+   */
+  noDebug?: boolean;
+
+  /**
+   * 来自先前的重启进程的可选参数
+   * 该数据作为'terminated'事件的'restart'属性传递
+   * 客户端需保证数据完整性
+   */
+  __restart?: any;
+
+  /**
+   * 默认的调试工具栏视图位置
+   * 默认值：default
+   */
+  debugViewLocation?: DebugViewLocation;
+
+  preLaunchTask?: string;
+
+  /**
+   * 打开调试(左侧面板)视图时机
+   * 默认值：neverOpen
+   */
+  openDebug?: 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart' | 'openOnDebugBreak';
+
+  /**
+   * 打开内置DebugConsole（底部面板）视图时机
+   * 默认值：neverOpen
+   */
+  internalConsoleOptions?: 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
+}
+
+export namespace DebugConfiguration {
+  export function is(arg: DebugConfiguration | any): arg is DebugConfiguration {
+    return !!arg && typeof arg === 'object' && 'type' in arg && 'name' in arg && 'request' in arg;
+  }
+}
+
+export const DEFAULT_ADD_CONFIGURATION_KEY = '__ADD_CONF__';
+export const DEFAULT_NO_CONFIGURATION_KEY = '__NO_CONF__';
+export const DEFAULT_CONFIGURATION_NAME_SEPARATOR = '__CONF__';
+export const DEFAULT_CONFIGURATION_INDEX_SEPARATOR = '__INDEX__';

package/src/common/debug-editor.ts

@@ -0,0 +1,4 @@
+// eslint-disable-next-line import/no-restricted-paths
+import type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+export const DebugEditor = Symbol('DebugEditor');
+export type DebugEditor = IMonacoCodeEditor;

package/src/common/debug-hover.ts

@@ -0,0 +1,31 @@
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+export interface IDebugHoverWidget extends monaco.editor.IContentWidget {
+  show: (options?: ShowDebugHoverOptions | undefined) => void;
+  hide: (options?: ShowDebugHoverOptions | undefined) => void;
+}
+
+export interface ShowDebugHoverOptions {
+  /**
+   * 选中区域
+   */
+  selection: monaco.Range;
+  /**
+   * 是否为焦点
+   * 默认值：false
+   */
+  focus?: boolean;
+  /**
+   * 是否立即调用，当为true时会清理之前的队列
+   * 默认值：true
+   */
+  immediate?: boolean;
+}
+
+export interface HideDebugHoverOptions {
+  /**
+   * 是否立即调用，当为true时会清理之前的队列
+   * 默认值：true
+   */
+  immediate?: boolean;
+}

package/src/common/debug-model.ts

@@ -0,0 +1,247 @@
+import stream from 'stream';
+
+import {
+  IDisposable,
+  MaybePromise,
+  IJSONSchema,
+  IJSONSchemaSnippet,
+  URI,
+  Disposable,
+  Emitter,
+  BinaryBuffer,
+  decodeBase64,
+  encodeBase64,
+} from '@opensumi/ide-core-common';
+import type { editor } from '@opensumi/monaco-editor-core';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import {
+  IRuntimeBreakpoint,
+  ISourceBreakpoint,
+  DebugBreakpointWidgetContext,
+  TSourceBrekpointProperties,
+} from './debug-breakpoint';
+import { DebugConfiguration } from './debug-configuration';
+import { DebugEditor } from './debug-editor';
+import { IDebugHoverWidget } from './debug-hover';
+import { IMemoryInvalidationEvent, IMemoryRegion, MemoryRange, MemoryRangeType } from './debug-service';
+import { IDebugSession } from './debug-session';
+
+export interface IDebugBreakpointWidget extends IDisposable {
+  position: monaco.Position | undefined;
+}
+
+export interface IDebugBreakpointWidget extends IDisposable {
+  position: monaco.Position | undefined;
+}
+
+export const DebugAdapterSession = Symbol('DebugAdapterSession');
+
+export interface DebugAdapterSession {
+  id: string;
+  start(channel: any): Promise<void>;
+  stop(): Promise<void>;
+}
+
+export const DebugAdapterSessionFactory = Symbol('DebugAdapterSessionFactory');
+
+export interface DebugAdapterSessionFactory {
+  get(sessionId: string, communicationProvider: DebugStreamConnection): DebugAdapterSession;
+}
+
+export interface DebugAdapterSpawnExecutable {
+  command: string;
+  args?: string[];
+}
+
+export interface DebugAdapterForkExecutable {
+  modulePath: string;
+  args?: string[];
+}
+
+/**
+ * 可执行的调试适配器类型
+ * 用于实例化调试适配器的参数
+ *
+ * 在Launch适配器进程的情况下，参数包含命令和参数。例如：
+ * {'command' : 'COMMAND_TO_LAUNCH_DEBUG_ADAPTER', args : [ { 'arg1', 'arg2' } ] }
+ *
+ * 在Fork适配器进程的情况下，包含要转换的modulePath。例如：
+ * {'modulePath' : 'NODE_COMMAND_TO_LAUNCH_DEBUG_ADAPTER', args : [ { 'arg1', 'arg2' } ] }
+ */
+export type DebugAdapterExecutable = DebugAdapterSpawnExecutable | DebugAdapterForkExecutable;
+
+/**
+ * 与调试进程的通讯渠道
+ */
+export interface DebugStreamConnection extends IDisposable {
+  output: stream.Readable;
+  input: stream.Writable;
+}
+
+export const DebugAdapterFactory = Symbol('DebugAdapterFactory');
+
+export interface DebugAdapterFactory {
+  start(executable: DebugAdapterExecutable): DebugStreamConnection;
+  connect(debugServerPort: number): DebugStreamConnection;
+}
+
+export const DebugAdapterContribution = Symbol('DebugAdapterContribution');
+
+export interface DebugAdapterContribution {
+  /**
+   * The debug type. Should be a unique value among all debug adapters.
+   */
+  readonly type: string;
+
+  readonly label?: MaybePromise<string | undefined>;
+
+  readonly languages?: MaybePromise<string[] | undefined>;
+
+  /**
+   * The [debug adapter session](#DebugAdapterSession) factory.
+   * If a default implementation of the debug adapter session does not
+   * fit all needs it is possible to provide its own implementation using
+   * this factory. But it is strongly recommended to extend the default
+   * implementation if so.
+   */
+  debugAdapterSessionFactory?: DebugAdapterSessionFactory;
+
+  /**
+   * @returns The contributed configuration schema for this debug type.
+   */
+  getSchemaAttributes?(): MaybePromise<IJSONSchema[]>;
+
+  getConfigurationSnippets?(): MaybePromise<IJSONSchemaSnippet[]>;
+
+  /**
+   * Provides a [debug adapter executable](#DebugAdapterExecutable)
+   * based on [debug configuration](#DebugConfiguration) to launch a new debug adapter
+   * or to connect to existed one.
+   * @param config The resolved [debug configuration](#DebugConfiguration).
+   * @returns The [debug adapter executable](#DebugAdapterExecutable).
+   */
+  provideDebugAdapterExecutable?(config: DebugConfiguration): MaybePromise<DebugAdapterExecutable | undefined>;
+
+  /**
+   * Provides initial [debug configuration](#DebugConfiguration).
+   * @returns An array of [debug configurations](#DebugConfiguration).
+   */
+  provideDebugConfigurations?(workspaceFolderUri?: string): MaybePromise<DebugConfiguration[]>;
+
+  /**
+   * Resolves a [debug configuration](#DebugConfiguration) by filling in missing values
+   * or by adding/changing/removing attributes.
+   * @param config The [debug configuration](#DebugConfiguration) to resolve.
+   * @returns The resolved debug configuration.
+   */
+  resolveDebugConfiguration?(
+    config: DebugConfiguration,
+    workspaceFolderUri?: string,
+  ): MaybePromise<DebugConfiguration | undefined>;
+}
+
+export const DebugModelFactory = Symbol('DebugModelFactory');
+export type DebugModelFactory = (editor: DebugEditor) => IDebugModel;
+
+export const IDebugModel = Symbol('IDebugModel');
+export interface IDebugModel extends IDisposable {
+  uri: URI;
+  position: monaco.Position;
+  init: () => Promise<void>;
+  renderBreakpoints: () => void;
+  toggleBreakpoint: (position?: monaco.Position) => void;
+  openBreakpointView: (
+    position: monaco.Position,
+    context?: DebugBreakpointWidgetContext,
+    defaultContext?: TSourceBrekpointProperties,
+  ) => void;
+  closeBreakpointView: () => void;
+  acceptBreakpoint: () => void;
+  focusStackFrame: () => void;
+  breakpoint: ISourceBreakpoint | IRuntimeBreakpoint | undefined;
+  onContextMenu: (event: editor.IEditorMouseEvent | editor.IPartialEditorMouseEvent) => void;
+  onMouseDown: (event: editor.IEditorMouseEvent | editor.IPartialEditorMouseEvent) => void;
+  onMouseMove: (event: editor.IEditorMouseEvent | editor.IPartialEditorMouseEvent) => void;
+  onMouseLeave: (event: editor.IEditorMouseEvent | editor.IPartialEditorMouseEvent) => void;
+  getBreakpoints(
+    uri?: URI | undefined,
+    filter?: Partial<monaco.IPosition> | undefined,
+  ): Array<ISourceBreakpoint | IRuntimeBreakpoint>;
+  getEditor: () => DebugEditor;
+  getBreakpointWidget: () => IDebugBreakpointWidget;
+  getDebugHoverWidget: () => IDebugHoverWidget;
+  render: () => void;
+}
+
+export class MemoryRegion extends Disposable implements IMemoryRegion {
+  private readonly invalidateEmitter = this.registerDispose(new Emitter<IMemoryInvalidationEvent>());
+
+  /** @inheritdoc */
+  public readonly onDidInvalidate = this.invalidateEmitter.event;
+
+  /** @inheritdoc */
+  public readonly writable = !!this.session.capabilities.supportsWriteMemoryRequest;
+
+  constructor(private readonly memoryReference: string, private readonly session: IDebugSession) {
+    super();
+    this.registerDispose(
+      session.onDidInvalidateMemory((e) => {
+        if (e.body.memoryReference === memoryReference) {
+          this.invalidate(e.body.offset, e.body.count - e.body.offset);
+        }
+      }),
+    );
+  }
+
+  public async read(fromOffset: number, toOffset: number): Promise<MemoryRange[]> {
+    const length = toOffset - fromOffset;
+    const offset = fromOffset;
+    const result = await this.session.readMemory(this.memoryReference, offset, length);
+
+    if (result === undefined || !result.body?.data) {
+      return [{ type: MemoryRangeType.Unreadable, offset, length }];
+    }
+
+    let data: BinaryBuffer;
+    try {
+      data = decodeBase64(result.body.data);
+    } catch (e) {
+      return [{ type: MemoryRangeType.Error, offset, length, error: e.message }];
+    }
+
+    const unreadable = result.body.unreadableBytes || 0;
+    const dataLength = length - unreadable;
+    if (data.byteLength < dataLength) {
+      const pad = BinaryBuffer.alloc(dataLength - data.byteLength);
+      pad.buffer.fill(0);
+      data = BinaryBuffer.concat([data, pad], dataLength);
+    } else if (data.byteLength > dataLength) {
+      data = data.slice(0, dataLength);
+    }
+
+    if (!unreadable) {
+      return [{ type: MemoryRangeType.Valid, offset, length, data }];
+    }
+
+    return [
+      { type: MemoryRangeType.Valid, offset, length: dataLength, data },
+      { type: MemoryRangeType.Unreadable, offset: offset + dataLength, length: unreadable },
+    ];
+  }
+
+  public async write(offset: number, data: BinaryBuffer): Promise<number> {
+    const result = await this.session.writeMemory(this.memoryReference, offset, encodeBase64(data), true);
+    const written = result?.body?.bytesWritten ?? data.byteLength;
+    this.invalidate(offset, offset + written);
+    return written;
+  }
+
+  public override dispose() {
+    super.dispose();
+  }
+
+  private invalidate(fromOffset: number, toOffset: number) {
+    this.invalidateEmitter.fire({ fromOffset, toOffset });
+  }
+}

package/src/common/debug-progress.ts

@@ -0,0 +1,8 @@
+import { DebugState, IDebugSessionManager } from './debug-session';
+
+export const IDebugProgress = Symbol('DebugProgress');
+
+export interface IDebugProgress {
+  run: (sm: IDebugSessionManager) => void;
+  onDebugServiceStateChange: (state: DebugState) => void;
+}

package/src/common/debug-schema-updater.ts

@@ -0,0 +1 @@
+export const launchSchemaUri = 'vscode://schemas/launch';

package/src/common/debug-service.ts

@@ -0,0 +1,176 @@
+import {
+  IDisposable,
+  IJSONSchema,
+  IJSONSchemaSnippet,
+  ApplicationError,
+  Event,
+  BinaryBuffer,
+} from '@opensumi/ide-core-common';
+
+import { DebugConfiguration } from './debug-configuration';
+import { IDebugSessionDTO } from './debug-session-options';
+
+export interface IMemoryInvalidationEvent {
+  fromOffset: number;
+  toOffset: number;
+}
+
+export const enum MemoryRangeType {
+  Valid,
+  Unreadable,
+  Error,
+}
+
+export interface IMemoryRange {
+  type: MemoryRangeType;
+  offset: number;
+  length: number;
+}
+
+export interface IUnreadableMemoryRange extends IMemoryRange {
+  type: MemoryRangeType.Unreadable;
+}
+
+export interface IErrorMemoryRange extends IMemoryRange {
+  type: MemoryRangeType.Error;
+  error: string;
+}
+
+export interface IValidMemoryRange extends IMemoryRange {
+  type: MemoryRangeType.Valid;
+  offset: number;
+  length: number;
+  data: BinaryBuffer;
+}
+
+/**
+ * Union type of memory that can be returned from read(). Since a read request
+ * could encompass multiple previously-read ranges, multiple of these types
+ * are possible to return.
+ */
+export type MemoryRange = IValidMemoryRange | IUnreadableMemoryRange | IErrorMemoryRange;
+
+/**
+ * An IMemoryRegion corresponds to a contiguous range of memory referred to
+ * by a DAP `memoryReference`.
+ */
+export interface IMemoryRegion extends IDisposable {
+  /**
+   * Event that fires when memory changes. Can be a result of memory events or
+   * `write` requests.
+   */
+  readonly onDidInvalidate: Event<IMemoryInvalidationEvent>;
+
+  /**
+   * Whether writes are supported on this memory region.
+   */
+  readonly writable: boolean;
+
+  /**
+   * Requests memory ranges from the debug adapter. It returns a list of memory
+   * ranges that overlap (but may exceed!) the given offset. Use the `offset`
+   * and `length` of each range for display.
+   */
+  read(fromOffset: number, toOffset: number): Promise<MemoryRange[]>;
+
+  /**
+   * Writes memory to the debug adapter at the given offset.
+   */
+  write(offset: number, data: BinaryBuffer): Promise<number>;
+}
+
+export interface DebuggerDescription {
+  type: string;
+  label: string;
+}
+
+export const DebugAdapterPath = 'DebugAdaptor';
+
+// Browser DI Token
+export const IDebugServer = Symbol('DebugServer');
+
+export interface DebugServer extends IDisposable {
+  /**
+   * 查找并返回注册了的Debug类型
+   * @returns Debug 类型数组
+   */
+  debugTypes(): Promise<string[]>;
+
+  /**
+   * 根据语言获取对应的Debuggers
+   * @param language
+   */
+  getDebuggersForLanguage(language: string): Promise<DebuggerDescription[]>;
+
+  /**
+   * 根据调试类型获取支持的Schema
+   * @param debugType 调试类型
+   */
+  getSchemaAttributes(debugType: string): Promise<IJSONSchema[]>;
+
+  /**
+   * 根据调试类型获取对应的片段
+   */
+  getConfigurationSnippets(): Promise<IJSONSchemaSnippet[]>;
+
+  /**
+   * 提供对应调试类型下的配置
+   * @param debugType 调试类型
+   */
+  provideDebugConfigurations(debugType: string, workspaceFolderUri: string | undefined): Promise<DebugConfiguration[]>;
+
+  /**
+   * 处理调试配置，补全缺省值
+   * @param config 需要处理的配置
+   * @param workspaceFolderUri 工作区目录路径
+   */
+  resolveDebugConfiguration(
+    config: DebugConfiguration,
+    workspaceFolderUri: string | undefined,
+  ): Promise<DebugConfiguration | undefined | null>;
+
+  /**
+   * 进一步处理调试配置，通过补全缺省值的方式
+   * 具体实现通过插件进行二次实现
+   * @param {DebugConfiguration} 处理的配置
+   * @param {(string | undefined)} 工作区路径
+   */
+  resolveDebugConfigurationWithSubstitutedVariables(
+    config: DebugConfiguration,
+    workspaceFolderUri: string | undefined,
+  ): Promise<DebugConfiguration | undefined | null>;
+  /**
+   * 创建一个新的DebugAdapterSession进程
+   * @param config 传入配置
+   * @returns DebugAdapterSession对应sessionId.
+   */
+  createDebugSession(config: IDebugSessionDTO): Promise<string | void>;
+
+  /**
+   * 终止一个调试进程
+   * @param sessionId
+   */
+  terminateDebugSession(sessionId: string): Promise<void>;
+}
+
+export const IDebugService = Symbol('DebugService');
+
+export interface IDebugService {
+  onDidDebugContributionPointChange: Event<IDebugServiceContributionPoint>;
+  unregisterDebugContributionPoints(extensionFolder: string): void;
+  registerDebugContributionPoints(extensionFolder: string, contributions: IJSONSchema[]): void;
+  debugContributionPoints: Map<string, IJSONSchema[]>;
+}
+
+export interface IDebugServiceContributionPoint {
+  path: string;
+  contributions: IJSONSchema[];
+  removed?: boolean;
+}
+
+export namespace DebugError {
+  export const NotFound = ApplicationError.declare(-41000, (type: string) => ({
+    message: `'${type}' debugger type is not supported.`,
+    data: { type },
+  }));
+}

package/src/common/debug-session-options.ts

@@ -0,0 +1,19 @@
+import { DebugConfiguration } from './debug-configuration';
+import { IDebugSessionOptions } from './debug-session';
+
+export interface DebugSessionOptions extends IDebugSessionOptions {
+  configuration: DebugConfiguration;
+  workspaceFolderUri?: string;
+  index: number;
+}
+
+export interface IDebugSessionDTO extends DebugSessionOptions {
+  id: number;
+  parent?: string;
+}
+
+export namespace IDebugSessionDTO {
+  export function is(options: DebugSessionOptions): options is IDebugSessionDTO {
+    return 'id' in options;
+  }
+}