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

package/src/browser/view/console/debug-console.view.tsx

@@ -0,0 +1,500 @@
+import cls from 'classnames';
+import debounce from 'lodash/debounce';
+import { observer } from 'mobx-react-lite';
+import React from 'react';
+
+import {
+  RecycleTree,
+  IRecycleTreeHandle,
+  TreeNodeType,
+  INodeRendererWrapProps,
+  ClasslistComposite,
+  INodeRendererProps,
+  CompositeTreeNode,
+  TreeNode,
+  TreeNodeEvent,
+} from '@opensumi/ide-components';
+import { Loading } from '@opensumi/ide-components';
+import { useInjectable, ViewState, getIcon } from '@opensumi/ide-core-browser';
+import { PreferenceService, PreferenceChange, CoreConfiguration } from '@opensumi/ide-core-browser';
+import { Disposable } from '@opensumi/ide-core-common';
+
+import { LinkDetector } from '../../debug-link-detector';
+import { CharWidthReader } from '../../debugUtils';
+import { DebugConsoleNode, AnsiConsoleNode, DebugVariableContainer, TreeWithLinkWrapper } from '../../tree';
+
+import { DebugConsoleFilterService } from './debug-console-filter.service';
+import { IDebugConsoleModel } from './debug-console-tree.model.service';
+import styles from './debug-console.module.less';
+import { DebugConsoleService } from './debug-console.service';
+
+declare const ResizeObserver: any;
+
+export const DebugConsoleView = observer(({ viewState }: { viewState: ViewState }) => {
+  const debugConsoleService = useInjectable<DebugConsoleService>(DebugConsoleService);
+  const debugConsoleFilterService = useInjectable<DebugConsoleFilterService>(DebugConsoleFilterService);
+  const preferenceService = useInjectable<PreferenceService>(PreferenceService);
+  const { consoleModel } = debugConsoleService;
+  const debugInputRef = React.createRef<HTMLDivElement>();
+  const { height, width } = viewState;
+  const [model, setModel] = React.useState<IDebugConsoleModel>();
+  const [consoleHeight, setConsoleHeight] = React.useState<number>(26);
+  const [filterValue, setFilterValue] = React.useState<string>('');
+  const [isWordWrap, setIsWordWrap] = React.useState<boolean>(true);
+  const disposer = new Disposable();
+  const wrapperRef: React.RefObject<HTMLDivElement> = React.createRef();
+
+  React.useEffect(() => {
+    debugConsoleService.init(debugInputRef.current);
+  }, [debugInputRef.current]);
+
+  React.useEffect(() => {
+    disposer.addDispose(
+      consoleModel.onDidUpdateTreeModel(async (model: IDebugConsoleModel) => {
+        if (model) {
+          await model.treeModel.ensureReady;
+          disposer.addDispose(
+            model.treeModel.root.watcher.on(TreeNodeEvent.WillChangeExpansionState, () => {
+              consoleModel.treeHandle.layoutItem();
+            }),
+          );
+        }
+        setModel(model);
+      }),
+    );
+
+    disposer.addDispose(
+      debugConsoleFilterService.onDidValueChange((value: string) => {
+        setFilterValue(value);
+      }),
+    );
+
+    disposer.addDispose(
+      debugConsoleService.onInputHeightChange((height: number) => {
+        setConsoleHeight(height);
+      }),
+    );
+
+    disposer.addDispose(
+      preferenceService.onSpecificPreferenceChange('debug.console.wordWrap', (change: PreferenceChange) => {
+        const { newValue } = change;
+        setIsWordWrap(newValue);
+      }),
+    );
+
+    setIsWordWrap(!!preferenceService.get('debug.console.wordWrap', isWordWrap));
+
+    return () => {
+      consoleModel.removeNodeDecoration();
+      disposer.dispose();
+    };
+  }, []);
+
+  React.useEffect(() => {
+    if (wrapperRef.current && isWordWrap) {
+      let animationFrame: number;
+      const layoutDebounce = debounce(() => consoleModel.treeHandle?.layoutItem(), 10);
+      const resizeObserver = new ResizeObserver(() => {
+        animationFrame = window.requestAnimationFrame(() => layoutDebounce());
+      });
+      resizeObserver.observe(wrapperRef.current);
+      return () => {
+        if (wrapperRef.current) {
+          resizeObserver?.unobserve(wrapperRef.current);
+        }
+        if (animationFrame) {
+          window.cancelAnimationFrame(animationFrame);
+        }
+      };
+    }
+  }, [wrapperRef.current]);
+
+  React.useEffect(() => {
+    if (model && isWordWrap) {
+      disposer.addDispose(
+        model.treeModel.state.onChangeScrollOffset(() => {
+          consoleModel.treeHandle.layoutItem();
+        }),
+      );
+    }
+  }, [model, isWordWrap]);
+
+  const handleTreeReady = (handle: IRecycleTreeHandle) => {
+    consoleModel.handleTreeHandler({
+      ...handle,
+      getModel: () => model?.treeModel!,
+      hasDirectFocus: () => wrapperRef.current === document.activeElement,
+    });
+  };
+
+  const handleTwistierClick = (ev: React.MouseEvent, item: AnsiConsoleNode | DebugConsoleNode, type: TreeNodeType) => {
+    const selection = window.getSelection();
+    if (selection && selection.type === 'Range' && selection.rangeCount > 0) {
+      // 当用户有选中日志内容时阻止冒泡，防止在选中之后 focus 到 debug console input
+      ev.stopPropagation();
+    }
+
+    const { handleTwistierClick } = consoleModel;
+    if (!item) {
+      return;
+    }
+    handleTwistierClick(item, type);
+  };
+
+  const handlerContextMenu = (ev: React.MouseEvent, node: AnsiConsoleNode | DebugConsoleNode) => {
+    const { handleContextMenu } = consoleModel;
+    handleContextMenu(ev, node);
+  };
+
+  const handleOuterContextMenu = (ev: React.MouseEvent) => {
+    const { handleContextMenu } = consoleModel;
+    // 空白区域右键菜单
+    handleContextMenu(ev);
+  };
+
+  const handleConsoleClick = (ev: React.MouseEvent) => {
+    // 空白区域点击，取消焦点状态
+    const { enactiveNodeDecoration } = consoleModel;
+    enactiveNodeDecoration();
+
+    debugConsoleService.focusInput();
+  };
+
+  const handleOuterBlur = (ev: React.FocusEvent) => {
+    // 空白区域点击，取消焦点状态
+    const { enactiveNodeDecoration } = consoleModel;
+    enactiveNodeDecoration();
+  };
+
+  const filterMode = (): CoreConfiguration['debug.console.filter.mode'] => 'filter';
+
+  const fuzzyOptions = () => ({
+    pre: '<match>',
+    post: '</match>',
+    extract: (node: DebugConsoleNode | AnsiConsoleNode | DebugVariableContainer) =>
+      node.description ? node.description : node.name,
+  });
+
+  const renderOutputNode = React.useCallback(
+    (props: INodeRendererWrapProps) => {
+      const decorations = consoleModel.decorations.getDecorations(props.item as any);
+      return (
+        <DebugConsoleRenderedNode
+          item={props.item}
+          itemType={props.itemType}
+          decorations={decorations}
+          filterValue={filterValue}
+          filterMode={filterMode()}
+          onClick={handleTwistierClick}
+          onTwistierClick={handleTwistierClick}
+          onContextMenu={handlerContextMenu}
+          defaultLeftPadding={14}
+          isWordWrap={isWordWrap}
+          leftPadding={8}
+        />
+      );
+    },
+    [model, filterValue, isWordWrap],
+  );
+
+  const renderOutputContent = () => {
+    if (!model) {
+      return null;
+    }
+    return (
+      <RecycleTree
+        height={Math.max(height - consoleHeight, 26)}
+        width={width}
+        itemHeight={DEBUG_CONSOLE_TREE_NODE_HEIGHT}
+        onReady={handleTreeReady}
+        overScanCount={10}
+        filter={filterMode() === 'filter' ? filterValue : ''}
+        filterProvider={{ fuzzyOptions, filterAlways: true }}
+        model={model!.treeModel}
+        overflow={'auto'}
+        supportDynamicHeights={isWordWrap}
+      >
+        {renderOutputNode}
+      </RecycleTree>
+    );
+  };
+
+  return (
+    <div className={styles.debug_console} onContextMenu={handleOuterContextMenu} onClick={handleConsoleClick}>
+      <div
+        className={styles.debug_console_output}
+        tabIndex={-1}
+        onBlur={handleOuterBlur}
+        ref={wrapperRef}
+        data-name={DEBUG_CONSOLE_TREE_FIELD_NAME}
+      >
+        {renderOutputContent()}
+      </div>
+      <div className={styles.variable_repl_bar} style={{ maxHeight: height - 26 + 'px' }}>
+        <div className={styles.variable_repl_bar_icon}>
+          <span className={getIcon('right')}></span>
+        </div>
+        <div className={styles.variable_repl_editor} ref={debugInputRef}></div>
+      </div>
+    </div>
+  );
+});
+
+export interface IDebugConsoleNodeProps {
+  item: any;
+  defaultLeftPadding?: number;
+  leftPadding?: number;
+  filterValue?: string;
+  filterMode?: CoreConfiguration['debug.console.filter.mode'];
+  decorations?: ClasslistComposite;
+  isWordWrap?: boolean;
+  onClick: (ev: React.MouseEvent, item: AnsiConsoleNode | DebugConsoleNode | TreeNode, type: TreeNodeType) => void;
+  onTwistierClick: (
+    ev: React.MouseEvent,
+    item: AnsiConsoleNode | DebugConsoleNode | TreeNode,
+    type: TreeNodeType,
+  ) => void;
+  onContextMenu?: (
+    ev: React.MouseEvent,
+    item: AnsiConsoleNode | DebugConsoleNode | TreeNode,
+    type: TreeNodeType,
+  ) => void;
+}
+
+export type IDebugConsoleNodeRenderedProps = IDebugConsoleNodeProps & INodeRendererProps;
+
+export const DebugConsoleRenderedNode: React.FC<IDebugConsoleNodeRenderedProps> = ({
+  item,
+  decorations,
+  defaultLeftPadding,
+  leftPadding,
+  filterMode,
+  filterValue,
+  onClick,
+  onTwistierClick,
+  onContextMenu,
+  isWordWrap,
+  itemType,
+}: IDebugConsoleNodeRenderedProps) => {
+  const debugConsoleFilterService = useInjectable<DebugConsoleFilterService>(DebugConsoleFilterService);
+  const linkDetector: LinkDetector = useInjectable<LinkDetector>(LinkDetector);
+  const [computedStyle, setComputedStyle] = React.useState<string>();
+
+  React.useEffect(() => {
+    const computed = window.getComputedStyle(
+      AnsiConsoleNode.is(item) ? item.el : linkDetector.linkify((item as DebugConsoleNode).description),
+      null,
+    );
+    const fontStyle = `${computed.fontStyle} ${computed.fontWeight} ${computed.fontSize}/${computed.lineHeight} ${computed.fontFamily}`;
+    setComputedStyle(fontStyle);
+  }, [item]);
+
+  const handleClick = (ev: React.MouseEvent) => {
+    onClick(ev, item, CompositeTreeNode.is(item) ? TreeNodeType.CompositeTreeNode : TreeNodeType.TreeNode);
+  };
+
+  const handleContextMenu = (ev: React.MouseEvent) => {
+    if (ev.nativeEvent.which === 0) {
+      return;
+    }
+    if (itemType === TreeNodeType.TreeNode || itemType === TreeNodeType.CompositeTreeNode) {
+      onContextMenu && onContextMenu(ev, item as AnsiConsoleNode, itemType);
+    }
+  };
+
+  const acquireVariableName = () => {
+    if (AnsiConsoleNode.is(item)) {
+      return '';
+    }
+    return (
+      (DebugConsoleNode.is(item) ? '' : (item as any).name) +
+      (item.description && !DebugConsoleNode.is(item) ? ': ' : '')
+    );
+  };
+
+  const getTextWidth = (char: string, font: string): number => CharWidthReader.getInstance().getCharWidth(char, font);
+
+  const renderSelectionFilter = React.useCallback(() => {
+    if (!computedStyle) {
+      return;
+    }
+
+    const desc = acquireVariableName() + item.description;
+    const matchers = debugConsoleFilterService.findMatches(desc || '');
+    const toNumFixed = (n: number) => Number(n.toFixed(4));
+
+    const calcWidth = (index: number, count: number) =>
+      Array.from({ length: count }, (_, i) => i).reduce(
+        (pre: number, cur: number) => pre + toNumFixed(getTextWidth(desc.charAt(index + cur), computedStyle)),
+        0,
+      );
+
+    // 在每次计算 left 的时候临时存储上一次的结果（这在每次计算大量日志内容的时候很有用）
+    const cacheLeftMap: Map<number, { startIndex: number; left: number }> = new Map();
+
+    const calcLeft = (startIndex: number, preIndex: number) => {
+      if (startIndex > 0) {
+        const excute = (len: number, start: number, initial: number) =>
+          Array.from({ length: len - start }, (_, i) => start + i).reduce(
+            (pre: number, cur: number) => toNumFixed(pre + getTextWidth(desc.charAt(cur), computedStyle)),
+            initial,
+          );
+
+        let left: number;
+        if (preIndex !== 0 && cacheLeftMap.has(matchers[preIndex].startIndex)) {
+          const pre = cacheLeftMap.get(matchers[preIndex].startIndex)!;
+          left = excute(startIndex, pre.startIndex, pre.left);
+        } else {
+          left = excute(startIndex, 0, 0);
+        }
+        cacheLeftMap.set(startIndex, { startIndex, left });
+        return left;
+      }
+      return 0;
+    };
+
+    const matStyles: React.CSSProperties[] = matchers.map((m, i) => ({
+      height: 16,
+      top: 3,
+      width: calcWidth(m.startIndex, m.count),
+      left: calcLeft(m.startIndex, Math.max(0, i - 1)),
+    }));
+
+    return matStyles.map((s) => <div key={s.left} className={styles.block} style={s}></div>);
+  }, [filterValue, computedStyle]);
+
+  const renderDisplayName = (node: DebugConsoleNode | AnsiConsoleNode) => {
+    if (AnsiConsoleNode.is(node)) {
+      return null;
+    }
+    if (node instanceof DebugConsoleNode && node.variablesReference === 0) {
+      return null;
+    }
+    return (
+      <div
+        className={cls(
+          styles.debug_console_node_segment,
+          !DebugConsoleNode.is(node) && styles.debug_console_node_displayname,
+          styles.debug_console_variable,
+          (item as DebugConsoleNode).description ? styles.name : styles.info,
+        )}
+      >
+        {<TreeWithLinkWrapper html={linkDetector.linkify(acquireVariableName())}></TreeWithLinkWrapper>}
+      </div>
+    );
+  };
+
+  const renderDescription = (node: DebugConsoleNode | AnsiConsoleNode) => {
+    const booleanRegex = /^true|false$/i;
+    const stringRegex = /^(['"]).*\1$/;
+    const description = (node as DebugConsoleNode).description || '';
+    const addonClass = [styles.debug_console_variable];
+    if (AnsiConsoleNode.is(node)) {
+      return (
+        <div className={cls(styles.debug_console_node_segment, styles.debug_console_node_displayname)}>
+          {(node as AnsiConsoleNode).template()}
+        </div>
+      );
+    }
+    if (item.variableType === 'number' || item.variableType === 'boolean' || item.variableType === 'string') {
+      addonClass.push(styles[item.variableType]);
+    } else if (!isNaN(+description)) {
+      addonClass.push(styles.number);
+    } else if (booleanRegex.test(description)) {
+      addonClass.push(styles.boolean);
+    } else if (stringRegex.test(description)) {
+      addonClass.push(styles.string);
+    }
+    return (
+      <div
+        className={cls(styles.debug_console_node_segment_grow, styles.debug_console_node_description, ...addonClass)}
+      >
+        <TreeWithLinkWrapper html={linkDetector.linkify(description)}></TreeWithLinkWrapper>
+      </div>
+    );
+  };
+
+  const renderStatusTail = () => (
+    <div className={cls(styles.debug_console_node_segment, styles.debug_console_node_tail)}>{renderBadge()}</div>
+  );
+
+  const renderBadge = () => {
+    if (AnsiConsoleNode.is(item)) {
+      return (
+        <div className={styles.debug_console_node_status} title={item.source?.path}>
+          {item.source?.name ? `${item.source?.name}:${item.line}` : ''}
+        </div>
+      );
+    }
+    return <div className={styles.debug_console_node_status}>{item.badge}</div>;
+  };
+
+  const getItemTooltip = () => {
+    const tooltip = item.tooltip;
+    return tooltip;
+  };
+
+  const renderToggle = (node: DebugConsoleNode, clickHandler: any) => {
+    const handleTwiceClick = (ev: React.MouseEvent) => {
+      clickHandler(ev, node, itemType);
+    };
+    if (decorations && decorations?.classlist.indexOf(styles.mod_loading) > -1) {
+      return (
+        <div className={cls(styles.debug_console_node_segment, styles.expansion_toggle)}>
+          <Loading />
+        </div>
+      );
+    }
+    if (node instanceof DebugConsoleNode && (node as DebugConsoleNode).variablesReference === 0) {
+      return null;
+    }
+
+    return (
+      <div
+        onClick={handleTwiceClick}
+        className={cls(styles.debug_console_node_segment, styles.expansion_toggle, getIcon('right'), {
+          [`${styles.mod_collapsed}`]: !(node as DebugConsoleNode).expanded,
+        })}
+      />
+    );
+  };
+
+  const renderTwice = (item) => {
+    if (CompositeTreeNode.is(item)) {
+      return renderToggle(item as DebugConsoleNode, onTwistierClick);
+    }
+  };
+
+  return (
+    <div
+      key={item.id}
+      onClick={handleClick}
+      onContextMenu={handleContextMenu}
+      title={getItemTooltip()}
+      className={cls(styles.debug_console_node, decorations ? decorations.classlist : null)}
+      style={{
+        paddingLeft: `${(defaultLeftPadding || 8) + (item.depth || 0) * (leftPadding || 0)}px`,
+      }}
+      data-id={item.id}
+    >
+      <div className={cls(styles.debug_console_node_content)}>
+        {renderTwice(item)}
+        <div
+          className={styles.debug_console_node_overflow_wrap}
+          style={{
+            whiteSpace: isWordWrap ? 'pre-wrap' : 'nowrap',
+            cursor: item instanceof DebugVariableContainer ? 'pointer' : 'initial',
+          }}
+        >
+          {renderDisplayName(item)}
+          {renderDescription(item)}
+        </div>
+        {renderStatusTail()}
+      </div>
+      <div className={styles.debug_console_selection}>{filterMode === 'matcher' && renderSelectionFilter()}</div>
+    </div>
+  );
+};
+
+export const DEBUG_CONSOLE_TREE_NODE_HEIGHT = 22;
+export const DEBUG_CONSOLE_TREE_FIELD_NAME = 'DEBUG_CONSOLE_TREE_FIELD';

package/src/browser/view/debug-view-model.ts

@@ -0,0 +1,182 @@
+/** ******************************************************************************
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+// Some code copied and modified from https://github.com/eclipse-theia/theia/tree/v1.14.0/packages/debug/src/browser/view/debug-view-model.ts
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI, IDisposable, DisposableCollection, Event, Emitter } from '@opensumi/ide-core-browser';
+
+import { DebugState, IDebugSessionManager } from '../../common/debug-session';
+import { DebugSession } from '../debug-session';
+import { DebugSessionManager } from '../debug-session-manager';
+import { DebugStackFrame } from '../model/debug-stack-frame';
+import { DebugThread } from '../model/debug-thread';
+
+
+@Injectable()
+export class DebugViewModel implements IDisposable {
+  @Autowired(IDebugSessionManager)
+  protected readonly manager: DebugSessionManager;
+
+  protected readonly onDidChangeEmitter = new Emitter<void>();
+  readonly onDidChange: Event<void> = this.onDidChangeEmitter.event;
+  protected fireDidChange(): void {
+    this.onDidChangeEmitter.fire(undefined);
+  }
+
+  protected readonly onDidChangeBreakpointsEmitter = new Emitter<URI>();
+  readonly onDidChangeBreakpoints: Event<URI> = this.onDidChangeBreakpointsEmitter.event;
+  protected fireDidChangeBreakpoints(uri: URI): void {
+    this.onDidChangeBreakpointsEmitter.fire(uri);
+  }
+
+  protected readonly toDispose = new DisposableCollection(this.onDidChangeEmitter, this.onDidChangeBreakpointsEmitter);
+
+  protected readonly _sessions = new Set<DebugSession>();
+
+  get sessions(): IterableIterator<DebugSession> {
+    return this._sessions.values();
+  }
+
+  get sessionCount(): number {
+    return this._sessions.size;
+  }
+
+  push(session: DebugSession): void {
+    if (this._sessions.has(session)) {
+      return;
+    }
+    this._sessions.add(session);
+    this.fireDidChange();
+  }
+
+  delete(session: DebugSession): boolean {
+    if (this._sessions.delete(session)) {
+      this.fireDidChange();
+      return true;
+    }
+    return false;
+  }
+
+  get session(): DebugSession | undefined {
+    return this.sessions.next().value;
+  }
+
+  get id(): string {
+    return (this.session && this.session.id) || '-1';
+  }
+  get label(): string {
+    return (this.session && this.session.label) || 'Unknown Session';
+  }
+  has(session: DebugSession | undefined): session is DebugSession {
+    return !!session && this._sessions.has(session);
+  }
+
+  init(seesion: DebugSession): void {
+    if (seesion) {
+      this.push(seesion);
+    }
+    this.toDispose.push(
+      this.manager.onDidChangeActiveDebugSession(({ previous, current }) => {
+        if (this.has(previous) && !this.has(current)) {
+          this.fireDidChange();
+        }
+      }),
+    );
+    this.toDispose.push(
+      this.manager.onDidChange((current) => {
+        if (this.has(current)) {
+          this.fireDidChange();
+        }
+      }),
+    );
+    this.toDispose.push(
+      this.manager.onDidDestroyDebugSession((current) => {
+        if (this.has(current)) {
+          this.fireDidChange();
+        }
+      }),
+    );
+  }
+
+  dispose(): void {
+    this.toDispose.dispose();
+  }
+
+  get threads(): IterableIterator<DebugThread> | undefined {
+    if (this.manager.currentSession) {
+      return this.manager.currentSession.getThreads(() => true);
+    }
+  }
+  get currentSession(): DebugSession | undefined {
+    const { currentSession } = this.manager;
+    return (this.has(currentSession) && currentSession) || this.session;
+  }
+  set currentSession(currentSession: DebugSession | undefined) {
+    this.manager.updateCurrentSession(currentSession);
+  }
+
+  get state(): DebugState {
+    const { currentSession } = this;
+    return (currentSession && currentSession.state) || DebugState.Inactive;
+  }
+  get currentThread(): DebugThread | undefined {
+    const { currentSession } = this;
+    return currentSession && currentSession.currentThread;
+  }
+  get currentFrame(): DebugStackFrame | undefined {
+    const { currentThread } = this;
+    return currentThread && currentThread.currentFrame;
+  }
+
+  async start(): Promise<void> {
+    const { session } = this;
+    if (!session) {
+      return;
+    }
+    const newSession = await this.manager.start(session.options);
+    if (newSession) {
+      this._sessions.delete(session);
+      this._sessions.add(newSession);
+      this.fireDidChange();
+    }
+  }
+
+  async restart(): Promise<void> {
+    const { currentSession } = this;
+    if (!currentSession) {
+      return;
+    }
+
+    const newSession = await this.manager.restart(currentSession);
+    if (newSession !== currentSession) {
+      this._sessions.delete(currentSession);
+      this._sessions.add(newSession);
+    }
+    this.fireDidChange();
+  }
+
+  report(name: string, msg: string | undefined, extra?: any) {
+    return this.manager.report(name, msg, extra);
+  }
+
+  reportTime(name: string, defaults?: any) {
+    return this.manager.reportTime(name, defaults);
+  }
+
+  reportAction(sessionId: string, threadId: number | string | undefined, action: string) {
+    return this.manager.reportAction(sessionId, threadId, action);
+  }
+}