Rework showing of generic error message

extension/src/cli/actions.ts

@@ -1,6 +1,7 @@
 import { Args, Flag } from './args'
 import { Prompt } from './output'
-import { getWarningResponse, showGenericError } from '../vscode/modal'
+import { MaybeConsoleError } from './error'
+import { getWarningResponse } from '../vscode/modal'
 import { CommandId, InternalCommands } from '../commands/internal'
 
 const offerToForce = async (
@@ -27,13 +28,13 @@ export const tryThenMaybeForce = async (
 ): Promise<string | undefined> => {
   try {
     return await internalCommands.executeCommand(commandId, ...args)
-  } catch (e) {
-    const stderr = e.stderr
+  } catch (e: unknown) {
+    const stderr = (e as MaybeConsoleError).stderr
 
     if (stderr?.includes(Prompt.TRY_FORCE)) {
       return offerToForce(stderr, internalCommands, commandId, ...args)
     }
 
-    return showGenericError()
+    throw e
   }
 }

extension/src/commands/external.ts

@@ -1,8 +1,3 @@
-import { commands } from 'vscode'
-import { Disposable } from '../extension'
-import { sendTelemetryEventAndThrow, sendTelemetryEvent } from '../telemetry'
-import { StopWatch } from '../util/time'
-
 export enum RegisteredCommands {
   EXPERIMENT_APPLY = 'dvc.applyExperiment',
   EXPERIMENT_BRANCH = 'dvc.branchExperiment',
@@ -46,20 +41,3 @@ export enum RegisteredCommands {
   TRACKED_EXPLORER_COPY_FILE_PATH = 'dvc.copyFilePath',
   TRACKED_EXPLORER_COPY_REL_FILE_PATH = 'dvc.copyRelativeFilePath'
 }
-
-export const registerInstrumentedCommand = <T = string | undefined>(
-  name: RegisteredCommands,
-  func: (arg: T) => unknown
-): Disposable =>
-  commands.registerCommand(name, async arg => {
-    const stopWatch = new StopWatch()
-    try {
-      const res = await func(arg)
-      sendTelemetryEvent(name, undefined, {
-        duration: stopWatch.getElapsedTime()
-      })
-      return res
-    } catch (e: unknown) {
-      sendTelemetryEventAndThrow(name, e as Error, stopWatch.getElapsedTime())
-    }
-  })

extension/src/commands/internal.test.ts

@@ -1,17 +1,25 @@
 import { AvailableCommands, CommandId, InternalCommands } from './internal'
 import { ICli } from '../cli'
 import { Config } from '../config'
+import { OutputChannel } from '../vscode/outputChannel'
 
 const mockedConfig = {
   getDefaultProject: jest.fn()
 } as unknown as Config
 
+const mockedOutputChannel = {
+  show: jest.fn()
+} as unknown as OutputChannel
+
 beforeEach(() => {
   jest.resetAllMocks()
 })
 
 describe('InternalCommands', () => {
-  const internalCommands = new InternalCommands(mockedConfig)
+  const internalCommands = new InternalCommands(
+    mockedConfig,
+    mockedOutputChannel
+  )
 
   describe('executeCommand', () => {
     it('should throw an error if we try to run a non-registered command', () => {
@@ -39,7 +47,9 @@ describe('InternalCommands', () => {
         func: jest.fn()
       } as unknown as ICli
 
-      expect(() => new InternalCommands(mockedConfig, mockedCli)).toThrow()
+      expect(
+        () => new InternalCommands(mockedConfig, mockedOutputChannel, mockedCli)
+      ).toThrow()
     })
   })
 })

extension/src/commands/internal.ts

@@ -1,18 +1,25 @@
+import { commands } from 'vscode'
 import { Disposable } from '@hediet/std/disposable'
+import { RegisteredCommands } from './external'
 import { ICli } from '../cli'
 import { Args } from '../cli/args'
-import { Config } from '../config'
-import { quickPickOne } from '../vscode/quickPick'
 import { autoRegisteredCommands as CliExecutorCommands } from '../cli/executor'
 import { autoRegisteredCommands as CliReaderCommands } from '../cli/reader'
 import { autoRegisteredCommands as CliRunnerCommands } from '../cli/runner'
+import { Config } from '../config'
+import { OutputChannel } from '../vscode/outputChannel'
+import { quickPickOne } from '../vscode/quickPick'
+import { StopWatch } from '../util/time'
+import { sendTelemetryEvent, sendTelemetryEventAndThrow } from '../telemetry'
+import { showGenericError } from '../vscode/modal'
 
 type Command = (...args: Args) => unknown | Promise<unknown>
 
 export const AvailableCommands = Object.assign(
   {
     GET_DEFAULT_OR_PICK_PROJECT: 'getDefaultOrPickProject',
-    GET_THEME: 'getTheme'
+    GET_THEME: 'getTheme',
+    REGISTER_EXTERNAL_COMMAND: 'registerExternalCommand'
   } as const,
   CliExecutorCommands,
   CliReaderCommands,
@@ -24,9 +31,15 @@ export class InternalCommands {
   public dispose = Disposable.fn()
 
   private readonly commands = new Map<string, Command>()
+  private readonly outputChannel: OutputChannel
 
-  constructor(config: Config, ...cliInteractors: ICli[]) {
+  constructor(
+    config: Config,
+    outputChannel: OutputChannel,
+    ...cliInteractors: ICli[]
+  ) {
     cliInteractors.forEach(cli => this.autoRegisterCommands(cli))
+    this.outputChannel = outputChannel
 
     this.registerCommand(
       AvailableCommands.GET_DEFAULT_OR_PICK_PROJECT,
@@ -65,6 +78,32 @@ export class InternalCommands {
     this.commands.set(commandId, command)
   }
 
+  public registerExternalCommand<T = string | undefined>(
+    name: RegisteredCommands,
+    func: (arg: T) => unknown
+  ): void {
+    this.dispose.track(
+      commands.registerCommand(name, async arg => {
+        const stopWatch = new StopWatch()
+        try {
+          const res = await func(arg)
+          sendTelemetryEvent(name, undefined, {
+            duration: stopWatch.getElapsedTime()
+          })
+          return res
+        } catch (e: unknown) {
+          showGenericError()
+          this.outputChannel.show()
+          sendTelemetryEventAndThrow(
+            name,
+            e as Error,
+            stopWatch.getElapsedTime()
+          )
+        }
+      })
+    )
+  }
+
   private autoRegisterCommands(cli: ICli) {
     cli.autoRegisteredCommands.forEach((commandId: string) => {
       if (!this.confirmedId(commandId)) {

extension/src/experiments/commands/register.ts

@@ -1,47 +1,50 @@
 import { pickGarbageCollectionFlags } from '../quickPick'
 import { Experiments } from '..'
-import { AvailableCommands } from '../../commands/internal'
-import {
-  RegisteredCommands,
-  registerInstrumentedCommand
-} from '../../commands/external'
+import { AvailableCommands, InternalCommands } from '../../commands/internal'
+import { RegisteredCommands } from '../../commands/external'
 
-const registerCommand = (
+const registerExperimentCwdCommands = (
   experiments: Experiments,
-  name: RegisteredCommands,
-  func: (arg?: string) => unknown
-): void => {
-  experiments.dispose.track(registerInstrumentedCommand(name, func))
-}
-
-const registerExperimentCwdCommands = (experiments: Experiments): void =>
-  registerCommand(experiments, RegisteredCommands.QUEUE_EXPERIMENT, () =>
-    experiments.getCwdThenRun(AvailableCommands.EXPERIMENT_QUEUE)
+  internalCommands: InternalCommands
+): void =>
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.QUEUE_EXPERIMENT,
+    () => experiments.getCwdThenRun(AvailableCommands.EXPERIMENT_QUEUE)
   )
 
-const registerExperimentNameCommands = (experiments: Experiments): void => {
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_APPLY, () =>
-    experiments.getExpNameThenRun(AvailableCommands.EXPERIMENT_APPLY)
+const registerExperimentNameCommands = (
+  experiments: Experiments,
+  internalCommands: InternalCommands
+): void => {
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_APPLY,
+    () => experiments.getExpNameThenRun(AvailableCommands.EXPERIMENT_APPLY)
   )
 
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_REMOVE, () =>
-    experiments.getExpNameThenRun(AvailableCommands.EXPERIMENT_REMOVE)
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_REMOVE,
+    () => experiments.getExpNameThenRun(AvailableCommands.EXPERIMENT_REMOVE)
   )
 }
 
-const registerExperimentInputCommands = (experiments: Experiments): void =>
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_BRANCH, () =>
-    experiments.getExpNameAndInputThenRun(
-      AvailableCommands.EXPERIMENT_BRANCH,
-      'Name the new branch'
-    )
+const registerExperimentInputCommands = (
+  experiments: Experiments,
+  internalCommands: InternalCommands
+): void =>
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_BRANCH,
+    () =>
+      experiments.getExpNameAndInputThenRun(
+        AvailableCommands.EXPERIMENT_BRANCH,
+        'Name the new branch'
+      )
   )
 
 const registerExperimentQuickPickCommands = (
-  experiments: Experiments
+  experiments: Experiments,
+  internalCommands: InternalCommands
 ): void => {
-  registerCommand(
-    experiments,
+  internalCommands.registerExternalCommand(
     RegisteredCommands.EXPERIMENT_GARBAGE_COLLECT,
     () =>
       experiments.getCwdAndQuickPickThenRun(
@@ -50,55 +53,66 @@ const registerExperimentQuickPickCommands = (
       )
   )
 
-  registerCommand(
-    experiments,
+  internalCommands.registerExternalCommand(
     RegisteredCommands.EXPERIMENT_FILTER_ADD,
     (dvcRoot?: string) => experiments.addFilter(dvcRoot)
   )
 
-  registerCommand(
-    experiments,
+  internalCommands.registerExternalCommand(
     RegisteredCommands.EXPERIMENT_FILTERS_REMOVE,
     () => experiments.removeFilters()
   )
 
-  registerCommand(
-    experiments,
+  internalCommands.registerExternalCommand(
     RegisteredCommands.EXPERIMENT_SORT_ADD,
     (dvcRoot?: string) => experiments.addSort(dvcRoot)
   )
 
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_SORTS_REMOVE, () =>
-    experiments.removeSorts()
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_SORTS_REMOVE,
+    () => experiments.removeSorts()
   )
 }
 
-const registerExperimentRunCommands = (experiments: Experiments): void => {
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_RUN, () =>
-    experiments.showExperimentsTableThenRun(AvailableCommands.EXPERIMENT_RUN)
+const registerExperimentRunCommands = (
+  experiments: Experiments,
+  internalCommands: InternalCommands
+): void => {
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_RUN,
+    () =>
+      experiments.showExperimentsTableThenRun(AvailableCommands.EXPERIMENT_RUN)
   )
 
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_RUN_RESET, () =>
-    experiments.showExperimentsTableThenRun(
-      AvailableCommands.EXPERIMENT_RUN_RESET
-    )
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_RUN_RESET,
+    () =>
+      experiments.showExperimentsTableThenRun(
+        AvailableCommands.EXPERIMENT_RUN_RESET
+      )
   )
 
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_RUN_QUEUED, () =>
-    experiments.showExperimentsTableThenRun(
-      AvailableCommands.EXPERIMENT_RUN_QUEUED
-    )
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_RUN_QUEUED,
+    () =>
+      experiments.showExperimentsTableThenRun(
+        AvailableCommands.EXPERIMENT_RUN_QUEUED
+      )
   )
 
-  registerCommand(experiments, RegisteredCommands.EXPERIMENT_SHOW, () =>
-    experiments.showExperimentsTable()
+  internalCommands.registerExternalCommand(
+    RegisteredCommands.EXPERIMENT_SHOW,
+    () => experiments.showExperimentsTable()
   )
 }
 
-export const registerExperimentCommands = (experiments: Experiments) => {
-  registerExperimentCwdCommands(experiments)
-  registerExperimentNameCommands(experiments)
-  registerExperimentInputCommands(experiments)
-  registerExperimentQuickPickCommands(experiments)
-  registerExperimentRunCommands(experiments)
+export const registerExperimentCommands = (
+  experiments: Experiments,
+  internalCommands: InternalCommands
+) => {
+  registerExperimentCwdCommands(experiments, internalCommands)
+  registerExperimentNameCommands(experiments, internalCommands)
+  registerExperimentInputCommands(experiments, internalCommands)
+  registerExperimentQuickPickCommands(experiments, internalCommands)
+  registerExperimentRunCommands(experiments, internalCommands)
 }

extension/src/experiments/index.test.ts

@@ -12,6 +12,7 @@ import {
 } from '../commands/internal'
 import { getInput } from '../vscode/inputBox'
 import { buildMockMemento } from '../test/util'
+import { OutputChannel } from '../vscode/outputChannel'
 
 const mockedShowWebview = jest.fn()
 const mockedDisposable = mocked(Disposable)
@@ -39,9 +40,14 @@ beforeEach(() => {
 })
 
 describe('Experiments', () => {
-  const mockedInternalCommands = new InternalCommands({
-    getDefaultProject: mockedGetDefaultProject
-  } as unknown as Config)
+  const mockedInternalCommands = new InternalCommands(
+    {
+      getDefaultProject: mockedGetDefaultProject
+    } as unknown as Config,
+    {
+      show: jest.fn()
+    } as unknown as OutputChannel
+  )
 
   const mockedCommandId = 'mockedExpFunc' as CommandId
   mockedInternalCommands.registerCommand(mockedCommandId, (...args) =>