another round of coderabbit

Author: brianignacio5

src/build/dfuExecution.ts

@@ -26,14 +26,20 @@ import { getIdfTargetFromSdkconfig } from "../workspaceConfig";
 import { configureEnvVariables } from "../common/prepareEnv";
 import { selectedDFUAdapterId } from "../flash/transports/dfu/helpers";
 import { getVirtualEnvPythonPath } from "../pythonManager";
-import { addProcessTask, type MaybeIdfTaskExecution } from "../taskManager";
+import { addProcessTask, type IdfTaskExecution } from "../taskManager";
 
 export async function appendDfuExecution(
-  executions: Exclude<MaybeIdfTaskExecution, undefined>[],
+  executions: IdfTaskExecution[],
   workspace: Uri,
   captureOutput?: boolean
 ): Promise<boolean> {
-  const buildPath = readParameter("idf.buildPath", workspace) as string;
+  const buildPath = (readParameter("idf.buildPath", workspace) as string)?.trim();
+  if (!buildPath) {
+    Logger.warnNotify(
+      "idf.buildPath is not configured. Set the build directory in ESP-IDF settings before building for DFU."
+    );
+    return false;
+  }
   if (!(await pathExists(join(buildPath, "flasher_args.json")))) {
     Logger.warnNotify(
       "flasher_args.json file is missing from the build directory, can't proceed, please build properly!"

src/build/index.ts

@@ -50,10 +50,14 @@ export async function build(
     async (_progress, cancelToken, wsFolder) => {
       let resolvedFlashType = flashType;
       if (!resolvedFlashType) {
-        resolvedFlashType = readParameter(
-          "idf.flashType",
-          wsFolder
-        ) as ESP.FlashType;
+        const fromConfig = readParameter("idf.flashType", wsFolder);
+        const raw =
+          typeof fromConfig === "string" ? fromConfig.trim() : "";
+        resolvedFlashType = Object.values(ESP.FlashType).includes(
+          raw as ESP.FlashType
+        )
+          ? (raw as ESP.FlashType)
+          : ESP.FlashType.UART;
       }
       await buildMain(wsFolder.uri, cancelToken, resolvedFlashType, buildType);
     }

src/cdtDebugAdapter/debugConfProvider.ts

@@ -38,24 +38,31 @@ import { createNewIdfMonitor } from "../espIdf/monitor/command";
 import { ESP } from "../config";
 import { buildFlashAndMonitor } from "../buildFlashMonitor";
 
+async function getOrPickWorkspaceFolder(
+  folder: WorkspaceFolder | undefined
+): Promise<WorkspaceFolder> {
+  if (!folder) {
+    folder = ESP.GlobalConfiguration.store.getSelectedWorkspaceFolder();
+    if (!folder) {
+      folder = await window.showWorkspaceFolderPick({
+        placeHolder: "Pick a workspace folder to start a debug session.",
+      });
+      if (!folder) {
+        throw new Error("No folder was selected to start debug session");
+      }
+    }
+  }
+  return folder;
+}
+
 export class CDTDebugConfigurationProvider
   implements DebugConfigurationProvider {
   public async resolveDebugConfigurationWithSubstitutedVariables(
     folder: WorkspaceFolder | undefined,
     debugConfiguration: DebugConfiguration,
     token?: CancellationToken
   ) {
-    if (!folder) {
-      folder = ESP.GlobalConfiguration.store.getSelectedWorkspaceFolder();
-      if (!folder) {
-        folder = await window.showWorkspaceFolderPick({
-          placeHolder: "Pick a workspace folder to start a debug session.",
-        });
-        if (!folder) {
-          throw new Error("No folder was selected to start debug session");
-        }
-      }
-    }
+    folder = await getOrPickWorkspaceFolder(folder);
     const useMonitorWithDebug = readParameter(
       "idf.launchMonitorOnDebugSession",
       folder
@@ -87,17 +94,7 @@ export class CDTDebugConfigurationProvider
     token?: CancellationToken
   ): Promise<DebugConfiguration | undefined> {
     try {
-      if (!folder) {
-        folder = ESP.GlobalConfiguration.store.getSelectedWorkspaceFolder();
-        if (!folder) {
-          folder = await window.showWorkspaceFolderPick({
-            placeHolder: "Pick a workspace folder to start a debug session.",
-          });
-          if (!folder) {
-            throw new Error("No folder was selected to start debug session");
-          }
-        }
-      }
+      folder = await getOrPickWorkspaceFolder(folder);
       if (!config.program) {
         const elfFilePath = await getProjectElfFilePath(folder.uri);
         const elfFileExists = await pathExists(elfFilePath);
@@ -183,10 +180,25 @@ export class CDTDebugConfigurationProvider
           esp32c5: 4,
           esp32c61: 4,
         };
+        const rawIdfTarget = idfTarget ?? "";
+        const watchpointNum =
+          rawIdfTarget !== "" &&
+          Object.prototype.hasOwnProperty.call(
+            idfTargetWatchpointMap,
+            rawIdfTarget
+          )
+            ? idfTargetWatchpointMap[rawIdfTarget as IdfTarget]
+            : undefined;
+        if (watchpointNum === undefined && rawIdfTarget !== "") {
+          Logger.info(
+            `Unknown IDF target "${rawIdfTarget}" for CPU hardware watchpoint mapping; using default 2.`,
+            { context: "CDTDebugConfigurationProvider" }
+          );
+        }
         config.initCommands = config.initCommands.map((cmd: string) =>
           cmd.replace(
             "{IDF_TARGET_CPU_WATCHPOINT_NUM}",
-            String(idfTargetWatchpointMap[idfTarget as IdfTarget] ?? 2)
+            String(watchpointNum ?? 2)
           )
         );
       }

src/extension.ts

@@ -2774,6 +2774,14 @@ export async function activate(context: vscode.ExtensionContext) {
               workspaceFolder,
               conf
             );
+            if (!resolvedConf) {
+              await vscode.window.showErrorMessage(
+                vscode.l10n.t(
+                  "Could not resolve the gdbtarget debug configuration. Check the ESP-IDF output for details."
+                )
+              );
+              return;
+            }
             await vscode.debug.startDebugging(workspaceFolder, resolvedConf);
             return;
           }

src/flash/transports/jtag/flashTclClient.ts

@@ -17,18 +17,19 @@
  */
 
 import { TCLClient } from "../../../espIdf/openOcd/tcl/tclClient";
-import { IdfTaskExecution } from "../../../taskManager";
+import { Logger } from "../../../logger/logger";
 import {
+  CaptureableTaskExecution,
   CapturedTaskOutput,
   CustomExecutionTaskResult,
 } from "../../../taskManager/customExecution";
 
 export function createCapturedExecution(
   output: CapturedTaskOutput
-): IdfTaskExecution {
-  return ({
+): CaptureableTaskExecution {
+  return {
     getOutput: async () => output,
-  } as unknown) as IdfTaskExecution;
+  };
 }
 
 /**
@@ -94,6 +95,11 @@ export async function jtagFlash(
     };
 
     const onError = (err: unknown) => {
+      Logger.error(
+        "jtagFlash OpenOCD TCL error",
+        err instanceof Error ? err : new Error(String(err)),
+        "jtagFlash onError"
+      );
       const stderr =
         err instanceof Error
           ? err.message

src/flash/transports/uart/uartFlashCmd.ts

@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 import { join } from "path";
-import { CancellationToken, Uri } from "vscode";
+import { CancellationToken, Disposable, Uri } from "vscode";
 import { Logger } from "../../../logger/logger";
 import {
   collectExecutions,
@@ -51,12 +51,18 @@ export async function uartFlashCommandMain(
   if (FlashSession.isFlashing) {
     throw new Error("ALREADY_FLASHING");
   }
-  cancelToken.onCancellationRequested(() => {
-    TaskManager.cancelTasks();
-    FlashSession.isFlashing = false;
-  });
+  let ownsFlashSession = false;
+  let cancelSubscription: Disposable | undefined;
   try {
     FlashSession.isFlashing = true;
+    ownsFlashSession = true;
+    cancelSubscription = cancelToken.onCancellationRequested(() => {
+      if (!ownsFlashSession) {
+        return;
+      }
+      TaskManager.cancelTasks();
+      FlashSession.isFlashing = false;
+    });
     const model = await createFlashModel(
       flasherArgsJsonPath,
       port,
@@ -105,7 +111,10 @@ export async function uartFlashCommandMain(
       ),
     };
   } finally {
-    FlashSession.isFlashing = false;
+    cancelSubscription?.dispose();
+    if (ownsFlashSession) {
+      FlashSession.isFlashing = false;
+    }
     TaskManager.disposeListeners();
   }
 }

src/langTools/index.ts

@@ -275,6 +275,13 @@ export function activateLanguageTool(context: vscode.ExtensionContext) {
           }
 
           if (TASK_COMMANDS.has(commandName)) {
+            if (!continueFlag) {
+              outputs.unshift(
+                new vscode.LanguageModelTextPart(
+                  `Command "${commandName}" did not complete successfully.`
+                )
+              );
+            }
             for (const execution of taskExecutions) {
               if (execution && "getOutput" in execution) {
                 const output = await (execution as
@@ -316,6 +323,13 @@ export function activateLanguageTool(context: vscode.ExtensionContext) {
               ),
             ]);
           }
+          if (errorMessage === "ALREADY_ERASING") {
+            return new vscode.LanguageModelToolResult([
+              new vscode.LanguageModelTextPart(
+                "An erase-flash operation is already in progress."
+              ),
+            ]);
+          }
           if (errorMessage === "NO_DFU_DEVICE_SELECTED") {
             return new vscode.LanguageModelToolResult([
               new vscode.LanguageModelTextPart("No DFU was selected"),