@opensumi/ide-debug 2.21.13 → 2.22.0

package/src/common/commands.ts

@@ -0,0 +1,146 @@
+import { Command } from '@opensumi/ide-core-common';
+
+export namespace DEBUG_COMMANDS {
+  export const ADD_WATCHER: Command = {
+    id: 'debug.watch.add',
+  };
+  export const COLLAPSE_ALL_WATCHER: Command = {
+    id: 'debug.watch.collapseAll',
+  };
+  export const REMOVE_ALL_WATCHER: Command = {
+    id: 'debug.watch.removeAll',
+  };
+  export const REMOVE_WATCHER: Command = {
+    id: 'debug.watch.remove',
+  };
+  export const EDIT_WATCHER: Command = {
+    id: 'debug.watch.edit',
+  };
+  export const COPY_WATCHER_VALUE: Command = {
+    id: 'debug.watch.copyValue',
+  };
+  export const REMOVE_ALL_BREAKPOINTS: Command = {
+    id: 'debug.breakpoints.remove.all',
+  };
+  export const TOGGLE_BREAKPOINTS: Command = {
+    id: 'debug.breakpoints.toggle',
+  };
+  export const START: Command = {
+    id: 'debug.start',
+  };
+  export const NEXT: Command = {
+    id: 'debug.next',
+  };
+  export const PREV: Command = {
+    id: 'debug.prev',
+  };
+  export const OVER: Command = {
+    id: 'debug.over',
+  };
+  export const STOP: Command = {
+    id: 'debug.stop',
+  };
+  export const CONTINUE: Command = {
+    id: 'debug.continue',
+  };
+  export const RESTART: Command = {
+    id: 'debug.restart',
+  };
+  export const PAUSE: Command = {
+    id: 'debug.pause',
+  };
+  // menu commands
+  export const DELETE_BREAKPOINT: Command = {
+    id: 'debug.delete.breakpoint',
+    label: '%debug.menu.delete.breakpoint%',
+  };
+  export const EDIT_BREAKPOINT: Command = {
+    id: 'debug.edit.breakpoint',
+    label: '%debug.menu.edit.breakpoint%',
+  };
+  export const DISABLE_BREAKPOINT: Command = {
+    id: 'debug.disable.breakpoint',
+    label: '%debug.menu.disable.breakpoint%',
+  };
+  export const ENABLE_BREAKPOINT: Command = {
+    id: 'debug.enable.breakpoint',
+    label: '%debug.menu.enable.breakpoint%',
+  };
+  export const ENABLE_LOGPOINT: Command = {
+    id: 'debug.enable.logpoint',
+    label: '%debug.menu.enable.logpoint',
+  };
+  export const ADD_BREAKPOINT: Command = {
+    id: 'debug.add.breakpoint',
+    label: '%debug.menu.add.breakpoint%',
+  };
+  export const ADD_LOGPOINT: Command = {
+    id: 'debug.add.logpoint',
+    label: '%debug.menu.add.logpoint%',
+  };
+  export const ADD_CONDITIONAL_BREAKPOINT: Command = {
+    id: 'debug.add.conditional',
+    label: '%debug.menu.add.conditional%',
+  };
+  export const RESTART_FRAME: Command = {
+    id: 'debug.callstack.restart.frame',
+  };
+  export const COPY_STACK_TRACE: Command = {
+    id: 'debug.callstack.copy',
+  };
+  // variables
+  export const SET_VARIABLE_VALUE: Command = {
+    id: 'debug.variables.setValue',
+  };
+  export const COPY_VARIABLE_VALUE: Command = {
+    id: 'debug.variables.copy',
+  };
+  export const COPY_EVALUATE_PATH: Command = {
+    id: 'debug.evaluate.copy',
+  };
+  export const ADD_TO_WATCH_ID: Command = {
+    id: 'debug.addToWatchExpressions',
+  };
+  export const VIEW_MEMORY_ID: Command = {
+    id: 'debug.variables.view.memory',
+  };
+  // console commands
+  export const CLEAR_CONSOLE: Command = {
+    id: 'debug.console.clear',
+    label: '%debug.console.clear%',
+  };
+  export const COPY_CONSOLE_ITEM: Command = {
+    id: 'debug.console.copy',
+  };
+  export const COPY_CONSOLE_ALL: Command = {
+    id: 'debug.console.copyALl',
+  };
+  export const COLLAPSE_ALL_CONSOLE_ITEM: Command = {
+    id: 'debug.console.collapseAll',
+    label: '%debug.console.collapseAll%',
+  };
+  export const CONSOLE_ENTER_EVALUATE: Command = {
+    id: 'debug.console.keybing.enter.evaluate',
+  };
+  export const CONSOLE_INPUT_DOWN_ARROW: Command = {
+    id: 'debug.console.input.down.arrow',
+  };
+  export const CONSOLE_INPUT_UP_ARROW: Command = {
+    id: 'debug.console.input.up.arrow',
+  };
+  export const CONSOLE_FILTER_FOCUS: Command = {
+    id: 'debug.console.filter.input.focus',
+  };
+  export const RUN_TO_CURSOR: Command = {
+    id: 'debug.action.runToCursor',
+    label: '%debug.action.runToCursor%',
+  };
+  export const FORCE_RUN_TO_CURSOR: Command = {
+    id: 'debug.action.forceRunToCursor',
+    label: '%debug.action.forceRunToCursor%',
+  };
+  // exception widget
+  export const EXCEPTION_WIDGET_CLOSE: Command = {
+    id: 'debug.action.closeExceptionWidget',
+  };
+}

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-console.ts

@@ -0,0 +1,20 @@
+import { ITree, ITreeNode } from '@opensumi/ide-components/lib/recycle-tree/types';
+import { Event } from '@opensumi/ide-core-common';
+
+export const IDebugConsoleModelService = Symbol('IDebugConsoleModelService');
+
+export interface IDebugConsoleSession extends ITree {
+  clear(): void;
+  append(value: string): void;
+  appendLine(value: string): void;
+  onDidChange: Event<void>;
+  execute(value: string): Promise<void>;
+}
+
+export interface IDebugConsoleModelService {
+  debugConsoleSession: IDebugConsoleSession;
+  clear(): void;
+  copyAll(): void;
+  collapseAll(): void;
+  copy(node: ITreeNode): void;
+}

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,272 @@
+import stream from 'stream';
+
+import {
+  IDisposable,
+  MaybePromise,
+  IJSONSchema,
+  IJSONSchemaSnippet,
+  URI,
+  Disposable,
+  Emitter,
+  BinaryBuffer,
+  decodeBase64,
+  encodeBase64,
+  Event,
+} from '@opensumi/ide-core-common';
+// eslint-disable-next-line import/no-restricted-paths
+import type { ICodeEditor as IMonacoCodeEditor } from '@opensumi/ide-monaco/lib/browser/monaco-api/types';
+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 });
+  }
+}
+
+export enum DebugModelSupportedEventType {
+  down = 'Down',
+  move = 'Move',
+  leave = 'Leave',
+  contextMenu = 'contextMenu',
+}
+
+export const IDebugModelManager = Symbol('DebugModelManager');
+
+export interface IDebugModelManager {
+  init(session?: IDebugSession): void;
+  model: IDebugModel | undefined;
+  resolve(uri: URI): IDebugModel[] | undefined;
+  handleMouseEvent(
+    uri: URI,
+    type: DebugModelSupportedEventType,
+    event: monaco.editor.IEditorMouseEvent | monaco.editor.IPartialEditorMouseEvent,
+    monacoEditor: IMonacoCodeEditor,
+  ): void;
+  onModelChanged: Event<monaco.editor.IModelChangedEvent>;
+}

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,3 @@
+import { CodeSchemaId } from '@opensumi/ide-core-common';
+
+export const launchSchemaUri = CodeSchemaId.launch;