refactor: extract error diagnostics logic from webviewMessageHandler

Author: daniel-lxs

src/core/webview/__tests__/diagnosticsHandler.spec.ts

@@ -0,0 +1,188 @@
+// npx vitest src/core/webview/__tests__/diagnosticsHandler.spec.ts
+
+import * as path from "path"
+
+// Mock vscode first
+vi.mock("vscode", () => {
+	const showErrorMessage = vi.fn()
+	const openTextDocument = vi.fn().mockResolvedValue({})
+	const showTextDocument = vi.fn().mockResolvedValue(undefined)
+
+	return {
+		window: {
+			showErrorMessage,
+			showTextDocument,
+		},
+		workspace: {
+			openTextDocument,
+		},
+	}
+})
+
+// Mock storage utilities
+vi.mock("../../../utils/storage", () => ({
+	getTaskDirectoryPath: vi.fn(async () => "/mock/task-dir"),
+}))
+
+// Mock fs utilities
+vi.mock("../../../utils/fs", () => ({
+	fileExistsAtPath: vi.fn(),
+}))
+
+// Mock fs/promises
+vi.mock("fs/promises", () => {
+	const mockReadFile = vi.fn()
+	const mockWriteFile = vi.fn().mockResolvedValue(undefined)
+
+	return {
+		default: {
+			readFile: mockReadFile,
+			writeFile: mockWriteFile,
+		},
+		readFile: mockReadFile,
+		writeFile: mockWriteFile,
+	}
+})
+
+import * as vscode from "vscode"
+import * as fs from "fs/promises"
+import * as fsUtils from "../../../utils/fs"
+import { generateErrorDiagnostics } from "../diagnosticsHandler"
+
+describe("generateErrorDiagnostics", () => {
+	const mockLog = vi.fn()
+
+	beforeEach(() => {
+		vi.clearAllMocks()
+	})
+
+	it("generates a diagnostics file with error metadata and history", async () => {
+		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(true as any)
+		vi.mocked(fs.readFile).mockResolvedValue('[{"role": "user", "content": "test"}]' as any)
+
+		const result = await generateErrorDiagnostics({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			values: {
+				timestamp: "2025-01-01T00:00:00.000Z",
+				version: "1.2.3",
+				provider: "test-provider",
+				model: "test-model",
+				details: "Sample error details",
+			},
+			log: mockLog,
+		})
+
+		expect(result.success).toBe(true)
+		expect(result.filePath).toContain("roo-diagnostics-")
+
+		// Verify we attempted to read API history
+		expect(fs.readFile).toHaveBeenCalledWith(path.join("/mock/task-dir", "api_conversation_history.json"), "utf8")
+
+		// Verify we wrote a diagnostics file with the expected content
+		expect(fs.writeFile).toHaveBeenCalledTimes(1)
+		const [writtenPath, writtenContent] = vi.mocked(fs.writeFile).mock.calls[0]
+		// taskId.slice(0, 8) = "test-tas" from "test-task-id"
+		expect(String(writtenPath)).toContain("roo-diagnostics-test-tas")
+		expect(String(writtenContent)).toContain(
+			"// Please share this file with Roo Code Support (support@roocode.com) to diagnose the issue faster",
+		)
+		expect(String(writtenContent)).toContain('"error":')
+		expect(String(writtenContent)).toContain('"history":')
+		expect(String(writtenContent)).toContain('"version": "1.2.3"')
+		expect(String(writtenContent)).toContain('"provider": "test-provider"')
+		expect(String(writtenContent)).toContain('"model": "test-model"')
+		expect(String(writtenContent)).toContain('"details": "Sample error details"')
+
+		// Verify VS Code APIs were used to open the generated file
+		expect(vscode.workspace.openTextDocument).toHaveBeenCalledTimes(1)
+		expect(vscode.window.showTextDocument).toHaveBeenCalledTimes(1)
+	})
+
+	it("uses empty history when API history file does not exist", async () => {
+		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(false as any)
+
+		const result = await generateErrorDiagnostics({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			values: {
+				timestamp: "2025-01-01T00:00:00.000Z",
+				version: "1.0.0",
+				provider: "test",
+				model: "test",
+				details: "error",
+			},
+			log: mockLog,
+		})
+
+		expect(result.success).toBe(true)
+
+		// Should not attempt to read file when it doesn't exist
+		expect(fs.readFile).not.toHaveBeenCalled()
+
+		// Verify empty history in output
+		const [, writtenContent] = vi.mocked(fs.writeFile).mock.calls[0]
+		expect(String(writtenContent)).toContain('"history": []')
+	})
+
+	it("uses default values when values are not provided", async () => {
+		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(false as any)
+
+		const result = await generateErrorDiagnostics({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			log: mockLog,
+		})
+
+		expect(result.success).toBe(true)
+
+		// Verify defaults in output
+		const [, writtenContent] = vi.mocked(fs.writeFile).mock.calls[0]
+		expect(String(writtenContent)).toContain('"version": ""')
+		expect(String(writtenContent)).toContain('"provider": ""')
+		expect(String(writtenContent)).toContain('"model": ""')
+		expect(String(writtenContent)).toContain('"details": ""')
+	})
+
+	it("handles JSON parse error gracefully", async () => {
+		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(true as any)
+		vi.mocked(fs.readFile).mockResolvedValue("invalid json" as any)
+
+		const result = await generateErrorDiagnostics({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			values: {
+				timestamp: "2025-01-01T00:00:00.000Z",
+				version: "1.0.0",
+				provider: "test",
+				model: "test",
+				details: "error",
+			},
+			log: mockLog,
+		})
+
+		// Should still succeed but with empty history
+		expect(result.success).toBe(true)
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to parse api_conversation_history.json")
+
+		// Verify empty history in output
+		const [, writtenContent] = vi.mocked(fs.writeFile).mock.calls[0]
+		expect(String(writtenContent)).toContain('"history": []')
+	})
+
+	it("returns error result when file write fails", async () => {
+		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(false as any)
+		vi.mocked(fs.writeFile).mockRejectedValue(new Error("Write failed"))
+
+		const result = await generateErrorDiagnostics({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			log: mockLog,
+		})
+
+		expect(result.success).toBe(false)
+		expect(result.error).toBe("Write failed")
+		expect(mockLog).toHaveBeenCalledWith("Error generating diagnostics: Write failed")
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("Failed to generate diagnostics: Write failed")
+	})
+})

src/core/webview/__tests__/webviewMessageHandler.spec.ts

@@ -5,9 +5,9 @@ import type { Mock } from "vitest"
 // Mock dependencies - must come before imports
 vi.mock("../../../api/providers/fetchers/modelCache")
 
-// Mock storage utilities used by debug/diagnostics handlers
-vi.mock("../../../utils/storage", () => ({
-	getTaskDirectoryPath: vi.fn(async () => "/mock/task-dir"),
+// Mock the diagnosticsHandler module
+vi.mock("../diagnosticsHandler", () => ({
+	generateErrorDiagnostics: vi.fn().mockResolvedValue({ success: true, filePath: "/tmp/diagnostics.json" }),
 }))
 
 import { webviewMessageHandler } from "../webviewMessageHandler"
@@ -110,6 +110,7 @@ import * as path from "path"
 import * as fsUtils from "../../../utils/fs"
 import { getWorkspacePath } from "../../../utils/path"
 import { ensureSettingsDirectoryExists } from "../../../utils/globalContext"
+import { generateErrorDiagnostics } from "../diagnosticsHandler"
 import type { ModeConfig } from "@roo-code/types"
 
 vi.mock("../../../utils/fs")
@@ -771,18 +772,9 @@ describe("webviewMessageHandler - downloadErrorDiagnostics", () => {
 		vi.mocked(mockClineProvider.getCurrentTask).mockReturnValue({
 			taskId: "test-task-id",
 		} as any)
-
-		// fileExistsAtPath should report that the history file exists
-		vi.mocked(fsUtils.fileExistsAtPath).mockResolvedValue(true as any)
 	})
 
-	it("generates a diagnostics file with error metadata and history", async () => {
-		const readFileSpy = vi.spyOn(fs, "readFile").mockResolvedValue("[{}]" as any)
-		const writeFileSpy = vi.spyOn(fs, "writeFile").mockResolvedValue(undefined as any)
-
-		const openTextDocumentSpy = vi.spyOn(vscode.workspace, "openTextDocument")
-		const showTextDocumentSpy = vi.spyOn(vscode.window, "showTextDocument")
-
+	it("calls generateErrorDiagnostics with correct parameters", async () => {
 		await webviewMessageHandler(mockClineProvider, {
 			type: "downloadErrorDiagnostics",
 			values: {
@@ -794,25 +786,31 @@ describe("webviewMessageHandler - downloadErrorDiagnostics", () => {
 			},
 		} as any)
 
-		// Ensure we attempted to read API history
-		expect(readFileSpy).toHaveBeenCalledWith(path.join("/mock/task-dir", "api_conversation_history.json"), "utf8")
+		// Verify generateErrorDiagnostics was called with the correct parameters
+		expect(generateErrorDiagnostics).toHaveBeenCalledTimes(1)
+		expect(generateErrorDiagnostics).toHaveBeenCalledWith({
+			taskId: "test-task-id",
+			globalStoragePath: "/mock/global/storage",
+			values: {
+				timestamp: "2025-01-01T00:00:00.000Z",
+				version: "1.2.3",
+				provider: "test-provider",
+				model: "test-model",
+				details: "Sample error details",
+			},
+			log: expect.any(Function),
+		})
+	})
 
-		// Ensure we wrote a diagnostics file with the expected header and JSON content
-		expect(writeFileSpy).toHaveBeenCalledTimes(1)
-		const [writtenPath, writtenContent] = writeFileSpy.mock.calls[0]
-		expect(String(writtenPath)).toContain("roo-diagnostics-")
-		expect(String(writtenContent)).toContain(
-			"// Please share this file with Roo Code Support (support@roocode.com) to diagnose the issue faster",
-		)
-		expect(String(writtenContent)).toContain('"error":')
-		expect(String(writtenContent)).toContain('"history":')
-		expect(String(writtenContent)).toContain('"version": "1.2.3"')
-		expect(String(writtenContent)).toContain('"provider": "test-provider"')
-		expect(String(writtenContent)).toContain('"model": "test-model"')
-		expect(String(writtenContent)).toContain('"details": "Sample error details"')
-
-		// Ensure VS Code APIs were used to open the generated file
-		expect(openTextDocumentSpy).toHaveBeenCalledTimes(1)
-		expect(showTextDocumentSpy).toHaveBeenCalledTimes(1)
+	it("shows error when no active task", async () => {
+		vi.mocked(mockClineProvider.getCurrentTask).mockReturnValue(null as any)
+
+		await webviewMessageHandler(mockClineProvider, {
+			type: "downloadErrorDiagnostics",
+			values: {},
+		} as any)
+
+		expect(vscode.window.showErrorMessage).toHaveBeenCalledWith("No active task to generate diagnostics for")
+		expect(generateErrorDiagnostics).not.toHaveBeenCalled()
 	})
 })

src/core/webview/diagnosticsHandler.ts

@@ -0,0 +1,92 @@
+import * as path from "path"
+import * as os from "os"
+import * as fs from "fs/promises"
+import * as vscode from "vscode"
+
+import { getTaskDirectoryPath } from "../../utils/storage"
+import { fileExistsAtPath } from "../../utils/fs"
+
+export interface ErrorDiagnosticsValues {
+	timestamp?: string
+	version?: string
+	provider?: string
+	model?: string
+	details?: string
+}
+
+export interface GenerateDiagnosticsParams {
+	taskId: string
+	globalStoragePath: string
+	values?: ErrorDiagnosticsValues
+	log: (message: string) => void
+}
+
+export interface GenerateDiagnosticsResult {
+	success: boolean
+	filePath?: string
+	error?: string
+}
+
+/**
+ * Generates an error diagnostics file containing error metadata and API conversation history.
+ * The file is created in the system temp directory and opened in VS Code for the user to review
+ * before sharing with support.
+ */
+export async function generateErrorDiagnostics(params: GenerateDiagnosticsParams): Promise<GenerateDiagnosticsResult> {
+	const { taskId, globalStoragePath, values, log } = params
+
+	try {
+		const taskDirPath = await getTaskDirectoryPath(globalStoragePath, taskId)
+
+		// Load API conversation history from the same file used by openDebugApiHistory
+		const apiHistoryPath = path.join(taskDirPath, "api_conversation_history.json")
+		let history: unknown = []
+
+		if (await fileExistsAtPath(apiHistoryPath)) {
+			const content = await fs.readFile(apiHistoryPath, "utf8")
+			try {
+				history = JSON.parse(content)
+			} catch {
+				// If parsing fails, fall back to empty history but still generate diagnostics file
+				vscode.window.showErrorMessage("Failed to parse api_conversation_history.json")
+			}
+		}
+
+		const diagnostics = {
+			error: {
+				timestamp: values?.timestamp ?? new Date().toISOString(),
+				version: values?.version ?? "",
+				provider: values?.provider ?? "",
+				model: values?.model ?? "",
+				details: values?.details ?? "",
+			},
+			history,
+		}
+
+		// Prepend human-readable guidance comments before the JSON payload
+		const headerComment =
+			"// Please share this file with Roo Code Support (support@roocode.com) to diagnose the issue faster\n" +
+			"// Just make sure you're OK sharing the contents of the conversation below.\n\n"
+		const jsonContent = JSON.stringify(diagnostics, null, 2)
+		const fullContent = headerComment + jsonContent
+
+		// Create a temporary diagnostics file
+		const tmpDir = os.tmpdir()
+		const timestamp = Date.now()
+		const tempFileName = `roo-diagnostics-${taskId.slice(0, 8)}-${timestamp}.json`
+		const tempFilePath = path.join(tmpDir, tempFileName)
+
+		await fs.writeFile(tempFilePath, fullContent, "utf8")
+
+		// Open the diagnostics file in VS Code
+		const doc = await vscode.workspace.openTextDocument(tempFilePath)
+		await vscode.window.showTextDocument(doc, { preview: true })
+
+		return { success: true, filePath: tempFilePath }
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error)
+		log(`Error generating diagnostics: ${errorMessage}`)
+		vscode.window.showErrorMessage(`Failed to generate diagnostics: ${errorMessage}`)
+		return { success: false, error: errorMessage }
+	}
+}