DevkitsCommand.ts

/*
 * Project: ESP-IDF VSCode Extension
 * File Created: Friday, 8th January 2021 5:34:24 pm
 * Copyright 2021 Espressif Systems (Shanghai) CO LTD
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import * as vscode from "vscode";
import * as fs from "fs";
import { join } from "path";
import * as idfConf from "../../idfConfiguration";
import { Logger } from "../../logger/logger";
import { getVirtualEnvPythonPath } from "../../pythonManager";
import { OpenOCDManager } from "../openOcd/openOcdManager";
import { execChildProcess, isBinInPath } from "../../utils";
import { OutputChannel } from "../../logger/outputChannel";
import { getOpenOcdScripts } from "../openOcd/boardConfiguration";
import { configureEnvVariables } from "../../common/prepareEnv";

export class DevkitsCommand {
  private workspaceFolderUri: vscode.Uri;

  constructor(workspaceFolder: vscode.Uri) {
    this.workspaceFolderUri = workspaceFolder;
  }

  public async runDevkitsScript(
    openOCDVersion: string,
    opts?: { silent?: boolean }
  ): Promise<string> {
    try {
      const workspaceFolder = vscode.workspace.getWorkspaceFolder(
        this.workspaceFolderUri
      );
      if (!workspaceFolder) {
        throw new Error("No workspace folder found");
      }

      if (!openOCDVersion) {
        throw new Error("Could not get OpenOCD version");
      }
      
      const scriptPath = await this.getScriptPath(openOCDVersion);
      if (!scriptPath) {
        throw new Error(
          "Could not locate esp_detect_config.py for the current OpenOCD installation"
        );
      }
      
      const openOcdScriptsPath = await getOpenOcdScripts(
        this.workspaceFolderUri
      );
      if (!openOcdScriptsPath) {
        throw new Error("Could not get OpenOCD scripts path");
      }
      
      const espConfigPath = join(openOcdScriptsPath, "esp-config.json");
      
      const notificationMode = idfConf.readParameter(
        "idf.notificationMode",
        this.workspaceFolderUri
      ) as string;
      
      const ProgressLocation =
      notificationMode === idfConf.NotificationMode.All ||
      notificationMode === idfConf.NotificationMode.Notifications
      ? vscode.ProgressLocation.Notification
      : vscode.ProgressLocation.Window;
      
      const pythonBinPath = getVirtualEnvPythonPath();
      if (!pythonBinPath) {
        throw new Error("Could not get Python binary path");
      }
      const modifiedEnv = await configureEnvVariables(this.workspaceFolderUri);

      // Remove OPENOCD_USB_ADAPTER_LOCATION from environment during device detection
      // to allow scanning all available devices, not just the one at the configured location
      delete modifiedEnv.OPENOCD_USB_ADAPTER_LOCATION;

      const isSilent = !!opts?.silent;
      if (!isSilent) {
        OutputChannel.init();
        OutputChannel.appendLine(
          "Running ESP Detect Config...",
          "ESP Detect Config"
        );
        OutputChannel.show();
      }

      if (isSilent) {
        // Silent mode: no progress UI, no output channel, no completion notification.
        return await execChildProcess(
          pythonBinPath,
          [scriptPath, "--esp-config", espConfigPath],
          this.workspaceFolderUri.fsPath,
          undefined,
          { env: modifiedEnv }
        );
      }

      return await vscode.window.withProgress(
        {
          cancellable: true,
          location: ProgressLocation,
          title: "ESP-IDF: Running ESP Detect Config",
        },
        async (
          progress: vscode.Progress<{ message: string; increment: number }>,
          cancelToken: vscode.CancellationToken
        ) => {
          try {
            const result = await execChildProcess(
              pythonBinPath,
              [scriptPath, "--esp-config", espConfigPath],
              this.workspaceFolderUri.fsPath,
              OutputChannel.init(),
              { env: modifiedEnv },
              cancelToken
            );

            OutputChannel.appendLine(result, "ESP Detect Config");
            OutputChannel.show();
            vscode.window.showInformationMessage("ESP Detect Config completed");
            return result;
          } catch (error) {
            const msg = error instanceof Error && error.message
              ? error.message
              : "Error running ESP Detect Config";
            Logger.errorNotify(msg, error as Error, "DevkitsCommand");
            OutputChannel.appendLine(msg, "ESP Detect Config");
            OutputChannel.show();
            throw error;
          }
        }
      );
    } catch (error) {
      const msg = error instanceof Error && error.message
        ? error.message
        : "Error running ESP Detect Config";
      if (opts?.silent) {
        Logger.error(msg, error as Error, "DevkitsCommand");
        throw error;
      } else {
        Logger.errorNotify(msg, error as Error, "DevkitsCommand");
        OutputChannel.appendLine(msg, "ESP Detect Config");
        OutputChannel.show();
      }
    }
  }

  public async getScriptPath(openOCDVersion: string): Promise<string | null> {
    try {
      const modifiedEnv = await configureEnvVariables(this.workspaceFolderUri);
      const openOcdPath = await OpenOCDManager.getOpenOcdPath(
        this.workspaceFolderUri,
        modifiedEnv
      );

      if (!openOcdPath || !openOCDVersion) {
        return null;
      }

      const scriptPath = join(
        openOcdPath,
        "..",
        "..",
        "share",
        "openocd",
        "espressif",
        "tools",
        "esp_detect_config.py"
      );

      return fs.existsSync(scriptPath) ? scriptPath : null;
    } catch (error) {
      return null;
    }
  }
}