Merge branch 'feat/dcg-binary-service' into feat/dcg-setting

Author: navedmerchant

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

@@ -925,7 +925,7 @@ describe("semble-downloader", () => {
 				// excluded by the currentArchivePath guard). It is unlinked only by
 				// the pre-download partial-archive cleanup and the post-install
 				// archive cleanup steps. unrelated.txt is never touched.
-				expect(fs.unlink).not.toHaveBeenCalledWith(path.join("/storage", "unrelated.txt"))
+				expect(fs.rm).not.toHaveBeenCalledWith(path.join("/storage", "unrelated.txt"), expect.anything())
 				// Sanity: the current archive path is never passed to the stale sweep.
 				// It is unlinked exactly twice (pre-download cleanup + post-install
 				// archive cleanup), never via cleanupStaleArchives.

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

@@ -26,6 +26,7 @@ const SEMBLE_ARCHIVES: Record<string, { archive: string; binary: string }> = {
 export const SEMBLE_VERSION = "v0.4.1"
 const DOWNLOAD_BASE_URL = `https://github.com/Zoo-Code-Org/sembleexec/releases/download/${SEMBLE_VERSION}`
 const VERSION_FILE = ".semble-version"
+const MAX_ARCHIVE_BYTES = 50 * 1024 * 1024
 
 /**
  * SHA-256 checksums for each platform archive at SEMBLE_VERSION.
@@ -121,13 +122,16 @@ export async function downloadSemble(storageDir: string): Promise<string | undef
 				name: "Semble",
 				trustedDomains: TRUSTED_DOWNLOAD_DOMAINS,
 				timeoutMs: 120_000,
+				maxBytes: MAX_ARCHIVE_BYTES,
 			}),
 		verifyArchive: (archivePath) => verifyChecksum(archivePath, expectedChecksum),
 		extractArchive: async (archivePath, stagingDir) => {
 			if (info.archive.endsWith(".tar.gz")) {
 				await extractTarGzArchive(archivePath, stagingDir)
 			} else if (info.archive.endsWith(".zip")) {
 				await extractZipArchive(archivePath, stagingDir)
+			} else {
+				throw new Error(`Unsupported semble archive format: ${info.archive}`)
 			}
 		},
 	})

src/services/destructive-command-guard/__tests__/manager.spec.ts

@@ -63,6 +63,7 @@ describe("Destructive Command Guard manager", () => {
 		expect(isTrustedDownloadUrl("https://cdn.objects.githubusercontent.com/release")).toBe(true)
 		expect(isTrustedDownloadUrl("http://github.com/release")).toBe(false)
 		expect(isTrustedDownloadUrl("https://evilgithub.com/release")).toBe(false)
+		expect(isTrustedDownloadUrl("https://github.com.evil.com/release")).toBe(false)
 		expect(isTrustedDownloadUrl("not a URL")).toBe(false)
 	})
 
@@ -72,8 +73,70 @@ describe("Destructive Command Guard manager", () => {
 		)
 	})
 
+	it("rejects non-successful HTTP responses", async () => {
+		const response = Object.assign(new PassThrough(), { statusCode: 503, headers: {}, destroy: vi.fn() })
+		const request = Object.assign(new EventEmitter(), { setTimeout: vi.fn(), destroy: vi.fn() })
+		mockGet.mockImplementation((_url, optionsOrCallback, optionalCallback) => {
+			const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : optionalCallback
+			setImmediate(() => callback?.(response as unknown as IncomingMessage))
+			return request as unknown as ReturnType<typeof get>
+		})
+
+		await expect(downloadFile("https://github.com/release", path.join(tempDir, "archive"))).rejects.toThrow(
+			"DCG download failed with HTTP 503",
+		)
+	})
+
+	it("rejects request errors", async () => {
+		const request = Object.assign(new EventEmitter(), { setTimeout: vi.fn(), destroy: vi.fn() })
+		mockGet.mockReturnValue(request as unknown as ReturnType<typeof get>)
+
+		const download = downloadFile("https://github.com/release", path.join(tempDir, "archive"))
+		request.emit("error", new Error("socket failed"))
+
+		await expect(download).rejects.toThrow("socket failed")
+	})
+
+	it("times out stalled requests", async () => {
+		const request = Object.assign(new EventEmitter(), {
+			setTimeout: vi.fn((_timeout: number, callback: () => void) => setImmediate(callback)),
+			destroy: vi.fn((error: Error) => request.emit("error", error)),
+		})
+		mockGet.mockReturnValue(request as unknown as ReturnType<typeof get>)
+
+		await expect(downloadFile("https://github.com/release", path.join(tempDir, "archive"))).rejects.toThrow(
+			"DCG download timed out",
+		)
+		expect(request.setTimeout).toHaveBeenCalledWith(120_000, expect.any(Function))
+	})
+
+	it("rejects archives larger than 50 MiB", async () => {
+		const response = Object.assign(new PassThrough(), {
+			statusCode: 200,
+			headers: { "content-length": String(50 * 1024 * 1024 + 1) },
+			destroy: vi.fn(),
+		})
+		const request = Object.assign(new EventEmitter(), { setTimeout: vi.fn(), destroy: vi.fn() })
+		mockGet.mockImplementation((_url, optionsOrCallback, optionalCallback) => {
+			const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : optionalCallback
+			setImmediate(() => callback?.(response as unknown as IncomingMessage))
+			return request as unknown as ReturnType<typeof get>
+		})
+
+		await expect(downloadFile("https://github.com/release", path.join(tempDir, "archive"))).rejects.toThrow(
+			"DCG archive exceeds the download size limit",
+		)
+	})
+
 	it("allows trusted relative redirects and rejects unsafe or exhausted redirects", () => {
 		expect(resolveTrustedRedirect("https://github.com/release", "/asset", 5)).toBe("https://github.com/asset")
+		expect(
+			resolveTrustedRedirect(
+				"https://github.com/release",
+				"https://release-assets.githubusercontent.com/asset",
+				5,
+			),
+		).toBe("https://release-assets.githubusercontent.com/asset")
 		expect(() => resolveTrustedRedirect("https://github.com/release", "https://example.com/asset", 5)).toThrow(
 			"DCG download redirected to an untrusted host",
 		)
@@ -92,9 +155,7 @@ describe("Destructive Command Guard manager", () => {
 		const checksum = createHash("sha256").update(contents).digest("hex")
 
 		await expect(verifyChecksum(filePath, checksum)).resolves.toBeUndefined()
-		await expect(verifyChecksum(filePath, "0".repeat(64))).rejects.toThrow(
-			"DCG archive checksum verification failed",
-		)
+		await expect(verifyChecksum(filePath, "0".repeat(64))).rejects.toThrow(`got ${checksum}`)
 	})
 
 	it("uses the platform ZIP extractor", async () => {
@@ -180,6 +241,22 @@ describe("Destructive Command Guard manager", () => {
 		}
 	})
 
+	it("warns when the current platform is unsupported", async () => {
+		const platformKey = `${process.platform}-${process.arch}`
+		const info = DCG_ARCHIVES[platformKey]
+		if (!info) return
+		const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+		Reflect.deleteProperty(DCG_ARCHIVES, platformKey)
+
+		try {
+			await expect(ensureDcgInstalled(tempDir)).resolves.toBeUndefined()
+			expect(warnSpy).toHaveBeenCalledWith(`[DCG] Unsupported platform: ${platformKey}`)
+		} finally {
+			Reflect.set(DCG_ARCHIVES, platformKey, info)
+			warnSpy.mockRestore()
+		}
+	})
+
 	it("downloads, verifies, extracts, and deduplicates a new installation", async () => {
 		const info = getDcgArchiveInfo()
 		expect(info).toBeDefined()
@@ -251,4 +328,60 @@ describe("Destructive Command Guard manager", () => {
 			Object.defineProperty(info, "sha256", { value: originalChecksum, configurable: true })
 		}
 	})
+
+	it.skipIf(!getDcgArchiveInfo()?.archive.endsWith(".zip"))(
+		"downloads, verifies, extracts, and installs a ZIP archive",
+		async () => {
+			const info = getDcgArchiveInfo()
+			if (!info) throw new Error("Expected a ZIP archive in this test")
+
+			const archive = Buffer.from("test ZIP archive")
+			const originalChecksum = info.sha256
+			Object.defineProperty(info, "sha256", {
+				value: createHash("sha256").update(archive).digest("hex"),
+				configurable: true,
+			})
+			const response = Object.assign(new PassThrough(), {
+				statusCode: 200,
+				headers: { "content-length": String(archive.length) },
+			})
+			const request = Object.assign(new EventEmitter(), { setTimeout: vi.fn(), destroy: vi.fn() })
+			mockGet.mockImplementation((_url, optionsOrCallback, optionalCallback) => {
+				const callback = typeof optionsOrCallback === "function" ? optionsOrCallback : optionalCallback
+				setImmediate(() => {
+					callback?.(response as unknown as IncomingMessage)
+					response.end(archive)
+				})
+				return request as unknown as ReturnType<typeof get>
+			})
+			mockSpawn.mockImplementation((_executable, args) => {
+				const child = Object.assign(new EventEmitter(), {
+					stdout: new PassThrough(),
+					stderr: new PassThrough(),
+					kill: vi.fn(),
+				})
+				setImmediate(async () => {
+					const destinationIndex = args.indexOf(
+						"$archivePath = $args[0]; $destination = $args[1]; Expand-Archive -LiteralPath $archivePath -DestinationPath $destination -Force",
+					)
+					const stagingDir = args[destinationIndex + 2]
+					await writeFile(path.join(stagingDir, info.binary), "ZIP executable")
+					child.emit("close", 0)
+				})
+				return child as unknown as ReturnType<typeof spawn>
+			})
+
+			try {
+				const binaryPath = await ensureDcgInstalled(tempDir)
+				if (!binaryPath) throw new Error("Expected DCG to be supported in this test")
+				expect(await readFile(binaryPath, "utf8")).toBe("ZIP executable")
+				expect(await readFile(path.join(tempDir, "destructive-command-guard", ".dcg-version"), "utf8")).toBe(
+					DCG_VERSION,
+				)
+				await expect(access(path.join(tempDir, `${DCG_VERSION}-${info.archive}`))).rejects.toThrow()
+			} finally {
+				Object.defineProperty(info, "sha256", { value: originalChecksum, configurable: true })
+			}
+		},
+	)
 })

src/services/destructive-command-guard/__tests__/runner.spec.ts

@@ -35,12 +35,18 @@ function emitResult(child: MockChild, payload: unknown, code: number): void {
 }
 
 describe("runDcg", () => {
+	let warnSpy: ReturnType<typeof vi.spyOn>
+
 	beforeEach(() => {
 		vi.useRealTimers()
 		mockSpawn.mockReset()
+		warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
 	})
 
-	afterEach(() => vi.useRealTimers())
+	afterEach(() => {
+		vi.useRealTimers()
+		warnSpy.mockRestore()
+	})
 
 	it.each([
 		[{ schema_version: 1, decision: "allow" }, 0, { decision: "allow" }],
@@ -67,6 +73,34 @@ describe("runDcg", () => {
 			expect.any(Array),
 			expect.objectContaining({ cwd: "/workspace" }),
 		)
+		if (expected.decision === "deny") {
+			const reason = "reason" in expected ? expected.reason : undefined
+			expect(warnSpy).toHaveBeenCalledWith("[DCG] Command denied", reason ?? "No reason provided")
+		}
+	})
+
+	it("passes only the environment variables DCG requires", async () => {
+		const child = createChild()
+		useChild(child)
+		const originalToken = process.env.GITHUB_TOKEN
+		const originalTmpdir = process.env.TMPDIR
+		process.env.GITHUB_TOKEN = "secret"
+		process.env.TMPDIR = "/sandbox/tmp"
+
+		try {
+			const result = runDcg("/dcg", "echo test", "/workspace")
+			emitResult(child, { schema_version: 1, decision: "allow" }, 0)
+			await result
+
+			const options = mockSpawn.mock.calls[0][2]
+			expect(options?.env).toMatchObject({ NO_COLOR: "1", TMPDIR: "/sandbox/tmp" })
+			expect(options?.env).not.toHaveProperty("GITHUB_TOKEN")
+		} finally {
+			if (originalToken === undefined) delete process.env.GITHUB_TOKEN
+			else process.env.GITHUB_TOKEN = originalToken
+			if (originalTmpdir === undefined) delete process.env.TMPDIR
+			else process.env.TMPDIR = originalTmpdir
+		}
 	})
 
 	it.each([
@@ -82,6 +116,7 @@ describe("runDcg", () => {
 		child.emit("close", code, null)
 
 		await expect(result).rejects.toThrow(message)
+		expect(warnSpy).toHaveBeenCalledWith("[DCG]", message)
 	})
 
 	it("rejects non-DCG exit statuses with stderr", async () => {
@@ -93,6 +128,7 @@ describe("runDcg", () => {
 		child.emit("close", 2, null)
 
 		await expect(result).rejects.toThrow("DCG evaluation failed: failure details")
+		expect(warnSpy).toHaveBeenCalledWith("[DCG]", "DCG evaluation failed: failure details")
 	})
 
 	it("rejects process startup errors", async () => {
@@ -103,6 +139,7 @@ describe("runDcg", () => {
 		child.emit("error", new Error("ENOENT"))
 
 		await expect(result).rejects.toThrow("Unable to start DCG: ENOENT")
+		expect(warnSpy).toHaveBeenCalledWith("[DCG]", "Unable to start DCG: ENOENT")
 	})
 
 	it("rejects excessive output and kills the process", async () => {

src/services/destructive-command-guard/manager.ts

@@ -7,7 +7,7 @@ import {
 	resolveTrustedRedirect as resolveManagedBinaryRedirect,
 	verifySha256Checksum,
 } from "../managed-binary/download"
-import { ensureManagedBinaryInstalled, getManagedBinaryPaths } from "../managed-binary/install"
+import { ensureManagedBinaryInstalled } from "../managed-binary/install"
 
 import {
 	DCG_ARCHIVES,
@@ -18,6 +18,7 @@ import {
 } from "./constants"
 
 const VERSION_FILE = ".dcg-version"
+const MAX_ARCHIVE_BYTES = 50 * 1024 * 1024
 
 export function getDcgArchiveInfo(platform = process.platform, arch = process.arch): DcgArchiveInfo | undefined {
 	return DCG_ARCHIVES[`${platform}-${arch}`]
@@ -53,11 +54,16 @@ export function downloadFile(url: string, destination: string, maxRedirects = 5)
 		trustedDomains: DCG_TRUSTED_DOWNLOAD_DOMAINS,
 		timeoutMs: 120_000,
 		maxRedirects,
+		maxBytes: MAX_ARCHIVE_BYTES,
 	})
 }
 
 export async function verifyChecksum(filePath: string, expected: string): Promise<void> {
-	await verifySha256Checksum(filePath, expected, () => new Error("DCG archive checksum verification failed"))
+	await verifySha256Checksum(
+		filePath,
+		expected,
+		(actual) => new Error(`DCG archive checksum verification failed (got ${actual})`),
+	)
 }
 
 export async function extractSingleBinary(
@@ -76,6 +82,7 @@ export async function extractSingleBinary(
 function installDcg(storageDir: string): Promise<string | undefined> {
 	const info = getDcgArchiveInfo()
 	if (!info) {
+		console.warn(`[DCG] Unsupported platform: ${process.platform}-${process.arch}`)
 		return Promise.resolve(undefined)
 	}