@opensumi/ide-debug 2.21.13 → 2.22.0

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;
+  }
+}

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,16 @@
+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-console';
+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';
+export * from './commands';

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;
+}