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`,

Signed-off-by: Akos Kitta <[email protected]>

Author: Akos Kitta

.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/src/browser/arduino-ide-frontend-module.ts

@@ -361,6 +361,8 @@ 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 { SelectProgrammer } from './contributions/select-programmer';
+import { AutoSelectProgrammer } from './contributions/auto-select-programmer';
 
 // Hack to fix copy/cut/paste issue after electron version update in Theia.
 // https://github.com/eclipse-theia/theia/issues/12487
@@ -753,6 +755,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
   Contribution.configure(bind, CreateCloudCopy);
   Contribution.configure(bind, UpdateArduinoState);
   Contribution.configure(bind, BoardsDataMenuUpdater);
+  Contribution.configure(bind, SelectProgrammer);
+  Contribution.configure(bind, AutoSelectProgrammer);
 
   bindContributionProvider(bind, StartupTaskProvider);
   bind(StartupTaskProvider).toService(BoardsServiceProvider); // to reuse the boards config in another window

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

@@ -4,12 +4,15 @@ 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 } 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,
+  isProgrammer,
 } from '../../common/protocol';
 import { notEmpty } from '../../common/utils';
 import { NotificationCenter } from '../notification-center';
@@ -43,7 +46,7 @@ export class BoardsDataStore implements FrontendApplicationContribution {
           const key = this.getStorageKey(fqbn);
           let data = await this.storageService.getData<ConfigOption[]>(key);
           if (!data || !data.length) {
-            const details = await this.getBoardDetailsSafe(fqbn);
+            const details = await this.loadBoardDetails(fqbn);
             if (details) {
               data = details.configOptions;
               if (data.length) {
@@ -91,14 +94,15 @@ export class BoardsDataStore implements FrontendApplicationContribution {
       return data;
     }
 
-    const boardDetails = await this.getBoardDetailsSafe(fqbn);
+    const boardDetails = await this.loadBoardDetails(fqbn);
     if (!boardDetails) {
       return BoardsDataStore.Data.EMPTY;
     }
 
     data = {
       configOptions: boardDetails.configOptions,
       programmers: boardDetails.programmers,
+      selectedProgrammer: boardDetails.programmers.find((p) => p.default),
     };
     await this.storageService.setData(key, data);
     return data;
@@ -142,11 +146,12 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     }
     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) {
@@ -172,9 +177,7 @@ export class BoardsDataStore implements FrontendApplicationContribution {
     return `.arduinoIDE-configOptions-${fqbn}`;
   }
 
-  protected async getBoardDetailsSafe(
-    fqbn: string
-  ): Promise<BoardDetails | undefined> {
+  async loadBoardDetails(fqbn: string): Promise<BoardDetails | undefined> {
     try {
       const details = this.boardsService.getBoardDetails({ fqbn });
       return details;
@@ -213,14 +216,23 @@ export namespace BoardsDataStore {
       configOptions: [],
       programmers: [],
     };
-    export function is(arg: any): arg is Data {
+    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))
       );
     }
   }
 }
+
+export function isEmptyData(data: BoardsDataStore.Data): boolean {
+  return (
+    Boolean(!data.configOptions.length) &&
+    Boolean(!data.programmers.length) &&
+    Boolean(!data.selectedProgrammer)
+  );
+}

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

@@ -0,0 +1,90 @@
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { isBoardIdentifierChangeEvent } from '../../common/protocol';
+import { BoardsDataStore, 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<void> {
+    const fqbn = this.boardsServiceProvider.boardsConfig.selectedBoard?.fqbn;
+    if (!fqbn) {
+      return;
+    }
+    console.debug(`Ensuring a programmer is selected for ${fqbn}...`);
+    const data = await this.boardsDataStore.getData(fqbn);
+    if (isEmptyData(data)) {
+      // For example, the platform is not installed.
+      console.debug(`Skipping. No boards data is available for ${fqbn}.`);
+      return;
+    }
+    if (data.selectedProgrammer) {
+      console.debug(
+        `A programmer is already selected for ${fqbn}: '${data.selectedProgrammer.id}'.`
+      );
+      return;
+    }
+    let programmer = data.programmers.find((p) => p.default);
+    if (programmer) {
+      // select the programmer if the default info is available
+      await this.boardsDataStore.selectProgrammer({
+        fqbn,
+        selectedProgrammer: programmer,
+      });
+      console.debug(`Selected '${programmer.id}' programmer for ${fqbn}.`);
+      return;
+    }
+    console.debug(`Reloading board details for ${fqbn}...`);
+    const reloadedData = await this.boardsDataStore.loadBoardDetails(fqbn);
+    if (!reloadedData) {
+      console.debug(`Skipping. No board details found for ${fqbn}.`);
+      return;
+    }
+    if (!reloadedData.programmers.length) {
+      console.debug(`Skipping. ${fqbn} does not have programmers.`);
+      return;
+    }
+    programmer = reloadedData.programmers.find((p) => p.default);
+    if (!programmer) {
+      console.debug(
+        `Skipping. Could not find a default programmer for ${fqbn}. Programmers were: `
+      );
+      return;
+    }
+    const result = await this.boardsDataStore.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}.`
+      );
+    }
+  }
+}