codeloop-mcp-server 0.1.48 → 0.1.49

package/dist/index.js

@@ -2,7 +2,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { readFileSync, writeFileSync, existsSync, readdirSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, readdirSync, statSync } from "fs";
 function dirHasFile(dir, predicate) {
     try {
         if (!existsSync(dir))
@@ -20,6 +20,7 @@ import { loadConfig } from "./config.js";
 import { validateApiKey, isActivationRequired } from "./auth/api_key.js";
 import { identifyKeySource, buildRevokedKeyDiagnostic } from "./auth/key_source.js";
 import { warmCliCache } from "./auth/cli_cache_warmer.js";
+import { recordInitialisedDir, wasInitialisedAtPath, } from "./auth/init_hint_cache.js";
 import { startUpdateCheck, getUpdateInfo, formatUpdateNotice, getRunningVersion, } from "./auth/update_check.js";
 import { applyUpdate, applyUpdateInputSchema, } from "./tools/apply_update.js";
 import { trackUsage } from "./auth/usage_tracker.js";
@@ -87,6 +88,49 @@ if (!process.env.CODELOOP_PROJECT_DIR &&
         `or set CODELOOP_PROJECT_DIR in your MCP config so future calls auto-resolve. ` +
         `codeloop_init_project will REFUSE to scaffold here.`);
 }
+// 0.1.49 — stale CODELOOP_PROJECT_DIR detection.
+//
+// When init writes a workspace pin into .cursor/mcp.json, it bakes
+// the absolute path of the workspace at the time. If the user later
+// renames or moves the workspace folder (common on Windows when a
+// project graduates from D:\Work\<name> to D:\Repos\<name>), the pin
+// keeps pointing at the old path that no longer exists, and every
+// MCP boot resolves projectDir to a non-existent directory — which
+// silently turns init/verify/gate into no-ops because every "does
+// the .codeloop/ folder exist?" check returns false.
+//
+// We log a single, loud, agent-readable line on stderr so the agent
+// knows to re-run `npx codeloop init` (which rewrites the pin to
+// the workspace's current absolute path — see G8 in the CLI).
+{
+    const pinned = process.env.CODELOOP_PROJECT_DIR;
+    if (pinned) {
+        let stale = false;
+        let reason = "";
+        try {
+            if (!existsSync(pinned)) {
+                stale = true;
+                reason = "path does not exist";
+            }
+            else if (!statSync(pinned).isDirectory()) {
+                stale = true;
+                reason = "path is not a directory";
+            }
+            else if (!existsSync(join(pinned, ".codeloop", "config.json"))) {
+                stale = true;
+                reason = "no .codeloop/config.json under the pinned path";
+            }
+        }
+        catch (e) {
+            stale = true;
+            reason = e.message;
+        }
+        if (stale) {
+            console.error(`[CodeLoop] ⚠ CODELOOP_PROJECT_DIR=${pinned} is stale (${reason}) — falling back to discovery. ` +
+                `Re-run \`npx codeloop init\` from the workspace's current location to rewrite the pin.`);
+        }
+    }
+}
 const config = loadConfig(projectDir);
 const apiKey = process.env.CODELOOP_API_KEY || config.api_key;
 // Pre-warm the npx cache for the `codeloop` CLI in the background so
@@ -310,6 +354,13 @@ function rememberInitializedDir(dir) {
         return;
     if (isProjectInitialized(dir)) {
         lastInitializedDir = dir;
+        // 0.1.49 — also persist to ~/.codeloop/init-hint-cache.json so
+        // the next MCP server boot (every IDE restart) doesn't false-
+        // positive the "project not initialised" hint until the agent
+        // has happened to forward `dir` to a handler that calls back
+        // into this function. Best-effort; failures swallowed inside
+        // recordInitialisedDir.
+        recordInitialisedDir(dir);
     }
 }
 function withInitHint(content, dir) {
@@ -336,7 +387,12 @@ function withInitHint(content, dir) {
     //      home folder on Windows / Cursor — see CODELOOP_PROJECT_DIR
     //      auto-injection notes in setup-project.ts).
     const candidates = [dir, lastInitializedDir, projectDir].filter((d) => typeof d === "string" && d.length > 0);
-    const anyInitialized = candidates.some((d) => isProjectInitialized(d));
+    // 0.1.49 — also consult the persistent cache so the very first
+    // tool call after an IDE restart doesn't false-positive the hint
+    // when `dir` wasn't passed and `lastInitializedDir` is empty (the
+    // session's not warmed up yet).
+    const anyInitialized = candidates.some((d) => isProjectInitialized(d)) ||
+        candidates.some((d) => wasInitialisedAtPath(d));
     if (!anyInitialized) {
         head.push({ type: "text", text: INIT_HINT });
     }
@@ -1206,13 +1262,12 @@ Returns: confirmation + the captured image as an MCP ImageContent block so you c
         // agent forgot app_name — and the auto-fix loop would then
         // burn cycles trying to "fix design diffs" against a
         // screenshot of the editor.
-        const { detectPlatform } = await import("./tools/verify.js");
         const { loadConfig } = await import("./config.js");
-        const platform = detectPlatform(cwd);
-        const isDesktopAppProject = platform === "dotnet" || platform === "xcode" || platform === "android";
+        const { isDesktopAppProject } = await import("./tools/desktop_app_mode.js");
+        const desktopApp = isDesktopAppProject(cwd);
         const cfg = loadConfig(cwd);
         const targetApp = params.app_name ?? cfg.evidence?.target_app;
-        const result = await captureScreenshot(screenshotsDir, params.screen_name, targetApp, undefined, { desktopAppMode: isDesktopAppProject });
+        const result = await captureScreenshot(screenshotsDir, params.screen_name, targetApp, undefined, { desktopAppMode: desktopApp });
         // Photometry-DB E2E 8 follow-on: when we capture a desktop app
         // window, also resolve its on-screen bounds so the agent can
         // (a) compute window-relative coords from the returned image
@@ -1223,7 +1278,7 @@ Returns: confirmation + the captured image as an MCP ImageContent block so you c
         // of the image and clicked tens or hundreds of pixels off the
         // intended target.
         let windowBounds = null;
-        if (isDesktopAppProject && targetApp && result.captured) {
+        if (desktopApp && targetApp && result.captured) {
             try {
                 const wm = await import("./runners/window_manager.js");
                 const b = await wm.getWindowBounds(targetApp);
@@ -2012,10 +2067,25 @@ Returns: checklist of completed and pending verification steps.`, {
                 const verdict = evaluateDepth(coverage, minimums, discoverySnapshot);
                 const b = coverage.buckets;
                 const breakdown = `click=${b.click}, navigation=${b.navigation}, input=${b.input}, commit=${b.commit}, toggle=${b.toggle}, gesture=${b.gesture}, upload=${b.upload}, keystroke=${b.keystroke}, inspect=${b.inspect}`;
+                // 0.1.49: coordinate_clicks_without_intent is now a HARD
+                // step-7 PENDING blocker so the agent sees the gap BEFORE
+                // gate_check, not after. Pre-0.1.49 this only surfaced as
+                // a verify postscript note, which agents commonly ignored
+                // until the user_journey_evidence gate failed at the
+                // bottom of a long verify→capture→video→gate cycle —
+                // wasting the entire UI-evidence loop.
+                const coordsWithoutIntent = coverage.coordinate_clicks_without_intent;
                 if (!minimums.enabled) {
                     depthStatus = "n/a";
                     depthDetail = `Depth gate disabled in .codeloop/config.json. Observed buckets: ${breakdown}.`;
                 }
+                else if (coordsWithoutIntent > 0) {
+                    depthStatus = "PENDING";
+                    depthDetail =
+                        `${coverage.successful} successful interactions across ${runs.length} run(s) (${breakdown}). ` +
+                            `BLOCKER: ${coordsWithoutIntent} coordinate-only click(s) dispatched without intent / description / purpose / step fields — the CRUD classifier in user_journey_evidence cannot credit them as edit/delete/create. ` +
+                            `Re-run codeloop_interact for those clicks WITH \`intent\` (e.g. intent="confirm delete dialog", intent="save form"). Otherwise gate_check will return continue_fixing on user_journey_evidence even after the rest of the workflow is green.`;
+                }
                 else if (verdict.passed) {
                     depthStatus = "done";
                     depthDetail = `${coverage.successful} successful interactions across ${runs.length} run(s) (${breakdown}). Depth minimums met.`;
@@ -2180,7 +2250,8 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
     description: z.string().optional().describe("[Alias for intent] Same semantics."),
     purpose: z.string().optional().describe("[Alias for intent] Same semantics."),
     step: z.string().optional().describe("Plan-step name when this interaction is driving a codeloop_plan_user_journey arc (e.g. 'edit', 'delete', 'create', 'save', 'verify'). Logged alongside `intent` and read by the CRUD classifier."),
-    coords: z.enum(["auto", "window", "screen"]).optional().describe("How to interpret x/y for desktop click/double_click/right_click/hover/scroll/drag/long_press. `auto` (default): if `app_name` resolves to a visible window AND (x, y) fits inside the window's client area, treat as window-relative and auto-offset by the window origin; otherwise leave as raw screen-absolute coords. `window`: ALWAYS add the window origin offset (errors if the window isn't found). `screen`: ALWAYS pass through (legacy behaviour, matches CGEvent / user32.dll / xdotool semantics). Fixes the Photometry-DB E2E 8 failure mode where the agent captured a 1600×900 window screenshot, computed click coords against the image, and missed the sidebar because the window's actual top-left was (286, 286) on a 5120×1440 screen."),
+    coords: z.enum(["auto", "window", "screen", "screenshot"]).optional().describe("How to interpret x/y for desktop click/double_click/right_click/hover/scroll/drag/long_press. `auto` (default): if `app_name` resolves to a visible window AND (x, y) fits inside the window's client area, treat as window-relative and auto-offset by the window origin; otherwise leave as raw screen-absolute coords. `window`: ALWAYS add the window origin offset (errors if the window isn't found). `screen`: ALWAYS pass through (legacy behaviour, matches CGEvent / user32.dll / xdotool semantics). `screenshot` (most accurate for vision-driven agents): treat (x, y) as coordinates against a captured screenshot — provide `screenshot_path` so the runner can read the image's actual width/height, scale (x, y) to the window's true pixel dimensions, then add the window origin and apply DPI. Use this whenever you computed coords from the image returned by codeloop_capture_screenshot, especially when the MCP transport may have downscaled the PNG. Fixes the Photometry-DB E2E 8 failure mode where the agent captured a 1600×900 window screenshot, computed click coords against the image, and missed the sidebar because the window's actual top-left was (286, 286) on a 5120×1440 screen."),
+    screenshot_path: z.string().optional().describe("Absolute path to the screenshot PNG that x/y were computed against. Used with `coords: \"screenshot\"` to scale agent-supplied coords from the captured image dimensions to the window's actual pixel dimensions before applying the window origin and DPI factor. Pass the `path` field returned by codeloop_capture_screenshot."),
     project_dir: z.string().optional().describe("Absolute path to project root."),
     workspace_root: z.string().optional().describe("[Alias for project_dir] Pass either; they're equivalent."),
 }, async (params) => {
@@ -2211,6 +2282,7 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         }
         // Bring the app to front before desktop interactions (non-browser, non-mobile).
         let windowOriginOffset = null;
+        let screenshotDims = null;
         if (tt === "desktop") {
             const appName = params.app_name || vr.getActiveRecordingAppName();
             if (appName && action !== "wait") {
@@ -2233,14 +2305,35 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
                     try {
                         const b = await wm.getWindowBounds(appName);
                         if (b && b.width > 0 && b.height > 0) {
-                            windowOriginOffset = { dx: b.x, dy: b.y, width: b.width, height: b.height };
+                            windowOriginOffset = {
+                                dx: b.x,
+                                dy: b.y,
+                                width: b.width,
+                                height: b.height,
+                                dpiX: b.dpi_x,
+                                dpiY: b.dpi_y,
+                            };
                         }
                     }
                     catch { /* best-effort */ }
                 }
+                // For coords:"screenshot", load the actual PNG dims so we
+                // can scale agent-supplied (x, y) up from the (possibly
+                // MCP-downscaled) image to the window's true pixel size.
+                if (coordsMode === "screenshot" && params.screenshot_path) {
+                    try {
+                        const { readPngDims } = await import("./runners/png_dims.js");
+                        screenshotDims = readPngDims(params.screenshot_path);
+                    }
+                    catch { /* best-effort */ }
+                }
             }
         }
         // Helper used by every coordinate-driven desktop action below.
+        // Photometry-DB E2E 8 + 0.1.49 hardening: handles four modes
+        // (auto / window / screen / screenshot) plus an optional DPI
+        // factor on the window bounds so high-DPI Windows / Retina
+        // displays don't drop clicks 100s of pixels off-target.
         const translateXY = (x, y) => {
             if (tt !== "desktop" || x == null || y == null || !windowOriginOffset) {
                 return { x, y };
@@ -2248,8 +2341,35 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
             const mode = params.coords ?? "auto";
             if (mode === "screen")
                 return { x, y };
+            const applyDpi = (px, py) => {
+                // window_manager records DPI in physical-pixel-per-logical
+                // form (1.0 = 96 DPI baseline; 2.0 = 200% / Retina). When
+                // the screenshot was captured in logical pixels but the
+                // OS click API expects physical pixels (Win32 user32.dll
+                // and modern macOS CGEvent both expect physical), scale up.
+                const dpiX = windowOriginOffset.dpiX ?? 1;
+                const dpiY = windowOriginOffset.dpiY ?? 1;
+                if (dpiX === 1 && dpiY === 1)
+                    return { x: px, y: py };
+                return { x: px * dpiX, y: py * dpiY };
+            };
+            if (mode === "screenshot") {
+                // Scale (x, y) from screenshot dims → window dims,
+                // then add the window origin, then DPI.
+                let sx = x;
+                let sy = y;
+                if (screenshotDims && screenshotDims.width > 0 && screenshotDims.height > 0) {
+                    const ratioX = windowOriginOffset.width / screenshotDims.width;
+                    const ratioY = windowOriginOffset.height / screenshotDims.height;
+                    sx = x * ratioX;
+                    sy = y * ratioY;
+                }
+                const dpi = applyDpi(sx, sy);
+                return { x: dpi.x + windowOriginOffset.dx, y: dpi.y + windowOriginOffset.dy };
+            }
             if (mode === "window") {
-                return { x: x + windowOriginOffset.dx, y: y + windowOriginOffset.dy };
+                const dpi = applyDpi(x, y);
+                return { x: dpi.x + windowOriginOffset.dx, y: dpi.y + windowOriginOffset.dy };
             }
             // auto: if (x, y) fits inside the window's client area,
             // assume the agent computed against a window-cropped
@@ -2258,7 +2378,8 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
             const inside = x >= 0 && x <= windowOriginOffset.width &&
                 y >= 0 && y <= windowOriginOffset.height;
             if (inside) {
-                return { x: x + windowOriginOffset.dx, y: y + windowOriginOffset.dy };
+                const dpi = applyDpi(x, y);
+                return { x: dpi.x + windowOriginOffset.dx, y: dpi.y + windowOriginOffset.dy };
             }
             return { x, y };
         };
@@ -3113,6 +3234,42 @@ No project_dir / workspace_root required — this tool is workspace-independent.
         ]),
     };
 });
+server.tool("codeloop_self_test", TOOL_BOOTSTRAP + `Pre-flight smoke test for CodeLoop on the current workspace. Run this on any NEW project BEFORE your first verify cycle, or whenever something looks off (silent IDE captures, "no .exe found", design_compare returning 0%, etc.).
+
+It validates every critical pre-condition synthetically (no live build, no live screenshot, no network past the platform sniff):
+- Workspace exists on disk and is a directory
+- codeloop_init_project has been run (.codeloop/config.json present)
+- Platform detection produced a known platform
+- isDesktopAppProject correctly identifies the project type (so captureScreenshot won't silently fall back to fullscreen)
+- evidence.target_app is set when desktop-app mode is ON (so launchDesktopApp + captureScreenshot can resolve a window)
+- PNG decoder skip path is wired (corrupt PNGs become skip warnings, not 0% match)
+- Coordinate translation round-trips on a synthetic high-DPI fixture (so clicks land where the agent expects on Retina / 200%-DPI displays)
+
+Returns a structured pass/fail report with per-check fix suggestions and a single \`next_step\` directive.
+
+Use this tool FIRST when:
+- The user reports CodeLoop "isn't working" or evidence is missing
+- Switching to a project / repo you've never run CodeLoop against
+- Debugging unexplained gate failures that don't match the agent's mental model
+
+Idempotent and free — safe to call as the first step of every new chat.`, {
+    project_dir: z.string().optional().describe("Absolute path to the project root. Defaults to CODELOOP_PROJECT_DIR env var or auto-discovered project directory."),
+    workspace_root: z.string().optional().describe("[Alias for project_dir] Same semantics."),
+}, async (params) => {
+    const result = await withAuth(async () => {
+        const cwd = (params.project_dir || params.workspace_root || projectDir);
+        const { runSelfTest } = await import("./tools/self_test.js");
+        return runSelfTest(cwd);
+    }, { tool: "codeloop_self_test", cwd: (params.project_dir || params.workspace_root || projectDir), input: params });
+    if (typeof result === "object" && result !== null && "error" in result) {
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    return {
+        content: withInitHint([
+            { type: "text", text: JSON.stringify(result, null, 2) },
+        ]),
+    };
+});
 server.tool("codeloop_apply_update", TOOL_BOOTSTRAP + `Apply a pending CodeLoop MCP server update to the current chat session — without asking the user to restart their IDE.
 
 Use this tool when: