gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

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

@@ -5,8 +5,9 @@
  * Results are cached for 30 seconds to avoid shelling out on every
  * model-availability check.
  *
- * Auth verification follows the T3 Code pattern: run `claude auth status`
- * and check the exit code + output for an authenticated session.
+ * Auth verification runs `claude auth status --json` and inspects the
+ * `loggedIn` field, falling back to a text heuristic when the JSON shape
+ * is unavailable (older Claude CLI builds).
  */
 import { execFileSync } from "node:child_process";
 /**
@@ -23,18 +24,36 @@ const CLAUDE_COMMAND = process.platform === "win32" ? "claude.cmd" : "claude";
  * installed" results in readiness checks.
  */
 const CLAUDE_COMMAND_CANDIDATES = process.platform === "win32" ? [CLAUDE_COMMAND, "claude.exe", "claude"] : [CLAUDE_COMMAND];
-function execClaude(args) {
+// Codes treated as "this candidate didn't run — try the next one" rather than
+// fatal failures. ENOENT/EINVAL cover the original Windows .cmd shim cases.
+// ETIMEDOUT and EAGAIN cover slow-spawn cases where cmd.exe wrapping plus
+// the Claude CLI startup path together exceed the per-attempt timeout
+// (Issue #4997 regression on Windows + Node 25).
+const SOFT_FAIL_CODES = new Set(["ENOENT", "EINVAL", "ETIMEDOUT", "EAGAIN"]);
+// Keep the version probe snappy — `claude --version` is a quick path.
+const VERSION_TIMEOUT_MS = 5_000;
+// Auth status can be much slower on Windows because the spawn goes through
+// cmd.exe → claude.cmd → node → Claude CLI. 15s leaves headroom on cold spawns
+// without making startup feel hung when the CLI is genuinely missing.
+const AUTH_TIMEOUT_MS = 15_000;
+/**
+ * Run the requested Claude CLI command against each supported executable name.
+ * Returns the first successful output buffer and rethrows hard failures.
+ */
+function execClaude(args, timeoutMs) {
     let lastError;
     for (const command of CLAUDE_COMMAND_CANDIDATES) {
         try {
-            return execFileSync(command, args, { timeout: 5_000, stdio: "pipe" });
+            return execFileSync(command, args, {
+                timeout: timeoutMs,
+                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") {
+            if (code && SOFT_FAIL_CODES.has(code)) {
                 continue;
             }
             throw error;
@@ -42,10 +61,42 @@ function execClaude(args) {
     }
     throw lastError ?? new Error(`Claude CLI executable not found (tried: ${CLAUDE_COMMAND_CANDIDATES.join(", ")})`);
 }
+/**
+ * Decide auth state from `claude auth status` output.
+ *
+ * Newer Claude CLI builds emit JSON by default with a `loggedIn` boolean.
+ * Older builds emit free-form text. We prefer the structured signal and fall
+ * back to a text heuristic. Note: the text heuristic only covers English
+ * phrasing — the JSON path is the durable signal.
+ */
+function parseAuthStatus(output) {
+    const trimmed = output.trim();
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed.loggedIn === "boolean") {
+                return parsed.loggedIn;
+            }
+        }
+        catch {
+            // Fall through to text heuristic.
+        }
+    }
+    const lower = trimmed.toLowerCase();
+    if (/not logged in|no credentials|unauthenticated|not authenticated/.test(lower)) {
+        return false;
+    }
+    // Exit-0 with non-error output and no negative markers — treat as authed.
+    return true;
+}
 let cachedBinaryPresent = null;
 let cachedAuthed = null;
 let lastCheckMs = 0;
 const CHECK_INTERVAL_MS = 30_000;
+/**
+ * Refresh the cached binary/auth state when the cache window has expired.
+ * Preserves a known auth state across soft-fail auth probes.
+ */
 function refreshCache() {
     const now = Date.now();
     if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) {
@@ -55,7 +106,7 @@ function refreshCache() {
     lastCheckMs = now;
     // Check binary presence
     try {
-        execClaude(["--version"]);
+        execClaude(["--version"], VERSION_TIMEOUT_MS);
         cachedBinaryPresent = true;
     }
     catch {
@@ -63,16 +114,21 @@ function refreshCache() {
         cachedAuthed = false;
         return;
     }
-    // Check auth status — exit code 0 with non-error output means authenticated
+    // Request JSON explicitly so older CLI builds that defaulted to text and
+    // newer builds that default to JSON produce a consistent shape.
     try {
-        const output = execClaude(["auth", "status"])
-            .toString()
-            .toLowerCase();
-        // The CLI outputs "not logged in", "no credentials", or similar when unauthenticated
-        cachedAuthed = !(/not logged in|no credentials|unauthenticated|not authenticated/i.test(output));
+        const output = execClaude(["auth", "status", "--json"], AUTH_TIMEOUT_MS).toString();
+        cachedAuthed = parseAuthStatus(output);
     }
-    catch {
-        // Non-zero exit code means not authenticated
+    catch (error) {
+        const code = error?.code;
+        // Spawn-shape failures (timeout, transient) shouldn't be treated as
+        // "definitely not authed" — leave the previous value if we have one,
+        // otherwise default to false. The version probe already established
+        // the binary works, so a flaky auth probe is more likely transient.
+        if (code && SOFT_FAIL_CODES.has(code) && cachedAuthed !== null) {
+            return;
+        }
         cachedAuthed = false;
     }
 }