feat: use new debug -I -P CLI output

- Can pick a programmer if missing,
 - Can auto-select a programmer on app start,
 - Can edit the `launch.json`,
 - Adjust board discovery to new gRPC API. From now on, it's a client
 read stream, not a duplex.
 - Allow `.cxx` and `.cc` file extensions. (Closes #2265)
 - Drop `debuggingSupported` from `BoardDetails`.
 - Dedicated service endpoint for checking the debugger.

Signed-off-by: Akos Kitta <a.kitta@arduino.cc>

.eslintrc.js

@@ -18,7 +18,7 @@ module.exports = {
     'electron-app/src-gen/*',
     'electron-app/gen-webpack*.js',
     '!electron-app/webpack.config.js',
-    'plugins/*',
+    'electron-app/plugins/*',
     'arduino-ide-extension/src/node/cli-protocol',
     '**/lib/*',
   ],

arduino-ide-extension/package.json

@@ -69,6 +69,7 @@
     "deepmerge": "^4.2.2",
     "drivelist": "^9.2.4",
     "electron-updater": "^4.6.5",
+    "fast-deep-equal": "^3.1.3",
     "fast-json-stable-stringify": "^2.1.0",
     "fast-safe-stringify": "^2.1.1",
     "filename-reserved-regex": "^2.0.0",
@@ -169,7 +170,7 @@
   ],
   "arduino": {
     "arduino-cli": {
-      "version": "0.34.0"
+      "version": "0.35.0-rc.7"
     },
     "arduino-fwuploader": {
       "version": "2.4.1"

arduino-ide-extension/src/browser/arduino-ide-frontend-module.ts

@@ -1,5 +1,5 @@
 import '../../src/browser/style/index.css';
-import { ContainerModule } from '@theia/core/shared/inversify';
+import { Container, ContainerModule } from '@theia/core/shared/inversify';
 import { WidgetFactory } from '@theia/core/lib/browser/widget-manager';
 import { CommandContribution } from '@theia/core/lib/common/command';
 import { bindViewContribution } from '@theia/core/lib/browser/shell/view-contribution';
@@ -361,6 +361,16 @@ import { TerminalFrontendContribution as TheiaTerminalFrontendContribution } fro
 import { SelectionService } from '@theia/core/lib/common/selection-service';
 import { CommandService } from '@theia/core/lib/common/command';
 import { CorePreferences } from '@theia/core/lib/browser/core-preferences';
+import { AutoSelectProgrammer } from './contributions/auto-select-programmer';
+import { HostedPluginSupport } from './hosted/hosted-plugin-support';
+import { DebugSessionManager as TheiaDebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
+import { DebugSessionManager } from './theia/debug/debug-session-manager';
+import { DebugWidget } from '@theia/debug/lib/browser/view/debug-widget';
+import { DebugViewModel } from '@theia/debug/lib/browser/view/debug-view-model';
+import { DebugSessionWidget } from '@theia/debug/lib/browser/view/debug-session-widget';
+import { DebugConfigurationWidget } from './theia/debug/debug-configuration-widget';
+import { DebugConfigurationWidget as TheiaDebugConfigurationWidget } from '@theia/debug/lib/browser/view/debug-configuration-widget';
+import { DebugToolBar } from '@theia/debug/lib/browser/view/debug-toolbar-widget';
 
 // Hack to fix copy/cut/paste issue after electron version update in Theia.
 // https://github.com/eclipse-theia/theia/issues/12487
@@ -756,6 +766,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
   Contribution.configure(bind, CreateCloudCopy);
   Contribution.configure(bind, UpdateArduinoState);
   Contribution.configure(bind, BoardsDataMenuUpdater);
+  Contribution.configure(bind, AutoSelectProgrammer);
 
   bindContributionProvider(bind, StartupTaskProvider);
   bind(StartupTaskProvider).toService(BoardsServiceProvider); // to reuse the boards config in another window
@@ -857,6 +868,28 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
   // To be able to use a `launch.json` from outside of the workspace.
   bind(DebugConfigurationManager).toSelf().inSingletonScope();
   rebind(TheiaDebugConfigurationManager).toService(DebugConfigurationManager);
+  // To update the currently selected debug config <select> option when starting a debug session.
+  bind(DebugSessionManager).toSelf().inSingletonScope();
+  rebind(TheiaDebugSessionManager).toService(DebugSessionManager);
+  // Customized debug widget with its customized config <select> to update it programmatically.
+  bind(WidgetFactory)
+    .toDynamicValue(({ container }) => ({
+      id: DebugWidget.ID,
+      createWidget: () => {
+        const child = new Container({ defaultScope: 'Singleton' });
+        child.parent = container;
+        child.bind(DebugViewModel).toSelf();
+        child.bind(DebugToolBar).toSelf();
+        child.bind(DebugSessionWidget).toSelf();
+        child.bind(DebugConfigurationWidget).toSelf(); // with the patched select
+        child // use the customized one in the Theia DI
+          .bind(TheiaDebugConfigurationWidget)
+          .toService(DebugConfigurationWidget);
+        child.bind(DebugWidget).toSelf();
+        return child.get(DebugWidget);
+      },
+    }))
+    .inSingletonScope();
 
   // To avoid duplicate tabs use deepEqual instead of string equal: https://github.com/eclipse-theia/theia/issues/11309
   bind(WidgetManager).toSelf().inSingletonScope();

arduino-ide-extension/src/browser/boards/boards-data-store.ts

@@ -10,13 +10,16 @@ import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { Emitter, Event } from '@theia/core/lib/common/event';
 import { ILogger } from '@theia/core/lib/common/logger';
 import { deepClone, deepFreeze } from '@theia/core/lib/common/objects';
+import type { Mutable } from '@theia/core/lib/common/types';
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import {
   BoardDetails,
   BoardsService,
   ConfigOption,
+  ConfigValue,
   Programmer,
   isBoardIdentifierChangeEvent,
+  isProgrammer,
 } from '../../common/protocol';
 import { notEmpty } from '../../common/utils';
 import type {
@@ -74,7 +77,7 @@ export class BoardsDataStore
           const storedData =
             await this.storageService.getData<BoardsDataStore.Data>(key);
           if (!storedData) {
-            // if not previously value is available for the board, do not update the cache
+            // if no previously value is available for the board, do not update the cache
             continue;
           }
           const details = await this.loadBoardDetails(fqbn);
@@ -88,6 +91,13 @@ export class BoardsDataStore
           this.fireChanged(...changes);
         }
       }),
+      this.onDidChange((event) => {
+        const selectedFqbn =
+          this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
+        if (event.changes.find((change) => change.fqbn === selectedFqbn)) {
+          this.updateSelectedBoardData(selectedFqbn);
+        }
+      }),
     ]);
 
     Promise.all([
@@ -174,7 +184,7 @@ export class BoardsDataStore
       return storedData;
     }
 
-    const boardDetails = await this.getBoardDetailsSafe(fqbn);
+    const boardDetails = await this.loadBoardDetails(fqbn);
     if (!boardDetails) {
       return BoardsDataStore.Data.EMPTY;
     }
@@ -220,11 +230,12 @@ export class BoardsDataStore
     }
     let updated = false;
     for (const value of configOption.values) {
-      if (value.value === selectedValue) {
-        (value as any).selected = true;
+      const mutable: Mutable<ConfigValue> = value;
+      if (mutable.value === selectedValue) {
+        mutable.selected = true;
         updated = true;
       } else {
-        (value as any).selected = false;
+        mutable.selected = false;
       }
     }
     if (!updated) {
@@ -245,9 +256,7 @@ export class BoardsDataStore
     return `.arduinoIDE-configOptions-${fqbn}`;
   }
 
-  protected async getBoardDetailsSafe(
-    fqbn: string
-  ): Promise<BoardDetails | undefined> {
+  async loadBoardDetails(fqbn: string): Promise<BoardDetails | undefined> {
     try {
       const details = await this.boardsService.getBoardDetails({ fqbn });
       return details;
@@ -280,21 +289,24 @@ export namespace BoardsDataStore {
     readonly configOptions: ConfigOption[];
     readonly programmers: Programmer[];
     readonly selectedProgrammer?: Programmer;
+    readonly defaultProgrammerId?: string;
   }
   export namespace Data {
     export const EMPTY: Data = deepFreeze({
       configOptions: [],
       programmers: [],
-      defaultProgrammerId: undefined,
     });
 
     export function is(arg: unknown): arg is Data {
       return (
-        !!arg &&
-        'configOptions' in arg &&
-        Array.isArray(arg['configOptions']) &&
-        'programmers' in arg &&
-        Array.isArray(arg['programmers'])
+        typeof arg === 'object' &&
+        arg !== null &&
+        Array.isArray((<Data>arg).configOptions) &&
+        Array.isArray((<Data>arg).programmers) &&
+        ((<Data>arg).selectedProgrammer === undefined ||
+          isProgrammer((<Data>arg).selectedProgrammer)) &&
+        ((<Data>arg).defaultProgrammerId === undefined ||
+          typeof (<Data>arg).defaultProgrammerId === 'string')
       );
     }
   }
@@ -304,7 +316,8 @@ export function isEmptyData(data: BoardsDataStore.Data): boolean {
   return (
     Boolean(!data.configOptions.length) &&
     Boolean(!data.programmers.length) &&
-    Boolean(!data.selectedProgrammer)
+    Boolean(!data.selectedProgrammer) &&
+    Boolean(!data.defaultProgrammerId)
   );
 }
 
@@ -324,16 +337,18 @@ export function findDefaultProgrammer(
 function createDataStoreEntry(details: BoardDetails): BoardsDataStore.Data {
   const configOptions = details.configOptions.slice();
   const programmers = details.programmers.slice();
+  const { defaultProgrammerId } = details;
   const selectedProgrammer = findDefaultProgrammer(
     programmers,
-    details.defaultProgrammerId
+    defaultProgrammerId
   );
-  return {
+  const data = {
     configOptions,
     programmers,
-    defaultProgrammerId: details.defaultProgrammerId,
-    selectedProgrammer,
+    ...(selectedProgrammer ? { selectedProgrammer } : {}),
+    ...(defaultProgrammerId ? { defaultProgrammerId } : {}),
   };
+  return data;
 }
 
 export interface BoardsDataStoreChange {

arduino-ide-extension/src/browser/contributions/auto-select-programmer.ts

@@ -0,0 +1,123 @@
+import type { MaybePromise } from '@theia/core/lib/common/types';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import {
+  BoardDetails,
+  Programmer,
+  isBoardIdentifierChangeEvent,
+} from '../../common/protocol';
+import {
+  BoardsDataStore,
+  findDefaultProgrammer,
+  isEmptyData,
+} from '../boards/boards-data-store';
+import { BoardsServiceProvider } from '../boards/boards-service-provider';
+import { Contribution } from './contribution';
+
+/**
+ * Before CLI 0.35.0-rc.3, there was no `programmer#default` property in the `board details` response.
+ * This method does the programmer migration in the data store. If there is a programmer selected, it's a noop.
+ * If no programmer is selected, it forcefully reloads the details from the CLI and updates it in the local storage.
+ */
+@injectable()
+export class AutoSelectProgrammer extends Contribution {
+  @inject(BoardsServiceProvider)
+  private readonly boardsServiceProvider: BoardsServiceProvider;
+  @inject(BoardsDataStore)
+  private readonly boardsDataStore: BoardsDataStore;
+
+  override onStart(): void {
+    this.boardsServiceProvider.onBoardsConfigDidChange((event) => {
+      if (isBoardIdentifierChangeEvent(event)) {
+        this.ensureProgrammerIsSelected();
+      }
+    });
+  }
+
+  override onReady(): void {
+    this.boardsServiceProvider.ready.then(() =>
+      this.ensureProgrammerIsSelected()
+    );
+  }
+
+  private async ensureProgrammerIsSelected(): Promise<boolean> {
+    return ensureProgrammerIsSelected({
+      fqbn: this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn,
+      getData: (fqbn) => this.boardsDataStore.getData(fqbn),
+      loadBoardDetails: (fqbn) => this.boardsDataStore.loadBoardDetails(fqbn),
+      selectProgrammer: (arg) => this.boardsDataStore.selectProgrammer(arg),
+    });
+  }
+}
+
+interface EnsureProgrammerIsSelectedParams {
+  fqbn: string | undefined;
+  getData: (fqbn: string | undefined) => MaybePromise<BoardsDataStore.Data>;
+  loadBoardDetails: (fqbn: string) => MaybePromise<BoardDetails | undefined>;
+  selectProgrammer(options: {
+    fqbn: string;
+    selectedProgrammer: Programmer;
+  }): MaybePromise<boolean>;
+}
+
+export async function ensureProgrammerIsSelected(
+  params: EnsureProgrammerIsSelectedParams
+): Promise<boolean> {
+  const { fqbn, getData, loadBoardDetails, selectProgrammer } = params;
+  if (!fqbn) {
+    return false;
+  }
+  console.debug(`Ensuring a programmer is selected for ${fqbn}...`);
+  const data = await getData(fqbn);
+  if (isEmptyData(data)) {
+    // For example, the platform is not installed.
+    console.debug(`Skipping. No boards data is available for ${fqbn}.`);
+    return false;
+  }
+  if (data.selectedProgrammer) {
+    console.debug(
+      `A programmer is already selected for ${fqbn}: '${data.selectedProgrammer.id}'.`
+    );
+    return true;
+  }
+  let programmer = findDefaultProgrammer(data.programmers, data);
+  if (programmer) {
+    // select the programmer if the default info is available
+    const result = await selectProgrammer({
+      fqbn,
+      selectedProgrammer: programmer,
+    });
+    if (result) {
+      console.debug(`Selected '${programmer.id}' programmer for ${fqbn}.`);
+      return result;
+    }
+  }
+  console.debug(`Reloading board details for ${fqbn}...`);
+  const reloadedData = await loadBoardDetails(fqbn);
+  if (!reloadedData) {
+    console.debug(`Skipping. No board details found for ${fqbn}.`);
+    return false;
+  }
+  if (!reloadedData.programmers.length) {
+    console.debug(`Skipping. ${fqbn} does not have programmers.`);
+    return false;
+  }
+  programmer = findDefaultProgrammer(reloadedData.programmers, reloadedData);
+  if (!programmer) {
+    console.debug(
+      `Skipping. Could not find a default programmer for ${fqbn}. Programmers were: `
+    );
+    return false;
+  }
+  const result = await selectProgrammer({
+    fqbn,
+    selectedProgrammer: programmer,
+  });
+  if (result) {
+    console.debug(`Selected '${programmer.id}' programmer for ${fqbn}.`);
+  } else {
+    console.debug(
+      `Could not select '${programmer.id}' programmer for ${fqbn}.`
+    );
+  }
+  return result;
+}

arduino-ide-extension/src/browser/contributions/debug.ts

@@ -1,12 +1,20 @@
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import { MenuModelRegistry } from '@theia/core/lib/common/menu/menu-model-registry';
+import { nls } from '@theia/core/lib/common/nls';
+import { MaybePromise } from '@theia/core/lib/common/types';
 import { inject, injectable } from '@theia/core/shared/inversify';
+import { noBoardSelected } from '../../common/nls';
 import {
-  Board,
+  BoardDetails,
   BoardIdentifier,
   BoardsService,
+  CheckDebugEnabledParams,
   ExecutableService,
+  SketchRef,
   isBoardIdentifierChangeEvent,
-  Sketch,
+  isCompileSummary,
 } from '../../common/protocol';
+import { BoardsDataStore } from '../boards/boards-data-store';
 import { BoardsServiceProvider } from '../boards/boards-service-provider';
 import { HostedPluginSupport } from '../hosted/hosted-plugin-support';
 import { ArduinoMenus } from '../menu/arduino-menus';
@@ -14,95 +22,119 @@ import { NotificationCenter } from '../notification-center';
 import { CurrentSketch } from '../sketches-service-client-impl';
 import { ArduinoToolbar } from '../toolbar/arduino-toolbar';
 import {
-  URI,
   Command,
   CommandRegistry,
   SketchContribution,
   TabBarToolbarRegistry,
+  URI,
 } from './contribution';
-import { MenuModelRegistry, nls } from '@theia/core/lib/common';
-import { CurrentSketch } from '../sketches-service-client-impl';
-import { ArduinoMenus } from '../menu/arduino-menus';
 
 const COMPILE_FOR_DEBUG_KEY = 'arduino-compile-for-debug';
 
+interface StartDebugParams {
+  /**
+   * Absolute filesystem path to the Arduino CLI executable.
+   */
+  readonly cliPath: string;
+  /**
+   * The the board to debug.
+   */
+  readonly board: Readonly<{ fqbn: string; name?: string }>;
+  /**
+   * Absolute filesystem path of the sketch to debug.
+   */
+  readonly sketchPath: string;
+  /**
+   * Location where the `launch.json` will be created on the fly before starting every debug session.
+   * If not defined, it falls back to `sketchPath/.vscode/launch.json`.
+   */
+  readonly launchConfigsDirPath?: string;
+  /**
+   * Absolute path to the `arduino-cli.yaml` file. If not specified, it falls back to `~/.arduinoIDE/arduino-cli.yaml`.
+   */
+  readonly cliConfigPath?: string;
+  /**
+   * Programmer for the debugging.
+   */
+  readonly programmer?: string;
+  /**
+   * Custom progress title to use when getting the debug information from the CLI.
+   */
+  readonly title?: string;
+}
+type StartDebugResult = boolean;
+
 @injectable()
 export class Debug extends SketchContribution {
   @inject(HostedPluginSupport)
   private readonly hostedPluginSupport: HostedPluginSupport;
-
   @inject(NotificationCenter)
   private readonly notificationCenter: NotificationCenter;
-
   @inject(ExecutableService)
   private readonly executableService: ExecutableService;
-
   @inject(BoardsService)
   private readonly boardService: BoardsService;
-
   @inject(BoardsServiceProvider)
   private readonly boardsServiceProvider: BoardsServiceProvider;
+  @inject(BoardsDataStore)
+  private readonly boardsDataStore: BoardsDataStore;
 
   /**
-   * If `undefined`, debugging is enabled. Otherwise, the reason why it's disabled.
+   * If `undefined`, debugging is enabled. Otherwise, the human-readable reason why it's disabled.
    */
-  private _disabledMessages?: string = nls.localize(
-    'arduino/common/noBoardSelected',
-    'No board selected'
-  ); // Initial pessimism.
-  private disabledMessageDidChangeEmitter = new Emitter<string | undefined>();
-  private onDisabledMessageDidChange =
-    this.disabledMessageDidChangeEmitter.event;
+  private _message?: string = noBoardSelected; // Initial pessimism.
+  private didChangeMessageEmitter = new Emitter<string | undefined>();
+  private onDidChangeMessage = this.didChangeMessageEmitter.event;
 
-  private get disabledMessage(): string | undefined {
-    return this._disabledMessages;
+  private get message(): string | undefined {
+    return this._message;
   }
-  private set disabledMessage(message: string | undefined) {
-    this._disabledMessages = message;
-    this.disabledMessageDidChangeEmitter.fire(this._disabledMessages);
+  private set message(message: string | undefined) {
+    this._message = message;
+    this.didChangeMessageEmitter.fire(this._message);
   }
 
   private readonly debugToolbarItem = {
     id: Debug.Commands.START_DEBUGGING.id,
     command: Debug.Commands.START_DEBUGGING.id,
     tooltip: `${
-      this.disabledMessage
+      this.message
         ? nls.localize(
             'arduino/debug/debugWithMessage',
             'Debug - {0}',
-            this.disabledMessage
+            this.message
           )
         : Debug.Commands.START_DEBUGGING.label
     }`,
     priority: 3,
-    onDidChange: this.onDisabledMessageDidChange as Event<void>,
+    onDidChange: this.onDidChangeMessage as Event<void>,
   };
 
   override onStart(): void {
-    this.onDisabledMessageDidChange(
+    this.onDidChangeMessage(
       () =>
         (this.debugToolbarItem.tooltip = `${
-          this.disabledMessage
+          this.message
             ? nls.localize(
                 'arduino/debug/debugWithMessage',
                 'Debug - {0}',
-                this.disabledMessage
+                this.message
               )
             : Debug.Commands.START_DEBUGGING.label
         }`)
     );
     this.boardsServiceProvider.onBoardsConfigDidChange((event) => {
       if (isBoardIdentifierChangeEvent(event)) {
-        this.refreshState(event.selectedBoard);
+        this.updateMessage();
       }
     });
-    this.notificationCenter.onPlatformDidInstall(() => this.refreshState());
-    this.notificationCenter.onPlatformDidUninstall(() => this.refreshState());
+    this.notificationCenter.onPlatformDidInstall(() => this.updateMessage());
+    this.notificationCenter.onPlatformDidUninstall(() => this.updateMessage());
     this.boardsDataStore.onDidChange((event) => {
       const selectedFqbn =
         this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
       if (event.changes.find((change) => change.fqbn === selectedFqbn)) {
-        this.refreshState();
+        this.updateMessage();
       }
     });
     this.commandService.onDidExecuteCommand((event) => {
@@ -111,13 +143,13 @@ export class Debug extends SketchContribution {
         commandId === 'arduino.languageserver.notifyBuildDidComplete' &&
         isCompileSummary(args[0])
       ) {
-        this.refreshState();
+        this.updateMessage();
       }
     });
   }
 
   override onReady(): void {
-    this.boardsServiceProvider.ready.then(() => this.refreshState());
+    this.boardsServiceProvider.ready.then(() => this.updateMessage());
   }
 
   override registerCommands(registry: CommandRegistry): void {
@@ -125,7 +157,7 @@ export class Debug extends SketchContribution {
       execute: () => this.startDebug(),
       isVisible: (widget) =>
         ArduinoToolbar.is(widget) && widget.side === 'left',
-      isEnabled: () => !this.disabledMessage,
+      isEnabled: () => !this.message,
     });
     registry.registerCommand(Debug.Commands.TOGGLE_OPTIMIZE_FOR_DEBUG, {
       execute: () => this.toggleCompileForDebug(),
@@ -148,94 +180,56 @@ export class Debug extends SketchContribution {
     });
   }
 
-  private async refreshState(
-    board: Board | undefined = this.boardsServiceProvider.boardsConfig
+  private async updateMessage(): Promise<void> {
+    try {
+      await this.isDebugEnabled();
+      this.message = undefined;
+    } catch (err) {
+      let message = String(err);
+      if (err instanceof Error) {
+        message = err.message;
+      }
+      this.message = message;
+    }
+  }
+
+  private async isDebugEnabled(
+    board: BoardIdentifier | undefined = this.boardsServiceProvider.boardsConfig
       .selectedBoard
-  ): Promise<void> {
-    if (!board) {
-      this.disabledMessage = nls.localize(
-        'arduino/common/noBoardSelected',
-        'No board selected'
-      );
-      return;
-    }
-    const fqbn = board.fqbn;
-    if (!fqbn) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/noPlatformInstalledFor',
-        "Platform is not installed for '{0}'",
-        board.name
-      );
-      return;
-    }
-    const details = await this.boardService.getBoardDetails({ fqbn });
-    if (!details) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/noPlatformInstalledFor',
-        "Platform is not installed for '{0}'",
-        board.name
-      );
-      return;
-    }
-    const { debuggingSupported } = details;
-    if (!debuggingSupported) {
-      this.disabledMessage = nls.localize(
-        'arduino/debug/debuggingNotSupported',
-        "Debugging is not supported by '{0}'",
-        board.name
-      );
-    } else {
-      this.disabledMessage = undefined;
-    }
+  ): Promise<string> {
+    const debugFqbn = await isDebugEnabled(
+      board,
+      (fqbn) => this.boardService.getBoardDetails({ fqbn }),
+      (fqbn) => this.boardsDataStore.getData(fqbn),
+      (fqbn) => this.boardsDataStore.appendConfigToFqbn(fqbn),
+      (params) => this.boardService.checkDebugEnabled(params)
+    );
+    return debugFqbn;
   }
 
   private async startDebug(
     board: BoardIdentifier | undefined = this.boardsServiceProvider.boardsConfig
-      .selectedBoard
-  ): Promise<void> {
-    if (!board) {
-      return;
+      .selectedBoard,
+    sketch:
+      | CurrentSketch
+      | undefined = this.sketchServiceClient.tryGetCurrentSketch()
+  ): Promise<StartDebugResult> {
+    if (!CurrentSketch.isValid(sketch)) {
+      return false;
     }
-    const { name, fqbn } = board;
-    if (!fqbn) {
-      return;
+    const params = await this.createStartDebugParams(board);
+    if (!params) {
+      return false;
     }
     await this.hostedPluginSupport.didStart;
-    const [sketch, executables] = await Promise.all([
-      this.sketchServiceClient.currentSketch(),
-      this.executableService.list(),
-    ]);
-    if (!CurrentSketch.isValid(sketch)) {
-      return;
-    }
-    const ideTempFolderUri = await this.sketchesService.getIdeTempFolderUri(
-      sketch
-    );
-    const [cliPath, sketchPath, configPath] = await Promise.all([
-      this.fileService.fsPath(new URI(executables.cliUri)),
-      this.fileService.fsPath(new URI(sketch.uri)),
-      this.fileService.fsPath(new URI(ideTempFolderUri)),
-    ]);
-    const config = {
-      cliPath,
-      board: {
-        fqbn,
-        name,
-      },
-      sketchPath,
-      configPath,
-    };
     try {
-      await this.commandService.executeCommand('arduino.debug.start', config);
+      const result = await this.debug(params);
+      return Boolean(result);
     } catch (err) {
       if (await this.isSketchNotVerifiedError(err, sketch)) {
         const yes = nls.localize('vscode/extensionsUtils/yes', 'Yes');
         const answer = await this.messageService.error(
-          nls.localize(
-            'arduino/debug/sketchIsNotCompiled',
-            "Sketch '{0}' must be verified before starting a debug session. Please verify the sketch and start debugging again. Do you want to verify the sketch now?",
-            sketch.name
-          ),
+          sketchIsNotCompiled(sketch.name),
           yes
         );
         if (answer === yes) {
@@ -247,6 +241,16 @@ export class Debug extends SketchContribution {
         );
       }
     }
+    return false;
+  }
+
+  private async debug(
+    params: StartDebugParams
+  ): Promise<StartDebugResult | undefined> {
+    return this.commandService.executeCommand<StartDebugResult>(
+      'arduino.debug.start',
+      params
+    );
   }
 
   get compileForDebug(): boolean {
@@ -254,7 +258,7 @@ export class Debug extends SketchContribution {
     return value === 'true';
   }
 
-  async toggleCompileForDebug(): Promise<void> {
+  private toggleCompileForDebug(): void {
     const oldState = this.compileForDebug;
     const newState = !oldState;
     window.localStorage.setItem(COMPILE_FOR_DEBUG_KEY, String(newState));
@@ -263,7 +267,7 @@ export class Debug extends SketchContribution {
 
   private async isSketchNotVerifiedError(
     err: unknown,
-    sketch: Sketch
+    sketch: SketchRef
   ): Promise<boolean> {
     if (err instanceof Error) {
       try {
@@ -277,6 +281,48 @@ export class Debug extends SketchContribution {
     }
     return false;
   }
+
+  private async createStartDebugParams(
+    board: BoardIdentifier | undefined
+  ): Promise<StartDebugParams | undefined> {
+    if (!board || !board.fqbn) {
+      return undefined;
+    }
+    let debugFqbn: string | undefined = undefined;
+    try {
+      debugFqbn = await this.isDebugEnabled(board);
+    } catch {}
+    if (!debugFqbn) {
+      return undefined;
+    }
+    const [sketch, executables, boardsData] = await Promise.all([
+      this.sketchServiceClient.currentSketch(),
+      this.executableService.list(),
+      this.boardsDataStore.getData(board.fqbn),
+    ]);
+    if (!CurrentSketch.isValid(sketch)) {
+      return undefined;
+    }
+    const ideTempFolderUri = await this.sketchesService.getIdeTempFolderUri(
+      sketch
+    );
+    const [cliPath, sketchPath, launchConfigsDirPath] = await Promise.all([
+      this.fileService.fsPath(new URI(executables.cliUri)),
+      this.fileService.fsPath(new URI(sketch.uri)),
+      this.fileService.fsPath(new URI(ideTempFolderUri)),
+    ]);
+    return {
+      board: { fqbn: debugFqbn, name: board.name },
+      cliPath,
+      sketchPath,
+      launchConfigsDirPath,
+      programmer: boardsData.selectedProgrammer?.id,
+      title: nls.localize(
+        'arduino/debug/getDebugInfo',
+        'Getting debug info...'
+      ),
+    };
+  }
 }
 export namespace Debug {
   export namespace Commands {
@@ -301,3 +347,89 @@ export namespace Debug {
     };
   }
 }
+
+/**
+ * (non-API)
+ */
+export async function isDebugEnabled(
+  board: BoardIdentifier | undefined,
+  getDetails: (fqbn: string) => MaybePromise<BoardDetails | undefined>,
+  getData: (fqbn: string) => MaybePromise<BoardsDataStore.Data>,
+  appendConfigToFqbn: (fqbn: string) => MaybePromise<string | undefined>,
+  checkDebugEnabled: (params: CheckDebugEnabledParams) => MaybePromise<string>
+): Promise<string> {
+  if (!board) {
+    throw new Error(noBoardSelected);
+  }
+  const { fqbn } = board;
+  if (!fqbn) {
+    throw new Error(noPlatformInstalledFor(board.name));
+  }
+  const [details, data, fqbnWithConfig] = await Promise.all([
+    getDetails(fqbn),
+    getData(fqbn),
+    appendConfigToFqbn(fqbn),
+  ]);
+  if (!details) {
+    throw new Error(noPlatformInstalledFor(board.name));
+  }
+  if (!fqbnWithConfig) {
+    throw new Error(
+      `Failed to append boards config to the FQBN. Original FQBN was: ${fqbn}`
+    );
+  }
+  if (!data.selectedProgrammer) {
+    throw new Error(noProgrammerSelectedFor(board.name));
+  }
+  const params = {
+    fqbn: fqbnWithConfig,
+    programmer: data.selectedProgrammer.id,
+  };
+  try {
+    const debugFqbn = await checkDebugEnabled(params);
+    return debugFqbn;
+  } catch (err) {
+    throw new Error(debuggingNotSupported(board.name));
+  }
+}
+
+/**
+ * (non-API)
+ */
+export function sketchIsNotCompiled(sketchName: string): string {
+  return nls.localize(
+    'arduino/debug/sketchIsNotCompiled',
+    "Sketch '{0}' must be verified before starting a debug session. Please verify the sketch and start debugging again. Do you want to verify the sketch now?",
+    sketchName
+  );
+}
+/**
+ * (non-API)
+ */
+export function noPlatformInstalledFor(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/noPlatformInstalledFor',
+    "Platform is not installed for '{0}'",
+    boardName
+  );
+}
+/**
+ * (non-API)
+ */
+export function debuggingNotSupported(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/debuggingNotSupported',
+    "Debugging is not supported by '{0}'",
+    boardName
+  );
+}
+/**
+ * (non-API)
+ */
+export function noProgrammerSelectedFor(boardName: string): string {
+  return nls.localize(
+    'arduino/debug/noProgrammerSelectedFor',
+    "No programmer selected for '{0}'",
+    boardName
+  );
+}

arduino-ide-extension/src/browser/contributions/ino-language.ts

@@ -20,26 +20,83 @@ import { NotificationCenter } from '../notification-center';
 import { SketchContribution, URI } from './contribution';
 import { BoardsDataStore } from '../boards/boards-data-store';
 
+interface DaemonAddress {
+  /**
+   * The host where the Arduino CLI daemon is available.
+   */
+  readonly hostname: string;
+  /**
+   * The port where the Arduino CLI daemon is listening.
+   */
+  readonly port: number;
+  /**
+   * The [id](https://arduino.github.io/arduino-cli/latest/rpc/commands/#instance) of the initialized core Arduino client instance.
+   */
+  readonly instance: number;
+}
+
+interface StartLanguageServerParams {
+  /**
+   * Absolute filesystem path to the Arduino Language Server executable.
+   */
+  readonly lsPath: string;
+  /**
+   * The hostname and the port for the gRPC channel connecting to the Arduino CLI daemon.
+   * The `instance` number is for the initialized core Arduino client.
+   */
+  readonly daemonAddress: DaemonAddress;
+  /**
+   * Absolute filesystem path to [`clangd`](https://clangd.llvm.org/).
+   */
+  readonly clangdPath: string;
+  /**
+   * The board is relevant to start a specific "flavor" of the language.
+   */
+  readonly board: { fqbn: string; name?: string };
+  /**
+   * `true` if the LS should generate the log files into the default location. The default location is the `cwd` of the process.
+   * It's very often the same as the workspace root of the IDE, aka the sketch folder.
+   * When it is a string, it is the absolute filesystem path to the folder to generate the log files.
+   * If `string`, but the path is inaccessible, the log files will be generated into the default location.
+   */
+  readonly log?: boolean | string;
+  /**
+   * Optional `env` for the language server process.
+   */
+  readonly env?: NodeJS.ProcessEnv;
+  /**
+   * Additional flags for the Arduino Language server process.
+   */
+  readonly flags?: readonly string[];
+  /**
+   * Set to `true`, to enable `Diagnostics`.
+   */
+  readonly realTimeDiagnostics?: boolean;
+  /**
+   * If `true`, the logging is not forwarded to the _Output_ view via the language client.
+   */
+  readonly silentOutput?: boolean;
+}
+
+/**
+ * The FQBN the language server runs with or `undefined` if it could not start.
+ */
+type StartLanguageServerResult = string | undefined;
+
 @injectable()
 export class InoLanguage extends SketchContribution {
   @inject(HostedPluginEvents)
   private readonly hostedPluginEvents: HostedPluginEvents;
-
   @inject(ExecutableService)
   private readonly executableService: ExecutableService;
-
   @inject(ArduinoDaemon)
   private readonly daemon: ArduinoDaemon;
-
   @inject(BoardsService)
   private readonly boardsService: BoardsService;
-
   @inject(BoardsServiceProvider)
   private readonly boardsServiceProvider: BoardsServiceProvider;
-
   @inject(NotificationCenter)
   private readonly notificationCenter: NotificationCenter;
-
   @inject(BoardsDataStore)
   private readonly boardDataStore: BoardsDataStore;
 
@@ -129,6 +186,10 @@ export class InoLanguage extends SketchContribution {
     if (!port) {
       return;
     }
+    const portNumber = Number.parseInt(port, 10); // TODO: IDE2 APIs should provide a number and not string
+    if (Number.isNaN(portNumber)) {
+      return;
+    }
     const release = await this.languageServerStartMutex.acquire();
     const toDisposeOnRelease = new DisposableCollection();
     try {
@@ -197,22 +258,22 @@ export class InoLanguage extends SketchContribution {
           );
           toDisposeOnRelease.push(Disposable.create(() => clearTimeout(timer)));
         }),
-        this.commandService.executeCommand<string>(
-          'arduino.languageserver.start',
-          {
-            lsPath,
-            cliDaemonAddr: `localhost:${port}`,
-            clangdPath,
-            log: currentSketchPath ? currentSketchPath : log,
-            cliDaemonInstance: '1',
-            board: {
-              fqbn: fqbnWithConfig,
-              name: name ? `"${name}"` : undefined,
-            },
-            realTimeDiagnostics,
-            silentOutput: true,
-          }
-        ),
+        this.start({
+          lsPath,
+          daemonAddress: {
+            hostname: 'localhost',
+            port: portNumber,
+            instance: 1, // TODO: get it from the backend
+          },
+          clangdPath,
+          log: currentSketchPath ? currentSketchPath : log,
+          board: {
+            fqbn: fqbnWithConfig,
+            name,
+          },
+          realTimeDiagnostics,
+          silentOutput: true,
+        }),
       ]);
     } catch (e) {
       console.log(`Failed to start language server. Original FQBN: ${fqbn}`, e);
@@ -222,4 +283,13 @@ export class InoLanguage extends SketchContribution {
       release();
     }
   }
+
+  private async start(
+    params: StartLanguageServerParams
+  ): Promise<StartLanguageServerResult | undefined> {
+    return this.commandService.executeCommand<StartLanguageServerResult>(
+      'arduino.languageserver.start',
+      params
+    );
+  }
 }

arduino-ide-extension/src/browser/sketches-service-client-impl.ts

@@ -67,6 +67,7 @@ export class SketchesServiceClientImpl
   );
 
   private _currentSketch: CurrentSketch | undefined;
+  private _currentIdeTempFolderUri: URI | undefined;
   private currentSketchLoaded = new Deferred<CurrentSketch>();
 
   onStart(): void {
@@ -74,7 +75,10 @@ export class SketchesServiceClientImpl
     this.watchSketchbookDir(sketchDirUri);
     const refreshCurrentSketch = async () => {
       const currentSketch = await this.loadCurrentSketch();
-      this.useCurrentSketch(currentSketch);
+      const ideTempFolderUri = await this.getIdeTempFolderUriForSketch(
+        currentSketch
+      );
+      this.useCurrentSketch(currentSketch, ideTempFolderUri);
     };
     this.toDispose.push(
       this.configService.onDidChangeSketchDirUri((sketchDirUri) => {
@@ -141,7 +145,10 @@ export class SketchesServiceClientImpl
             }
 
             if (!Sketch.sameAs(this._currentSketch, reloadedSketch)) {
-              this.useCurrentSketch(reloadedSketch, true);
+              const ideTempFolderUri = await this.getIdeTempFolderUriForSketch(
+                reloadedSketch
+              );
+              this.useCurrentSketch(reloadedSketch, ideTempFolderUri, true);
             }
             return;
           }
@@ -179,11 +186,23 @@ export class SketchesServiceClientImpl
     ]);
   }
 
+  private async getIdeTempFolderUriForSketch(
+    sketch: CurrentSketch
+  ): Promise<URI | undefined> {
+    if (CurrentSketch.isValid(sketch)) {
+      const uri = await this.sketchesService.getIdeTempFolderUri(sketch);
+      return new URI(uri);
+    }
+    return undefined;
+  }
+
   private useCurrentSketch(
     currentSketch: CurrentSketch,
+    ideTempFolderUri: URI | undefined,
     reassignPromise = false
   ) {
     this._currentSketch = currentSketch;
+    this._currentIdeTempFolderUri = ideTempFolderUri;
     if (reassignPromise) {
       this.currentSketchLoaded = new Deferred();
     }
@@ -273,6 +292,14 @@ export class SketchesServiceClientImpl
       return false;
     }
 
+    if (
+      this._currentIdeTempFolderUri &&
+      this._currentIdeTempFolderUri.resolve('launch.json').toString() ===
+        toCheck.toString()
+    ) {
+      return false;
+    }
+
     const isCloudSketch = toCheck
       .toString()
       .includes(`${REMOTE_SKETCHBOOK_FOLDER}/${ARDUINO_CLOUD_FOLDER}`);

arduino-ide-extension/src/browser/theia/debug/debug-configuration-manager.ts

@@ -1,44 +1,44 @@
-import debounce from 'p-debounce';
-import { inject, injectable } from '@theia/core/shared/inversify';
-import URI from '@theia/core/lib/common/uri';
-import { Event, Emitter } from '@theia/core/lib/common/event';
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
-import { DebugConfiguration } from '@theia/debug/lib/common/debug-common';
-import { DebugConfigurationModel as TheiaDebugConfigurationModel } from '@theia/debug/lib/browser/debug-configuration-model';
+import { Disposable } from '@theia/core/lib/common/disposable';
+import { Emitter, Event } from '@theia/core/lib/common/event';
+import URI from '@theia/core/lib/common/uri';
+import { inject, injectable } from '@theia/core/shared/inversify';
 import { DebugConfigurationManager as TheiaDebugConfigurationManager } from '@theia/debug/lib/browser/debug-configuration-manager';
+import { DebugConfigurationModel as TheiaDebugConfigurationModel } from '@theia/debug/lib/browser/debug-configuration-model';
+import { DebugConfiguration } from '@theia/debug/lib/common/debug-common';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import {
+  FileOperationError,
+  FileOperationResult,
+} from '@theia/filesystem/lib/common/files';
+import debounce from 'p-debounce';
 import { SketchesService } from '../../../common/protocol';
 import {
   CurrentSketch,
   SketchesServiceClientImpl,
 } from '../../sketches-service-client-impl';
+import { maybeUpdateReadOnlyState } from '../monaco/monaco-editor-provider';
 import { DebugConfigurationModel } from './debug-configuration-model';
-import {
-  FileOperationError,
-  FileOperationResult,
-} from '@theia/filesystem/lib/common/files';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
 
 @injectable()
 export class DebugConfigurationManager extends TheiaDebugConfigurationManager {
   @inject(SketchesService)
-  protected readonly sketchesService: SketchesService;
-
+  private readonly sketchesService: SketchesService;
   @inject(SketchesServiceClientImpl)
-  protected readonly sketchesServiceClient: SketchesServiceClientImpl;
-
+  private readonly sketchesServiceClient: SketchesServiceClientImpl;
   @inject(FrontendApplicationStateService)
-  protected readonly appStateService: FrontendApplicationStateService;
-
+  private readonly appStateService: FrontendApplicationStateService;
   @inject(FileService)
-  protected readonly fileService: FileService;
+  private readonly fileService: FileService;
 
-  protected onTempContentDidChangeEmitter =
+  private onTempContentDidChangeEmitter =
     new Emitter<TheiaDebugConfigurationModel.JsonContent>();
   get onTempContentDidChange(): Event<TheiaDebugConfigurationModel.JsonContent> {
     return this.onTempContentDidChangeEmitter.event;
   }
 
   protected override async doInit(): Promise<void> {
+    this.watchLaunchConfigEditor();
     this.appStateService.reachedState('ready').then(async () => {
       const tempContent = await this.getTempLaunchJsonContent();
       if (!tempContent) {
@@ -75,6 +75,19 @@ export class DebugConfigurationManager extends TheiaDebugConfigurationManager {
     return super.doInit();
   }
 
+  /**
+   * Sets a listener on current sketch change, and maybe updates the readonly state of the editor showing the debug configuration. aka the `launch.json`.
+   */
+  private watchLaunchConfigEditor(): Disposable {
+    return this.sketchesServiceClient.onCurrentSketchDidChange(() => {
+      for (const widget of this.editorManager.all) {
+        maybeUpdateReadOnlyState(widget, (uri) =>
+          this.sketchesServiceClient.isReadOnly(uri)
+        );
+      }
+    });
+  }
+
   protected override updateModels = debounce(async () => {
     await this.appStateService.reachedState('ready');
     const roots = await this.workspaceService.roots;
@@ -111,7 +124,7 @@ export class DebugConfigurationManager extends TheiaDebugConfigurationManager {
     this.updateCurrent();
   }, 500);
 
-  protected async getTempLaunchJsonContent(): Promise<
+  private async getTempLaunchJsonContent(): Promise<
     (TheiaDebugConfigurationModel.JsonContent & { uri: URI }) | URI | undefined
   > {
     const sketch = await this.sketchesServiceClient.currentSketch();

arduino-ide-extension/src/browser/theia/debug/debug-configuration-widget.tsx

@@ -0,0 +1,57 @@
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { nls } from '@theia/core/lib/common/nls';
+import { injectable } from '@theia/core/shared/inversify';
+import React from '@theia/core/shared/react';
+import { DebugAction } from '@theia/debug/lib/browser/view/debug-action';
+import { DebugConfigurationSelect as TheiaDebugConfigurationSelect } from '@theia/debug/lib/browser/view/debug-configuration-select';
+import { DebugConfigurationWidget as TheiaDebugConfigurationWidget } from '@theia/debug/lib/browser/view/debug-configuration-widget';
+
+/**
+ * Patched to programmatically update the debug config <select> in the widget.
+ */
+@injectable()
+export class DebugConfigurationWidget extends TheiaDebugConfigurationWidget {
+  override render(): React.ReactNode {
+    return (
+      <React.Fragment>
+        <DebugAction
+          run={this.start}
+          label={nls.localizeByDefault('Start Debugging')}
+          iconClass="debug-start"
+          ref={this.setStepRef}
+        />
+        {/* The customized select component that will refresh when the config manager did change */}
+        <DebugConfigurationSelect
+          manager={this.manager}
+          quickInputService={this.quickInputService}
+          isMultiRoot={this.workspaceService.isMultiRootWorkspaceOpened}
+        />
+        <DebugAction
+          run={this.openConfiguration}
+          label={nls.localizeByDefault('Open {0}', '"launch.json"')}
+          iconClass="settings-gear"
+        />
+        <DebugAction
+          run={this.openConsole}
+          label={nls.localizeByDefault('Debug Console')}
+          iconClass="terminal"
+        />
+      </React.Fragment>
+    );
+  }
+}
+
+class DebugConfigurationSelect extends TheiaDebugConfigurationSelect {
+  private readonly toDisposeOnUnmount = new DisposableCollection();
+
+  override componentDidMount(): void {
+    super.componentDidMount();
+    this.toDisposeOnUnmount.push(
+      this['manager'].onDidChange(() => this.refreshDebugConfigurations())
+    );
+  }
+
+  override componentWillUnmount(): void {
+    this.toDisposeOnUnmount.dispose();
+  }
+}

arduino-ide-extension/src/browser/theia/debug/debug-session-manager.ts

@@ -0,0 +1,39 @@
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { DebugSession } from '@theia/debug/lib/browser/debug-session';
+import { DebugSessionManager as TheiaDebugSessionManager } from '@theia/debug/lib/browser/debug-session-manager';
+import { DebugConfigurationSessionOptions } from '@theia/debug/lib/browser/debug-session-options';
+import { WorkspaceService } from '@theia/workspace/lib/browser/workspace-service';
+import deepEqual from 'fast-deep-equal';
+
+@injectable()
+export class DebugSessionManager extends TheiaDebugSessionManager {
+  @inject(WorkspaceService)
+  private readonly workspaceService: WorkspaceService;
+
+  protected override doStart(
+    sessionId: string,
+    options: DebugConfigurationSessionOptions
+  ): Promise<DebugSession> {
+    this.syncCurrentOptions(options);
+    return super.doStart(sessionId, options);
+  }
+
+  /**
+   * If the debug config manager knows about the currently started options, and it's not the currently selected one, select it.
+   */
+  private syncCurrentOptions(options: DebugConfigurationSessionOptions): void {
+    const knownConfigOptions = this.debugConfigurationManager.find(
+      options.configuration,
+      options.workspaceFolderUri ??
+        this.workspaceService
+          .tryGetRoots()
+          .map((stat) => stat.resource.toString())[0]
+    );
+    if (
+      knownConfigOptions &&
+      !deepEqual(knownConfigOptions, this.debugConfigurationManager.current)
+    ) {
+      this.debugConfigurationManager.current = knownConfigOptions;
+    }
+  }
+}

arduino-ide-extension/src/browser/theia/monaco/monaco-editor-provider.ts

@@ -1,17 +1,20 @@
-import { inject, injectable } from '@theia/core/shared/inversify';
-import URI from '@theia/core/lib/common/uri';
+import { LOCKED_CLASS, lock } from '@theia/core/lib/browser/widgets/widget';
 import {
   Disposable,
   DisposableCollection,
 } from '@theia/core/lib/common/disposable';
+import URI from '@theia/core/lib/common/uri';
+import { Title, Widget } from '@theia/core/shared/@phosphor/widgets';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { EditorWidget } from '@theia/editor/lib/browser/editor-widget';
+import * as monaco from '@theia/monaco-editor-core';
+import type { ReferencesModel } from '@theia/monaco-editor-core/esm/vs/editor/contrib/gotoSymbol/browser/referencesModel';
 import {
   EditorServiceOverrides,
   MonacoEditor,
 } from '@theia/monaco/lib/browser/monaco-editor';
 import { MonacoEditorProvider as TheiaMonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
 import { SketchesServiceClientImpl } from '../../sketches-service-client-impl';
-import * as monaco from '@theia/monaco-editor-core';
-import type { ReferencesModel } from '@theia/monaco-editor-core/esm/vs/editor/contrib/gotoSymbol/browser/referencesModel';
 
 type CancelablePromise = Promise<ReferencesModel> & {
   cancel: () => void;
@@ -101,3 +104,30 @@ export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
     editor.updateOptions({ readOnly });
   }
 }
+
+// Theia cannot dynamically set an editor to writable once it was readonly.
+export function maybeUpdateReadOnlyState(
+  widget: EditorWidget,
+  isReadOnly: (uri: string | URI | monaco.Uri) => boolean
+): void {
+  const editor = widget.editor;
+  if (!(editor instanceof MonacoEditor)) {
+    return;
+  }
+  const model = editor.document;
+  const oldReadOnly = model.readOnly;
+  const resource = model['resource'];
+  const newReadOnly = Boolean(resource.isReadonly) || isReadOnly(resource.uri);
+  if (oldReadOnly !== newReadOnly) {
+    editor.getControl().updateOptions({ readOnly: newReadOnly });
+    if (newReadOnly) {
+      lock(widget.title);
+    } else {
+      unlock(widget.title);
+    }
+  }
+}
+
+function unlock(title: Title<Widget>): void {
+  title.className = title.className.replace(LOCKED_CLASS, '').trim();
+}

arduino-ide-extension/src/browser/theia/monaco/monaco-text-model-service.ts

@@ -77,7 +77,7 @@ class MaybeReadonlyMonacoEditorModel extends SilentMonacoEditorModel {
     }
     this._dirty = dirty;
     if (dirty === false) {
-      (this as any).updateSavedVersionId();
+      this['updateSavedVersionId']();
     }
     this.onDirtyChangedEmitter.fire(undefined);
   }

arduino-ide-extension/src/common/nls.ts

@@ -20,8 +20,22 @@ export const InstallManually = nls.localize(
   'arduino/common/installManually',
   'Install Manually'
 );
+export const SelectManually = nls.localize(
+  'arduino/common/selectManually',
+  'Select Manually'
+);
 
 export const serialMonitorWidgetLabel = nls.localize(
   'arduino/common/serialMonitor',
   'Serial Monitor'
 );
+
+export const noBoardSelected = nls.localize(
+  'arduino/common/noBoardSelected',
+  'No board selected'
+);
+
+export const noSketchOpened = nls.localize(
+  'arduino/common/noSketchOpened',
+  'No sketch opened'
+);

arduino-ide-extension/src/common/protocol/boards-service.ts

@@ -80,6 +80,22 @@ export interface BoardsService
     fqbn: string;
     protocol: string;
   }): Promise<BoardUserField[]>;
+  /**
+   * Checks whether the debugging is enabled with the FQBN, programmer, current sketch, and custom board options.
+   *
+   * When the debugging is enabled, the promise resolves with the FQBN to use with the debugger. This is the same
+   * FQBN given in the `CheckDebugEnabledParams#fqbn` but cleaned up of the board options that do not affect the debugger configuration.
+   * It may be used by clients/IDE to group slightly different boards option selections under the same debug configuration.
+   */
+  checkDebugEnabled(params: CheckDebugEnabledParams): Promise<string>;
+}
+
+export interface CheckDebugEnabledParams {
+  /**
+   * The FQBN might contain custom board config options. For example, `arduino:esp32:nano_nora:USBMode=hwcdc,option2=value2`.
+   */
+  readonly fqbn: string;
+  readonly programmer: string;
 }
 
 export interface BoardSearch extends Searchable.Options {
@@ -330,10 +346,10 @@ export interface BoardDetails {
   readonly requiredTools: Tool[];
   readonly configOptions: ConfigOption[];
   readonly programmers: Programmer[];
-  readonly debuggingSupported: boolean;
   readonly VID: string;
   readonly PID: string;
   readonly buildProperties: string[];
+  readonly defaultProgrammerId?: string;
 }
 
 export interface Tool {
@@ -425,6 +441,18 @@ export namespace Programmer {
     );
   }
 }
+export function isProgrammer(arg: unknown): arg is Programmer {
+  return (
+    typeof arg === 'object' &&
+    arg !== null &&
+    (<Programmer>arg).id !== undefined &&
+    typeof (<Programmer>arg).id === 'string' &&
+    (<Programmer>arg).name !== undefined &&
+    typeof (<Programmer>arg).name === 'string' &&
+    (<Programmer>arg).platform !== undefined &&
+    typeof (<Programmer>arg).platform === 'string'
+  );
+}
 
 export namespace Board {
   export function is(board: any): board is Board {

arduino-ide-extension/src/common/protocol/sketches-service.ts

@@ -121,7 +121,7 @@ export interface SketchesService {
    * Hence, IDE2 has to provide multiple build paths on Windows. This hack will be obsolete when the CLI can provide error codes:
    * https://github.com/arduino/arduino-cli/issues/1762.
    */
-  tempBuildPath(sketch: Sketch): Promise<string[]>;
+  tempBuildPath(sketch: SketchRef): Promise<string[]>;
 }
 
 export interface SketchRef {
@@ -308,7 +308,7 @@ export namespace Sketch {
   export namespace Extensions {
     export const DEFAULT = '.ino';
     export const MAIN = [DEFAULT, '.pde'];
-    export const SOURCE = ['.c', '.cpp', '.S'];
+    export const SOURCE = ['.c', '.cpp', '.S', '.cxx', '.cc'];
     export const CODE_FILES = [
       ...MAIN,
       ...SOURCE,

arduino-ide-extension/src/node/board-discovery.ts

@@ -1,4 +1,4 @@
-import type { ClientDuplexStream } from '@grpc/grpc-js';
+import type { ClientReadableStream } from '@grpc/grpc-js';
 import {
   Disposable,
   DisposableCollection,
@@ -30,9 +30,9 @@ import type { Port as RpcPort } from './cli-protocol/cc/arduino/cli/commands/v1/
 import { CoreClientAware } from './core-client-provider';
 import { ServiceError } from './service-error';
 
-type Duplex = ClientDuplexStream<BoardListWatchRequest, BoardListWatchResponse>;
+type Stream = ClientReadableStream<BoardListWatchResponse>;
 interface StreamWrapper extends Disposable {
-  readonly stream: Duplex;
+  readonly stream: Stream;
   readonly uuid: string; // For logging only
 }
 
@@ -121,34 +121,15 @@ export class BoardDiscovery
     return Disposable.create(() => clearTimeout(timer));
   }
 
-  private async requestStartWatch(
-    req: BoardListWatchRequest,
-    duplex: Duplex
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      if (
-        !duplex.write(req, (err: Error | undefined) => {
-          if (err) {
-            reject(err);
-            return;
-          }
-        })
-      ) {
-        duplex.once('drain', resolve);
-      } else {
-        process.nextTick(resolve);
-      }
-    });
-  }
-
   private async createWrapper(
-    client: ArduinoCoreServiceClient
+    client: ArduinoCoreServiceClient,
+    req: BoardListWatchRequest
   ): Promise<StreamWrapper> {
     if (this.wrapper) {
       throw new Error(`Duplex was already set.`);
     }
     const stream = client
-      .boardListWatch()
+      .boardListWatch(req)
       .on('end', () => {
         this.logger.info('received end');
         this.onStreamDidEndEmitter.fire();
@@ -202,14 +183,11 @@ export class BoardDiscovery
     this.watching = new Deferred();
     this.logger.info('start new deferred');
     const { client, instance } = await this.coreClient;
-    const wrapper = await this.createWrapper(client);
-    wrapper.stream.on('data', (resp) => this.onBoardListWatchResponse(resp));
-    this.logger.info('start request start watch');
-    await this.requestStartWatch(
-      new BoardListWatchRequest().setInstance(instance),
-      wrapper.stream
+    const wrapper = await this.createWrapper(
+      client,
+      new BoardListWatchRequest().setInstance(instance)
     );
-    this.logger.info('start requested start watch');
+    wrapper.stream.on('data', (resp) => this.onBoardListWatchResponse(resp));
     this.watching.resolve();
     this.logger.info('start resolved watching');
   }

arduino-ide-extension/src/node/boards-service-impl.ts

@@ -1,27 +1,38 @@
-import { injectable, inject } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core/lib/common/logger';
+import { nls } from '@theia/core/lib/common/nls';
 import { notEmpty } from '@theia/core/lib/common/objects';
+import { inject, injectable } from '@theia/core/shared/inversify';
 import {
-  BoardsService,
-  Installable,
-  BoardsPackage,
   Board,
   BoardDetails,
+  BoardSearch,
+  BoardUserField,
+  BoardWithPackage,
+  BoardsPackage,
+  BoardsService,
+  CheckDebugEnabledParams,
   ConfigOption,
   ConfigValue,
+  DetectedPorts,
+  Installable,
+  NotificationServiceServer,
   Programmer,
   ResponseService,
-  NotificationServiceServer,
-  DetectedPorts,
-  BoardWithPackage,
-  BoardUserField,
-  BoardSearch,
-  sortComponents,
   SortGroup,
-  platformInstallFailed,
   createPlatformIdentifier,
   platformIdentifierEquals,
+  platformInstallFailed,
+  sortComponents,
 } from '../common/protocol';
+import { BoardDiscovery } from './board-discovery';
+import {
+  BoardDetailsRequest,
+  BoardDetailsResponse,
+  BoardListAllRequest,
+  BoardListAllResponse,
+  BoardSearchRequest,
+} from './cli-protocol/cc/arduino/cli/commands/v1/board_pb';
+import { Platform } from './cli-protocol/cc/arduino/cli/commands/v1/common_pb';
 import {
   PlatformInstallRequest,
   PlatformListRequest,
@@ -30,25 +41,16 @@ import {
   PlatformSearchResponse,
   PlatformUninstallRequest,
 } from './cli-protocol/cc/arduino/cli/commands/v1/core_pb';
-import { Platform } from './cli-protocol/cc/arduino/cli/commands/v1/common_pb';
-import { BoardDiscovery } from './board-discovery';
-import { CoreClientAware } from './core-client-provider';
-import {
-  BoardDetailsRequest,
-  BoardDetailsResponse,
-  BoardListAllRequest,
-  BoardListAllResponse,
-  BoardSearchRequest,
-} from './cli-protocol/cc/arduino/cli/commands/v1/board_pb';
+import { IsDebugSupportedRequest } from './cli-protocol/cc/arduino/cli/commands/v1/debug_pb';
 import {
   ListProgrammersAvailableForUploadRequest,
   ListProgrammersAvailableForUploadResponse,
   SupportedUserFieldsRequest,
   SupportedUserFieldsResponse,
 } from './cli-protocol/cc/arduino/cli/commands/v1/upload_pb';
+import { CoreClientAware } from './core-client-provider';
 import { ExecuteWithProgress } from './grpc-progressible';
 import { ServiceError } from './service-error';
-import { nls } from '@theia/core/lib/common';
 
 @injectable()
 export class BoardsServiceImpl
@@ -99,8 +101,6 @@ export class BoardsServiceImpl
       return undefined;
     }
 
-    const debuggingSupported = detailsResp.getDebuggingSupported();
-
     const requiredTools = detailsResp.getToolsDependenciesList().map((t) => ({
       name: t.getName(),
       packager: t.getPackager(),
@@ -146,6 +146,7 @@ export class BoardsServiceImpl
           platform: p.getPlatform(),
         }
     );
+    const defaultProgrammerId = detailsResp.getDefaultProgrammerId();
 
     let VID = 'N/A';
     let PID = 'N/A';
@@ -164,13 +165,43 @@ export class BoardsServiceImpl
       requiredTools,
       configOptions,
       programmers,
-      debuggingSupported,
       VID,
       PID,
       buildProperties,
+      ...(defaultProgrammerId ? { defaultProgrammerId } : {}),
     };
   }
 
+  async checkDebugEnabled(params: CheckDebugEnabledParams): Promise<string> {
+    const { fqbn, programmer } = params;
+    const { client, instance } = await this.coreClient;
+    const req = new IsDebugSupportedRequest()
+      .setInstance(instance)
+      .setFqbn(fqbn)
+      .setProgrammer(programmer);
+    try {
+      const debugFqbn = await new Promise<string>((resolve, reject) =>
+        client.isDebugSupported(req, (err, resp) => {
+          if (err) {
+            reject(err);
+            return;
+          }
+          if (resp.getDebuggingSupported()) {
+            const debugFqbn = resp.getDebugFqbn();
+            if (debugFqbn) {
+              resolve(debugFqbn);
+            }
+          }
+          reject(new Error(`Debugging is not supported.`));
+        })
+      );
+      return debugFqbn;
+    } catch (err) {
+      console.error(`Failed to get debug config: ${fqbn}, ${programmer}`, err);
+      throw err;
+    }
+  }
+
   async getBoardPackage(options: {
     id: string;
   }): Promise<BoardsPackage | undefined> {

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/board_pb.d.ts

@@ -74,8 +74,6 @@ export class BoardDetailsResponse extends jspb.Message {
     getProgrammersList(): Array<cc_arduino_cli_commands_v1_common_pb.Programmer>;
     setProgrammersList(value: Array<cc_arduino_cli_commands_v1_common_pb.Programmer>): BoardDetailsResponse;
     addProgrammers(value?: cc_arduino_cli_commands_v1_common_pb.Programmer, index?: number): cc_arduino_cli_commands_v1_common_pb.Programmer;
-    getDebuggingSupported(): boolean;
-    setDebuggingSupported(value: boolean): BoardDetailsResponse;
     clearIdentificationPropertiesList(): void;
     getIdentificationPropertiesList(): Array<BoardIdentificationProperties>;
     setIdentificationPropertiesList(value: Array<BoardIdentificationProperties>): BoardDetailsResponse;
@@ -84,6 +82,8 @@ export class BoardDetailsResponse extends jspb.Message {
     getBuildPropertiesList(): Array<string>;
     setBuildPropertiesList(value: Array<string>): BoardDetailsResponse;
     addBuildProperties(value: string, index?: number): string;
+    getDefaultProgrammerId(): string;
+    setDefaultProgrammerId(value: string): BoardDetailsResponse;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): BoardDetailsResponse.AsObject;
@@ -109,9 +109,9 @@ export namespace BoardDetailsResponse {
         toolsDependenciesList: Array<ToolsDependencies.AsObject>,
         configOptionsList: Array<ConfigOption.AsObject>,
         programmersList: Array<cc_arduino_cli_commands_v1_common_pb.Programmer.AsObject>,
-        debuggingSupported: boolean,
         identificationPropertiesList: Array<BoardIdentificationProperties.AsObject>,
         buildPropertiesList: Array<string>,
+        defaultProgrammerId: string,
     }
 }
 
@@ -488,8 +488,6 @@ export class BoardListWatchRequest extends jspb.Message {
     clearInstance(): void;
     getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
     setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): BoardListWatchRequest;
-    getInterrupt(): boolean;
-    setInterrupt(value: boolean): BoardListWatchRequest;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): BoardListWatchRequest.AsObject;
@@ -504,7 +502,6 @@ export class BoardListWatchRequest extends jspb.Message {
 export namespace BoardListWatchRequest {
     export type AsObject = {
         instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
-        interrupt: boolean,
     }
 }
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/board_pb.js

@@ -730,10 +730,10 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.toObject = function(includ
     proto.cc.arduino.cli.commands.v1.ConfigOption.toObject, includeInstance),
     programmersList: jspb.Message.toObjectList(msg.getProgrammersList(),
     cc_arduino_cli_commands_v1_common_pb.Programmer.toObject, includeInstance),
-    debuggingSupported: jspb.Message.getBooleanFieldWithDefault(msg, 14, false),
     identificationPropertiesList: jspb.Message.toObjectList(msg.getIdentificationPropertiesList(),
     proto.cc.arduino.cli.commands.v1.BoardIdentificationProperties.toObject, includeInstance),
-    buildPropertiesList: (f = jspb.Message.getRepeatedField(msg, 16)) == null ? undefined : f
+    buildPropertiesList: (f = jspb.Message.getRepeatedField(msg, 16)) == null ? undefined : f,
+    defaultProgrammerId: jspb.Message.getFieldWithDefault(msg, 17, "")
   };
 
   if (includeInstance) {
@@ -823,10 +823,6 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.deserializeBinaryFromReade
       reader.readMessage(value,cc_arduino_cli_commands_v1_common_pb.Programmer.deserializeBinaryFromReader);
       msg.addProgrammers(value);
       break;
-    case 14:
-      var value = /** @type {boolean} */ (reader.readBool());
-      msg.setDebuggingSupported(value);
-      break;
     case 15:
       var value = new proto.cc.arduino.cli.commands.v1.BoardIdentificationProperties;
       reader.readMessage(value,proto.cc.arduino.cli.commands.v1.BoardIdentificationProperties.deserializeBinaryFromReader);
@@ -836,6 +832,10 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.deserializeBinaryFromReade
       var value = /** @type {string} */ (reader.readString());
       msg.addBuildProperties(value);
       break;
+    case 17:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setDefaultProgrammerId(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -954,13 +954,6 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.serializeBinaryToWriter =
       cc_arduino_cli_commands_v1_common_pb.Programmer.serializeBinaryToWriter
     );
   }
-  f = message.getDebuggingSupported();
-  if (f) {
-    writer.writeBool(
-      14,
-      f
-    );
-  }
   f = message.getIdentificationPropertiesList();
   if (f.length > 0) {
     writer.writeRepeatedMessage(
@@ -976,6 +969,13 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.serializeBinaryToWriter =
       f
     );
   }
+  f = message.getDefaultProgrammerId();
+  if (f.length > 0) {
+    writer.writeString(
+      17,
+      f
+    );
+  }
 };
 
 
@@ -1293,24 +1293,6 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.clearProgrammers
 };
 
 
-/**
- * optional bool debugging_supported = 14;
- * @return {boolean}
- */
-proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.getDebuggingSupported = function() {
-  return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 14, false));
-};
-
-
-/**
- * @param {boolean} value
- * @return {!proto.cc.arduino.cli.commands.v1.BoardDetailsResponse} returns this
- */
-proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.setDebuggingSupported = function(value) {
-  return jspb.Message.setProto3BooleanField(this, 14, value);
-};
-
-
 /**
  * repeated BoardIdentificationProperties identification_properties = 15;
  * @return {!Array<!proto.cc.arduino.cli.commands.v1.BoardIdentificationProperties>}
@@ -1386,6 +1368,24 @@ proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.clearBuildProper
 };
 
 
+/**
+ * optional string default_programmer_id = 17;
+ * @return {string}
+ */
+proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.getDefaultProgrammerId = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 17, ""));
+};
+
+
+/**
+ * @param {string} value
+ * @return {!proto.cc.arduino.cli.commands.v1.BoardDetailsResponse} returns this
+ */
+proto.cc.arduino.cli.commands.v1.BoardDetailsResponse.prototype.setDefaultProgrammerId = function(value) {
+  return jspb.Message.setProto3StringField(this, 17, value);
+};
+
+
 
 
 
@@ -4181,8 +4181,7 @@ proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.prototype.toObject = func
  */
 proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.toObject = function(includeInstance, msg) {
   var f, obj = {
-    instance: (f = msg.getInstance()) && cc_arduino_cli_commands_v1_common_pb.Instance.toObject(includeInstance, f),
-    interrupt: jspb.Message.getBooleanFieldWithDefault(msg, 2, false)
+    instance: (f = msg.getInstance()) && cc_arduino_cli_commands_v1_common_pb.Instance.toObject(includeInstance, f)
   };
 
   if (includeInstance) {
@@ -4224,10 +4223,6 @@ proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.deserializeBinaryFromRead
       reader.readMessage(value,cc_arduino_cli_commands_v1_common_pb.Instance.deserializeBinaryFromReader);
       msg.setInstance(value);
       break;
-    case 2:
-      var value = /** @type {boolean} */ (reader.readBool());
-      msg.setInterrupt(value);
-      break;
     default:
       reader.skipField();
       break;
@@ -4265,13 +4260,6 @@ proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.serializeBinaryToWriter =
       cc_arduino_cli_commands_v1_common_pb.Instance.serializeBinaryToWriter
     );
   }
-  f = message.getInterrupt();
-  if (f) {
-    writer.writeBool(
-      2,
-      f
-    );
-  }
 };
 
 
@@ -4312,24 +4300,6 @@ proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.prototype.hasInstance = f
 };
 
 
-/**
- * optional bool interrupt = 2;
- * @return {boolean}
- */
-proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.prototype.getInterrupt = function() {
-  return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 2, false));
-};
-
-
-/**
- * @param {boolean} value
- * @return {!proto.cc.arduino.cli.commands.v1.BoardListWatchRequest} returns this
- */
-proto.cc.arduino.cli.commands.v1.BoardListWatchRequest.prototype.setInterrupt = function(value) {
-  return jspb.Message.setProto3BooleanField(this, 2, value);
-};
-
-
 
 
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_grpc_pb.d.ts

@@ -11,6 +11,7 @@ import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino
 import * as cc_arduino_cli_commands_v1_board_pb from "../../../../../cc/arduino/cli/commands/v1/board_pb";
 import * as cc_arduino_cli_commands_v1_compile_pb from "../../../../../cc/arduino/cli/commands/v1/compile_pb";
 import * as cc_arduino_cli_commands_v1_core_pb from "../../../../../cc/arduino/cli/commands/v1/core_pb";
+import * as cc_arduino_cli_commands_v1_debug_pb from "../../../../../cc/arduino/cli/commands/v1/debug_pb";
 import * as cc_arduino_cli_commands_v1_monitor_pb from "../../../../../cc/arduino/cli/commands/v1/monitor_pb";
 import * as cc_arduino_cli_commands_v1_upload_pb from "../../../../../cc/arduino/cli/commands/v1/upload_pb";
 import * as cc_arduino_cli_commands_v1_lib_pb from "../../../../../cc/arduino/cli/commands/v1/lib_pb";
@@ -55,6 +56,9 @@ interface IArduinoCoreServiceService extends grpc.ServiceDefinition<grpc.Untyped
     libraryList: IArduinoCoreServiceService_ILibraryList;
     monitor: IArduinoCoreServiceService_IMonitor;
     enumerateMonitorPortSettings: IArduinoCoreServiceService_IEnumerateMonitorPortSettings;
+    debug: IArduinoCoreServiceService_IDebug;
+    isDebugSupported: IArduinoCoreServiceService_IIsDebugSupported;
+    getDebugConfig: IArduinoCoreServiceService_IGetDebugConfig;
 }
 
 interface IArduinoCoreServiceService_ICreate extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_commands_pb.CreateRequest, cc_arduino_cli_commands_v1_commands_pb.CreateResponse> {
@@ -185,7 +189,7 @@ interface IArduinoCoreServiceService_IBoardSearch extends grpc.MethodDefinition<
 }
 interface IArduinoCoreServiceService_IBoardListWatch extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse> {
     path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardListWatch";
-    requestStream: true;
+    requestStream: false;
     responseStream: true;
     requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest>;
     requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest>;
@@ -408,6 +412,33 @@ interface IArduinoCoreServiceService_IEnumerateMonitorPortSettings extends grpc.
     responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse>;
     responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse>;
 }
+interface IArduinoCoreServiceService_IDebug extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/Debug";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.DebugRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.DebugRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+}
+interface IArduinoCoreServiceService_IIsDebugSupported extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/IsDebugSupported";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse>;
+}
+interface IArduinoCoreServiceService_IGetDebugConfig extends grpc.MethodDefinition<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse> {
+    path: "/cc.arduino.cli.commands.v1.ArduinoCoreService/GetDebugConfig";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest>;
+    requestDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest>;
+    responseSerialize: grpc.serialize<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse>;
+    responseDeserialize: grpc.deserialize<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse>;
+}
 
 export const ArduinoCoreServiceService: IArduinoCoreServiceService;
 
@@ -426,7 +457,7 @@ export interface IArduinoCoreServiceServer extends grpc.UntypedServiceImplementa
     boardList: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardListRequest, cc_arduino_cli_commands_v1_board_pb.BoardListResponse>;
     boardListAll: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardListAllRequest, cc_arduino_cli_commands_v1_board_pb.BoardListAllResponse>;
     boardSearch: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse>;
-    boardListWatch: grpc.handleBidiStreamingCall<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    boardListWatch: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
     compile: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_compile_pb.CompileRequest, cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
     platformInstall: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
     platformDownload: grpc.handleServerStreamingCall<cc_arduino_cli_commands_v1_core_pb.PlatformDownloadRequest, cc_arduino_cli_commands_v1_core_pb.PlatformDownloadResponse>;
@@ -451,6 +482,9 @@ export interface IArduinoCoreServiceServer extends grpc.UntypedServiceImplementa
     libraryList: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_lib_pb.LibraryListRequest, cc_arduino_cli_commands_v1_lib_pb.LibraryListResponse>;
     monitor: grpc.handleBidiStreamingCall<cc_arduino_cli_commands_v1_monitor_pb.MonitorRequest, cc_arduino_cli_commands_v1_monitor_pb.MonitorResponse>;
     enumerateMonitorPortSettings: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse>;
+    debug: grpc.handleBidiStreamingCall<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    isDebugSupported: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse>;
+    getDebugConfig: grpc.handleUnaryCall<cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse>;
 }
 
 export interface IArduinoCoreServiceClient {
@@ -493,9 +527,8 @@ export interface IArduinoCoreServiceClient {
     boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
     boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
     boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
-    boardListWatch(): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
-    boardListWatch(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
-    boardListWatch(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    boardListWatch(request: cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    boardListWatch(request: cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
     compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
     compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
     platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
@@ -553,6 +586,15 @@ export interface IArduinoCoreServiceClient {
     enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
     enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
     enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
+    debug(): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    debug(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    debug(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
 }
 
 export class ArduinoCoreServiceClient extends grpc.Client implements IArduinoCoreServiceClient {
@@ -596,8 +638,8 @@ export class ArduinoCoreServiceClient extends grpc.Client implements IArduinoCor
     public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
     public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
     public boardSearch(request: cc_arduino_cli_commands_v1_board_pb.BoardSearchRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_board_pb.BoardSearchResponse) => void): grpc.ClientUnaryCall;
-    public boardListWatch(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
-    public boardListWatch(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    public boardListWatch(request: cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
+    public boardListWatch(request: cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse>;
     public compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
     public compile(request: cc_arduino_cli_commands_v1_compile_pb.CompileRequest, metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_compile_pb.CompileResponse>;
     public platformInstall(request: cc_arduino_cli_commands_v1_core_pb.PlatformInstallRequest, options?: Partial<grpc.CallOptions>): grpc.ClientReadableStream<cc_arduino_cli_commands_v1_core_pb.PlatformInstallResponse>;
@@ -654,4 +696,12 @@ export class ArduinoCoreServiceClient extends grpc.Client implements IArduinoCor
     public enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
     public enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
     public enumerateMonitorPortSettings(request: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse) => void): grpc.ClientUnaryCall;
+    public debug(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    public debug(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_commands_v1_debug_pb.DebugRequest, cc_arduino_cli_commands_v1_debug_pb.DebugResponse>;
+    public isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    public isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    public isDebugSupported(request: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse) => void): grpc.ClientUnaryCall;
+    public getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    public getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
+    public getDebugConfig(request: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
 }

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_grpc_pb.js

@@ -23,6 +23,7 @@ var cc_arduino_cli_commands_v1_common_pb = require('../../../../../cc/arduino/cl
 var cc_arduino_cli_commands_v1_board_pb = require('../../../../../cc/arduino/cli/commands/v1/board_pb.js');
 var cc_arduino_cli_commands_v1_compile_pb = require('../../../../../cc/arduino/cli/commands/v1/compile_pb.js');
 var cc_arduino_cli_commands_v1_core_pb = require('../../../../../cc/arduino/cli/commands/v1/core_pb.js');
+var cc_arduino_cli_commands_v1_debug_pb = require('../../../../../cc/arduino/cli/commands/v1/debug_pb.js');
 var cc_arduino_cli_commands_v1_monitor_pb = require('../../../../../cc/arduino/cli/commands/v1/monitor_pb.js');
 var cc_arduino_cli_commands_v1_upload_pb = require('../../../../../cc/arduino/cli/commands/v1/upload_pb.js');
 var cc_arduino_cli_commands_v1_lib_pb = require('../../../../../cc/arduino/cli/commands/v1/lib_pb.js');
@@ -225,6 +226,28 @@ function deserialize_cc_arduino_cli_commands_v1_CreateResponse(buffer_arg) {
   return cc_arduino_cli_commands_v1_commands_pb.CreateResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_cc_arduino_cli_commands_v1_DebugRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.DebugRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.DebugRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_DebugRequest(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.DebugRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_commands_v1_DebugResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.DebugResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.DebugResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_DebugResponse(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.DebugResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_cc_arduino_cli_commands_v1_DestroyRequest(arg) {
   if (!(arg instanceof cc_arduino_cli_commands_v1_commands_pb.DestroyRequest)) {
     throw new Error('Expected argument of type cc.arduino.cli.commands.v1.DestroyRequest');
@@ -269,6 +292,28 @@ function deserialize_cc_arduino_cli_commands_v1_EnumerateMonitorPortSettingsResp
   return cc_arduino_cli_commands_v1_monitor_pb.EnumerateMonitorPortSettingsResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_cc_arduino_cli_commands_v1_GetDebugConfigRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.GetDebugConfigRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_GetDebugConfigRequest(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_commands_v1_GetDebugConfigResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.GetDebugConfigResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_GetDebugConfigResponse(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_cc_arduino_cli_commands_v1_GitLibraryInstallRequest(arg) {
   if (!(arg instanceof cc_arduino_cli_commands_v1_lib_pb.GitLibraryInstallRequest)) {
     throw new Error('Expected argument of type cc.arduino.cli.commands.v1.GitLibraryInstallRequest');
@@ -313,6 +358,28 @@ function deserialize_cc_arduino_cli_commands_v1_InitResponse(buffer_arg) {
   return cc_arduino_cli_commands_v1_commands_pb.InitResponse.deserializeBinary(new Uint8Array(buffer_arg));
 }
 
+function serialize_cc_arduino_cli_commands_v1_IsDebugSupportedRequest(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.IsDebugSupportedRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_IsDebugSupportedRequest(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_cc_arduino_cli_commands_v1_IsDebugSupportedResponse(arg) {
+  if (!(arg instanceof cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse)) {
+    throw new Error('Expected argument of type cc.arduino.cli.commands.v1.IsDebugSupportedResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_cc_arduino_cli_commands_v1_IsDebugSupportedResponse(buffer_arg) {
+  return cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
 function serialize_cc_arduino_cli_commands_v1_LibraryDownloadRequest(arg) {
   if (!(arg instanceof cc_arduino_cli_commands_v1_lib_pb.LibraryDownloadRequest)) {
     throw new Error('Expected argument of type cc.arduino.cli.commands.v1.LibraryDownloadRequest');
@@ -1065,7 +1132,7 @@ boardSearch: {
   // List boards connection and disconnected events.
 boardListWatch: {
     path: '/cc.arduino.cli.commands.v1.ArduinoCoreService/BoardListWatch',
-    requestStream: true,
+    requestStream: false,
     responseStream: true,
     requestType: cc_arduino_cli_commands_v1_board_pb.BoardListWatchRequest,
     responseType: cc_arduino_cli_commands_v1_board_pb.BoardListWatchResponse,
@@ -1367,5 +1434,41 @@ enumerateMonitorPortSettings: {
     responseSerialize: serialize_cc_arduino_cli_commands_v1_EnumerateMonitorPortSettingsResponse,
     responseDeserialize: deserialize_cc_arduino_cli_commands_v1_EnumerateMonitorPortSettingsResponse,
   },
+  // Start a debug session and communicate with the debugger tool.
+debug: {
+    path: '/cc.arduino.cli.commands.v1.ArduinoCoreService/Debug',
+    requestStream: true,
+    responseStream: true,
+    requestType: cc_arduino_cli_commands_v1_debug_pb.DebugRequest,
+    responseType: cc_arduino_cli_commands_v1_debug_pb.DebugResponse,
+    requestSerialize: serialize_cc_arduino_cli_commands_v1_DebugRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_commands_v1_DebugRequest,
+    responseSerialize: serialize_cc_arduino_cli_commands_v1_DebugResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_commands_v1_DebugResponse,
+  },
+  // Determine if debugging is suported given a specific configuration.
+isDebugSupported: {
+    path: '/cc.arduino.cli.commands.v1.ArduinoCoreService/IsDebugSupported',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedRequest,
+    responseType: cc_arduino_cli_commands_v1_debug_pb.IsDebugSupportedResponse,
+    requestSerialize: serialize_cc_arduino_cli_commands_v1_IsDebugSupportedRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_commands_v1_IsDebugSupportedRequest,
+    responseSerialize: serialize_cc_arduino_cli_commands_v1_IsDebugSupportedResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_commands_v1_IsDebugSupportedResponse,
+  },
+  // Query the debugger information given a specific configuration.
+getDebugConfig: {
+    path: '/cc.arduino.cli.commands.v1.ArduinoCoreService/GetDebugConfig',
+    requestStream: false,
+    responseStream: false,
+    requestType: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigRequest,
+    responseType: cc_arduino_cli_commands_v1_debug_pb.GetDebugConfigResponse,
+    requestSerialize: serialize_cc_arduino_cli_commands_v1_GetDebugConfigRequest,
+    requestDeserialize: deserialize_cc_arduino_cli_commands_v1_GetDebugConfigRequest,
+    responseSerialize: serialize_cc_arduino_cli_commands_v1_GetDebugConfigResponse,
+    responseDeserialize: deserialize_cc_arduino_cli_commands_v1_GetDebugConfigResponse,
+  },
 };
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_pb.d.ts

@@ -10,6 +10,7 @@ import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino
 import * as cc_arduino_cli_commands_v1_board_pb from "../../../../../cc/arduino/cli/commands/v1/board_pb";
 import * as cc_arduino_cli_commands_v1_compile_pb from "../../../../../cc/arduino/cli/commands/v1/compile_pb";
 import * as cc_arduino_cli_commands_v1_core_pb from "../../../../../cc/arduino/cli/commands/v1/core_pb";
+import * as cc_arduino_cli_commands_v1_debug_pb from "../../../../../cc/arduino/cli/commands/v1/debug_pb";
 import * as cc_arduino_cli_commands_v1_monitor_pb from "../../../../../cc/arduino/cli/commands/v1/monitor_pb";
 import * as cc_arduino_cli_commands_v1_upload_pb from "../../../../../cc/arduino/cli/commands/v1/upload_pb";
 import * as cc_arduino_cli_commands_v1_lib_pb from "../../../../../cc/arduino/cli/commands/v1/lib_pb";

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/commands_pb.js

@@ -31,6 +31,8 @@ var cc_arduino_cli_commands_v1_compile_pb = require('../../../../../cc/arduino/c
 goog.object.extend(proto, cc_arduino_cli_commands_v1_compile_pb);
 var cc_arduino_cli_commands_v1_core_pb = require('../../../../../cc/arduino/cli/commands/v1/core_pb.js');
 goog.object.extend(proto, cc_arduino_cli_commands_v1_core_pb);
+var cc_arduino_cli_commands_v1_debug_pb = require('../../../../../cc/arduino/cli/commands/v1/debug_pb.js');
+goog.object.extend(proto, cc_arduino_cli_commands_v1_debug_pb);
 var cc_arduino_cli_commands_v1_monitor_pb = require('../../../../../cc/arduino/cli/commands/v1/monitor_pb.js');
 goog.object.extend(proto, cc_arduino_cli_commands_v1_monitor_pb);
 var cc_arduino_cli_commands_v1_upload_pb = require('../../../../../cc/arduino/cli/commands/v1/upload_pb.js');

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/common_pb.d.ts

@@ -195,6 +195,23 @@ export namespace Programmer {
     }
 }
 
+export class MissingProgrammerError extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): MissingProgrammerError.AsObject;
+    static toObject(includeInstance: boolean, msg: MissingProgrammerError): MissingProgrammerError.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: MissingProgrammerError, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): MissingProgrammerError;
+    static deserializeBinaryFromReader(message: MissingProgrammerError, reader: jspb.BinaryReader): MissingProgrammerError;
+}
+
+export namespace MissingProgrammerError {
+    export type AsObject = {
+    }
+}
+
 export class Platform extends jspb.Message { 
     getId(): string;
     setId(value: string): Platform;

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/common_pb.js

@@ -30,6 +30,7 @@ goog.exportSymbol('proto.cc.arduino.cli.commands.v1.DownloadProgressUpdate', nul
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.HelpResources', null, global);
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.InstalledPlatformReference', null, global);
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.Instance', null, global);
+goog.exportSymbol('proto.cc.arduino.cli.commands.v1.MissingProgrammerError', null, global);
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.Platform', null, global);
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.Profile', null, global);
 goog.exportSymbol('proto.cc.arduino.cli.commands.v1.Programmer', null, global);
@@ -181,6 +182,27 @@ if (goog.DEBUG && !COMPILED) {
    */
   proto.cc.arduino.cli.commands.v1.Programmer.displayName = 'proto.cc.arduino.cli.commands.v1.Programmer';
 }
+/**
+ * Generated by JsPbCodeGenerator.
+ * @param {Array=} opt_data Optional initial data array, typically from a
+ * server response, or constructed directly in Javascript. The array is used
+ * in place and becomes part of the constructed object. It is not cloned.
+ * If no data is provided, the constructed object will be empty, but still
+ * valid.
+ * @extends {jspb.Message}
+ * @constructor
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError = function(opt_data) {
+  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
+};
+goog.inherits(proto.cc.arduino.cli.commands.v1.MissingProgrammerError, jspb.Message);
+if (goog.DEBUG && !COMPILED) {
+  /**
+   * @public
+   * @override
+   */
+  proto.cc.arduino.cli.commands.v1.MissingProgrammerError.displayName = 'proto.cc.arduino.cli.commands.v1.MissingProgrammerError';
+}
 /**
  * Generated by JsPbCodeGenerator.
  * @param {Array=} opt_data Optional initial data array, typically from a
@@ -1587,6 +1609,107 @@ proto.cc.arduino.cli.commands.v1.Programmer.prototype.setName = function(value)
 
 
 
+
+
+if (jspb.Message.GENERATE_TO_OBJECT) {
+/**
+ * Creates an object representation of this proto.
+ * Field names that are reserved in JavaScript and will be renamed to pb_name.
+ * Optional fields that are not set will be set to undefined.
+ * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
+ * For the list of reserved names please see:
+ *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
+ * @param {boolean=} opt_includeInstance Deprecated. whether to include the
+ *     JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @return {!Object}
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.prototype.toObject = function(opt_includeInstance) {
+  return proto.cc.arduino.cli.commands.v1.MissingProgrammerError.toObject(opt_includeInstance, this);
+};
+
+
+/**
+ * Static version of the {@see toObject} method.
+ * @param {boolean|undefined} includeInstance Deprecated. Whether to include
+ *     the JSPB instance for transitional soy proto support:
+ *     http://goto/soy-param-migration
+ * @param {!proto.cc.arduino.cli.commands.v1.MissingProgrammerError} msg The msg instance to transform.
+ * @return {!Object}
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.toObject = function(includeInstance, msg) {
+  var f, obj = {
+
+  };
+
+  if (includeInstance) {
+    obj.$jspbMessageInstance = msg;
+  }
+  return obj;
+};
+}
+
+
+/**
+ * Deserializes binary data (in protobuf wire format).
+ * @param {jspb.ByteSource} bytes The bytes to deserialize.
+ * @return {!proto.cc.arduino.cli.commands.v1.MissingProgrammerError}
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.deserializeBinary = function(bytes) {
+  var reader = new jspb.BinaryReader(bytes);
+  var msg = new proto.cc.arduino.cli.commands.v1.MissingProgrammerError;
+  return proto.cc.arduino.cli.commands.v1.MissingProgrammerError.deserializeBinaryFromReader(msg, reader);
+};
+
+
+/**
+ * Deserializes binary data (in protobuf wire format) from the
+ * given reader into the given message object.
+ * @param {!proto.cc.arduino.cli.commands.v1.MissingProgrammerError} msg The message object to deserialize into.
+ * @param {!jspb.BinaryReader} reader The BinaryReader to use.
+ * @return {!proto.cc.arduino.cli.commands.v1.MissingProgrammerError}
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.deserializeBinaryFromReader = function(msg, reader) {
+  while (reader.nextField()) {
+    if (reader.isEndGroup()) {
+      break;
+    }
+    var field = reader.getFieldNumber();
+    switch (field) {
+    default:
+      reader.skipField();
+      break;
+    }
+  }
+  return msg;
+};
+
+
+/**
+ * Serializes the message to binary data (in protobuf wire format).
+ * @return {!Uint8Array}
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.prototype.serializeBinary = function() {
+  var writer = new jspb.BinaryWriter();
+  proto.cc.arduino.cli.commands.v1.MissingProgrammerError.serializeBinaryToWriter(this, writer);
+  return writer.getResultBuffer();
+};
+
+
+/**
+ * Serializes the given message to binary data (in protobuf wire
+ * format), writing to the given BinaryWriter.
+ * @param {!proto.cc.arduino.cli.commands.v1.MissingProgrammerError} message
+ * @param {!jspb.BinaryWriter} writer
+ * @suppress {unusedLocalVariables} f is only used for nested messages
+ */
+proto.cc.arduino.cli.commands.v1.MissingProgrammerError.serializeBinaryToWriter = function(message, writer) {
+  var f = undefined;
+};
+
+
+
 /**
  * List of repeated fields within this message type.
  * @private {!Array<number>}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/core_pb.d.ts

@@ -23,6 +23,8 @@ export class PlatformInstallRequest extends jspb.Message {
     setSkipPostInstall(value: boolean): PlatformInstallRequest;
     getNoOverwrite(): boolean;
     setNoOverwrite(value: boolean): PlatformInstallRequest;
+    getSkipPreUninstall(): boolean;
+    setSkipPreUninstall(value: boolean): PlatformInstallRequest;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): PlatformInstallRequest.AsObject;
@@ -42,6 +44,7 @@ export namespace PlatformInstallRequest {
         version: string,
         skipPostInstall: boolean,
         noOverwrite: boolean,
+        skipPreUninstall: boolean,
     }
 }
 
@@ -156,6 +159,8 @@ export class PlatformUninstallRequest extends jspb.Message {
     setPlatformPackage(value: string): PlatformUninstallRequest;
     getArchitecture(): string;
     setArchitecture(value: string): PlatformUninstallRequest;
+    getSkipPreUninstall(): boolean;
+    setSkipPreUninstall(value: boolean): PlatformUninstallRequest;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): PlatformUninstallRequest.AsObject;
@@ -172,6 +177,7 @@ export namespace PlatformUninstallRequest {
         instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
         platformPackage: string,
         architecture: string,
+        skipPreUninstall: boolean,
     }
 }
 
@@ -227,6 +233,8 @@ export class PlatformUpgradeRequest extends jspb.Message {
     setArchitecture(value: string): PlatformUpgradeRequest;
     getSkipPostInstall(): boolean;
     setSkipPostInstall(value: boolean): PlatformUpgradeRequest;
+    getSkipPreUninstall(): boolean;
+    setSkipPreUninstall(value: boolean): PlatformUpgradeRequest;
 
     serializeBinary(): Uint8Array;
     toObject(includeInstance?: boolean): PlatformUpgradeRequest.AsObject;
@@ -244,6 +252,7 @@ export namespace PlatformUpgradeRequest {
         platformPackage: string,
         architecture: string,
         skipPostInstall: boolean,
+        skipPreUninstall: boolean,
     }
 }
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/core_pb.js

@@ -368,7 +368,8 @@ proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.toObject = function(incl
     architecture: jspb.Message.getFieldWithDefault(msg, 3, ""),
     version: jspb.Message.getFieldWithDefault(msg, 4, ""),
     skipPostInstall: jspb.Message.getBooleanFieldWithDefault(msg, 5, false),
-    noOverwrite: jspb.Message.getBooleanFieldWithDefault(msg, 6, false)
+    noOverwrite: jspb.Message.getBooleanFieldWithDefault(msg, 6, false),
+    skipPreUninstall: jspb.Message.getBooleanFieldWithDefault(msg, 7, false)
   };
 
   if (includeInstance) {
@@ -430,6 +431,10 @@ proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.deserializeBinaryFromRea
       var value = /** @type {boolean} */ (reader.readBool());
       msg.setNoOverwrite(value);
       break;
+    case 7:
+      var value = /** @type {boolean} */ (reader.readBool());
+      msg.setSkipPreUninstall(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -502,6 +507,13 @@ proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.serializeBinaryToWriter
       f
     );
   }
+  f = message.getSkipPreUninstall();
+  if (f) {
+    writer.writeBool(
+      7,
+      f
+    );
+  }
 };
 
 
@@ -632,6 +644,24 @@ proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.prototype.setNoOverwrite
 };
 
 
+/**
+ * optional bool skip_pre_uninstall = 7;
+ * @return {boolean}
+ */
+proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.prototype.getSkipPreUninstall = function() {
+  return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 7, false));
+};
+
+
+/**
+ * @param {boolean} value
+ * @return {!proto.cc.arduino.cli.commands.v1.PlatformInstallRequest} returns this
+ */
+proto.cc.arduino.cli.commands.v1.PlatformInstallRequest.prototype.setSkipPreUninstall = function(value) {
+  return jspb.Message.setProto3BooleanField(this, 7, value);
+};
+
+
 
 
 
@@ -1361,7 +1391,8 @@ proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.toObject = function(in
   var f, obj = {
     instance: (f = msg.getInstance()) && cc_arduino_cli_commands_v1_common_pb.Instance.toObject(includeInstance, f),
     platformPackage: jspb.Message.getFieldWithDefault(msg, 2, ""),
-    architecture: jspb.Message.getFieldWithDefault(msg, 3, "")
+    architecture: jspb.Message.getFieldWithDefault(msg, 3, ""),
+    skipPreUninstall: jspb.Message.getBooleanFieldWithDefault(msg, 4, false)
   };
 
   if (includeInstance) {
@@ -1411,6 +1442,10 @@ proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.deserializeBinaryFromR
       var value = /** @type {string} */ (reader.readString());
       msg.setArchitecture(value);
       break;
+    case 4:
+      var value = /** @type {boolean} */ (reader.readBool());
+      msg.setSkipPreUninstall(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -1462,6 +1497,13 @@ proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.serializeBinaryToWrite
       f
     );
   }
+  f = message.getSkipPreUninstall();
+  if (f) {
+    writer.writeBool(
+      4,
+      f
+    );
+  }
 };
 
 
@@ -1538,6 +1580,24 @@ proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.prototype.setArchitect
 };
 
 
+/**
+ * optional bool skip_pre_uninstall = 4;
+ * @return {boolean}
+ */
+proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.prototype.getSkipPreUninstall = function() {
+  return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 4, false));
+};
+
+
+/**
+ * @param {boolean} value
+ * @return {!proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest} returns this
+ */
+proto.cc.arduino.cli.commands.v1.PlatformUninstallRequest.prototype.setSkipPreUninstall = function(value) {
+  return jspb.Message.setProto3BooleanField(this, 4, value);
+};
+
+
 
 
 
@@ -1825,7 +1885,8 @@ proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.toObject = function(incl
     instance: (f = msg.getInstance()) && cc_arduino_cli_commands_v1_common_pb.Instance.toObject(includeInstance, f),
     platformPackage: jspb.Message.getFieldWithDefault(msg, 2, ""),
     architecture: jspb.Message.getFieldWithDefault(msg, 3, ""),
-    skipPostInstall: jspb.Message.getBooleanFieldWithDefault(msg, 4, false)
+    skipPostInstall: jspb.Message.getBooleanFieldWithDefault(msg, 4, false),
+    skipPreUninstall: jspb.Message.getBooleanFieldWithDefault(msg, 5, false)
   };
 
   if (includeInstance) {
@@ -1879,6 +1940,10 @@ proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.deserializeBinaryFromRea
       var value = /** @type {boolean} */ (reader.readBool());
       msg.setSkipPostInstall(value);
       break;
+    case 5:
+      var value = /** @type {boolean} */ (reader.readBool());
+      msg.setSkipPreUninstall(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -1937,6 +2002,13 @@ proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.serializeBinaryToWriter
       f
     );
   }
+  f = message.getSkipPreUninstall();
+  if (f) {
+    writer.writeBool(
+      5,
+      f
+    );
+  }
 };
 
 
@@ -2031,6 +2103,24 @@ proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.prototype.setSkipPostIns
 };
 
 
+/**
+ * optional bool skip_pre_uninstall = 5;
+ * @return {boolean}
+ */
+proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.prototype.getSkipPreUninstall = function() {
+  return /** @type {boolean} */ (jspb.Message.getBooleanFieldWithDefault(this, 5, false));
+};
+
+
+/**
+ * @param {boolean} value
+ * @return {!proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest} returns this
+ */
+proto.cc.arduino.cli.commands.v1.PlatformUpgradeRequest.prototype.setSkipPreUninstall = function(value) {
+  return jspb.Message.setProto3BooleanField(this, 5, value);
+};
+
+
 
 
 

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/debug_grpc_pb.js

@@ -0,0 +1 @@
+// GENERATED CODE -- NO SERVICES IN PROTO

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/commands/v1/debug_pb.d.ts

@@ -0,0 +1,274 @@
+// package: cc.arduino.cli.commands.v1
+// file: cc/arduino/cli/commands/v1/debug.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
+import * as cc_arduino_cli_commands_v1_port_pb from "../../../../../cc/arduino/cli/commands/v1/port_pb";
+import * as google_protobuf_any_pb from "google-protobuf/google/protobuf/any_pb";
+
+export class DebugRequest extends jspb.Message { 
+
+    hasDebugRequest(): boolean;
+    clearDebugRequest(): void;
+    getDebugRequest(): GetDebugConfigRequest | undefined;
+    setDebugRequest(value?: GetDebugConfigRequest): DebugRequest;
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): DebugRequest;
+    getSendInterrupt(): boolean;
+    setSendInterrupt(value: boolean): DebugRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugRequest): DebugRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugRequest;
+    static deserializeBinaryFromReader(message: DebugRequest, reader: jspb.BinaryReader): DebugRequest;
+}
+
+export namespace DebugRequest {
+    export type AsObject = {
+        debugRequest?: GetDebugConfigRequest.AsObject,
+        data: Uint8Array | string,
+        sendInterrupt: boolean,
+    }
+}
+
+export class DebugResponse extends jspb.Message { 
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): DebugResponse;
+    getError(): string;
+    setError(value: string): DebugResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugResponse): DebugResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugResponse;
+    static deserializeBinaryFromReader(message: DebugResponse, reader: jspb.BinaryReader): DebugResponse;
+}
+
+export namespace DebugResponse {
+    export type AsObject = {
+        data: Uint8Array | string,
+        error: string,
+    }
+}
+
+export class IsDebugSupportedRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): IsDebugSupportedRequest;
+    getFqbn(): string;
+    setFqbn(value: string): IsDebugSupportedRequest;
+
+    hasPort(): boolean;
+    clearPort(): void;
+    getPort(): cc_arduino_cli_commands_v1_port_pb.Port | undefined;
+    setPort(value?: cc_arduino_cli_commands_v1_port_pb.Port): IsDebugSupportedRequest;
+    getInterpreter(): string;
+    setInterpreter(value: string): IsDebugSupportedRequest;
+    getProgrammer(): string;
+    setProgrammer(value: string): IsDebugSupportedRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): IsDebugSupportedRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: IsDebugSupportedRequest): IsDebugSupportedRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: IsDebugSupportedRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): IsDebugSupportedRequest;
+    static deserializeBinaryFromReader(message: IsDebugSupportedRequest, reader: jspb.BinaryReader): IsDebugSupportedRequest;
+}
+
+export namespace IsDebugSupportedRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        fqbn: string,
+        port?: cc_arduino_cli_commands_v1_port_pb.Port.AsObject,
+        interpreter: string,
+        programmer: string,
+    }
+}
+
+export class IsDebugSupportedResponse extends jspb.Message { 
+    getDebuggingSupported(): boolean;
+    setDebuggingSupported(value: boolean): IsDebugSupportedResponse;
+    getDebugFqbn(): string;
+    setDebugFqbn(value: string): IsDebugSupportedResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): IsDebugSupportedResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: IsDebugSupportedResponse): IsDebugSupportedResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: IsDebugSupportedResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): IsDebugSupportedResponse;
+    static deserializeBinaryFromReader(message: IsDebugSupportedResponse, reader: jspb.BinaryReader): IsDebugSupportedResponse;
+}
+
+export namespace IsDebugSupportedResponse {
+    export type AsObject = {
+        debuggingSupported: boolean,
+        debugFqbn: string,
+    }
+}
+
+export class GetDebugConfigRequest extends jspb.Message { 
+
+    hasInstance(): boolean;
+    clearInstance(): void;
+    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
+    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): GetDebugConfigRequest;
+    getFqbn(): string;
+    setFqbn(value: string): GetDebugConfigRequest;
+    getSketchPath(): string;
+    setSketchPath(value: string): GetDebugConfigRequest;
+
+    hasPort(): boolean;
+    clearPort(): void;
+    getPort(): cc_arduino_cli_commands_v1_port_pb.Port | undefined;
+    setPort(value?: cc_arduino_cli_commands_v1_port_pb.Port): GetDebugConfigRequest;
+    getInterpreter(): string;
+    setInterpreter(value: string): GetDebugConfigRequest;
+    getImportDir(): string;
+    setImportDir(value: string): GetDebugConfigRequest;
+    getProgrammer(): string;
+    setProgrammer(value: string): GetDebugConfigRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetDebugConfigRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: GetDebugConfigRequest): GetDebugConfigRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetDebugConfigRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetDebugConfigRequest;
+    static deserializeBinaryFromReader(message: GetDebugConfigRequest, reader: jspb.BinaryReader): GetDebugConfigRequest;
+}
+
+export namespace GetDebugConfigRequest {
+    export type AsObject = {
+        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
+        fqbn: string,
+        sketchPath: string,
+        port?: cc_arduino_cli_commands_v1_port_pb.Port.AsObject,
+        interpreter: string,
+        importDir: string,
+        programmer: string,
+    }
+}
+
+export class GetDebugConfigResponse extends jspb.Message { 
+    getExecutable(): string;
+    setExecutable(value: string): GetDebugConfigResponse;
+    getToolchain(): string;
+    setToolchain(value: string): GetDebugConfigResponse;
+    getToolchainPath(): string;
+    setToolchainPath(value: string): GetDebugConfigResponse;
+    getToolchainPrefix(): string;
+    setToolchainPrefix(value: string): GetDebugConfigResponse;
+    getServer(): string;
+    setServer(value: string): GetDebugConfigResponse;
+    getServerPath(): string;
+    setServerPath(value: string): GetDebugConfigResponse;
+
+    hasToolchainConfiguration(): boolean;
+    clearToolchainConfiguration(): void;
+    getToolchainConfiguration(): google_protobuf_any_pb.Any | undefined;
+    setToolchainConfiguration(value?: google_protobuf_any_pb.Any): GetDebugConfigResponse;
+
+    hasServerConfiguration(): boolean;
+    clearServerConfiguration(): void;
+    getServerConfiguration(): google_protobuf_any_pb.Any | undefined;
+    setServerConfiguration(value?: google_protobuf_any_pb.Any): GetDebugConfigResponse;
+
+    getCustomConfigsMap(): jspb.Map<string, string>;
+    clearCustomConfigsMap(): void;
+    getSvdFile(): string;
+    setSvdFile(value: string): GetDebugConfigResponse;
+    getProgrammer(): string;
+    setProgrammer(value: string): GetDebugConfigResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetDebugConfigResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: GetDebugConfigResponse): GetDebugConfigResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetDebugConfigResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetDebugConfigResponse;
+    static deserializeBinaryFromReader(message: GetDebugConfigResponse, reader: jspb.BinaryReader): GetDebugConfigResponse;
+}
+
+export namespace GetDebugConfigResponse {
+    export type AsObject = {
+        executable: string,
+        toolchain: string,
+        toolchainPath: string,
+        toolchainPrefix: string,
+        server: string,
+        serverPath: string,
+        toolchainConfiguration?: google_protobuf_any_pb.Any.AsObject,
+        serverConfiguration?: google_protobuf_any_pb.Any.AsObject,
+
+        customConfigsMap: Array<[string, string]>,
+        svdFile: string,
+        programmer: string,
+    }
+}
+
+export class DebugGCCToolchainConfiguration extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugGCCToolchainConfiguration.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugGCCToolchainConfiguration): DebugGCCToolchainConfiguration.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugGCCToolchainConfiguration, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugGCCToolchainConfiguration;
+    static deserializeBinaryFromReader(message: DebugGCCToolchainConfiguration, reader: jspb.BinaryReader): DebugGCCToolchainConfiguration;
+}
+
+export namespace DebugGCCToolchainConfiguration {
+    export type AsObject = {
+    }
+}
+
+export class DebugOpenOCDServerConfiguration extends jspb.Message { 
+    getPath(): string;
+    setPath(value: string): DebugOpenOCDServerConfiguration;
+    getScriptsDir(): string;
+    setScriptsDir(value: string): DebugOpenOCDServerConfiguration;
+    clearScriptsList(): void;
+    getScriptsList(): Array<string>;
+    setScriptsList(value: Array<string>): DebugOpenOCDServerConfiguration;
+    addScripts(value: string, index?: number): string;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DebugOpenOCDServerConfiguration.AsObject;
+    static toObject(includeInstance: boolean, msg: DebugOpenOCDServerConfiguration): DebugOpenOCDServerConfiguration.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DebugOpenOCDServerConfiguration, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DebugOpenOCDServerConfiguration;
+    static deserializeBinaryFromReader(message: DebugOpenOCDServerConfiguration, reader: jspb.BinaryReader): DebugOpenOCDServerConfiguration;
+}
+
+export namespace DebugOpenOCDServerConfiguration {
+    export type AsObject = {
+        path: string,
+        scriptsDir: string,
+        scriptsList: Array<string>,
+    }
+}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_grpc_pb.d.ts

@@ -1,59 +0,0 @@
-// package: cc.arduino.cli.debug.v1
-// file: cc/arduino/cli/debug/v1/debug.proto
-
-/* tslint:disable */
-/* eslint-disable */
-
-import * as grpc from "@grpc/grpc-js";
-import * as cc_arduino_cli_debug_v1_debug_pb from "../../../../../cc/arduino/cli/debug/v1/debug_pb";
-import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
-import * as cc_arduino_cli_commands_v1_port_pb from "../../../../../cc/arduino/cli/commands/v1/port_pb";
-
-interface IDebugServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
-    debug: IDebugServiceService_IDebug;
-    getDebugConfig: IDebugServiceService_IGetDebugConfig;
-}
-
-interface IDebugServiceService_IDebug extends grpc.MethodDefinition<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse> {
-    path: "/cc.arduino.cli.debug.v1.DebugService/Debug";
-    requestStream: true;
-    responseStream: true;
-    requestSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugRequest>;
-    requestDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugRequest>;
-    responseSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    responseDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-}
-interface IDebugServiceService_IGetDebugConfig extends grpc.MethodDefinition<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse> {
-    path: "/cc.arduino.cli.debug.v1.DebugService/GetDebugConfig";
-    requestStream: false;
-    responseStream: false;
-    requestSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest>;
-    requestDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest>;
-    responseSerialize: grpc.serialize<cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
-    responseDeserialize: grpc.deserialize<cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
-}
-
-export const DebugServiceService: IDebugServiceService;
-
-export interface IDebugServiceServer extends grpc.UntypedServiceImplementation {
-    debug: grpc.handleBidiStreamingCall<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    getDebugConfig: grpc.handleUnaryCall<cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse>;
-}
-
-export interface IDebugServiceClient {
-    debug(): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    debug(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    debug(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-    getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-}
-
-export class DebugServiceClient extends grpc.Client implements IDebugServiceClient {
-    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
-    public debug(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    public debug(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_debug_v1_debug_pb.DebugRequest, cc_arduino_cli_debug_v1_debug_pb.DebugResponse>;
-    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-    public getDebugConfig(request: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse) => void): grpc.ClientUnaryCall;
-}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_grpc_pb.js

@@ -1,95 +0,0 @@
-// GENERATED CODE -- DO NOT EDIT!
-
-// Original file comments:
-// This file is part of arduino-cli.
-//
-// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
-//
-// This software is released under the GNU General Public License version 3,
-// which covers the main part of arduino-cli.
-// The terms of this license can be found at:
-// https://www.gnu.org/licenses/gpl-3.0.en.html
-//
-// You can be released from the requirements of the above licenses by purchasing
-// a commercial license. Buying such a license is mandatory if you want to
-// modify or otherwise use the software for commercial activities involving the
-// Arduino software without disclosing the source code of your own applications.
-// To purchase a commercial license, send an email to license@arduino.cc.
-//
-'use strict';
-var cc_arduino_cli_debug_v1_debug_pb = require('../../../../../cc/arduino/cli/debug/v1/debug_pb.js');
-var cc_arduino_cli_commands_v1_common_pb = require('../../../../../cc/arduino/cli/commands/v1/common_pb.js');
-var cc_arduino_cli_commands_v1_port_pb = require('../../../../../cc/arduino/cli/commands/v1/port_pb.js');
-
-function serialize_cc_arduino_cli_debug_v1_DebugConfigRequest(arg) {
-  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest)) {
-    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugConfigRequest');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_debug_v1_DebugConfigRequest(buffer_arg) {
-  return cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-function serialize_cc_arduino_cli_debug_v1_DebugRequest(arg) {
-  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugRequest)) {
-    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugRequest');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_debug_v1_DebugRequest(buffer_arg) {
-  return cc_arduino_cli_debug_v1_debug_pb.DebugRequest.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-function serialize_cc_arduino_cli_debug_v1_DebugResponse(arg) {
-  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.DebugResponse)) {
-    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.DebugResponse');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_debug_v1_DebugResponse(buffer_arg) {
-  return cc_arduino_cli_debug_v1_debug_pb.DebugResponse.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-function serialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse(arg) {
-  if (!(arg instanceof cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse)) {
-    throw new Error('Expected argument of type cc.arduino.cli.debug.v1.GetDebugConfigResponse');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse(buffer_arg) {
-  return cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-
-// DebugService abstracts a debug Session usage
-var DebugServiceService = exports['cc.arduino.cli.debug.v1.DebugService'] = {
-  // Start a debug session and communicate with the debugger tool.
-debug: {
-    path: '/cc.arduino.cli.debug.v1.DebugService/Debug',
-    requestStream: true,
-    responseStream: true,
-    requestType: cc_arduino_cli_debug_v1_debug_pb.DebugRequest,
-    responseType: cc_arduino_cli_debug_v1_debug_pb.DebugResponse,
-    requestSerialize: serialize_cc_arduino_cli_debug_v1_DebugRequest,
-    requestDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugRequest,
-    responseSerialize: serialize_cc_arduino_cli_debug_v1_DebugResponse,
-    responseDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugResponse,
-  },
-  getDebugConfig: {
-    path: '/cc.arduino.cli.debug.v1.DebugService/GetDebugConfig',
-    requestStream: false,
-    responseStream: false,
-    requestType: cc_arduino_cli_debug_v1_debug_pb.DebugConfigRequest,
-    responseType: cc_arduino_cli_debug_v1_debug_pb.GetDebugConfigResponse,
-    requestSerialize: serialize_cc_arduino_cli_debug_v1_DebugConfigRequest,
-    requestDeserialize: deserialize_cc_arduino_cli_debug_v1_DebugConfigRequest,
-    responseSerialize: serialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse,
-    responseDeserialize: deserialize_cc_arduino_cli_debug_v1_GetDebugConfigResponse,
-  },
-};
-

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/debug/v1/debug_pb.d.ts

@@ -1,154 +0,0 @@
-// package: cc.arduino.cli.debug.v1
-// file: cc/arduino/cli/debug/v1/debug.proto
-
-/* tslint:disable */
-/* eslint-disable */
-
-import * as jspb from "google-protobuf";
-import * as cc_arduino_cli_commands_v1_common_pb from "../../../../../cc/arduino/cli/commands/v1/common_pb";
-import * as cc_arduino_cli_commands_v1_port_pb from "../../../../../cc/arduino/cli/commands/v1/port_pb";
-
-export class DebugRequest extends jspb.Message { 
-
-    hasDebugRequest(): boolean;
-    clearDebugRequest(): void;
-    getDebugRequest(): DebugConfigRequest | undefined;
-    setDebugRequest(value?: DebugConfigRequest): DebugRequest;
-    getData(): Uint8Array | string;
-    getData_asU8(): Uint8Array;
-    getData_asB64(): string;
-    setData(value: Uint8Array | string): DebugRequest;
-    getSendInterrupt(): boolean;
-    setSendInterrupt(value: boolean): DebugRequest;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): DebugRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: DebugRequest): DebugRequest.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: DebugRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): DebugRequest;
-    static deserializeBinaryFromReader(message: DebugRequest, reader: jspb.BinaryReader): DebugRequest;
-}
-
-export namespace DebugRequest {
-    export type AsObject = {
-        debugRequest?: DebugConfigRequest.AsObject,
-        data: Uint8Array | string,
-        sendInterrupt: boolean,
-    }
-}
-
-export class DebugConfigRequest extends jspb.Message { 
-
-    hasInstance(): boolean;
-    clearInstance(): void;
-    getInstance(): cc_arduino_cli_commands_v1_common_pb.Instance | undefined;
-    setInstance(value?: cc_arduino_cli_commands_v1_common_pb.Instance): DebugConfigRequest;
-    getFqbn(): string;
-    setFqbn(value: string): DebugConfigRequest;
-    getSketchPath(): string;
-    setSketchPath(value: string): DebugConfigRequest;
-
-    hasPort(): boolean;
-    clearPort(): void;
-    getPort(): cc_arduino_cli_commands_v1_port_pb.Port | undefined;
-    setPort(value?: cc_arduino_cli_commands_v1_port_pb.Port): DebugConfigRequest;
-    getInterpreter(): string;
-    setInterpreter(value: string): DebugConfigRequest;
-    getImportDir(): string;
-    setImportDir(value: string): DebugConfigRequest;
-    getProgrammer(): string;
-    setProgrammer(value: string): DebugConfigRequest;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): DebugConfigRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: DebugConfigRequest): DebugConfigRequest.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: DebugConfigRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): DebugConfigRequest;
-    static deserializeBinaryFromReader(message: DebugConfigRequest, reader: jspb.BinaryReader): DebugConfigRequest;
-}
-
-export namespace DebugConfigRequest {
-    export type AsObject = {
-        instance?: cc_arduino_cli_commands_v1_common_pb.Instance.AsObject,
-        fqbn: string,
-        sketchPath: string,
-        port?: cc_arduino_cli_commands_v1_port_pb.Port.AsObject,
-        interpreter: string,
-        importDir: string,
-        programmer: string,
-    }
-}
-
-export class DebugResponse extends jspb.Message { 
-    getData(): Uint8Array | string;
-    getData_asU8(): Uint8Array;
-    getData_asB64(): string;
-    setData(value: Uint8Array | string): DebugResponse;
-    getError(): string;
-    setError(value: string): DebugResponse;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): DebugResponse.AsObject;
-    static toObject(includeInstance: boolean, msg: DebugResponse): DebugResponse.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: DebugResponse, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): DebugResponse;
-    static deserializeBinaryFromReader(message: DebugResponse, reader: jspb.BinaryReader): DebugResponse;
-}
-
-export namespace DebugResponse {
-    export type AsObject = {
-        data: Uint8Array | string,
-        error: string,
-    }
-}
-
-export class GetDebugConfigResponse extends jspb.Message { 
-    getExecutable(): string;
-    setExecutable(value: string): GetDebugConfigResponse;
-    getToolchain(): string;
-    setToolchain(value: string): GetDebugConfigResponse;
-    getToolchainPath(): string;
-    setToolchainPath(value: string): GetDebugConfigResponse;
-    getToolchainPrefix(): string;
-    setToolchainPrefix(value: string): GetDebugConfigResponse;
-    getServer(): string;
-    setServer(value: string): GetDebugConfigResponse;
-    getServerPath(): string;
-    setServerPath(value: string): GetDebugConfigResponse;
-
-    getToolchainConfigurationMap(): jspb.Map<string, string>;
-    clearToolchainConfigurationMap(): void;
-
-    getServerConfigurationMap(): jspb.Map<string, string>;
-    clearServerConfigurationMap(): void;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetDebugConfigResponse.AsObject;
-    static toObject(includeInstance: boolean, msg: GetDebugConfigResponse): GetDebugConfigResponse.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetDebugConfigResponse, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetDebugConfigResponse;
-    static deserializeBinaryFromReader(message: GetDebugConfigResponse, reader: jspb.BinaryReader): GetDebugConfigResponse;
-}
-
-export namespace GetDebugConfigResponse {
-    export type AsObject = {
-        executable: string,
-        toolchain: string,
-        toolchainPath: string,
-        toolchainPrefix: string,
-        server: string,
-        serverPath: string,
-
-        toolchainConfigurationMap: Array<[string, string]>,
-
-        serverConfigurationMap: Array<[string, string]>,
-    }
-}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_grpc_pb.d.ts

@@ -1,42 +0,0 @@
-// package: cc.arduino.cli.monitor.v1
-// file: cc/arduino/cli/monitor/v1/monitor.proto
-
-/* tslint:disable */
-/* eslint-disable */
-
-import * as grpc from "@grpc/grpc-js";
-import {handleClientStreamingCall} from "@grpc/grpc-js/build/src/server-call";
-import * as cc_arduino_cli_monitor_v1_monitor_pb from "../../../../../cc/arduino/cli/monitor/v1/monitor_pb";
-import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
-
-interface IMonitorServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
-    streamingOpen: IMonitorServiceService_IStreamingOpen;
-}
-
-interface IMonitorServiceService_IStreamingOpen extends grpc.MethodDefinition<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse> {
-    path: "/cc.arduino.cli.monitor.v1.MonitorService/StreamingOpen";
-    requestStream: true;
-    responseStream: true;
-    requestSerialize: grpc.serialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest>;
-    requestDeserialize: grpc.deserialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest>;
-    responseSerialize: grpc.serialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-    responseDeserialize: grpc.deserialize<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-}
-
-export const MonitorServiceService: IMonitorServiceService;
-
-export interface IMonitorServiceServer {
-    streamingOpen: grpc.handleBidiStreamingCall<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-}
-
-export interface IMonitorServiceClient {
-    streamingOpen(): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-    streamingOpen(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-    streamingOpen(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-}
-
-export class MonitorServiceClient extends grpc.Client implements IMonitorServiceClient {
-    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
-    public streamingOpen(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-    public streamingOpen(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest, cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse>;
-}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_grpc_pb.js

@@ -1,65 +0,0 @@
-// GENERATED CODE -- DO NOT EDIT!
-
-// Original file comments:
-// This file is part of arduino-cli.
-//
-// Copyright 2020 ARDUINO SA (http://www.arduino.cc/)
-//
-// This software is released under the GNU General Public License version 3,
-// which covers the main part of arduino-cli.
-// The terms of this license can be found at:
-// https://www.gnu.org/licenses/gpl-3.0.en.html
-//
-// You can be released from the requirements of the above licenses by purchasing
-// a commercial license. Buying such a license is mandatory if you want to
-// modify or otherwise use the software for commercial activities involving the
-// Arduino software without disclosing the source code of your own applications.
-// To purchase a commercial license, send an email to license@arduino.cc.
-//
-'use strict';
-var cc_arduino_cli_monitor_v1_monitor_pb = require('../../../../../cc/arduino/cli/monitor/v1/monitor_pb.js');
-var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
-
-function serialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest(arg) {
-  if (!(arg instanceof cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest)) {
-    throw new Error('Expected argument of type cc.arduino.cli.monitor.v1.StreamingOpenRequest');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest(buffer_arg) {
-  return cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-function serialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse(arg) {
-  if (!(arg instanceof cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse)) {
-    throw new Error('Expected argument of type cc.arduino.cli.monitor.v1.StreamingOpenResponse');
-  }
-  return Buffer.from(arg.serializeBinary());
-}
-
-function deserialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse(buffer_arg) {
-  return cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse.deserializeBinary(new Uint8Array(buffer_arg));
-}
-
-
-// MonitorService provides services for boards monitor.
-// DEPRECATION WARNING: MonitorService is deprecated and will be removed in a
-// future release. Use ArduinoCoreService.Monitor and
-// ArduinoCoreService.EnumerateMonitorPortSettings instead.
-var MonitorServiceService = exports['cc.arduino.cli.monitor.v1.MonitorService'] = {
-  // Open a bidirectional monitor stream. This can be used to implement
-// something similar to the Arduino IDE's Serial Monitor.
-streamingOpen: {
-    path: '/cc.arduino.cli.monitor.v1.MonitorService/StreamingOpen',
-    requestStream: true,
-    responseStream: true,
-    requestType: cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenRequest,
-    responseType: cc_arduino_cli_monitor_v1_monitor_pb.StreamingOpenResponse,
-    requestSerialize: serialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest,
-    requestDeserialize: deserialize_cc_arduino_cli_monitor_v1_StreamingOpenRequest,
-    responseSerialize: serialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse,
-    responseDeserialize: deserialize_cc_arduino_cli_monitor_v1_StreamingOpenResponse,
-  },
-};
-

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_pb.d.ts

@@ -1,131 +0,0 @@
-// package: cc.arduino.cli.monitor.v1
-// file: cc/arduino/cli/monitor/v1/monitor.proto
-
-/* tslint:disable */
-/* eslint-disable */
-
-import * as jspb from "google-protobuf";
-import * as google_protobuf_struct_pb from "google-protobuf/google/protobuf/struct_pb";
-
-export class StreamingOpenRequest extends jspb.Message { 
-
-    hasConfig(): boolean;
-    clearConfig(): void;
-    getConfig(): MonitorConfig | undefined;
-    setConfig(value?: MonitorConfig): StreamingOpenRequest;
-
-
-    hasData(): boolean;
-    clearData(): void;
-    getData(): Uint8Array | string;
-    getData_asU8(): Uint8Array;
-    getData_asB64(): string;
-    setData(value: Uint8Array | string): StreamingOpenRequest;
-
-
-    hasRecvAcknowledge(): boolean;
-    clearRecvAcknowledge(): void;
-    getRecvAcknowledge(): number;
-    setRecvAcknowledge(value: number): StreamingOpenRequest;
-
-
-    getContentCase(): StreamingOpenRequest.ContentCase;
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StreamingOpenRequest.AsObject;
-    static toObject(includeInstance: boolean, msg: StreamingOpenRequest): StreamingOpenRequest.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StreamingOpenRequest, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StreamingOpenRequest;
-    static deserializeBinaryFromReader(message: StreamingOpenRequest, reader: jspb.BinaryReader): StreamingOpenRequest;
-}
-
-export namespace StreamingOpenRequest {
-    export type AsObject = {
-        config?: MonitorConfig.AsObject,
-        data: Uint8Array | string,
-        recvAcknowledge: number,
-    }
-
-    export enum ContentCase {
-        CONTENT_NOT_SET = 0,
-    
-    CONFIG = 1,
-
-    DATA = 2,
-
-    RECV_ACKNOWLEDGE = 3,
-
-    }
-
-}
-
-export class MonitorConfig extends jspb.Message { 
-    getTarget(): string;
-    setTarget(value: string): MonitorConfig;
-
-    getType(): MonitorConfig.TargetType;
-    setType(value: MonitorConfig.TargetType): MonitorConfig;
-
-
-    hasAdditionalConfig(): boolean;
-    clearAdditionalConfig(): void;
-    getAdditionalConfig(): google_protobuf_struct_pb.Struct | undefined;
-    setAdditionalConfig(value?: google_protobuf_struct_pb.Struct): MonitorConfig;
-
-    getRecvRateLimitBuffer(): number;
-    setRecvRateLimitBuffer(value: number): MonitorConfig;
-
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): MonitorConfig.AsObject;
-    static toObject(includeInstance: boolean, msg: MonitorConfig): MonitorConfig.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: MonitorConfig, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): MonitorConfig;
-    static deserializeBinaryFromReader(message: MonitorConfig, reader: jspb.BinaryReader): MonitorConfig;
-}
-
-export namespace MonitorConfig {
-    export type AsObject = {
-        target: string,
-        type: MonitorConfig.TargetType,
-        additionalConfig?: google_protobuf_struct_pb.Struct.AsObject,
-        recvRateLimitBuffer: number,
-    }
-
-    export enum TargetType {
-    TARGET_TYPE_SERIAL = 0,
-    TARGET_TYPE_NULL = 99,
-    }
-
-}
-
-export class StreamingOpenResponse extends jspb.Message { 
-    getData(): Uint8Array | string;
-    getData_asU8(): Uint8Array;
-    getData_asB64(): string;
-    setData(value: Uint8Array | string): StreamingOpenResponse;
-
-    getDropped(): number;
-    setDropped(value: number): StreamingOpenResponse;
-
-
-    serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): StreamingOpenResponse.AsObject;
-    static toObject(includeInstance: boolean, msg: StreamingOpenResponse): StreamingOpenResponse.AsObject;
-    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: StreamingOpenResponse, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): StreamingOpenResponse;
-    static deserializeBinaryFromReader(message: StreamingOpenResponse, reader: jspb.BinaryReader): StreamingOpenResponse;
-}
-
-export namespace StreamingOpenResponse {
-    export type AsObject = {
-        data: Uint8Array | string,
-        dropped: number,
-    }
-}

arduino-ide-extension/src/node/cli-protocol/cc/arduino/cli/monitor/v1/monitor_pb.js

@@ -1,819 +0,0 @@
-// source: cc/arduino/cli/monitor/v1/monitor.proto
-/**
- * @fileoverview
- * @enhanceable
- * @suppress {missingRequire} reports error on implicit type usages.
- * @suppress {messageConventions} JS Compiler reports an error if a variable or
- *     field starts with 'MSG_' and isn't a translatable message.
- * @public
- */
-// GENERATED CODE -- DO NOT EDIT!
-/* eslint-disable */
-// @ts-nocheck
-
-var jspb = require('google-protobuf');
-var goog = jspb;
-var global = Function('return this')();
-
-var google_protobuf_struct_pb = require('google-protobuf/google/protobuf/struct_pb.js');
-goog.object.extend(proto, google_protobuf_struct_pb);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.MonitorConfig', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase', null, global);
-goog.exportSymbol('proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse', null, global);
-/**
- * Generated by JsPbCodeGenerator.
- * @param {Array=} opt_data Optional initial data array, typically from a
- * server response, or constructed directly in Javascript. The array is used
- * in place and becomes part of the constructed object. It is not cloned.
- * If no data is provided, the constructed object will be empty, but still
- * valid.
- * @extends {jspb.Message}
- * @constructor
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest = function(opt_data) {
-  jspb.Message.initialize(this, opt_data, 0, -1, null, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_);
-};
-goog.inherits(proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest, jspb.Message);
-if (goog.DEBUG && !COMPILED) {
-  /**
-   * @public
-   * @override
-   */
-  proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.displayName = 'proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest';
-}
-/**
- * Generated by JsPbCodeGenerator.
- * @param {Array=} opt_data Optional initial data array, typically from a
- * server response, or constructed directly in Javascript. The array is used
- * in place and becomes part of the constructed object. It is not cloned.
- * If no data is provided, the constructed object will be empty, but still
- * valid.
- * @extends {jspb.Message}
- * @constructor
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig = function(opt_data) {
-  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
-};
-goog.inherits(proto.cc.arduino.cli.monitor.v1.MonitorConfig, jspb.Message);
-if (goog.DEBUG && !COMPILED) {
-  /**
-   * @public
-   * @override
-   */
-  proto.cc.arduino.cli.monitor.v1.MonitorConfig.displayName = 'proto.cc.arduino.cli.monitor.v1.MonitorConfig';
-}
-/**
- * Generated by JsPbCodeGenerator.
- * @param {Array=} opt_data Optional initial data array, typically from a
- * server response, or constructed directly in Javascript. The array is used
- * in place and becomes part of the constructed object. It is not cloned.
- * If no data is provided, the constructed object will be empty, but still
- * valid.
- * @extends {jspb.Message}
- * @constructor
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse = function(opt_data) {
-  jspb.Message.initialize(this, opt_data, 0, -1, null, null);
-};
-goog.inherits(proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse, jspb.Message);
-if (goog.DEBUG && !COMPILED) {
-  /**
-   * @public
-   * @override
-   */
-  proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.displayName = 'proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse';
-}
-
-/**
- * Oneof group definitions for this message. Each group defines the field
- * numbers belonging to that group. When of these fields' value is set, all
- * other fields in the group are cleared. During deserialization, if multiple
- * fields are encountered for a group, only the last value seen will be kept.
- * @private {!Array<!Array<number>>}
- * @const
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_ = [[1,2,3]];
-
-/**
- * @enum {number}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase = {
-  CONTENT_NOT_SET: 0,
-  CONFIG: 1,
-  DATA: 2,
-  RECV_ACKNOWLEDGE: 3
-};
-
-/**
- * @return {proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getContentCase = function() {
-  return /** @type {proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.ContentCase} */(jspb.Message.computeOneofCase(this, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0]));
-};
-
-
-
-if (jspb.Message.GENERATE_TO_OBJECT) {
-/**
- * Creates an object representation of this proto.
- * Field names that are reserved in JavaScript and will be renamed to pb_name.
- * Optional fields that are not set will be set to undefined.
- * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
- * For the list of reserved names please see:
- *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
- * @param {boolean=} opt_includeInstance Deprecated. whether to include the
- *     JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @return {!Object}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.toObject(opt_includeInstance, this);
-};
-
-
-/**
- * Static version of the {@see toObject} method.
- * @param {boolean|undefined} includeInstance Deprecated. Whether to include
- *     the JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} msg The msg instance to transform.
- * @return {!Object}
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.toObject = function(includeInstance, msg) {
-  var f, obj = {
-    config: (f = msg.getConfig()) && proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject(includeInstance, f),
-    data: msg.getData_asB64(),
-    recvAcknowledge: jspb.Message.getFieldWithDefault(msg, 3, 0)
-  };
-
-  if (includeInstance) {
-    obj.$jspbMessageInstance = msg;
-  }
-  return obj;
-};
-}
-
-
-/**
- * Deserializes binary data (in protobuf wire format).
- * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinary = function(bytes) {
-  var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest;
-  return proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinaryFromReader(msg, reader);
-};
-
-
-/**
- * Deserializes binary data (in protobuf wire format) from the
- * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} msg The message object to deserialize into.
- * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.deserializeBinaryFromReader = function(msg, reader) {
-  while (reader.nextField()) {
-    if (reader.isEndGroup()) {
-      break;
-    }
-    var field = reader.getFieldNumber();
-    switch (field) {
-    case 1:
-      var value = new proto.cc.arduino.cli.monitor.v1.MonitorConfig;
-      reader.readMessage(value,proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader);
-      msg.setConfig(value);
-      break;
-    case 2:
-      var value = /** @type {!Uint8Array} */ (reader.readBytes());
-      msg.setData(value);
-      break;
-    case 3:
-      var value = /** @type {number} */ (reader.readInt32());
-      msg.setRecvAcknowledge(value);
-      break;
-    default:
-      reader.skipField();
-      break;
-    }
-  }
-  return msg;
-};
-
-
-/**
- * Serializes the message to binary data (in protobuf wire format).
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.serializeBinary = function() {
-  var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.serializeBinaryToWriter(this, writer);
-  return writer.getResultBuffer();
-};
-
-
-/**
- * Serializes the given message to binary data (in protobuf wire
- * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} message
- * @param {!jspb.BinaryWriter} writer
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.serializeBinaryToWriter = function(message, writer) {
-  var f = undefined;
-  f = message.getConfig();
-  if (f != null) {
-    writer.writeMessage(
-      1,
-      f,
-      proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter
-    );
-  }
-  f = /** @type {!(string|Uint8Array)} */ (jspb.Message.getField(message, 2));
-  if (f != null) {
-    writer.writeBytes(
-      2,
-      f
-    );
-  }
-  f = /** @type {number} */ (jspb.Message.getField(message, 3));
-  if (f != null) {
-    writer.writeInt32(
-      3,
-      f
-    );
-  }
-};
-
-
-/**
- * optional MonitorConfig config = 1;
- * @return {?proto.cc.arduino.cli.monitor.v1.MonitorConfig}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getConfig = function() {
-  return /** @type{?proto.cc.arduino.cli.monitor.v1.MonitorConfig} */ (
-    jspb.Message.getWrapperField(this, proto.cc.arduino.cli.monitor.v1.MonitorConfig, 1));
-};
-
-
-/**
- * @param {?proto.cc.arduino.cli.monitor.v1.MonitorConfig|undefined} value
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
-*/
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setConfig = function(value) {
-  return jspb.Message.setOneofWrapperField(this, 1, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
-};
-
-
-/**
- * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearConfig = function() {
-  return this.setConfig(undefined);
-};
-
-
-/**
- * Returns whether this field is set.
- * @return {boolean}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasConfig = function() {
-  return jspb.Message.getField(this, 1) != null;
-};
-
-
-/**
- * optional bytes data = 2;
- * @return {!(string|Uint8Array)}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData = function() {
-  return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 2, ""));
-};
-
-
-/**
- * optional bytes data = 2;
- * This is a type-conversion wrapper around `getData()`
- * @return {string}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData_asB64 = function() {
-  return /** @type {string} */ (jspb.Message.bytesAsB64(
-      this.getData()));
-};
-
-
-/**
- * optional bytes data = 2;
- * Note that Uint8Array is not supported on all browsers.
- * @see http://caniuse.com/Uint8Array
- * This is a type-conversion wrapper around `getData()`
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getData_asU8 = function() {
-  return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
-      this.getData()));
-};
-
-
-/**
- * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setData = function(value) {
-  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
-};
-
-
-/**
- * Clears the field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearData = function() {
-  return jspb.Message.setOneofField(this, 2, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], undefined);
-};
-
-
-/**
- * Returns whether this field is set.
- * @return {boolean}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasData = function() {
-  return jspb.Message.getField(this, 2) != null;
-};
-
-
-/**
- * optional int32 recv_acknowledge = 3;
- * @return {number}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.getRecvAcknowledge = function() {
-  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 3, 0));
-};
-
-
-/**
- * @param {number} value
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.setRecvAcknowledge = function(value) {
-  return jspb.Message.setOneofField(this, 3, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], value);
-};
-
-
-/**
- * Clears the field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.clearRecvAcknowledge = function() {
-  return jspb.Message.setOneofField(this, 3, proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.oneofGroups_[0], undefined);
-};
-
-
-/**
- * Returns whether this field is set.
- * @return {boolean}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenRequest.prototype.hasRecvAcknowledge = function() {
-  return jspb.Message.getField(this, 3) != null;
-};
-
-
-
-
-
-if (jspb.Message.GENERATE_TO_OBJECT) {
-/**
- * Creates an object representation of this proto.
- * Field names that are reserved in JavaScript and will be renamed to pb_name.
- * Optional fields that are not set will be set to undefined.
- * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
- * For the list of reserved names please see:
- *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
- * @param {boolean=} opt_includeInstance Deprecated. whether to include the
- *     JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @return {!Object}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject(opt_includeInstance, this);
-};
-
-
-/**
- * Static version of the {@see toObject} method.
- * @param {boolean|undefined} includeInstance Deprecated. Whether to include
- *     the JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} msg The msg instance to transform.
- * @return {!Object}
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.toObject = function(includeInstance, msg) {
-  var f, obj = {
-    target: jspb.Message.getFieldWithDefault(msg, 1, ""),
-    type: jspb.Message.getFieldWithDefault(msg, 2, 0),
-    additionalConfig: (f = msg.getAdditionalConfig()) && google_protobuf_struct_pb.Struct.toObject(includeInstance, f),
-    recvRateLimitBuffer: jspb.Message.getFieldWithDefault(msg, 4, 0)
-  };
-
-  if (includeInstance) {
-    obj.$jspbMessageInstance = msg;
-  }
-  return obj;
-};
-}
-
-
-/**
- * Deserializes binary data (in protobuf wire format).
- * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinary = function(bytes) {
-  var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.v1.MonitorConfig;
-  return proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader(msg, reader);
-};
-
-
-/**
- * Deserializes binary data (in protobuf wire format) from the
- * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} msg The message object to deserialize into.
- * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.deserializeBinaryFromReader = function(msg, reader) {
-  while (reader.nextField()) {
-    if (reader.isEndGroup()) {
-      break;
-    }
-    var field = reader.getFieldNumber();
-    switch (field) {
-    case 1:
-      var value = /** @type {string} */ (reader.readString());
-      msg.setTarget(value);
-      break;
-    case 2:
-      var value = /** @type {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} */ (reader.readEnum());
-      msg.setType(value);
-      break;
-    case 3:
-      var value = new google_protobuf_struct_pb.Struct;
-      reader.readMessage(value,google_protobuf_struct_pb.Struct.deserializeBinaryFromReader);
-      msg.setAdditionalConfig(value);
-      break;
-    case 4:
-      var value = /** @type {number} */ (reader.readInt32());
-      msg.setRecvRateLimitBuffer(value);
-      break;
-    default:
-      reader.skipField();
-      break;
-    }
-  }
-  return msg;
-};
-
-
-/**
- * Serializes the message to binary data (in protobuf wire format).
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.serializeBinary = function() {
-  var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter(this, writer);
-  return writer.getResultBuffer();
-};
-
-
-/**
- * Serializes the given message to binary data (in protobuf wire
- * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} message
- * @param {!jspb.BinaryWriter} writer
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.serializeBinaryToWriter = function(message, writer) {
-  var f = undefined;
-  f = message.getTarget();
-  if (f.length > 0) {
-    writer.writeString(
-      1,
-      f
-    );
-  }
-  f = message.getType();
-  if (f !== 0.0) {
-    writer.writeEnum(
-      2,
-      f
-    );
-  }
-  f = message.getAdditionalConfig();
-  if (f != null) {
-    writer.writeMessage(
-      3,
-      f,
-      google_protobuf_struct_pb.Struct.serializeBinaryToWriter
-    );
-  }
-  f = message.getRecvRateLimitBuffer();
-  if (f !== 0) {
-    writer.writeInt32(
-      4,
-      f
-    );
-  }
-};
-
-
-/**
- * @enum {number}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType = {
-  TARGET_TYPE_SERIAL: 0,
-  TARGET_TYPE_NULL: 99
-};
-
-/**
- * optional string target = 1;
- * @return {string}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getTarget = function() {
-  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
-};
-
-
-/**
- * @param {string} value
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setTarget = function(value) {
-  return jspb.Message.setProto3StringField(this, 1, value);
-};
-
-
-/**
- * optional TargetType type = 2;
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getType = function() {
-  return /** @type {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
-};
-
-
-/**
- * @param {!proto.cc.arduino.cli.monitor.v1.MonitorConfig.TargetType} value
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setType = function(value) {
-  return jspb.Message.setProto3EnumField(this, 2, value);
-};
-
-
-/**
- * optional google.protobuf.Struct additional_config = 3;
- * @return {?proto.google.protobuf.Struct}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getAdditionalConfig = function() {
-  return /** @type{?proto.google.protobuf.Struct} */ (
-    jspb.Message.getWrapperField(this, google_protobuf_struct_pb.Struct, 3));
-};
-
-
-/**
- * @param {?proto.google.protobuf.Struct|undefined} value
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
-*/
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setAdditionalConfig = function(value) {
-  return jspb.Message.setWrapperField(this, 3, value);
-};
-
-
-/**
- * Clears the message field making it undefined.
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.clearAdditionalConfig = function() {
-  return this.setAdditionalConfig(undefined);
-};
-
-
-/**
- * Returns whether this field is set.
- * @return {boolean}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.hasAdditionalConfig = function() {
-  return jspb.Message.getField(this, 3) != null;
-};
-
-
-/**
- * optional int32 recv_rate_limit_buffer = 4;
- * @return {number}
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.getRecvRateLimitBuffer = function() {
-  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 4, 0));
-};
-
-
-/**
- * @param {number} value
- * @return {!proto.cc.arduino.cli.monitor.v1.MonitorConfig} returns this
- */
-proto.cc.arduino.cli.monitor.v1.MonitorConfig.prototype.setRecvRateLimitBuffer = function(value) {
-  return jspb.Message.setProto3IntField(this, 4, value);
-};
-
-
-
-
-
-if (jspb.Message.GENERATE_TO_OBJECT) {
-/**
- * Creates an object representation of this proto.
- * Field names that are reserved in JavaScript and will be renamed to pb_name.
- * Optional fields that are not set will be set to undefined.
- * To access a reserved field use, foo.pb_<name>, eg, foo.pb_default.
- * For the list of reserved names please see:
- *     net/proto2/compiler/js/internal/generator.cc#kKeyword.
- * @param {boolean=} opt_includeInstance Deprecated. whether to include the
- *     JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @return {!Object}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.toObject = function(opt_includeInstance) {
-  return proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.toObject(opt_includeInstance, this);
-};
-
-
-/**
- * Static version of the {@see toObject} method.
- * @param {boolean|undefined} includeInstance Deprecated. Whether to include
- *     the JSPB instance for transitional soy proto support:
- *     http://goto/soy-param-migration
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} msg The msg instance to transform.
- * @return {!Object}
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.toObject = function(includeInstance, msg) {
-  var f, obj = {
-    data: msg.getData_asB64(),
-    dropped: jspb.Message.getFieldWithDefault(msg, 2, 0)
-  };
-
-  if (includeInstance) {
-    obj.$jspbMessageInstance = msg;
-  }
-  return obj;
-};
-}
-
-
-/**
- * Deserializes binary data (in protobuf wire format).
- * @param {jspb.ByteSource} bytes The bytes to deserialize.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinary = function(bytes) {
-  var reader = new jspb.BinaryReader(bytes);
-  var msg = new proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse;
-  return proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinaryFromReader(msg, reader);
-};
-
-
-/**
- * Deserializes binary data (in protobuf wire format) from the
- * given reader into the given message object.
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} msg The message object to deserialize into.
- * @param {!jspb.BinaryReader} reader The BinaryReader to use.
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.deserializeBinaryFromReader = function(msg, reader) {
-  while (reader.nextField()) {
-    if (reader.isEndGroup()) {
-      break;
-    }
-    var field = reader.getFieldNumber();
-    switch (field) {
-    case 1:
-      var value = /** @type {!Uint8Array} */ (reader.readBytes());
-      msg.setData(value);
-      break;
-    case 2:
-      var value = /** @type {number} */ (reader.readInt32());
-      msg.setDropped(value);
-      break;
-    default:
-      reader.skipField();
-      break;
-    }
-  }
-  return msg;
-};
-
-
-/**
- * Serializes the message to binary data (in protobuf wire format).
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.serializeBinary = function() {
-  var writer = new jspb.BinaryWriter();
-  proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.serializeBinaryToWriter(this, writer);
-  return writer.getResultBuffer();
-};
-
-
-/**
- * Serializes the given message to binary data (in protobuf wire
- * format), writing to the given BinaryWriter.
- * @param {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} message
- * @param {!jspb.BinaryWriter} writer
- * @suppress {unusedLocalVariables} f is only used for nested messages
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.serializeBinaryToWriter = function(message, writer) {
-  var f = undefined;
-  f = message.getData_asU8();
-  if (f.length > 0) {
-    writer.writeBytes(
-      1,
-      f
-    );
-  }
-  f = message.getDropped();
-  if (f !== 0) {
-    writer.writeInt32(
-      2,
-      f
-    );
-  }
-};
-
-
-/**
- * optional bytes data = 1;
- * @return {!(string|Uint8Array)}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData = function() {
-  return /** @type {!(string|Uint8Array)} */ (jspb.Message.getFieldWithDefault(this, 1, ""));
-};
-
-
-/**
- * optional bytes data = 1;
- * This is a type-conversion wrapper around `getData()`
- * @return {string}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData_asB64 = function() {
-  return /** @type {string} */ (jspb.Message.bytesAsB64(
-      this.getData()));
-};
-
-
-/**
- * optional bytes data = 1;
- * Note that Uint8Array is not supported on all browsers.
- * @see http://caniuse.com/Uint8Array
- * This is a type-conversion wrapper around `getData()`
- * @return {!Uint8Array}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getData_asU8 = function() {
-  return /** @type {!Uint8Array} */ (jspb.Message.bytesAsU8(
-      this.getData()));
-};
-
-
-/**
- * @param {!(string|Uint8Array)} value
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.setData = function(value) {
-  return jspb.Message.setProto3BytesField(this, 1, value);
-};
-
-
-/**
- * optional int32 dropped = 2;
- * @return {number}
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.getDropped = function() {
-  return /** @type {number} */ (jspb.Message.getFieldWithDefault(this, 2, 0));
-};
-
-
-/**
- * @param {number} value
- * @return {!proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse} returns this
- */
-proto.cc.arduino.cli.monitor.v1.StreamingOpenResponse.prototype.setDropped = function(value) {
-  return jspb.Message.setProto3IntField(this, 2, value);
-};
-
-
-goog.object.extend(exports, proto.cc.arduino.cli.monitor.v1);

arduino-ide-extension/src/node/sketches-service-impl.ts

@@ -555,12 +555,12 @@ export class SketchesServiceImpl
     return destinationUri;
   }
 
-  async getIdeTempFolderUri(sketch: Sketch): Promise<string> {
+  async getIdeTempFolderUri(sketch: SketchRef): Promise<string> {
     const genBuildPath = await this.getIdeTempFolderPath(sketch);
     return FileUri.create(genBuildPath).toString();
   }
 
-  private async getIdeTempFolderPath(sketch: Sketch): Promise<string> {
+  private async getIdeTempFolderPath(sketch: SketchRef): Promise<string> {
     const sketchPath = FileUri.fsPath(sketch.uri);
     await fs.readdir(sketchPath); // Validates the sketch folder and rejects if not accessible.
     const suffix = crypto.createHash('md5').update(sketchPath).digest('hex');

arduino-ide-extension/src/node/theia/plugin-ext/plugin-reader.ts

@@ -12,25 +12,25 @@ export class HostedPluginReader extends TheiaHostedPluginReader {
   ): Promise<PluginContribution | undefined> {
     const scanner = this.scanner.getScanner(plugin);
     const contributions = await scanner.getContribution(plugin);
-    return this.filterContribution(plugin.name, contributions);
+    return this.mapContribution(plugin.name, contributions);
   }
 
-  private filterContribution(
+  private mapContribution(
     pluginName: string,
     contributions: PluginContribution | undefined
   ): PluginContribution | undefined {
     if (!contributions) {
       return contributions;
     }
-    const filter = pluginFilters.get(pluginName);
-    return filter ? filter(contributions) : contributions;
+    const mapper = pluginMappers.get(pluginName);
+    return mapper ? mapper(contributions) : contributions;
   }
 }
 
-type PluginContributionFilter = (
+type PluginContributionMapper = (
   contribution: PluginContribution
 ) => PluginContribution | undefined;
-const cortexDebugFilter: PluginContributionFilter = (
+const cortexDebugMapper: PluginContributionMapper = (
   contribution: PluginContribution
 ) => {
   if (contribution.viewsContainers) {
@@ -81,9 +81,24 @@ const cortexDebugFilter: PluginContributionFilter = (
       }
     }
   }
+  for (const _debugger of contribution.debuggers ?? []) {
+    if (_debugger.type === 'cortex-debug') {
+      for (const attributes of _debugger.configurationAttributes ?? []) {
+        if (attributes.properties) {
+          // Patch the cortex-debug debug config schema to allow the in-house `configId`.
+          attributes.properties['configId'] = {
+            type: 'string',
+            description:
+              'Arduino debug configuration identifier consisting of the Fully Qualified Board Name (FQBN) and the programmer identifier (for example, `esptool`)',
+          };
+        }
+      }
+    }
+  }
+
   return contribution;
 };
 
-const pluginFilters = new Map<string, PluginContributionFilter>([
-  ['cortex-debug', cortexDebugFilter],
+const pluginMappers = new Map<string, PluginContributionMapper>([
+  ['cortex-debug', cortexDebugMapper],
 ]);

arduino-ide-extension/src/test/browser/auto-select-programmer.test.ts

@@ -0,0 +1,176 @@
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import {
+  Disposable,
+  DisposableCollection,
+} from '@theia/core/lib/common/disposable';
+import { expect } from 'chai';
+import { BoardsDataStore } from '../../browser/boards/boards-data-store';
+import { ensureProgrammerIsSelected } from '../../browser/contributions/auto-select-programmer';
+import { Programmer } from '../../common/protocol';
+
+disableJSDOM();
+
+describe('auto-select-programmer', () => {
+  describe('ensureProgrammerIsSelected', () => {
+    let debugMessages: string[];
+    const toDispose = new DisposableCollection();
+    const fqbn = 'a:b:c';
+    const programmer: Programmer = {
+      id: 'p1',
+      name: 'P1',
+      platform: 'a:b',
+    };
+    const anotherProgrammer: Programmer = {
+      id: 'p2',
+      name: 'P2',
+      platform: 'a:b',
+    };
+
+    before(() => {
+      const debug = console.debug;
+      console.debug = (message: string) => debugMessages.push(message);
+      toDispose.push(Disposable.create(() => (console.debug = debug)));
+    });
+
+    beforeEach(() => (debugMessages = []));
+
+    after(() => toDispose.dispose());
+
+    it('should not set when the fqbn is missing', async () => {
+      const ok = await ensureProgrammerIsSelected({
+        fqbn: undefined,
+        getData: () => BoardsDataStore.Data.EMPTY,
+        loadBoardDetails: () => undefined,
+        selectProgrammer: () => false,
+      });
+      expect(ok).to.be.false;
+      expect(debugMessages).to.be.empty;
+    });
+
+    it('should not set when no board details found (missing core)', async () => {
+      const ok = await ensureProgrammerIsSelected({
+        fqbn,
+        getData: () => BoardsDataStore.Data.EMPTY,
+        loadBoardDetails: () => undefined,
+        selectProgrammer: () => false,
+      });
+      expect(ok).to.be.false;
+      expect(debugMessages).to.be.deep.equal([
+        'Ensuring a programmer is selected for a:b:c...',
+        'Skipping. No boards data is available for a:b:c.',
+      ]);
+    });
+
+    it('should be noop when the programmer is already selected', async () => {
+      const ok = await ensureProgrammerIsSelected({
+        fqbn,
+        getData: () => ({
+          configOptions: [],
+          programmers: [programmer],
+          selectedProgrammer: programmer,
+          defaultProgrammerId: undefined,
+        }),
+        loadBoardDetails: () => undefined,
+        selectProgrammer: () => false,
+      });
+      expect(ok).to.be.true;
+      expect(debugMessages).to.be.deep.equal([
+        'Ensuring a programmer is selected for a:b:c...',
+        "A programmer is already selected for a:b:c: 'p1'.",
+      ]);
+    });
+
+    it('should automatically select the default one if not selected', async () => {
+      const selectedProgrammers: Record<string, Programmer | undefined> = {};
+      const ok = await ensureProgrammerIsSelected({
+        fqbn,
+        getData: () => ({
+          configOptions: [],
+          programmers: [anotherProgrammer, programmer],
+          selectedProgrammer: undefined,
+          defaultProgrammerId: programmer.id,
+        }),
+        loadBoardDetails: () => undefined,
+        selectProgrammer: (arg) => {
+          selectedProgrammers[arg.fqbn] = arg.selectedProgrammer;
+          return true;
+        },
+      });
+      expect(ok).to.be.true;
+      expect(debugMessages).to.be.deep.equal([
+        'Ensuring a programmer is selected for a:b:c...',
+        "Selected 'p1' programmer for a:b:c.",
+      ]);
+      expect(selectedProgrammers).to.be.deep.equal({
+        [fqbn]: programmer,
+      });
+    });
+
+    it('should not select the programmer when loading the board details fails', async () => {
+      const ok = await ensureProgrammerIsSelected({
+        fqbn,
+        getData: () => ({
+          configOptions: [],
+          programmers: [],
+          selectedProgrammer: undefined,
+          defaultProgrammerId: undefined,
+        }),
+        loadBoardDetails: () => undefined,
+        selectProgrammer: () => false,
+      });
+      expect(ok).to.be.false;
+      expect(debugMessages).to.be.deep.equal([
+        'Ensuring a programmer is selected for a:b:c...',
+        'Skipping. No boards data is available for a:b:c.',
+      ]);
+    });
+
+    it('should select the programmer after reloading the data', async () => {
+      const selectedProgrammers: Record<string, Programmer | undefined> = {};
+      const ok = await ensureProgrammerIsSelected({
+        fqbn,
+        getData: () => ({
+          configOptions: [
+            {
+              label: 'config',
+              option: 'opt1',
+              values: [{ label: 'Opt1', selected: true, value: 'Value' }],
+            },
+          ],
+          programmers: [],
+          selectedProgrammer: undefined,
+          defaultProgrammerId: undefined,
+        }),
+        loadBoardDetails: () => ({
+          fqbn,
+          requiredTools: [],
+          configOptions: [],
+          programmers: [programmer, anotherProgrammer],
+          debuggingSupported: false,
+          VID: 'VID',
+          PID: 'PID',
+          buildProperties: [],
+          defaultProgrammerId: programmer.id,
+        }),
+        selectProgrammer: (arg) => {
+          selectedProgrammers[arg.fqbn] = arg.selectedProgrammer;
+          return true;
+        },
+      });
+      expect(ok).to.be.true;
+      expect(debugMessages).to.be.deep.equal([
+        'Ensuring a programmer is selected for a:b:c...',
+        'Reloading board details for a:b:c...',
+        "Selected 'p1' programmer for a:b:c.",
+      ]);
+      expect(selectedProgrammers).to.be.deep.equal({
+        [fqbn]: programmer,
+      });
+    });
+  });
+});

arduino-ide-extension/src/test/browser/boards-data-store.test.ts

@@ -16,7 +16,6 @@ import {
 } from '@theia/core/lib/common/disposable';
 import { MessageService } from '@theia/core/lib/common/message-service';
 import { wait } from '@theia/core/lib/common/promise-util';
-import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
 import { Container, ContainerModule } from '@theia/core/shared/inversify';
 import { expect } from 'chai';
 import { BoardsDataStore } from '../../browser/boards/boards-data-store';
@@ -30,7 +29,7 @@ import {
   Programmer,
 } from '../../common/protocol/boards-service';
 import { NotificationServiceServer } from '../../common/protocol/notification-service';
-import { ConsoleLogger, bindCommon } from '../common/common-test-bindings';
+import { bindBrowser } from './browser-test-bindings';
 
 disableJSDOM();
 
@@ -76,7 +75,6 @@ describe('boards-data-store', function () {
     const storedData: BoardsDataStore.Data = {
       configOptions: [],
       programmers: [edbg],
-      selectedProgrammer: edbg,
     };
     await setStorageData(fqbn, storedData);
     const data = await boardsDataStore.getData(fqbn);
@@ -86,7 +84,7 @@ describe('boards-data-store', function () {
   it('should update board details of selected board (selected with FQBN)', async () => {
     const updated = boardsServiceProvider.updateConfig(board);
     expect(updated).to.be.ok;
-    await wait(50);
+    await wait(1);
 
     const selectedBoardData = boardsDataStore['_selectedBoardData'];
     expect(selectedBoardData).to.be.deep.equal({
@@ -104,7 +102,7 @@ describe('boards-data-store', function () {
     const board = { name, fqbn };
     const updated = boardsServiceProvider.updateConfig(board);
     expect(updated).to.ok;
-    await wait(50);
+    await wait(1);
 
     const selectedBoardData = boardsDataStore['_selectedBoardData'];
     expect(selectedBoardData).to.be.undefined;
@@ -113,7 +111,7 @@ describe('boards-data-store', function () {
   it('should unset the the board details of selected board when no board was selected', async () => {
     let updated = boardsServiceProvider.updateConfig(board);
     expect(updated).to.ok;
-    await wait(50);
+    await wait(1);
 
     let selectedBoardData = boardsDataStore['_selectedBoardData'];
     expect(selectedBoardData).to.be.deep.equal({
@@ -126,18 +124,18 @@ describe('boards-data-store', function () {
 
     updated = boardsServiceProvider.updateConfig('unset-board');
     expect(updated).to.be.true;
-    await wait(50);
+    await wait(1);
 
     selectedBoardData = boardsDataStore['_selectedBoardData'];
     expect(selectedBoardData).to.be.undefined;
   });
 
   it('should provide startup tasks when the data is available for the selected board', async () => {
-    const updated = boardsServiceProvider.updateConfig(board);
+    let updated = boardsServiceProvider.updateConfig(board);
     expect(updated).to.be.true;
-    await wait(50);
+    await wait(1);
 
-    const tasks = boardsDataStore.tasks();
+    let tasks = boardsDataStore.tasks();
     expect(tasks).to.be.deep.equal([
       {
         command: 'arduino-use-inherited-boards-data',
@@ -152,6 +150,13 @@ describe('boards-data-store', function () {
         ],
       },
     ]);
+
+    updated = boardsServiceProvider.updateConfig('unset-board');
+    expect(updated).to.be.true;
+    await wait(1);
+
+    tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.empty;
   });
 
   it('should not provide any startup tasks when no data is available for the selected board', async () => {
@@ -159,6 +164,187 @@ describe('boards-data-store', function () {
     expect(tasks).to.be.empty;
   });
 
+  it('should update the startup task arg when the selected programmer changes', async () => {
+    let tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.empty;
+
+    let data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [configOption1],
+      programmers: [edbg, jlink],
+    });
+
+    const updated = boardsServiceProvider.updateConfig(board);
+    expect(updated).to.be.ok;
+    await wait(1);
+
+    tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.deep.equal([
+      {
+        command: 'arduino-use-inherited-boards-data',
+        args: [
+          {
+            fqbn,
+            data: {
+              configOptions: [configOption1],
+              programmers: [edbg, jlink],
+            },
+          },
+        ],
+      },
+    ]);
+
+    const result = await boardsDataStore.selectProgrammer({
+      fqbn,
+      selectedProgrammer: edbg,
+    });
+    expect(result).to.be.ok;
+
+    data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [configOption1],
+      programmers: [edbg, jlink],
+      selectedProgrammer: edbg,
+    });
+    tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.deep.equal([
+      {
+        command: 'arduino-use-inherited-boards-data',
+        args: [
+          {
+            fqbn,
+            data: {
+              configOptions: [configOption1],
+              programmers: [edbg, jlink],
+              selectedProgrammer: edbg,
+            },
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should update the startup task arg when the config options change', async () => {
+    let tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.empty;
+
+    let data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [configOption1],
+      programmers: [edbg, jlink],
+    });
+
+    const updated = boardsServiceProvider.updateConfig(board);
+    expect(updated).to.be.ok;
+    await wait(1);
+
+    tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.deep.equal([
+      {
+        command: 'arduino-use-inherited-boards-data',
+        args: [
+          {
+            fqbn,
+            data: {
+              configOptions: [configOption1],
+              programmers: [edbg, jlink],
+            },
+          },
+        ],
+      },
+    ]);
+
+    const result = await boardsDataStore.selectConfigOption({
+      fqbn,
+      option: configOption1.option,
+      selectedValue: configOption1.values[1].value,
+    });
+    expect(result).to.be.ok;
+
+    data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [
+        {
+          ...configOption1,
+          values: [
+            { label: 'C1V1', selected: false, value: 'v1' },
+            { label: 'C1V2', selected: true, value: 'v2' },
+          ],
+        },
+      ],
+      programmers: [edbg, jlink],
+    });
+
+    tasks = boardsDataStore.tasks();
+    expect(tasks).to.be.deep.equal([
+      {
+        command: 'arduino-use-inherited-boards-data',
+        args: [
+          {
+            fqbn,
+            data: {
+              configOptions: [
+                {
+                  ...configOption1,
+                  values: [
+                    { label: 'C1V1', selected: false, value: 'v1' },
+                    { label: 'C1V2', selected: true, value: 'v2' },
+                  ],
+                },
+              ],
+              programmers: [edbg, jlink],
+            },
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('should select the default programmer', async () => {
+    const storedData = await getStoredData(fqbn);
+    expect(storedData).to.be.undefined;
+
+    toDisposeAfterEach.push(
+      mockBoardDetails([
+        {
+          fqbn,
+          ...baseDetails,
+          defaultProgrammerId: edbg.id,
+        },
+      ])
+    );
+
+    const data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [configOption1],
+      programmers: [edbg, jlink],
+      defaultProgrammerId: edbg.id,
+      selectedProgrammer: edbg,
+    });
+  });
+
+  it('should not select the default programmer when no match', async () => {
+    const storedData = await getStoredData(fqbn);
+    expect(storedData).to.be.undefined;
+
+    toDisposeAfterEach.push(
+      mockBoardDetails([
+        {
+          fqbn,
+          ...baseDetails,
+          defaultProgrammerId: 'missing',
+        },
+      ])
+    );
+
+    const data = await boardsDataStore.getData(fqbn);
+    expect(data).to.be.deep.equal({
+      configOptions: [configOption1],
+      programmers: [edbg, jlink],
+      defaultProgrammerId: 'missing',
+    });
+  });
+
   it('should select a programmer', async () => {
     let data = await boardsDataStore.getData(fqbn);
     expect(data).to.be.deep.equal({
@@ -306,7 +492,7 @@ describe('boards-data-store', function () {
       boardsDataStore.onDidChange(() => didChangeCounter++)
     );
     notificationCenter.notifyPlatformDidInstall({ item: boardsPackage });
-    await wait(50);
+    await wait(1);
     expect(didChangeCounter).to.be.equal(0);
 
     storedData = await getStoredData(fqbn);
@@ -326,7 +512,7 @@ describe('boards-data-store', function () {
       boardsDataStore.onDidChange(() => didChangeCounter++)
     );
     notificationCenter.notifyPlatformDidInstall({ item: boardsPackage });
-    await wait(50);
+    await wait(1);
     expect(didChangeCounter).to.be.equal(1);
 
     storedData = await getStoredData(fqbn);
@@ -359,7 +545,7 @@ describe('boards-data-store', function () {
       boardsDataStore.onDidChange(() => didChangeCounter++)
     );
     notificationCenter.notifyPlatformDidInstall({ item: boardsPackage });
-    await wait(50);
+    await wait(1);
     expect(didChangeCounter).to.be.equal(1);
 
     storedData = await boardsDataStore.getData(fqbn);
@@ -390,7 +576,7 @@ describe('boards-data-store', function () {
     const container = new Container({ defaultScope: 'Singleton' });
     container.load(
       new ContainerModule((bind, unbind, isBound, rebind) => {
-        bindCommon(bind);
+        bindBrowser(bind, unbind, isBound, rebind);
         bind(MessageService).toConstantValue(<MessageService>{});
         bind(BoardsService).toConstantValue(<BoardsService>{
           getDetectedPorts() {
@@ -415,11 +601,6 @@ describe('boards-data-store', function () {
         bind(WindowService).toConstantValue(<WindowService>{});
         bind(StorageService).toService(LocalStorageService);
         bind(BoardsServiceProvider).toSelf().inSingletonScope();
-        // IDE2's test console logger does not support `Loggable` arg.
-        // Rebind logger to suppress `[Function (anonymous)]` messages in tests when the storage service is initialized without `window.localStorage`.
-        // https://github.com/eclipse-theia/theia/blob/04c8cf07843ea67402131132e033cdd54900c010/packages/core/src/browser/storage-service.ts#L60
-        bind(MockLogger).toSelf().inSingletonScope();
-        rebind(ConsoleLogger).toService(MockLogger);
       })
     );
     return container;
@@ -460,7 +641,6 @@ describe('boards-data-store', function () {
     PID: '1',
     buildProperties: [],
     configOptions: [configOption1],
-    debuggingSupported: false,
     programmers: [edbg, jlink],
     requiredTools: [],
   };

arduino-ide-extension/src/test/browser/browser-test-bindings.ts

@@ -1,10 +1,43 @@
+import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
+import { LabelProvider } from '@theia/core/lib/browser/label-provider';
+import { OpenerService } from '@theia/core/lib/browser/opener-service';
+import {
+  LocalStorageService,
+  StorageService,
+} from '@theia/core/lib/browser/storage-service';
+import { WindowService } from '@theia/core/lib/browser/window/window-service';
+import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
+import { MessageService } from '@theia/core/lib/common/message-service';
 import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
-import { Container, ContainerModule } from '@theia/core/shared/inversify';
+import {
+  Container,
+  ContainerModule,
+  injectable,
+} from '@theia/core/shared/inversify';
+import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
+import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { ArduinoPreferences } from '../../browser/arduino-preferences';
+import { BoardsDataStore } from '../../browser/boards/boards-data-store';
+import { BoardsServiceProvider } from '../../browser/boards/boards-service-provider';
+import { ConfigServiceClient } from '../../browser/config/config-service-client';
+import { DialogService } from '../../browser/dialog-service';
+import { SettingsService } from '../../browser/dialogs/settings/settings';
+import { HostedPluginSupport } from '../../browser/hosted/hosted-plugin-support';
+import { NotificationCenter } from '../../browser/notification-center';
+import { SketchesServiceClientImpl } from '../../browser/sketches-service-client-impl';
+import { ApplicationConnectionStatusContribution } from '../../browser/theia/core/connection-status-service';
+import { OutputChannelManager } from '../../browser/theia/output/output-channel';
+import { WorkspaceService } from '../../browser/theia/workspace/workspace-service';
+import { MainMenuManager } from '../../common/main-menu-manager';
+import { FileSystemExt, SketchesService } from '../../common/protocol';
+import { BoardsService } from '../../common/protocol/boards-service';
+import { NotificationServiceServer } from '../../common/protocol/notification-service';
 import {
   Bind,
   ConsoleLogger,
   bindCommon,
 } from '../common/common-test-bindings';
+import { never } from '../utils';
 
 export function createBaseContainer(bind: Bind = bindBrowser): Container {
   const container = new Container({ defaultScope: 'Singleton' });
@@ -23,3 +56,57 @@ export const bindBrowser: Bind = function (
   bind(MockLogger).toSelf().inSingletonScope();
   rebind(ConsoleLogger).toService(MockLogger);
 };
+
+/**
+ * Binds all required services as a mock to test a `SketchesContribution` instance.
+ */
+export const bindSketchesContribution: Bind = function (
+  ...args: Parameters<Bind>
+): ReturnType<Bind> {
+  const [bind] = args;
+  bindBrowser(...args);
+  bind(MessageService).toConstantValue(<MessageService>{});
+  bind(BoardsService).toConstantValue(<BoardsService>{});
+  bind(NotificationCenter).toSelf().inSingletonScope();
+  bind(NotificationServiceServer).toConstantValue(<NotificationServiceServer>{
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    setClient(_) {
+      // nothing
+    },
+  });
+  bind(FrontendApplicationStateService).toSelf().inSingletonScope();
+  bind(BoardsDataStore).toConstantValue(<BoardsDataStore>{});
+  bind(LocalStorageService).toSelf().inSingletonScope();
+  bind(WindowService).toConstantValue(<WindowService>{});
+  bind(StorageService).toService(LocalStorageService);
+  bind(BoardsServiceProvider).toSelf().inSingletonScope();
+  bind(NoopHostedPluginSupport).toSelf().inSingletonScope();
+  bind(HostedPluginSupport).toService(NoopHostedPluginSupport);
+  bind(FileService).toConstantValue(<FileService>{});
+  bind(FileSystemExt).toConstantValue(<FileSystemExt>{});
+  bind(ConfigServiceClient).toConstantValue(<ConfigServiceClient>{});
+  bind(SketchesService).toConstantValue(<SketchesService>{});
+  bind(OpenerService).toConstantValue(<OpenerService>{});
+  bind(SketchesServiceClientImpl).toConstantValue(
+    <SketchesServiceClientImpl>{}
+  );
+  bind(EditorManager).toConstantValue(<EditorManager>{});
+  bind(OutputChannelManager).toConstantValue(<OutputChannelManager>{});
+  bind(EnvVariablesServer).toConstantValue(<EnvVariablesServer>{});
+  bind(ApplicationConnectionStatusContribution).toConstantValue(
+    <ApplicationConnectionStatusContribution>{}
+  );
+  bind(WorkspaceService).toConstantValue(<WorkspaceService>{});
+  bind(LabelProvider).toConstantValue(<LabelProvider>{});
+  bind(SettingsService).toConstantValue(<SettingsService>{});
+  bind(ArduinoPreferences).toConstantValue(<ArduinoPreferences>{});
+  bind(DialogService).toConstantValue(<DialogService>{});
+  bind(MainMenuManager).toConstantValue(<MainMenuManager>{});
+};
+
+@injectable()
+export class NoopHostedPluginSupport implements HostedPluginSupport {
+  readonly didStart = Promise.resolve();
+  readonly onDidCloseConnection = never();
+  readonly onDidLoad = never();
+}

arduino-ide-extension/src/test/browser/debug.test.ts

@@ -0,0 +1,379 @@
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+const disableJSDOM = enableJSDOM();
+
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
+
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+
+import { CommandEvent, CommandRegistry } from '@theia/core/lib/common/command';
+import { Emitter } from '@theia/core/lib/common/event';
+import { deepClone } from '@theia/core/lib/common/objects';
+import { wait } from '@theia/core/lib/common/promise-util';
+import { Mutable } from '@theia/core/lib/common/types';
+import {
+  Container,
+  ContainerModule,
+  injectable,
+} from '@theia/core/shared/inversify';
+import { expect } from 'chai';
+import { doesNotReject, rejects } from 'node:assert/strict';
+import {
+  BoardsDataStore,
+  BoardsDataStoreChangeEvent,
+} from '../../browser/boards/boards-data-store';
+import { BoardsServiceProvider } from '../../browser/boards/boards-service-provider';
+import {
+  Debug,
+  debuggingNotSupported,
+  isDebugEnabled,
+  noPlatformInstalledFor,
+  noProgrammerSelectedFor,
+} from '../../browser/contributions/debug';
+import { NotificationCenter } from '../../browser/notification-center';
+import { noBoardSelected } from '../../common/nls';
+import {
+  BoardsConfigChangeEvent,
+  BoardsPackage,
+  CompileSummary,
+  ExecutableService,
+  type BoardDetails,
+  type Programmer,
+} from '../../common/protocol';
+import {
+  BoardsConfig,
+  emptyBoardsConfig,
+} from '../../common/protocol/boards-service';
+import { bindSketchesContribution } from './browser-test-bindings';
+import { aPackage } from './fixtures/boards';
+
+disableJSDOM();
+
+describe('debug', () => {
+  describe('isDebugEnabled', () => {
+    const fqbn = 'a:b:c';
+    const name = 'ABC';
+    const board = { fqbn, name };
+    const p1: Programmer = { id: 'p1', name: 'P1', platform: 'The platform' };
+    const p2: Programmer = { id: 'p2', name: 'P2', platform: 'The platform' };
+    const data: BoardsDataStore.Data = {
+      configOptions: [],
+      defaultProgrammerId: 'p1',
+      programmers: [p1, p2],
+      selectedProgrammer: p1,
+    };
+    const boardDetails: BoardDetails = {
+      buildProperties: [],
+      configOptions: [],
+      defaultProgrammerId: 'p1',
+      programmers: [p1, p2],
+      fqbn,
+      PID: '0',
+      VID: '0',
+      requiredTools: [],
+    };
+
+    it('should error when no board selected', async () => {
+      await rejects(
+        isDebugEnabled(
+          undefined,
+          unexpectedCall(),
+          unexpectedCall(),
+          unexpectedCall(),
+          unexpectedCall()
+        ),
+        (reason) =>
+          reason instanceof Error && reason.message === noBoardSelected
+      );
+    });
+
+    it('should error when platform is not installed (FQBN is undefined)', async () => {
+      await rejects(
+        isDebugEnabled(
+          { name, fqbn: undefined },
+          unexpectedCall(),
+          unexpectedCall(),
+          unexpectedCall(),
+          unexpectedCall()
+        ),
+        (reason) =>
+          reason instanceof Error &&
+          reason.message === noPlatformInstalledFor(board.name)
+      );
+    });
+
+    it('should error when platform is not installed (board details not available)', async () => {
+      await rejects(
+        isDebugEnabled(
+          board,
+          () => undefined,
+          () => data,
+          (fqbn) => fqbn,
+          unexpectedCall()
+        ),
+        (reason) =>
+          reason instanceof Error &&
+          reason.message === noPlatformInstalledFor(board.name)
+      );
+    });
+
+    it('should error when no programmer selected', async () => {
+      const copyData: Mutable<BoardsDataStore.Data> = deepClone(data);
+      delete copyData.selectedProgrammer;
+      await rejects(
+        isDebugEnabled(
+          board,
+          () => boardDetails,
+          () => copyData,
+          (fqbn) => fqbn,
+          unexpectedCall()
+        ),
+        (reason) =>
+          reason instanceof Error &&
+          reason.message === noProgrammerSelectedFor(board.name)
+      );
+    });
+
+    it('should error when it fails to get the debug info from the CLI', async () => {
+      await rejects(
+        isDebugEnabled(
+          board,
+          () => boardDetails,
+          () => data,
+          (fqbn) => fqbn,
+          () => {
+            throw new Error('unhandled error');
+          }
+        ),
+        (reason) =>
+          reason instanceof Error &&
+          reason.message === debuggingNotSupported(board.name)
+      );
+    });
+
+    it('should resolve when debugging is supported', async () => {
+      await doesNotReject(
+        isDebugEnabled(
+          board,
+          () => boardDetails,
+          () => data,
+          (fqbn) => fqbn,
+          () => Promise.resolve(`${fqbn}:USBMode=hwcdc`)
+        )
+      );
+    });
+
+    describe('onDidChangeMessage', () => {
+      let debug: MockDebug;
+      let onDidChangeMessageEvents: (string | undefined)[];
+
+      let toDisposeAfterEach: DisposableCollection;
+      let mockBoardsConfig: BoardsConfig;
+      let mockBoardsConfigDidChangeEmitter: Emitter<BoardsConfigChangeEvent>;
+      let mockPlatformDidInstallEmitter: Emitter<{ item: BoardsPackage }>;
+      let mockPlatformDidUninstallEmitter: Emitter<{ item: BoardsPackage }>;
+      let mockBoardsDataStoreDidChangeEmitter: Emitter<BoardsDataStoreChangeEvent>;
+      let mockDidExecuteCommandEmitter: Emitter<CommandEvent>;
+
+      beforeEach(() => {
+        mockBoardsConfig = emptyBoardsConfig();
+        mockBoardsConfigDidChangeEmitter = new Emitter();
+        mockPlatformDidInstallEmitter = new Emitter();
+        mockPlatformDidUninstallEmitter = new Emitter();
+        mockBoardsDataStoreDidChangeEmitter = new Emitter();
+        mockDidExecuteCommandEmitter = new Emitter();
+        toDisposeAfterEach = new DisposableCollection(
+          mockBoardsConfigDidChangeEmitter,
+          mockPlatformDidInstallEmitter,
+          mockPlatformDidUninstallEmitter,
+          mockBoardsDataStoreDidChangeEmitter,
+          mockDidExecuteCommandEmitter
+        );
+
+        const container = createContainer();
+        const d = container.get<Debug>(Debug);
+        expect(d).to.be.an.instanceOf(MockDebug);
+        debug = d as MockDebug;
+
+        onDidChangeMessageEvents = [];
+        toDisposeAfterEach.push(
+          debug['onDidChangeMessage']((event) => {
+            onDidChangeMessageEvents.push(event);
+          })
+        );
+
+        const commandRegistry: Mutable<CommandRegistry> =
+          container.get<CommandRegistry>(CommandRegistry);
+        commandRegistry['onDidExecuteCommand'] =
+          mockDidExecuteCommandEmitter.event;
+        debug.onStart();
+      });
+
+      it('should update on board identifier change', async () => {
+        mockBoardsConfigDidChangeEmitter.fire({
+          previousSelectedBoard: undefined,
+          selectedBoard: { fqbn: 'a:b:c', name: 'ABC' },
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal([undefined]);
+      });
+
+      it('should not update on port identifier change', async () => {
+        mockBoardsConfigDidChangeEmitter.fire({
+          previousSelectedPort: undefined,
+          selectedPort: { protocol: 'serial', address: 'COM1' },
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).to.be.empty;
+      });
+
+      it('should update on platform install', async () => {
+        mockPlatformDidInstallEmitter.fire({
+          item: aPackage,
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal([undefined]);
+      });
+
+      it('should update on platform uninstall', async () => {
+        mockPlatformDidUninstallEmitter.fire({
+          item: aPackage,
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal([undefined]);
+      });
+
+      it('should update on boards data store change when affects the selected board', async () => {
+        mockBoardsConfig = {
+          selectedBoard: { fqbn: 'a:b:c', name: '' },
+          selectedPort: undefined,
+        };
+        mockBoardsDataStoreDidChangeEmitter.fire({
+          changes: [
+            {
+              fqbn: 'a:b:c',
+              data: BoardsDataStore.Data.EMPTY, // it does not matter
+            },
+          ],
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal([undefined]);
+      });
+
+      it('should not update on boards data store change when does not affect the selected board', async () => {
+        mockBoardsConfig = {
+          selectedBoard: { fqbn: 'a:b:c', name: '' },
+          selectedPort: undefined,
+        };
+        mockBoardsDataStoreDidChangeEmitter.fire({
+          changes: [
+            {
+              fqbn: 'x:y:z',
+              data: BoardsDataStore.Data.EMPTY, // it does not matter
+            },
+          ],
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).to.be.empty;
+      });
+
+      it('should update after verify', async () => {
+        const summary: CompileSummary = {
+          buildPath: '',
+          buildProperties: [],
+          executableSectionsSize: [],
+          usedLibraries: [],
+          boardPlatform: undefined,
+          buildPlatform: undefined,
+          buildOutputUri: '',
+        };
+        mockDidExecuteCommandEmitter.fire({
+          commandId: 'arduino.languageserver.notifyBuildDidComplete',
+          args: [summary],
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal([undefined]);
+      });
+
+      it('should not update when unrelated command executes', async () => {
+        mockDidExecuteCommandEmitter.fire({
+          commandId: 'other.command',
+          args: [],
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).to.be.empty;
+      });
+
+      it('should update the error message', async () => {
+        debug.isDebugEnabledMock = Promise.reject(new Error('my error'));
+        mockBoardsConfigDidChangeEmitter.fire({
+          previousSelectedBoard: undefined,
+          selectedBoard: { fqbn: 'a:b:c', name: 'ABC' },
+        });
+        await wait(1);
+
+        expect(onDidChangeMessageEvents).deep.equal(['my error']);
+      });
+
+      afterEach(() => toDisposeAfterEach.dispose());
+
+      function createContainer(): Container {
+        const container = new Container({ defaultScope: 'Singleton' });
+        container.load(
+          new ContainerModule((bind, unbind, isBound, rebind) => {
+            bind(MockDebug).toSelf().inSingletonScope();
+            bind(Debug).toService(MockDebug);
+            bindSketchesContribution(bind, unbind, isBound, rebind);
+            bind(ExecutableService).toConstantValue(<ExecutableService>{});
+            rebind(NotificationCenter).toConstantValue(<NotificationCenter>{
+              get onPlatformDidInstall() {
+                return mockPlatformDidInstallEmitter.event;
+              },
+              get onPlatformDidUninstall() {
+                return mockPlatformDidUninstallEmitter.event;
+              },
+            });
+            rebind(BoardsServiceProvider).toConstantValue(<
+              BoardsServiceProvider
+            >{
+              get onBoardsConfigDidChange() {
+                return mockBoardsConfigDidChangeEmitter.event;
+              },
+              get boardsConfig() {
+                return mockBoardsConfig;
+              },
+            });
+            rebind(BoardsDataStore).toConstantValue(<BoardsDataStore>{
+              get onDidChange() {
+                return mockBoardsDataStoreDidChangeEmitter.event;
+              },
+            });
+          })
+        );
+        return container;
+      }
+    });
+
+    function unexpectedCall(): () => never {
+      return () => expect.fail('unexpected call');
+    }
+  });
+});
+
+@injectable()
+class MockDebug extends Debug {
+  isDebugEnabledMock: Promise<string> = Promise.resolve('a:b:c:USBMode:hwcdc');
+
+  constructor() {
+    super();
+    this['isDebugEnabled'] = () => this.isDebugEnabledMock;
+  }
+}

arduino-ide-extension/src/test/browser/update-arduino-state.test.ts

@@ -5,29 +5,14 @@ import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/front
 FrontendApplicationConfigProvider.set({});
 
 import { FrontendApplicationStateService } from '@theia/core/lib/browser/frontend-application-state';
-import { LabelProvider } from '@theia/core/lib/browser/label-provider';
-import { OpenerService } from '@theia/core/lib/browser/opener-service';
-import {
-  LocalStorageService,
-  StorageService,
-} from '@theia/core/lib/browser/storage-service';
-import { WindowService } from '@theia/core/lib/browser/window/window-service';
 import {
   Disposable,
   DisposableCollection,
 } from '@theia/core/lib/common/disposable';
-import { EnvVariablesServer } from '@theia/core/lib/common/env-variables';
 import { Emitter } from '@theia/core/lib/common/event';
-import { MessageService } from '@theia/core/lib/common/message-service';
 import { wait } from '@theia/core/lib/common/promise-util';
 import URI from '@theia/core/lib/common/uri';
-import {
-  Container,
-  ContainerModule,
-  injectable,
-} from '@theia/core/shared/inversify';
-import { EditorManager } from '@theia/editor/lib/browser/editor-manager';
-import { FileService } from '@theia/filesystem/lib/browser/file-service';
+import { Container, ContainerModule } from '@theia/core/shared/inversify';
 import { expect } from 'chai';
 import type {
   BoardDetails as ApiBoardDetails,
@@ -35,8 +20,10 @@ import type {
   Port as ApiPort,
 } from 'vscode-arduino-api';
 import { URI as CodeURI } from 'vscode-uri';
-import { ArduinoPreferences } from '../../browser/arduino-preferences';
-import { BoardsDataStore } from '../../browser/boards/boards-data-store';
+import {
+  BoardsDataStore,
+  BoardsDataStoreChangeEvent,
+} from '../../browser/boards/boards-data-store';
 import { BoardsServiceProvider } from '../../browser/boards/boards-service-provider';
 import { ConfigServiceClient } from '../../browser/config/config-service-client';
 import { CommandRegistry } from '../../browser/contributions/contribution';
@@ -44,31 +31,18 @@ import {
   UpdateArduinoState,
   UpdateStateParams,
 } from '../../browser/contributions/update-arduino-state';
-import { DialogService } from '../../browser/dialog-service';
-import { SettingsService } from '../../browser/dialogs/settings/settings';
-import { HostedPluginSupport } from '../../browser/hosted/hosted-plugin-support';
 import { NotificationCenter } from '../../browser/notification-center';
 import {
   CurrentSketch,
   SketchesServiceClientImpl,
 } from '../../browser/sketches-service-client-impl';
-import { ApplicationConnectionStatusContribution } from '../../browser/theia/core/connection-status-service';
-import { OutputChannelManager } from '../../browser/theia/output/output-channel';
-import { WorkspaceService } from '../../browser/theia/workspace/workspace-service';
-import { MainMenuManager } from '../../common/main-menu-manager';
-import {
-  CompileSummary,
-  FileSystemExt,
-  SketchesService,
-} from '../../common/protocol';
+import { CompileSummary } from '../../common/protocol';
 import {
   BoardDetails,
   BoardsService,
   Port,
 } from '../../common/protocol/boards-service';
-import { NotificationServiceServer } from '../../common/protocol/notification-service';
-import { never } from '../utils';
-import { bindBrowser } from './browser-test-bindings';
+import { bindSketchesContribution } from './browser-test-bindings';
 
 disableJSDOM();
 
@@ -90,7 +64,7 @@ describe('update-arduino-state', function () {
   let onCurrentSketchDidChangeEmitter: Emitter<CurrentSketch>;
   let onDataDirDidChangeEmitter: Emitter<URI | undefined>;
   let onSketchDirDidChangeEmitter: Emitter<URI | undefined>;
-  let onDataStoreDidChangeEmitter: Emitter<string[]>;
+  let onDataStoreDidChangeEmitter: Emitter<BoardsDataStoreChangeEvent>;
 
   beforeEach(async () => {
     toDisposeAfterEach = new DisposableCollection();
@@ -157,10 +131,10 @@ describe('update-arduino-state', function () {
   it('should automatically update the boards config (board+port) on ready', async () => {
     const fqbn = 'a:b:c';
     const board = { fqbn, name: 'ABC' };
-    const boardDetails = {
+    const boardDetails: BoardDetails = {
       buildProperties: [],
       configOptions: [],
-      debuggingSupported: false,
+      defaultProgrammerId: undefined,
       fqbn,
       PID: '0',
       VID: '0',
@@ -290,7 +264,7 @@ describe('update-arduino-state', function () {
     const boardDetails = {
       buildProperties: [],
       configOptions: [],
-      debuggingSupported: false,
+      defaultProgrammerId: undefined,
       fqbn,
       PID: '0',
       VID: '0',
@@ -372,7 +346,7 @@ describe('update-arduino-state', function () {
     const boardDetails = {
       buildProperties: [],
       configOptions: [],
-      debuggingSupported: false,
+      defaultProgrammerId: undefined,
       fqbn,
       PID: '0',
       VID: '0',
@@ -525,7 +499,25 @@ describe('update-arduino-state', function () {
   });
 
   it('should not update the board details when data store did change but the selected board does not match', async () => {
-    onDataStoreDidChangeEmitter.fire(['a:b:c']);
+    onDataStoreDidChangeEmitter.fire({
+      changes: [
+        {
+          fqbn: 'a:b:c',
+          // the data does not matter
+          data: {
+            configOptions: [
+              {
+                label: 'C1',
+                option: 'c1',
+                values: [{ label: 'C1V1', selected: true, value: 'c1v1' }],
+              },
+            ],
+            programmers: [],
+            defaultProgrammerId: undefined,
+          },
+        },
+      ],
+    });
     await wait(50);
 
     expect(stateUpdateParams).to.be.empty;
@@ -537,7 +529,7 @@ describe('update-arduino-state', function () {
     const boardDetails = {
       buildProperties: [],
       configOptions: [],
-      debuggingSupported: false,
+      defaultProgrammerId: undefined,
       fqbn,
       PID: '0',
       VID: '0',
@@ -552,7 +544,19 @@ describe('update-arduino-state', function () {
       selectedPort: undefined,
     };
 
-    onDataStoreDidChangeEmitter.fire(['a:b:c']);
+    onDataStoreDidChangeEmitter.fire({
+      changes: [
+        {
+          fqbn: 'a:b:c',
+          // the data does not matter
+          data: {
+            configOptions: [],
+            programmers: [{ id: 'p1', name: 'P1', platform: 'The platform' }],
+            defaultProgrammerId: 'p1',
+          },
+        },
+      ],
+    });
     await wait(50);
 
     const params = stateUpdateParams.filter(
@@ -579,9 +583,9 @@ describe('update-arduino-state', function () {
     const container = new Container({ defaultScope: 'Singleton' });
     container.load(
       new ContainerModule((bind, unbind, isBound, rebind) => {
-        bindBrowser(bind, unbind, isBound, rebind);
-        bind(MessageService).toConstantValue(<MessageService>{});
-        bind(BoardsService).toConstantValue(<BoardsService>{
+        bindSketchesContribution(bind, unbind, isBound, rebind);
+        bind(UpdateArduinoState).toSelf().inSingletonScope();
+        rebind(BoardsService).toConstantValue(<BoardsService>{
           getDetectedPorts() {
             return {};
           },
@@ -589,17 +593,7 @@ describe('update-arduino-state', function () {
             return boardDetailsMocks[fqbn];
           },
         });
-        bind(NotificationCenter).toSelf().inSingletonScope();
-        bind(NotificationServiceServer).toConstantValue(<
-          NotificationServiceServer
-        >{
-          // eslint-disable-next-line @typescript-eslint/no-unused-vars
-          setClient(_) {
-            // nothing
-          },
-        });
-        bind(FrontendApplicationStateService).toSelf().inSingletonScope();
-        bind(BoardsDataStore).toConstantValue(<BoardsDataStore>{
+        rebind(BoardsDataStore).toConstantValue(<BoardsDataStore>{
           async getData(fqbn) {
             if (!fqbn) {
               return BoardsDataStore.Data.EMPTY;
@@ -607,20 +601,11 @@ describe('update-arduino-state', function () {
             const data = dataStoreMocks[fqbn] ?? BoardsDataStore.Data.EMPTY;
             return data;
           },
-          get onChanged() {
+          get onDidChange() {
             return onDataStoreDidChangeEmitter.event;
           },
         });
-        bind(LocalStorageService).toSelf().inSingletonScope();
-        bind(WindowService).toConstantValue(<WindowService>{});
-        bind(StorageService).toService(LocalStorageService);
-        bind(BoardsServiceProvider).toSelf().inSingletonScope();
-        bind(NoopHostedPluginSupport).toSelf().inSingletonScope();
-        bind(HostedPluginSupport).toService(NoopHostedPluginSupport);
-        bind(UpdateArduinoState).toSelf().inSingletonScope();
-        bind(FileService).toConstantValue(<FileService>{});
-        bind(FileSystemExt).toConstantValue(<FileSystemExt>{});
-        bind(ConfigServiceClient).toConstantValue(<ConfigServiceClient>{
+        rebind(ConfigServiceClient).toConstantValue(<ConfigServiceClient>{
           tryGetSketchDirUri() {
             return sketchDirUriMock;
           },
@@ -634,9 +619,7 @@ describe('update-arduino-state', function () {
             return onDataDirDidChangeEmitter.event;
           },
         });
-        bind(SketchesService).toConstantValue(<SketchesService>{});
-        bind(OpenerService).toConstantValue(<OpenerService>{});
-        bind(SketchesServiceClientImpl).toConstantValue(<
+        rebind(SketchesServiceClientImpl).toConstantValue(<
           SketchesServiceClientImpl
         >{
           tryGetCurrentSketch() {
@@ -644,27 +627,8 @@ describe('update-arduino-state', function () {
           },
           onCurrentSketchDidChange: onCurrentSketchDidChangeEmitter.event,
         });
-        bind(EditorManager).toConstantValue(<EditorManager>{});
-        bind(OutputChannelManager).toConstantValue(<OutputChannelManager>{});
-        bind(EnvVariablesServer).toConstantValue(<EnvVariablesServer>{});
-        bind(ApplicationConnectionStatusContribution).toConstantValue(
-          <ApplicationConnectionStatusContribution>{}
-        );
-        bind(WorkspaceService).toConstantValue(<WorkspaceService>{});
-        bind(LabelProvider).toConstantValue(<LabelProvider>{});
-        bind(SettingsService).toConstantValue(<SettingsService>{});
-        bind(ArduinoPreferences).toConstantValue(<ArduinoPreferences>{});
-        bind(DialogService).toConstantValue(<DialogService>{});
-        bind(MainMenuManager).toConstantValue(<MainMenuManager>{});
       })
     );
     return container;
   }
 });
-
-@injectable()
-class NoopHostedPluginSupport implements HostedPluginSupport {
-  readonly didStart = Promise.resolve();
-  readonly onDidCloseConnection = never();
-  readonly onDidLoad = never();
-}

electron-app/package.json

@@ -196,7 +196,7 @@
   "theiaPlugins": {
     "vscode-builtin-cpp": "https://open-vsx.org/api/vscode/cpp/1.52.1/file/vscode.cpp-1.52.1.vsix",
     "vscode-arduino-api": "https://github.com/dankeboy36/vscode-arduino-api/releases/download/0.1.2/vscode-arduino-api-0.1.2.vsix",
-    "vscode-arduino-tools": "https://downloads.arduino.cc/vscode-arduino-tools/vscode-arduino-tools-0.0.2-beta.8.vsix",
+    "vscode-arduino-tools": "https://downloads.arduino.cc/vscode-arduino-tools/vscode-arduino-tools-0.1.1.vsix",
     "vscode-builtin-json": "https://open-vsx.org/api/vscode/json/1.46.1/file/vscode.json-1.46.1.vsix",
     "vscode-builtin-json-language-features": "https://open-vsx.org/api/vscode/json-language-features/1.46.1/file/vscode.json-language-features-1.46.1.vsix",
     "cortex-debug": "https://downloads.arduino.cc/marus25.cortex-debug/marus25.cortex-debug-1.5.1.vsix",

i18n/en.json

@@ -139,6 +139,7 @@
       "installManually": "Install Manually",
       "later": "Later",
       "noBoardSelected": "No board selected",
+      "noSketchOpened": "No sketch opened",
       "notConnected": "[not connected]",
       "offlineIndicator": "You appear to be offline. Without an Internet connection, the Arduino CLI might not be able to download the required resources and could cause malfunction. Please connect to the Internet and restart the application.",
       "oldFormat": "The '{0}' still uses the old `.pde` format. Do you want to switch to the new `.ino` extension?",
@@ -146,6 +147,7 @@
       "processing": "Processing",
       "recommended": "Recommended",
       "retired": "Retired",
+      "selectManually": "Select Manually",
       "selectedOn": "on {0}",
       "serialMonitor": "Serial Monitor",
       "type": "Type",
@@ -209,7 +211,9 @@
     "debug": {
       "debugWithMessage": "Debug - {0}",
       "debuggingNotSupported": "Debugging is not supported by '{0}'",
+      "getDebugInfo": "Getting debug info...",
       "noPlatformInstalledFor": "Platform is not installed for '{0}'",
+      "noProgrammerSelectedFor": "No programmer selected for '{0}'",
       "optimizeForDebugging": "Optimize for Debugging",
       "sketchIsNotCompiled": "Sketch '{0}' must be verified before starting a debug session. Please verify the sketch and start debugging again. Do you want to verify the sketch now?"
     },