@opensumi/ide-debug 2.21.4 → 2.21.5-next-1668665440.0

package/src/common/debug-session.ts

@@ -0,0 +1,200 @@
+import { CancellationToken, Event, IDisposable } from '@opensumi/ide-core-common';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol';
+
+import { DebugConfiguration } from './debug-configuration';
+import { DebugSessionOptions, IDebugSessionDTO } from './debug-session-options';
+
+export interface IDebugExceptionInfo {
+  readonly id?: string;
+  readonly description?: string;
+  readonly breakMode: string | null;
+  readonly details?: DebugProtocol.ExceptionDetails;
+}
+
+export enum DebugState {
+  Inactive,
+  Initializing,
+  Running,
+  Stopped,
+}
+
+export type IDebugSessionReplMode = 'separate' | 'mergeWithParent';
+
+export interface IDebugSessionOptions {
+  noDebug?: boolean;
+  parentSession?: IDebugSession;
+  lifecycleManagedByParent?: boolean;
+  repl?: IDebugSessionReplMode;
+  compact?: boolean;
+}
+
+export const IDebugSession = Symbol('DebugSession');
+
+export const IDebugSessionManager = Symbol('DebugSessionManager');
+export interface IDebugSessionManager {
+  fireWillStartDebugSession(): Promise<void>;
+  resolveConfiguration(options: Readonly<DebugSessionOptions>): Promise<IDebugSessionDTO | undefined>;
+  resolveDebugConfiguration(
+    configuration: DebugConfiguration,
+    workspaceFolderUri: string | undefined,
+  ): Promise<DebugConfiguration | undefined | null>;
+  fireWillResolveDebugConfiguration(debugType: string): Promise<void>;
+  report(name: string, msg: string | undefined, extra?: any): void;
+  reportTime(name: string, defaults?: any): (msg: string | undefined, extra?: any) => number;
+  reportAction(sessionId: string, threadId: number | string | undefined, action: string): void;
+  getExtra(sessionId: string | undefined, threadId: number | string | undefined): DebugThreadExtra | undefined;
+  setExtra(sessionId: string, threadId: string, extra?: DebugThreadExtra);
+
+  [key: string]: any;
+}
+
+export interface IDebugSession extends IDisposable {
+  state: DebugState;
+  parentSession: IDebugSession | undefined;
+  id: string;
+  capabilities: DebugProtocol.Capabilities;
+  onDidInvalidateMemory: Event<DebugProtocol.MemoryEvent>;
+  readMemory(
+    memoryReference: string,
+    offset: number,
+    count: number,
+  ): Promise<DebugProtocol.ReadMemoryResponse | undefined>;
+  writeMemory(
+    memoryReference: string,
+    offset: number,
+    data: string,
+    allowPartial?: boolean | undefined,
+  ): Promise<DebugProtocol.WriteMemoryResponse | undefined>;
+  hasSeparateRepl: () => boolean;
+  getDebugProtocolBreakpoint(breakpointId: string): DebugProtocol.Breakpoint | undefined;
+  compact: boolean;
+  on: <K extends keyof DebugEventTypes>(kind: K, listener: (e: DebugEventTypes[K]) => any) => IDisposable;
+  sendRequest<K extends keyof DebugRequestTypes>(
+    command: K,
+    args: DebugRequestTypes[K][0],
+    token?: CancellationToken | undefined,
+  ): Promise<DebugRequestTypes[K][1]>;
+  restart(): Promise<boolean>;
+  disconnect(restart?: boolean | undefined): Promise<void>;
+  terminate(restart?: boolean | undefined): Promise<void>;
+}
+
+/**
+ * 埋点专用的额外数据
+ */
+export interface DebugBaseExtra {
+  /**
+   * adapterID 区分语言
+   */
+  adapterID: string;
+
+  /**
+   * request 区分 attach 或 launch
+   */
+  request: 'attach' | 'launch';
+
+  /**
+   * 跟 sessionId 一一对应，先于 sessionId 生成，可以跟踪初始化时的事件
+   */
+  traceId: string;
+
+  /**
+   * 是否为远程调试
+   * 0: 非远程
+   * 1: 远程
+   */
+  remote: 0 | 1;
+}
+export interface DebugSessionExtra extends DebugBaseExtra {
+  threads: Map<string, DebugThreadExtra>;
+}
+
+export interface DebugThreadExtra extends DebugBaseExtra {
+  threadId?: string;
+
+  /**
+   * 当前的用户操作
+   */
+  action?: string;
+
+  /**
+   * 文件所在的路径和行号
+   */
+  filePath?: string;
+  fileLineNumber?: number;
+}
+
+let DEBUG_SESSION_SEQUENCE_ID = 1;
+
+export function getSequenceId() {
+  // 获取递增的请求 ID
+  return DEBUG_SESSION_SEQUENCE_ID++;
+}
+
+export interface DebugExitEvent {
+  code?: number;
+  reason?: string | Error;
+}
+export interface DebugRequestTypes {
+  attach: [DebugProtocol.AttachRequestArguments, DebugProtocol.AttachResponse];
+  breakpointLocations: [DebugProtocol.BreakpointLocationsArguments, DebugProtocol.BreakpointLocationsResponse];
+  completions: [DebugProtocol.CompletionsArguments, DebugProtocol.CompletionsResponse];
+  configurationDone: [DebugProtocol.ConfigurationDoneArguments, DebugProtocol.ConfigurationDoneResponse];
+  continue: [DebugProtocol.ContinueArguments, DebugProtocol.ContinueResponse];
+  disconnect: [DebugProtocol.DisconnectArguments, DebugProtocol.DisconnectResponse];
+  evaluate: [DebugProtocol.EvaluateArguments, DebugProtocol.EvaluateResponse];
+  exceptionInfo: [DebugProtocol.ExceptionInfoArguments, DebugProtocol.ExceptionInfoResponse];
+  goto: [DebugProtocol.GotoArguments, DebugProtocol.GotoResponse];
+  gotoTargets: [DebugProtocol.GotoTargetsArguments, DebugProtocol.GotoTargetsResponse];
+  initialize: [DebugProtocol.InitializeRequestArguments, DebugProtocol.InitializeResponse];
+  launch: [DebugProtocol.LaunchRequestArguments, DebugProtocol.LaunchResponse];
+  loadedSources: [DebugProtocol.LoadedSourcesArguments, DebugProtocol.LoadedSourcesResponse];
+  modules: [DebugProtocol.ModulesArguments, DebugProtocol.ModulesResponse];
+  next: [DebugProtocol.NextArguments, DebugProtocol.NextResponse];
+  pause: [DebugProtocol.PauseArguments, DebugProtocol.PauseResponse];
+  restart: [DebugProtocol.RestartArguments, DebugProtocol.RestartResponse];
+  restartFrame: [DebugProtocol.RestartFrameArguments, DebugProtocol.RestartFrameResponse];
+  reverseContinue: [DebugProtocol.ReverseContinueArguments, DebugProtocol.ReverseContinueResponse];
+  scopes: [DebugProtocol.ScopesArguments, DebugProtocol.ScopesResponse];
+  setBreakpoints: [DebugProtocol.SetBreakpointsArguments, DebugProtocol.SetBreakpointsResponse];
+  setExceptionBreakpoints: [
+    DebugProtocol.SetExceptionBreakpointsArguments,
+    DebugProtocol.SetExceptionBreakpointsResponse,
+  ];
+  setExpression: [DebugProtocol.SetExpressionArguments, DebugProtocol.SetExpressionResponse];
+  setFunctionBreakpoints: [DebugProtocol.SetFunctionBreakpointsArguments, DebugProtocol.SetFunctionBreakpointsResponse];
+  setVariable: [DebugProtocol.SetVariableArguments, DebugProtocol.SetVariableResponse];
+  source: [DebugProtocol.SourceArguments, DebugProtocol.SourceResponse];
+  stackTrace: [DebugProtocol.StackTraceArguments, DebugProtocol.StackTraceResponse];
+  stepBack: [DebugProtocol.StepBackArguments, DebugProtocol.StepBackResponse];
+  stepIn: [DebugProtocol.StepInArguments, DebugProtocol.StepInResponse];
+  stepInTargets: [DebugProtocol.StepInTargetsArguments, DebugProtocol.StepInTargetsResponse];
+  stepOut: [DebugProtocol.StepOutArguments, DebugProtocol.StepOutResponse];
+  terminate: [DebugProtocol.TerminateArguments, DebugProtocol.TerminateResponse];
+  terminateThreads: [DebugProtocol.TerminateThreadsArguments, DebugProtocol.TerminateThreadsResponse];
+  threads: [DebugProtocol.ThreadsArguments | null, DebugProtocol.ThreadsResponse];
+  variables: [DebugProtocol.VariablesArguments, DebugProtocol.VariablesResponse];
+  cancel: [DebugProtocol.CancelArguments, DebugProtocol.CancelResponse];
+  readMemory: [DebugProtocol.ReadMemoryArguments, DebugProtocol.ReadMemoryResponse];
+  writeMemory: [DebugProtocol.WriteMemoryArguments, DebugProtocol.WriteMemoryResponse];
+}
+
+export interface DebugEventTypes {
+  breakpoint: DebugProtocol.BreakpointEvent;
+  capabilities: DebugProtocol.CapabilitiesEvent;
+  continued: DebugProtocol.ContinuedEvent;
+  exited: DebugExitEvent;
+  initialized: DebugProtocol.InitializedEvent;
+  loadedSource: DebugProtocol.LoadedSourceEvent;
+  module: DebugProtocol.ModuleEvent;
+  output: DebugProtocol.OutputEvent;
+  process: DebugProtocol.ProcessEvent;
+  stopped: DebugProtocol.StoppedEvent;
+  terminated: DebugProtocol.TerminatedEvent;
+  thread: DebugProtocol.ThreadEvent;
+  progressStart: DebugProtocol.ProgressStartEvent;
+  progressUpdate: DebugProtocol.ProgressUpdateEvent;
+  progressEnd: DebugProtocol.ProgressEndEvent;
+  memory: DebugProtocol.MemoryEvent;
+  invalidated: DebugProtocol.InvalidatedEvent;
+}

package/src/common/evaluatable-expression.ts

@@ -0,0 +1,43 @@
+import { CancellationToken } from '@opensumi/ide-core-common';
+import { IRange, Position } from '@opensumi/ide-core-common/lib/types';
+import type { ITextModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
+
+/**
+ * An evaluatable expression represents additional information for an expression in a document. Evaluatable expressions are
+ * evaluated by a debugger or runtime and their result is rendered in a tooltip-like widget.
+ * @internal
+ */
+export interface IEvaluatableExpression {
+  /**
+   * The range to which this expression applies.
+   */
+  range: IRange;
+  /**
+   * This expression overrides the expression extracted from the range.
+   */
+  expression?: string;
+}
+
+/**
+ * The evaluatable expression provider interface defines the contract between extensions and
+ * the debug hover. In this contract the provider returns an evaluatable expression for a given position
+ * in a document and VS Code evaluates this expression in the active debug session and shows the result in a debug hover.
+ */
+export interface EvaluatableExpressionProvider {
+  /**
+   * Provide an evaluatable expression for the given document and position.
+   * VS Code will evaluate this expression in the active debug session and will show the result in the debug hover.
+   * The expression can be implicitly specified by the range in the underlying document or by explicitly returning an expression.
+   *
+   * @param document The document for which the debug hover is about to appear.
+   * @param position The line and character position in the document where the debug hover is about to appear.
+   * @param token A cancellation token.
+   * @return An EvaluatableExpression or a thenable that resolves to such. The lack of a result can be
+   * signaled by returning `undefined` or `null`.
+   */
+  provideEvaluatableExpression(
+    document: ITextModel,
+    position: Position,
+    token: CancellationToken,
+  ): PromiseLike<IEvaluatableExpression | undefined>;
+}

package/src/common/index.ts

@@ -0,0 +1,14 @@
+export * from './debug-configuration';
+export * from './debug-service';
+export * from './debug-hover';
+export * from './debug-breakpoint';
+export * from './debug-model';
+export * from './debug-session';
+export * from './debug-session-options';
+export * from './debug-editor';
+export * from './debug-progress';
+export * from './debug-schema-updater';
+export * from './inline-values';
+export * from './types';
+export * from './constants';
+export * from './terminal';

package/src/common/inline-values.ts

@@ -0,0 +1,77 @@
+import { IRange, CancellationToken, Event } from '@opensumi/ide-core-common';
+import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
+import { ITextModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
+
+// Inline Values
+/**
+ * A value-object that contains contextual information when requesting inline values from a InlineValuesProvider.
+ * @internal
+ */
+export interface InlineValueContext {
+  frameId: number;
+  stoppedLocation: Range;
+}
+
+/**
+ * Provide inline value as text.
+ * @internal
+ */
+export interface InlineValueText {
+  type: 'text';
+  range: IRange;
+  text: string;
+}
+
+/**
+ * Provide inline value through a variable lookup.
+ * @internal
+ */
+export interface InlineValueVariableLookup {
+  type: 'variable';
+  range: IRange;
+  variableName?: string;
+  caseSensitiveLookup: boolean;
+}
+
+/**
+ * Provide inline value through an expression evaluation.
+ * @internal
+ */
+export interface InlineValueExpression {
+  type: 'expression';
+  range: IRange;
+  expression?: string;
+}
+
+/**
+ * Inline value information can be provided by different means:
+ * - directly as a text value (class InlineValueText).
+ * - as a name to use for a variable lookup (class InlineValueVariableLookup)
+ * - as an evaluatable expression (class InlineValueEvaluatableExpression)
+ * The InlineValue types combines all inline value types into one type.
+ * @internal
+ */
+export type InlineValue = InlineValueText | InlineValueVariableLookup | InlineValueExpression;
+
+/**
+ * The inline values provider interface defines the contract between extensions and
+ * the debugger's inline values feature.
+ * @internal
+ */
+export interface InlineValuesProvider {
+  /**
+   */
+  onDidChangeInlineValues?: Event<void> | undefined;
+  /**
+   * Provide the "inline values" for the given range and document. Multiple hovers at the same
+   * position will be merged by the editor. A hover can have a range which defaults
+   * to the word range at the position when omitted.
+   */
+  provideInlineValues(
+    model: ITextModel,
+    viewPort: Range,
+    context: InlineValueContext,
+    token: CancellationToken,
+  ): Thenable<InlineValue[]>;
+}
+// End Inline Values

package/src/common/terminal.ts

@@ -0,0 +1,163 @@
+/* eslint-disable guard-for-in */
+import { CharCode, isWindows } from '@opensumi/ide-core-common';
+
+const enum ShellType {
+  cmd,
+  powershell,
+  bash,
+}
+
+export function isWindowsDriveLetter(char0: number): boolean {
+  return (char0 >= CharCode.A && char0 <= CharCode.Z) || (char0 >= CharCode.a && char0 <= CharCode.z);
+}
+
+export function hasDriveLetter(path: string, isWindowsOS: boolean = isWindows): boolean {
+  if (isWindowsOS) {
+    return isWindowsDriveLetter(path.charCodeAt(0)) && path.charCodeAt(1) === CharCode.Colon;
+  }
+
+  return false;
+}
+
+export function getDriveLetter(path: string): string | undefined {
+  return hasDriveLetter(path) ? path[0] : undefined;
+}
+
+export function prepareCommand(
+  shell: string,
+  args: string[],
+  argsCanBeInterpretedByShell: boolean,
+  cwd?: string,
+  env?: { [key: string]: string | null },
+): string {
+  shell = shell.trim().toLowerCase();
+
+  // try to determine the shell type
+  let shellType;
+  if (shell.indexOf('powershell') >= 0 || shell.indexOf('pwsh') >= 0) {
+    shellType = ShellType.powershell;
+  } else if (shell.indexOf('cmd.exe') >= 0) {
+    shellType = ShellType.cmd;
+  } else if (shell.indexOf('bash') >= 0) {
+    shellType = ShellType.bash;
+  } else if (isWindows) {
+    shellType = ShellType.cmd; // pick a good default for Windows
+  } else {
+    shellType = ShellType.bash; // pick a good default for anything else
+  }
+
+  let quote: (s: string) => string;
+  // begin command with a space to avoid polluting shell history
+  let command = ' ';
+
+  switch (shellType) {
+    case ShellType.powershell:
+      quote = (s: string) => {
+        s = s.replace(/'/g, "''");
+        if (s.length > 0 && s.charAt(s.length - 1) === '\\') {
+          return `'${s}\\'`;
+        }
+        return `'${s}'`;
+      };
+
+      if (cwd) {
+        const driveLetter = getDriveLetter(cwd);
+        if (driveLetter) {
+          command += `${driveLetter}:; `;
+        }
+        command += `cd ${quote(cwd)}; `;
+      }
+      if (env) {
+        for (const key in env) {
+          const value = env[key];
+          if (value === null) {
+            command += `Remove-Item env:${key}; `;
+          } else {
+            command += `\${env:${key}}='${value}'; `;
+          }
+        }
+      }
+      if (args.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const arg = args.shift()!;
+        const cmd = argsCanBeInterpretedByShell ? arg : quote(arg);
+        command += cmd[0] === "'" ? `& ${cmd} ` : `${cmd} `;
+        for (const a of args) {
+          command += a === '<' || a === '>' || argsCanBeInterpretedByShell ? a : quote(a);
+          command += ' ';
+        }
+      }
+      break;
+
+    case ShellType.cmd:
+      quote = (s: string) => {
+        // Note: Wrapping in cmd /C "..." complicates the escaping.
+        // cmd /C "node -e "console.log(process.argv)" """A^>0"""" # prints "A>0"
+        // cmd /C "node -e "console.log(process.argv)" "foo^> bar"" # prints foo> bar
+        // Outside of the cmd /C, it could be a simple quoting, but here, the ^ is needed too
+        s = s.replace(/"/g, '""');
+        s = s.replace(/([><!^&|])/g, '^$1');
+        return ' "'.split('').some((char) => s.includes(char)) || s.length === 0 ? `"${s}"` : s;
+      };
+
+      if (cwd) {
+        const driveLetter = getDriveLetter(cwd);
+        if (driveLetter) {
+          command += `${driveLetter}: && `;
+        }
+        command += `cd ${quote(cwd)} && `;
+      }
+      if (env) {
+        command += 'cmd /C "';
+        for (const key in env) {
+          let value = env[key];
+          if (value === null) {
+            command += `set "${key}=" && `;
+          } else {
+            value = value.replace(/[&^|<>]/g, (s) => `^${s}`);
+            command += `set "${key}=${value}" && `;
+          }
+        }
+      }
+      for (const a of args) {
+        command += a === '<' || a === '>' || argsCanBeInterpretedByShell ? a : quote(a);
+        command += ' ';
+      }
+      if (env) {
+        command += '"';
+      }
+      break;
+
+    case ShellType.bash: {
+      quote = (s: string) => {
+        s = s.replace(/(["'\\$!><#()[\]*&^| ;{}`])/g, '\\$1');
+        return s.length === 0 ? '""' : s;
+      };
+
+      const hardQuote = (s: string) => (/[^\w@%/+=,.:^-]/.test(s) ? `'${s.replace(/'/g, "'\\''")}'` : s);
+
+      if (cwd) {
+        command += `cd ${quote(cwd)} ; `;
+      }
+      if (env) {
+        command += '/usr/bin/env';
+        for (const key in env) {
+          const value = env[key];
+          if (value === null) {
+            command += ` -u ${hardQuote(key)}`;
+          } else {
+            command += ` ${hardQuote(`${key}=${value}`)}`;
+          }
+        }
+        command += ' ';
+      }
+      for (const a of args) {
+        command += a === '<' || a === '>' || argsCanBeInterpretedByShell ? a : quote(a);
+        command += ' ';
+      }
+      break;
+    }
+  }
+
+  return command;
+}

package/src/common/types.ts

@@ -0,0 +1,86 @@
+import { IJSONSchemaSnippet } from '@opensumi/ide-core-common';
+
+export interface CallStackContext {
+  sessionId: string;
+  threadId: string;
+  frameId: string;
+}
+
+export interface IPlatformSpecificAdapterContribution {
+  program?: string;
+  args?: string[];
+  runtime?: string;
+  runtimeArgs?: string[];
+}
+
+export interface IDebuggerContribution extends IPlatformSpecificAdapterContribution {
+  type: string;
+  label?: string;
+  // debug adapter executable
+  adapterExecutableCommand?: string;
+  win?: IPlatformSpecificAdapterContribution;
+  winx86?: IPlatformSpecificAdapterContribution;
+  windows?: IPlatformSpecificAdapterContribution;
+  osx?: IPlatformSpecificAdapterContribution;
+  linux?: IPlatformSpecificAdapterContribution;
+
+  // internal
+  aiKey?: string;
+
+  // supported languages
+  languages?: string[];
+  enableBreakpointsFor?: { languageIds: string[] };
+
+  // debug configuration support
+  configurationAttributes?: any;
+  initialConfigurations?: any[];
+  configurationSnippets?: IJSONSchemaSnippet[];
+  variables?: { [key: string]: string };
+}
+
+export enum DEBUG_REPORT_NAME {
+  /**
+   * 启动调试响应耗时
+   */
+  DEBUG_SESSION_START_TIME = 'debugSessionStartTime',
+  /**
+   * preLaunchTask 耗时
+   */
+  DEBUG_PRE_LAUNCH_TASK_TIME = 'debugPreLaunchTaskTime',
+  /**
+   * 工具栏各操作响应耗时
+   */
+  DEBUG_TOOLBAR_OPERATION_TIME = 'debugToolBarOperationTime',
+  /**
+   * 工具栏各操作点击
+   */
+  DEBUG_TOOLBAR_OPERATION = 'debugToolBarOperation',
+  /**
+   * 左侧所有面板展开收起点击
+   */
+  DEBUG_PANEL_OPERATION_FOLDEXPR = 'debugPanelOperationFoldexpr',
+  /**
+   * 监听
+   */
+  DEBUG_WATCH = 'debugWatch',
+  /**
+   * 变量
+   */
+  DEBUG_VARIABLES = 'debugVariables',
+  /**
+   * 断点
+   */
+  DEBUG_BREAKPOINT = 'debugBreakpoint',
+  /**
+   * DAP 请求和响应耗时
+   */
+  DEBUG_ADAPTER_PROTOCOL_TIME = 'debugAdapterProtocolTime',
+  /**
+   * 断点命中
+   */
+  DEBUG_STOPPED = 'debugStopped',
+  /**
+   * 前端 UI 渲染层耗时
+   */
+  DEBUG_UI_FRONTEND_TIME = 'debugFrontEndTime',
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from './common';