gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/dist/resources/extensions/browser-tools/tests/browser-tools-unit.test.cjs

@@ -387,32 +387,44 @@ describe("formatArtifactTimestamp", () => {
 // ---------------------------------------------------------------------------
 
 describe("EVALUATE_HELPERS_SOURCE", () => {
-	it("is a parseable string (valid JavaScript)", () => {
-		assert.doesNotThrow(() => {
-			new Function(EVALUATE_HELPERS_SOURCE);
-		});
-	});
+	// Behaviour test: executing the source in a Node vm sandbox must
+	// populate a `window.__pi` namespace with every expected helper.
+	// No source grep — we actually run the code and verify the resulting
+	// object shape.
+	it("executing the source assigns all expected helpers to window.__pi", () => {
+		const vm = require("node:vm");
+		const expectedFunctions = [
+			"cssPath",
+			"simpleHash",
+			"isVisible",
+			"isEnabled",
+			"inferRole",
+			"accessibleName",
+			"isInteractiveEl",
+			"domPath",
+			"selectorHints",
+		];
 
-	const expectedFunctions = [
-		"cssPath",
-		"simpleHash",
-		"isVisible",
-		"isEnabled",
-		"inferRole",
-		"accessibleName",
-		"isInteractiveEl",
-		"domPath",
-		"selectorHints",
-	];
-
-	for (const fnName of expectedFunctions) {
-		it(`contains assignment for pi.${fnName}`, () => {
-			assert.ok(
-				EVALUATE_HELPERS_SOURCE.includes(`pi.${fnName} = function`),
-				`Expected pi.${fnName} = function assignment in source`,
+		// Playwright evaluates the source in a page context where `window`
+		// exists, so the helpers attach to `window.__pi`. Provide a minimal
+		// window stub in a vm context so we avoid polluting the test globals.
+		const sandbox = { window: {} };
+		const script = new vm.Script(EVALUATE_HELPERS_SOURCE);
+		script.runInNewContext(sandbox, { timeout: 1000 });
+
+		assert.ok(
+			sandbox.window.__pi && typeof sandbox.window.__pi === "object",
+			"executing EVALUATE_HELPERS_SOURCE must assign window.__pi",
+		);
+
+		for (const fnName of expectedFunctions) {
+			assert.equal(
+				typeof sandbox.window.__pi[fnName],
+				"function",
+				`window.__pi.${fnName} must be a function after executing the source`,
 			);
-		});
-	}
+		}
+	});
 });
 
 // ---------------------------------------------------------------------------

package/dist/resources/extensions/browser-tools/tests/capture-sharp-optional.test.cjs

@@ -1,93 +1,91 @@
 /**
  * Regression tests for the optional sharp dependency in capture.ts.
  *
- * Verifies two things:
- *   1. Static: the lazy-load pattern is structurally correct in the source.
- *   2. Behavioral: constrainScreenshot returns the raw buffer unchanged when
- *      sharp is unavailable, rather than throwing.
+ * Behaviour:
+ *   - constrainScreenshot must fall back to returning the raw buffer
+ *     unchanged when sharp is unavailable, rather than throwing.
+ *   - When sharp IS available, oversized screenshots get resized.
+ *
+ * No source-grep. The test drives the real constrainScreenshot function
+ * after seeding the module-private `_sharp` cache via the test-only
+ * `__setSharpForTesting` export.
  */
 
-const { describe, it } = require("node:test");
+const { describe, it, afterEach } = require("node:test");
 const assert = require("node:assert/strict");
-const { readFileSync } = require("node:fs");
-const { join } = require("node:path");
-
-// ---------------------------------------------------------------------------
-// 1. Static analysis — verify the lazy-load pattern is present in source
-// ---------------------------------------------------------------------------
+const jiti = require("jiti")(__filename, { interopDefault: true, debug: false });
 
-describe("capture.ts — sharp optional lazy-load (static)", () => {
-	const source = readFileSync(
-		join(process.cwd(), "src/resources/extensions/browser-tools/capture.ts"),
-		"utf-8",
-	);
+const { constrainScreenshot, __setSharpForTesting } = jiti("../capture.ts");
 
-	it("does not have a top-level static sharp import", () => {
-		assert.ok(
-			!source.includes('import sharp from "sharp"'),
-			'capture.ts must not contain a top-level `import sharp from "sharp"` — sharp must be loaded lazily',
-		);
+describe("constrainScreenshot — sharp unavailable (null)", () => {
+	afterEach(() => {
+		// Clear the test override so later tests don't inherit a null sharp.
+		__setSharpForTesting(undefined);
 	});
 
-	it("defines a getSharp lazy-loader function", () => {
-		assert.ok(
-			source.includes("async function getSharp()"),
-			"capture.ts must define an async getSharp() lazy-loader",
+	it("returns the raw buffer unchanged when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]); // PNG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/png", 80);
+
+		assert.strictEqual(
+			result,
+			rawBuffer,
+			"constrainScreenshot must return the exact same buffer instance when sharp is null",
 		);
 	});
 
-	it("guards constrainScreenshot with a null-sharp early return", () => {
-		assert.ok(
-			source.includes("if (!sharp) return buffer"),
-			"constrainScreenshot must return the raw buffer early when sharp is null",
-		);
+	it("returns the raw buffer unchanged for JPEG input when sharp is null", async () => {
+		__setSharpForTesting(null);
+
+		const rawBuffer = Buffer.from([0xff, 0xd8, 0xff, 0xe0]); // JPEG magic bytes
+		const result = await constrainScreenshot(null, rawBuffer, "image/jpeg", 80);
+
+		assert.strictEqual(result, rawBuffer);
 	});
 });
 
-// ---------------------------------------------------------------------------
-// 2. Behavioral — constrainScreenshot passes through buffer when sharp is null
-// ---------------------------------------------------------------------------
-
-describe("capture.ts — constrainScreenshot with sharp unavailable", () => {
-	it("returns the raw buffer unchanged when sharp is null", async () => {
-		// Simulate what getSharp() returns on platforms without sharp by
-		// directly calling constrainScreenshot through a module whose _sharp
-		// cache has been pre-seeded to null via the module-level variable reset.
-		//
-		// Because jiti caches modules across the test suite we use a fresh
-		// require-cache trick: load capture.ts source manually and evaluate the
-		// constrainScreenshot function with a stub getSharp that always returns null.
-		const captureSource = readFileSync(
-			join(process.cwd(), "src/resources/extensions/browser-tools/capture.ts"),
-			"utf-8",
-		);
+describe("constrainScreenshot — sharp available", () => {
+	afterEach(() => {
+		__setSharpForTesting(undefined);
+	});
 
-		// Verify the guard line is reachable (structural check already done above).
-		// For the behavioral test we use the actual constrainScreenshot imported
-		// via jiti — but we force getSharp() to return null by calling the function
-		// with a very small buffer where sharp IS available. Separately we test the
-		// null path by crafting a minimal wrapper.
-		//
-		// The simplest verifiable behaviour: if the guard `if (!sharp) return buffer`
-		// is present, passing a Buffer through a version of constrainScreenshot where
-		// _sharp=null must return that exact buffer. We verify this by extracting and
-		// running a minimal inline version of the guard logic.
+	it("passes through a small image unchanged (below cap)", async () => {
+		const sharp = require("sharp");
+		const small = await sharp({
+			create: {
+				width: 400,
+				height: 300,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
 
-		const rawBuffer = Buffer.from([0x89, 0x50, 0x4e, 0x47]); // fake PNG header
+		const result = await constrainScreenshot(null, small, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.equal(meta.width, 400, "small images must not be resized");
+		assert.equal(meta.height, 300);
+	});
 
-		// Inline the guard as it appears in capture.ts so the test is coupled to
-		// the actual contract, not an arbitrary helper.
-		async function constrainScreenshotWithNullSharp(buffer) {
-			const sharp = null; // simulates getSharp() returning null
-			if (!sharp) return buffer;
-			// (remainder of constrainScreenshot would run here with a real sharp)
-		}
+	it("resizes an oversized image to within 1568px", async () => {
+		const sharp = require("sharp");
+		const big = await sharp({
+			create: {
+				width: 3000,
+				height: 2000,
+				channels: 3,
+				background: { r: 128, g: 128, b: 128 },
+			},
+		})
+			.jpeg({ quality: 80 })
+			.toBuffer();
 
-		const result = await constrainScreenshotWithNullSharp(rawBuffer);
-		assert.strictEqual(
-			result,
-			rawBuffer,
-			"constrainScreenshot must return the exact same buffer instance when sharp is null",
-		);
+		const result = await constrainScreenshot(null, big, "image/jpeg", 80);
+		const meta = await sharp(result).metadata();
+		assert.ok(meta.width <= 1568, `width ${meta.width} must be <= 1568`);
+		assert.ok(meta.height <= 1568, `height ${meta.height} must be <= 1568`);
 	});
 });

package/dist/resources/extensions/browser-tools/tools/forms.js

@@ -4,7 +4,11 @@ import { setLastActionBeforeState, setLastActionAfterState, } from "../state.js"
  * Runs inside page.evaluate(). Finds the target form, inventories all fields
  * with full label resolution, and returns a structured result.
  */
-function buildFormAnalysisScript(selector) {
+// Exported for tests only (see tests/browser-tools-integration.test.mjs).
+// Keep this function treated as module-private for production call sites —
+// the only legitimate external caller is the Playwright-driven integration
+// suite that needs to evaluate the returned IIFE against real DOM.
+export function buildFormAnalysisScript(selector) {
     // We return a string that will be evaluated in the page context.
     // This avoids serialization issues with passing functions.
     return `(() => {

package/dist/resources/extensions/browser-tools/tools/intent.js

@@ -26,7 +26,11 @@ const INTENTS = [
  * Uses window.__pi utilities (injected via addInitScript) for element
  * metadata — no inline redeclarations.
  */
-function buildIntentScoringScript(intent, scope) {
+// Exported for tests only (see tests/browser-tools-integration.test.mjs).
+// Keep this function treated as module-private for production call sites —
+// the only legitimate external caller is the Playwright-driven integration
+// suite that needs to evaluate the returned IIFE against real DOM.
+export function buildIntentScoringScript(intent, scope) {
     const scopeSelector = JSON.stringify(scope ?? null);
     return `(() => {
 	var pi = window.__pi;

package/dist/resources/extensions/claude-code-cli/readiness.js

@@ -10,15 +10,42 @@
  */
 import { execFileSync } from "node:child_process";
 /**
- * Platform-correct binary name for the Claude Code CLI.
+ * Candidate executable names for the Claude Code CLI.
  *
- * On Windows, npm-global binaries are installed as `.cmd` shims and
- * `execFileSync` does not auto-resolve the extension — calling bare
- * `claude` would fail with ENOENT even when the CLI is installed and
- * authenticated. Mirrors the `NPM_COMMAND` pattern in
- * `src/resources/extensions/gsd/pre-execution-checks.ts`.
+ * Keep the explicit win32 ternary selector for regression coverage (Issue #4424):
+ * Node's execFileSync must target `claude.cmd` directly on Windows.
  */
 const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
+/**
+ * Windows installs vary: some environments expose `claude.cmd` (npm shim),
+ * `claude.exe` (direct binary install), or a bare `claude` shim on PATH
+ * (for example Git Bash wrappers). Try all three to avoid false "not
+ * installed" results in readiness checks.
+ */
+const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
+function execClaude(args) {
+    let lastError;
+    for (const command of CLAUDE_COMMAND_CANDIDATES) {
+        try {
+            return execFileSync(command, args, {
+                timeout: 5_000,
+                stdio: "pipe",
+                shell: process.platform === "win32",
+            });
+        }
+        catch (error) {
+            lastError = error;
+            const code = error?.code;
+            // Windows Git Bash can surface `.cmd` spawn failures as EINVAL instead
+            // of ENOENT. Treat both as "try next candidate".
+            if (code === "ENOENT" || code === "EINVAL") {
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
+}
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
@@ -32,7 +59,7 @@ function refreshCache() {
     lastCheckMs = now;
     // Check binary presence
     try {
-        execFileSync(CLAUDE_COMMAND, ["--version"], { timeout: 5_000, stdio: "pipe" });
+        execClaude(["--version"]);
         cachedBinaryPresent = true;
     }
     catch {
@@ -42,7 +69,7 @@ function refreshCache() {
     }
     // Check auth status — exit code 0 with non-error output means authenticated
     try {
-        const output = execFileSync(CLAUDE_COMMAND, ["auth", "status"], { timeout: 5_000, stdio: "pipe" })
+        const output = execClaude(["auth", "status"])
             .toString()
             .toLowerCase();
         // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated