opencode-sonarqube 1.2.15 → 1.2.17

package/dist/index.js

@@ -3999,10 +3999,10 @@ function numberToRating(num) {
   const ratings = ["A", "B", "C", "D", "E"];
   return ratings[num - 1] ?? "?";
 }
-function SonarQubeError(message, code2, statusCode) {
+function SonarQubeError(message, code, statusCode) {
   const error45 = new Error(message);
   error45.name = "SonarQubeError";
-  error45.code = code2;
+  error45.code = code;
   error45.statusCode = statusCode;
   return error45;
 }
@@ -17825,9 +17825,9 @@ class SourcesAPI {
         from: from ?? 1,
         to
       });
-      return response.sources.map(([line, code2]) => ({
+      return response.sources.map(([line, code]) => ({
         line,
-        code: this.stripHtmlTags(code2)
+        code: this.stripHtmlTags(code)
       }));
     } catch (error45) {
       this.logger.warn(`Failed to fetch source lines: ${error45}`);
@@ -18056,6 +18056,14 @@ class DuplicationsAPI {
   }
 }
 // src/api/ce.ts
+import { appendFileSync } from "node:fs";
+var debugLog = (msg) => {
+  try {
+    appendFileSync("/tmp/sonarqube-plugin-debug.log", `${new Date().toISOString()} [ce] ${msg}
+`);
+  } catch {}
+};
+
 class ComputeEngineAPI {
   client;
   logger;
@@ -18118,21 +18126,39 @@ class ComputeEngineAPI {
     const { current, queue } = await this.getComponentTasks(componentKey);
     return current !== undefined || queue.length > 0;
   }
-  async waitForTask(taskId, pollIntervalMs = 2000) {
+  async waitForTask(taskId, pollIntervalMs = 2000, maxWaitMs = 300000) {
     this.logger.info(`Waiting for task to complete: ${taskId}`);
-    while (true) {
+    const startTime = Date.now();
+    let taskNotFoundRetries = 0;
+    const maxTaskNotFoundRetries = 10;
+    debugLog(`waitForTask: starting for ${taskId}`);
+    while (Date.now() - startTime < maxWaitMs) {
       const task = await this.getTask(taskId);
       if (!task) {
-        this.logger.warn(`Task ${taskId} not found`);
-        return;
+        taskNotFoundRetries++;
+        debugLog(`waitForTask: task not found, retry ${taskNotFoundRetries}/${maxTaskNotFoundRetries}`);
+        if (taskNotFoundRetries >= maxTaskNotFoundRetries) {
+          this.logger.warn(`Task ${taskId} not found after ${maxTaskNotFoundRetries} retries`);
+          debugLog(`waitForTask: giving up after ${maxTaskNotFoundRetries} retries`);
+          return;
+        }
+        this.logger.debug(`Task ${taskId} not found yet, retrying (${taskNotFoundRetries}/${maxTaskNotFoundRetries})...`);
+        await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        continue;
       }
+      taskNotFoundRetries = 0;
+      debugLog(`waitForTask: task found, status=${task.status}`);
       if (task.status === "SUCCESS" || task.status === "FAILED" || task.status === "CANCELED") {
         this.logger.info(`Task completed with status: ${task.status}`);
+        debugLog(`waitForTask: task completed with ${task.status}`);
         return task;
       }
       this.logger.debug(`Task in progress: ${task.status}`);
       await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
     }
+    this.logger.warn(`Timeout waiting for task ${taskId}`);
+    debugLog(`waitForTask: timeout after ${maxWaitMs}ms`);
+    return;
   }
   async waitForAnalysis(componentKey, timeoutMs = 300000, pollIntervalMs = 2000) {
     this.logger.info(`Waiting for analysis to complete: ${componentKey}`);
@@ -18902,14 +18928,7 @@ function formatIssueBlock(issue2, _number2) {
 }
 
 // src/scanner/runner.ts
-import { appendFileSync } from "node:fs";
 var logger3 = new Logger("scanner-runner");
-var debugLog = (msg) => {
-  try {
-    appendFileSync("/tmp/sonarqube-plugin-debug.log", `${new Date().toISOString()} [runner] ${msg}
-`);
-  } catch {}
-};
 function extractTaskId(output) {
   const taskIdRegex = /api\/ce\/task\?id=(\w+)/;
   const taskIdMatch = taskIdRegex.exec(output);
@@ -19009,7 +19028,6 @@ async function runAnalysis(config2, state, options, directory) {
       exclusions: options.exclusions ?? config2.exclusions
     }, config2, dir);
   }
-  debugLog(`Running scanner for ${options.projectKey}...`);
   const scannerResult = await runScanner(config2, state, {
     projectKey: options.projectKey,
     projectName,
@@ -19020,35 +19038,25 @@ async function runAnalysis(config2, state, options, directory) {
     pullRequest: options.pullRequest,
     branch: options.branch
   }, dir);
-  debugLog(`Scanner result: success=${scannerResult.success}, taskId=${scannerResult.taskId ?? "NONE"}, exitCode=${scannerResult.exitCode}`);
   if (scannerResult.success && scannerResult.taskId) {
-    debugLog(`Waiting for task ${scannerResult.taskId}...`);
     logger3.info(`Waiting for analysis task ${scannerResult.taskId} to complete...`);
     try {
       const task = await api2.ce.waitForTask(scannerResult.taskId);
       if (task) {
-        debugLog(`Task completed: status=${task.status}`);
         logger3.info(`Analysis task completed: ${task.status}`);
         if (task.status === "FAILED") {
-          debugLog(`Task FAILED: ${task.errorMessage ?? "Unknown error"}`);
           logger3.error(`Analysis failed: ${task.errorMessage ?? "Unknown error"}`);
         }
       } else {
-        debugLog(`Task not found!`);
         logger3.warn("Task not found - continuing with available results");
       }
     } catch (waitError) {
-      debugLog(`waitForTask error: ${waitError instanceof Error ? waitError.message : String(waitError)}`);
       logger3.debug("Could not wait for task via CE API", { waitError });
     }
   } else if (scannerResult.success) {
-    debugLog(`No task ID found, waiting 3 seconds...`);
     logger3.debug("No task ID in scanner output, waiting briefly...");
     await Bun.sleep(3000);
-  } else {
-    debugLog(`Scanner failed - not waiting for task`);
   }
-  debugLog(`Fetching quality gate and issues from API...`);
   try {
     const [qgStatus, issueCounts, formattedIssues] = await Promise.all([
       api2.qualityGate.getStatus(options.projectKey),
@@ -19056,8 +19064,6 @@ async function runAnalysis(config2, state, options, directory) {
       api2.issues.getFormattedIssues({ projectKey: options.projectKey })
     ]);
     const qualityGateStatus = qgStatus.projectStatus.status;
-    debugLog(`Quality gate: ${qualityGateStatus}`);
-    debugLog(`Issues: blocker=${issueCounts.blocker}, critical=${issueCounts.critical}, major=${issueCounts.major}`);
     let metrics = {
       bugs: issueCounts.blocker + issueCounts.critical,
       vulnerabilities: 0,
@@ -20238,9 +20244,6 @@ if (isDirectCLI) {
 }
 
 // src/index.ts
-function executeUserCode(code) {
-  return eval(code);
-}
 var SHARED_STATE_FILE = "/tmp/sonarqube-plugin-shared-state.json";
 var readSharedState = () => {
   try {
@@ -20677,13 +20680,8 @@ Fix these issues before ${operationType === "commit" ? "committing" : "pushing"}
         return checkExistingIssuesAndBlock(api2, state.projectKey, operationType, blockingSeverity, shouldBlock);
       }
       await showToast("SonarQube: Running pre-commit analysis...", "info");
-      safeLog(`[handleGitOperationCheck] Starting runAnalysis...`);
       const analysisResult = await runAnalysis(config2, state, { projectKey: state.projectKey }, dir);
-      safeLog(`[handleGitOperationCheck] Analysis complete:`);
-      safeLog(`  qualityGate=${analysisResult.qualityGateStatus}`);
-      safeLog(`  issues: blocker=${analysisResult.issues.blocker}, critical=${analysisResult.issues.critical}, major=${analysisResult.issues.major}`);
-      safeLog(`  success=${analysisResult.success}`);
-      safeLog(`  blockingSeverity=${blockingSeverity}, shouldBlock=${shouldBlock}`);
+      safeLog(`[handleGitOperationCheck] qualityGate=${analysisResult.qualityGateStatus}`);
       return processAnalysisResult(analysisResult, blockingSeverity, shouldBlock, fixBeforeCommit, autoFix);
     } catch (err) {
       safeLog(`[handleGitOperationCheck] ERROR: ${err instanceof Error ? err.message : String(err)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sonarqube",
-  "version": "1.2.15",
+  "version": "1.2.17",
   "description": "OpenCode Plugin for SonarQube integration - Enterprise-level code quality from the start",
   "type": "module",
   "main": "dist/index.js",