fix: harden managed binary install and download against review findings

- Adopt a concurrently completed installation instead of removing it
  when another VS Code window finishes first, preventing transient
  ENOENT for consumers mid-swap.
- Destroy the piped output stream when aborting an oversized download
  so the file descriptor is not leaked until GC.
- Make the semble downloader test mock path-aware so the added
  mid-install re-check is modeled correctly.

Author: navedmerchant

src/services/code-index/semble/__tests__/semble-downloader.spec.ts

@@ -766,11 +766,9 @@ describe("semble-downloader", () => {
 			// Version matches
 			;(fs.readFile as any).mockResolvedValue("v0.4.1")
 			// But binary is missing
-			let accessCallCount = 0
-			;(fs.access as any).mockImplementation(() => {
-				accessCallCount++
-				// First call: binary path check (miss), subsequent: staged binary verify (pass)
-				if (accessCallCount === 1) {
+			;(fs.access as any).mockImplementation((target: string) => {
+				// The installed binary path misses; the staged binary verifies fine.
+				if (target === path.join("/storage", "semble", "semble")) {
 					return Promise.reject(new Error("ENOENT"))
 				}
 				return Promise.resolve(undefined)

src/services/managed-binary/__tests__/download.spec.ts

@@ -158,4 +158,36 @@ describe("managed binary downloads", () => {
 		).rejects.toThrow("Example archive exceeds the download size limit")
 		expect(mockCreateWriteStream).not.toHaveBeenCalled()
 	})
+
+	it("destroys the output stream when streamed data exceeds the size limit", async () => {
+		const request = createRequest()
+		const response = createResponse(200, { "content-length": "5" })
+		const output = Object.assign(new EventEmitter(), { close: vi.fn(), destroy: vi.fn() })
+		mockCreateWriteStream.mockReturnValue(output as unknown as ReturnType<typeof createWriteStream>)
+		mockGet.mockImplementation(
+			(
+				_url: string | URL,
+				optionsOrCallback: RequestOptions | ((response: IncomingMessage) => void),
+				optionalCallback?: (response: IncomingMessage) => void,
+			) => {
+				const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : optionalCallback
+				setImmediate(() => callback?.(response as unknown as IncomingMessage))
+				return request as unknown as ReturnType<typeof get>
+			},
+		)
+
+		const download = downloadBinaryFile("https://github.com/release", "/tmp/archive", {
+			name: "Example",
+			trustedDomains,
+			timeoutMs: 1_000,
+			maxBytes: 10,
+		})
+		await new Promise<void>((resolve) => setImmediate(resolve))
+		response.emit("data", Buffer.alloc(11))
+
+		await expect(download).rejects.toThrow("Example archive exceeds the download size limit")
+		expect(response.destroy).toHaveBeenCalled()
+		expect(output.destroy).toHaveBeenCalled()
+		expect(request.destroy).toHaveBeenCalledWith(expect.any(Error))
+	})
 })

src/services/managed-binary/__tests__/install.spec.ts

@@ -85,4 +85,24 @@ describe("managed binary installation", () => {
 		await expect(access(paths.archivePath)).rejects.toThrow()
 		await expect(access(paths.stagingDir)).rejects.toThrow()
 	})
+
+	it("adopts a valid installation completed by a concurrent process instead of replacing it", async () => {
+		const options = createOptions({
+			download: async (archivePath) => {
+				await writeFile(archivePath, "archive")
+			},
+			extractArchive: async (_archivePath, stagingDir) => {
+				await writeFile(path.join(stagingDir, "example"), "binary")
+				const paths = getManagedBinaryPaths(options)
+				await mkdir(paths.installRoot, { recursive: true })
+				await writeFile(paths.binaryPath, "concurrent binary")
+				await writeFile(paths.versionPath, options.version)
+			},
+		})
+		const paths = getManagedBinaryPaths(options)
+
+		await expect(ensureManagedBinaryInstalled(options)).resolves.toBe(paths.binaryPath)
+		expect(await readFile(paths.binaryPath, "utf8")).toBe("concurrent binary")
+		await expect(access(paths.stagingDir)).rejects.toThrow()
+	})
 })

src/services/managed-binary/download.ts

@@ -129,6 +129,7 @@ function downloadBinaryFileWithRedirects(
 						assertSizeWithinLimit(received, options.maxBytes, options.name)
 					} catch (error) {
 						response.destroy()
+						output.destroy()
 						request.destroy(error as Error)
 						reject(error)
 					}

src/services/managed-binary/install.ts

@@ -102,6 +102,15 @@ async function installManagedBinary(options: ManagedBinaryInstallOptions): Promi
 		await makeExecutable(paths.stagedBinaryPath)
 		await options.validateBinary?.(paths.stagedBinaryPath)
 		await fs.writeFile(path.join(paths.stagingDir, options.versionFile), options.version, "utf-8")
+		const currentVersion = await readInstalledVersion(paths.versionPath)
+		if (currentVersion === options.version) {
+			try {
+				await makeExecutable(paths.binaryPath)
+				return paths.binaryPath
+			} catch {
+				// A concurrent installer left a partial install, so replace it below.
+			}
+		}
 		await fs.rm(paths.installRoot, { recursive: true, force: true })
 		await fs.rename(paths.stagingDir, paths.installRoot)
 		await cleanupStaleArchives(options, paths.archivePath)