@opensumi/ide-debug 2.21.13 → 2.22.0

package/src/browser/debug-exception-widget.tsx

@@ -0,0 +1,89 @@
+import React, { useRef } from 'react';
+import ReactDOM from 'react-dom';
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { AppConfig, ConfigProvider, useInjectable } from '@opensumi/ide-core-browser';
+import { formatLocalize, localize } from '@opensumi/ide-core-common';
+import { ICodeEditor } from '@opensumi/ide-monaco';
+import { ZoneWidget } from '@opensumi/ide-monaco-enhance';
+import { EditorOption } from '@opensumi/monaco-editor-core/esm/vs/editor/common/config/editorOptions';
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+import { IDebugExceptionInfo } from '../common';
+
+import { LinkDetector } from './debug-link-detector';
+
+import './components/debug-exception-widget.less';
+
+function ExceptionInfoContainer({ info, layout }: { info: IDebugExceptionInfo; layout: () => void }) {
+  const linkDetector = useInjectable<LinkDetector>(LinkDetector);
+  const stackTraceRef = useRef<HTMLDivElement | null>(null);
+
+  React.useEffect(() => {
+    if (stackTraceRef.current) {
+      stackTraceRef.current.appendChild(linkDetector.linkify(info.details?.stackTrace || '', true));
+    }
+    layout();
+  }, [info.details, info.details?.stackTrace, stackTraceRef]);
+
+  return (
+    <div className={'exception_widget'}>
+      <div className={'title'}>
+        <div className={'label'}>
+          {info.id
+            ? formatLocalize('debug.widget.exception.thrownWithId', info.id)
+            : localize('debug.widget.exception.thrown')}
+        </div>
+      </div>
+      {info.description ? <div className={'description'}>{info.description}</div> : null}
+      {info.details && info.details.stackTrace ? <div className={'stack_trace'} ref={stackTraceRef}></div> : null}
+    </div>
+  );
+}
+
+@Injectable({ multiple: true })
+export class DebugExceptionWidget extends ZoneWidget {
+  @Autowired(AppConfig)
+  private configContext: AppConfig;
+
+  constructor(editor: ICodeEditor, private exceptionInfo: IDebugExceptionInfo) {
+    super(editor);
+
+    this.create();
+  }
+
+  protected applyClass(): void {}
+
+  protected applyStyle(): void {}
+
+  protected _fillContainer(container: HTMLElement): void {
+    this.setCssClass('exception_widget_container');
+    const fontInfo = this.editor.getOption(EditorOption.fontInfo);
+    container.style.fontSize = `${fontInfo.fontSize}px`;
+    container.style.lineHeight = `${fontInfo.lineHeight}px`;
+    container.tabIndex = 0;
+
+    ReactDOM.render(
+      <ConfigProvider value={this.configContext}>
+        <ExceptionInfoContainer
+          info={this.exceptionInfo}
+          layout={() => this.layout(undefined)}
+        ></ExceptionInfoContainer>
+      </ConfigProvider>,
+      container,
+    );
+  }
+
+  public layout(_info: monaco.editor.EditorLayoutInfo | undefined): void {
+    this._container!.style.height = 'initial';
+    const lineHeight = this.editor.getOption(EditorOption.lineHeight);
+    const arrowHeight = Math.round(lineHeight / 3);
+    const computedLinesNumber = Math.ceil((this._container!.offsetHeight + arrowHeight) / lineHeight);
+
+    this._relayout(computedLinesNumber);
+  }
+
+  public focus(): void {
+    this._container.focus();
+  }
+}

package/src/browser/debug-link-detector.ts

@@ -0,0 +1,234 @@
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Some code copied and modified from https://github.com/microsoft/vscode/blob/94c9ea46838a9a619aeafb7e8afd1170c967bb55/src/vs/workbench/contrib/debug/browser/linkDetector.ts
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { Schemes, IOpenerService, OS, formatLocalize } from '@opensumi/ide-core-browser';
+import { URI, IRange, isWindows, isMacintosh, path as osPath, OperatingSystem } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { IFileServiceClient, FileStat } from '@opensumi/ide-file-service/lib/common';
+import { IWorkspaceFolder } from '@opensumi/monaco-editor-core/esm/vs/platform/workspace/common/workspace';
+
+import styles from './view/console/debug-console.module.less';
+
+const CONTROL_CODES = '\\u0000-\\u0020\\u007f-\\u009f';
+const WEB_LINK_REGEX = new RegExp(
+  '(?:[a-zA-Z][a-zA-Z0-9+.-]{2,}:\\/\\/|data:|www\\.)[^\\s' +
+    CONTROL_CODES +
+    '"]{2,}[^\\s' +
+    CONTROL_CODES +
+    '"\')}\\],:;.!?]',
+  'ug',
+);
+
+const WIN_ABSOLUTE_PATH = /(?:[a-zA-Z]:(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_RELATIVE_PATH = /(?:(?:\~|\.)(?:(?:\\|\/)[\w\.-]*)+)/;
+const WIN_PATH = new RegExp(`(${WIN_ABSOLUTE_PATH.source}|${WIN_RELATIVE_PATH.source})`);
+const POSIX_PATH = /((?:\~|\.)?(?:\/[\w\.-]*)+)/;
+const LINE_COLUMN = /(?:\:([\d]+))?(?:\:([\d]+))?/;
+const PATH_LINK_REGEX = new RegExp(`${isWindows ? WIN_PATH.source : POSIX_PATH.source}${LINE_COLUMN.source}`, 'g');
+
+const MAX_LENGTH = 2000;
+
+type LinkKind = 'web' | 'path' | 'text';
+interface LinkPart {
+  kind: LinkKind;
+  value: string;
+  captures: string[];
+}
+
+@Injectable({ multiple: true })
+export class LinkDetector {
+  @Autowired(WorkbenchEditorService)
+  private readonly workbenchEditorService: WorkbenchEditorService;
+
+  @Autowired(IFileServiceClient)
+  private readonly fileServiceClient: IFileServiceClient;
+
+  @Autowired(IOpenerService)
+  private readonly openerService: IOpenerService;
+
+  linkify(text: string, splitLines?: boolean, workspaceFolder?: IWorkspaceFolder): HTMLElement {
+    if (splitLines) {
+      const lines = text.split('\n');
+      for (let i = 0; i < lines.length - 1; i++) {
+        lines[i] = lines[i] + '\n';
+      }
+      if (!lines[lines.length - 1]) {
+        lines.pop();
+      }
+      const elements = lines.map((line) => this.linkify(line, false, workspaceFolder));
+      if (elements.length === 1) {
+        return elements[0];
+      }
+      const container = document.createElement('span');
+      elements.forEach((e) => container.appendChild(e));
+      return container;
+    }
+
+    const container = document.createElement('span');
+    for (const part of this.detectLinks(text)) {
+      try {
+        switch (part.kind) {
+          case 'text':
+            container.appendChild(document.createTextNode(part.value));
+            break;
+          case 'web':
+            container.appendChild(this.createWebLink(part.value));
+            break;
+          case 'path': {
+            const path = part.captures[0];
+            const lineNumber = part.captures[1] ? Number(part.captures[1]) : 0;
+            const columnNumber = part.captures[2] ? Number(part.captures[2]) : 0;
+            container.appendChild(this.createPathLink(part.value, path, lineNumber, columnNumber, workspaceFolder));
+            break;
+          }
+        }
+      } catch (e) {
+        container.appendChild(document.createTextNode(part.value));
+      }
+    }
+    return container;
+  }
+
+  private createWebLink(url: string): Node {
+    const link = this.createLink(url);
+
+    const uri = URI.parse(url);
+    this.decorateLink(link, async () => {
+      if (uri.scheme === Schemes.file) {
+        const fsPath = uri.toString();
+        const path = OS.type() === OperatingSystem.Windows ? osPath.win32 : osPath.posix;
+        const fileUrl = osPath.normalize(
+          path.sep === osPath.posix.sep && isWindows ? fsPath.replace(/\\/g, osPath.posix.sep) : fsPath,
+        );
+
+        await this.workbenchEditorService.open(URI.parse(fileUrl));
+        return;
+      }
+
+      this.openerService.open(url);
+    });
+
+    return link;
+  }
+
+  private createPathLink(
+    text: string,
+    path: string,
+    lineNumber: number,
+    columnNumber: number,
+    workspaceFolder: IWorkspaceFolder | undefined,
+  ): Node {
+    if (path[0] === '/' && path[1] === '/') {
+      return document.createTextNode(text);
+    }
+
+    if (path[0] === '.') {
+      if (!workspaceFolder) {
+        return document.createTextNode(text);
+      }
+      const uri = workspaceFolder.toResource(path);
+      const link = this.createLink(text);
+      this.decorateLink(link, () => {
+        this.workbenchEditorService.open(URI.parse(uri.toString()));
+      });
+      return link;
+    }
+
+    const link = this.createLink(text);
+    link.tabIndex = 0;
+    const uri = URI.file(osPath.normalize(path));
+    this.fileServiceClient.getFileStat(uri.toString()).then((stat: FileStat | undefined) => {
+      if (!stat || (stat && stat.isDirectory)) {
+        return;
+      }
+
+      this.decorateLink(link, () => {
+        this.workbenchEditorService.open(URI.parse(uri.toString()), {
+          range: {
+            startColumn: columnNumber,
+            startLineNumber: lineNumber,
+            endLineNumber: lineNumber,
+            endColumn: columnNumber,
+          } as IRange,
+        });
+      });
+    });
+    return link;
+  }
+
+  private createLink(text: string): HTMLElement {
+    const link = document.createElement('a');
+    link.textContent = text;
+    return link;
+  }
+
+  private decorateLink(link: HTMLElement, onClick: (preserveFocus: boolean) => void) {
+    link.classList.add(styles.link);
+    link.title = formatLocalize('debug.console.followLink', isMacintosh ? 'Cmd' : 'Ctrl');
+    link.onmousemove = (event) => {
+      link.classList.toggle(styles.pointer, isMacintosh ? event.metaKey : event.ctrlKey);
+    };
+    link.onmouseleave = () => link.classList.remove(styles.pointer);
+    link.onclick = (event) => {
+      const selection = window.getSelection();
+      if (!selection || selection.type === 'Range') {
+        return;
+      }
+      if (!(isMacintosh ? event.metaKey : event.ctrlKey)) {
+        return;
+      }
+
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      onClick(false);
+    };
+  }
+
+  private detectLinks(text: string): LinkPart[] {
+    if (!text) {
+      return [];
+    }
+    if (text.length > MAX_LENGTH) {
+      return [{ kind: 'text', value: text, captures: [] }];
+    }
+
+    const regexes: RegExp[] = [WEB_LINK_REGEX, PATH_LINK_REGEX];
+    const kinds: LinkKind[] = ['web', 'path'];
+    const result: LinkPart[] = [];
+
+    const splitOne = (text: string, regexIndex: number) => {
+      if (regexIndex >= regexes.length) {
+        result.push({ value: text, kind: 'text', captures: [] });
+        return;
+      }
+      const regex = regexes[regexIndex];
+      let currentIndex = 0;
+      let match: RegExpExecArray | null;
+      regex.lastIndex = 0;
+      while ((match = regex.exec(text)) !== null) {
+        const stringBeforeMatch = text.substring(currentIndex, match.index);
+        if (stringBeforeMatch) {
+          splitOne(stringBeforeMatch, regexIndex + 1);
+        }
+        const value = match[0];
+        result.push({
+          value,
+          kind: kinds[regexIndex],
+          captures: match.slice(1),
+        });
+        currentIndex = match.index + value.length;
+      }
+      const stringAfterMatches = text.substring(currentIndex);
+      if (stringAfterMatches) {
+        splitOne(stringAfterMatches, regexIndex + 1);
+      }
+    };
+
+    splitOne(text, 0);
+    return result;
+  }
+}

package/src/browser/debug-memory.ts

@@ -0,0 +1,220 @@
+import clamp from 'lodash/clamp';
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { path } from '@opensumi/ide-core-common';
+import {
+  Event,
+  FileSystemProvider,
+  FileChangeEvent,
+  FileStat,
+  FileSystemProviderCapabilities,
+  FileType,
+  Uri,
+  BinaryBuffer,
+  Emitter,
+  Disposable,
+  ILogger,
+} from '@opensumi/ide-core-common';
+
+
+import {
+  DEBUG_MEMORY_SCHEME,
+  IDebugSession,
+  IDebugSessionManager,
+  IMemoryInvalidationEvent,
+  IMemoryRegion,
+  MemoryRange,
+  MemoryRangeType,
+} from '../common';
+
+import { DebugSessionManager } from './debug-session-manager';
+
+const { Path } = path;
+
+@Injectable()
+export class DebugMemoryFileSystemProvider implements FileSystemProvider {
+  @Autowired(IDebugSessionManager)
+  protected readonly debugSessionManager: DebugSessionManager;
+
+  @Autowired(ILogger)
+  protected readonly logger: ILogger;
+
+  private memoryFdCounter = 0;
+  private readonly changeEmitter = new Emitter<FileChangeEvent>();
+  private readonly fdMemory = new Map<number, { session: IDebugSession; region: IMemoryRegion }>();
+
+  public readonly capabilities: FileSystemProviderCapabilities =
+    0 | FileSystemProviderCapabilities.PathCaseSensitive | FileSystemProviderCapabilities.FileOpenReadWriteClose;
+
+  public readonly onDidChangeCapabilities = Event.None;
+
+  public onDidChangeFile: Event<FileChangeEvent> = this.changeEmitter.event;
+
+  public stat(uri: Uri): Promise<void | FileStat> {
+    return Promise.resolve({
+      type: FileType.File,
+      uri: uri.toString(),
+      mtime: 0,
+      ctime: 0,
+      size: 0,
+      lastModification: 0,
+      isDirectory: false,
+    });
+  }
+
+  public async readFile(uri: Uri): Promise<void | Uint8Array> {
+    const parse = this.parseUri(uri);
+    if (!parse) {
+      return this.toBuffer('');
+    }
+
+    if (!parse.offset) {
+      return this.toBuffer('');
+    }
+
+    const { session, memoryReference, offset } = parse;
+
+    const data = new Uint8Array(offset.toOffset - offset.fromOffset);
+
+    const fd = this.memoryFdCounter++;
+    let region = session.getMemory(memoryReference);
+    if (offset) {
+      region = new MemoryRegionView(region, offset);
+    }
+
+    this.fdMemory.set(fd, { session, region });
+    await this.read(fd, offset.fromOffset, data, 0, data.length);
+    return data;
+  }
+
+  public async read(fd: number, pos: number, data: Uint8Array, offset: number, length: number): Promise<number | void> {
+    const memory = this.fdMemory.get(fd);
+    if (!memory) {
+      return;
+    }
+
+    const ranges = await memory.region.read(pos, length);
+    let readSoFar = 0;
+    for (const range of ranges) {
+      switch (range.type) {
+        case MemoryRangeType.Unreadable:
+          return readSoFar;
+        case MemoryRangeType.Error:
+          if (readSoFar > 0) {
+            return readSoFar;
+          } else {
+            return this.logger.error(range.error);
+          }
+        case MemoryRangeType.Valid: {
+          const start = Math.max(0, pos - range.offset);
+          const toWrite = range.data.slice(start, Math.min(range.data.byteLength, start + (length - readSoFar)));
+          data.set(toWrite.buffer, offset + readSoFar);
+          readSoFar += toWrite.byteLength;
+          break;
+        }
+        default:
+          this.logger.log(range);
+      }
+    }
+
+    return readSoFar;
+  }
+
+  private toBuffer(s: string): Uint8Array {
+    return BinaryBuffer.fromString(s).buffer;
+  }
+
+  private parseUri(uri: Uri) {
+    if (uri.scheme !== DEBUG_MEMORY_SCHEME) {
+      return;
+    }
+
+    const session = this.debugSessionManager.sessions.find((s) => s.id.toLowerCase() === uri.authority.toLowerCase());
+    if (!session) {
+      return;
+    }
+
+    let offset: { fromOffset: number; toOffset: number } | undefined;
+    /**
+     * query 参数是 hex-editor 插件通过覆盖了 debug file accessor 处理过后添加上的，形如
+     * ?range=0:131072
+     */
+    const rangeMatch = /range=([0-9]+):([0-9]+)/.exec(uri.query);
+    if (rangeMatch) {
+      offset = { fromOffset: Number(rangeMatch[1]), toOffset: Number(rangeMatch[2]) };
+    }
+
+    const [, memoryReference] = uri.path.split(Path.separator);
+
+    return {
+      session,
+      offset,
+      readOnly: !session.capabilities.supportsWriteMemoryRequest,
+      sessionId: uri.authority,
+      memoryReference: decodeURIComponent(memoryReference),
+    };
+  }
+
+  public readDirectory(): never {
+    throw new Error('Not allowed');
+  }
+
+  public createDirectory(): never {
+    throw new Error('Not allowed');
+  }
+
+  public rename(): never {
+    throw new Error('Not allowed');
+  }
+
+  public delete(): never {
+    throw new Error('Not allowed');
+  }
+
+  public watch(): never {
+    throw new Error('Not allowed');
+  }
+
+  /**
+   * 目前仅支持读，不支持写
+   */
+  public writeFile(): never {
+    throw new Error('Method not implemented.');
+  }
+}
+
+class MemoryRegionView extends Disposable implements IMemoryRegion {
+  private readonly invalidateEmitter = new Emitter<IMemoryInvalidationEvent>();
+
+  public readonly onDidInvalidate = this.invalidateEmitter.event;
+  public readonly writable: boolean;
+  private readonly width = this.range.toOffset - this.range.fromOffset;
+
+  constructor(private readonly parent: IMemoryRegion, public readonly range: { fromOffset: number; toOffset: number }) {
+    super();
+    this.writable = parent.writable;
+
+    this.registerDispose(parent);
+    this.registerDispose(
+      parent.onDidInvalidate((e) => {
+        const fromOffset = clamp(e.fromOffset - range.fromOffset, 0, this.width);
+        const toOffset = clamp(e.toOffset - range.fromOffset, 0, this.width);
+        if (toOffset > fromOffset) {
+          this.invalidateEmitter.fire({ fromOffset, toOffset });
+        }
+      }),
+    );
+  }
+
+  public read(fromOffset: number, toOffset: number): Promise<MemoryRange[]> {
+    if (fromOffset < 0) {
+      throw new RangeError(`Invalid fromOffset: ${fromOffset}`);
+    }
+
+    return this.parent.read(this.range.fromOffset + fromOffset, this.range.fromOffset + Math.min(toOffset, this.width));
+  }
+
+  public write(offset: number, data: BinaryBuffer): Promise<number> {
+    return this.parent.write(this.range.fromOffset + offset, data);
+  }
+}

package/src/browser/debug-preferences.ts

@@ -0,0 +1,70 @@
+import { Injector } from '@opensumi/di';
+import {
+  PreferenceSchema,
+  PreferenceProxy,
+  PreferenceService,
+  createPreferenceProxy,
+  PreferenceContribution,
+  localize,
+} from '@opensumi/ide-core-browser';
+
+export const debugPreferencesSchema: PreferenceSchema = {
+  type: 'object',
+  properties: {
+    'debug.trace': {
+      type: 'boolean',
+      default: false,
+      description: localize('preference.debug.trace'),
+    },
+    'debug.debugViewLocation': {
+      enum: ['default', 'left', 'right', 'bottom'],
+      default: 'default',
+      description: localize('preference.debug.debugViewLocation'),
+    },
+    'debug.openDebug': {
+      enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart', 'openOnDebugBreak'],
+      default: 'openOnDebugBreak',
+      description: localize('preference.debug.openDebug'),
+    },
+    'debug.internalConsoleOptions': {
+      enum: ['neverOpen', 'openOnSessionStart', 'openOnFirstSessionStart'],
+      default: 'openOnFirstSessionStart',
+      description: localize('preference.debug.internalConsoleOptions'),
+    },
+    'debug.allowBreakpointsEverywhere': {
+      type: 'boolean',
+      description: localize('preference.debug.allowBreakpointsEverywhere'),
+      default: false,
+    },
+  },
+};
+
+export class IDebugConfiguration {
+  'debug.trace': boolean;
+  'debug.debugViewLocation': 'default' | 'left' | 'right' | 'bottom';
+  'debug.openDebug': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart' | 'openOnDebugBreak';
+  'debug.internalConsoleOptions': 'neverOpen' | 'openOnSessionStart' | 'openOnFirstSessionStart';
+  'debug.allowBreakpointsEverywhere': boolean;
+}
+
+export const DebugPreferences = Symbol('DebugPreferences');
+export type DebugPreferences = PreferenceProxy<IDebugConfiguration>;
+
+export function createDebugPreferences(preferences: PreferenceService): DebugPreferences {
+  return createPreferenceProxy(preferences, debugPreferencesSchema);
+}
+
+export function injectDebugPreferences(injector: Injector): void {
+  injector.addProviders({
+    token: DebugPreferences,
+    useFactory: (injector: Injector) => {
+      const preferences = injector.get(PreferenceService);
+      return createDebugPreferences(preferences);
+    },
+  });
+
+  injector.addProviders({
+    token: PreferenceContribution,
+    useValue: { schema: debugPreferencesSchema },
+  });
+}