codeloop-mcp-server 0.1.41 → 0.1.43

package/dist/index.js

@@ -20,7 +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 { startUpdateCheck, getUpdateInfo, formatUpdateNotice, } from "./auth/update_check.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";
 import { isLocalMode } from "./auth/local_mode.js";
@@ -264,18 +264,45 @@ function withUpdateNotice(content) {
         ...content,
     ];
 }
+/**
+ * Tiny footer appended to every tool response so the agent (and the
+ * user reading the chat) always know which MCP server version is
+ * actually serving the call. Without this, a stale long-lived child
+ * process from a pre-fix version can keep producing failing tool
+ * calls indefinitely with no visible signal of "you're running an
+ * old version". The startup banner only goes to stderr, which is
+ * hidden from the chat.
+ *
+ * Format is deliberately one short line so it doesn't drown the
+ * tool's actual JSON payload, and prefixed `[CodeLoop]` so an agent
+ * scanning the response can match on it without ambiguity.
+ */
+function buildVersionBanner() {
+    const v = getRunningVersion();
+    if (!v)
+        return null;
+    return {
+        type: "text",
+        text: `[CodeLoop server v${v}]`,
+    };
+}
 function withInitHint(content, dir) {
-    // Order matters: update notice goes FIRST (most actionable signal),
-    // then init hint (init-then-restart is a weird state but harmless),
-    // then the original content. Critical update notices override
-    // anything else the agent might do this turn.
+    // Order matters:
+    //   1. Update notice (most actionable signal — CRITICAL stays at top).
+    //   2. Init hint (only when project is not initialized).
+    //   3. The original content.
+    //   4. Version banner footer (so the agent can always see what
+    //      version it's talking to — survives across all responses).
+    const banner = buildVersionBanner();
     const withUpdate = withUpdateNotice(content);
-    if (isProjectInitialized(dir || projectDir))
-        return withUpdate;
-    return [
-        { type: "text", text: INIT_HINT },
-        ...withUpdate,
-    ];
+    const head = [];
+    if (!isProjectInitialized(dir || projectDir)) {
+        head.push({ type: "text", text: INIT_HINT });
+    }
+    const result = [...head, ...withUpdate];
+    if (banner)
+        result.push(banner);
+    return result;
 }
 const TOOL_BOOTSTRAP = "[CodeLoop] You MUST call codeloop_verify after every code change. If .codeloop/config.json is missing, call codeloop_init_project FIRST.\n\n";
 // ── Implemented Tools ────────────────────────────────────────────
@@ -1929,6 +1956,10 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
         .describe("For win_ui_automate"),
     app_name: z.string().optional().describe("App name to bring to front before interaction. Auto-detected from active recording if omitted. Also used for launch_app, win_ui_inspect, win_ui_automate."),
     package_id: z.string().optional().describe("Package/bundle ID for mobile actions"),
+    intent: z.string().optional().describe("Semantic label for what this interaction is doing — short verb-phrase like 'edit product row', 'confirm delete dialog', 'save form', 'create new range'. STRONGLY RECOMMENDED for desktop coordinate-based clicks (target_type='desktop' with only x/y) because the CRUD classifier in user_journey_evidence can't infer the meaning of a raw (x, y) pair the way it can from a Playwright selector or DOM aria_label. Without `intent`, a sequence of coordinate clicks that delete a record will score `delete_actions: 0` and fail the gate. The classifier reads `intent` (plus `description` / `purpose` / `step` as aliases) into the same target-text bucket as selectors and aria labels, so the SAME keywords that work for browsers (edit / delete / save / submit / create / new) also work here. Example: when clicking the 'Yes' button of a Windows MessageBox at (2640, 820), pass intent='confirm delete'."),
+    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."),
     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) => {
@@ -2537,6 +2568,24 @@ Wait 1-2 seconds between interactions so video frames capture state changes.`, {
             inputArgs.automation_action = params.automation_action;
         if (params.app_name)
             inputArgs.app_name = params.app_name;
+        // Semantic-intent fields. These are the ONLY hook coordinate-based
+        // desktop clicks (target_type='desktop' with only x/y) have to
+        // tell the CRUD classifier what they MEAN. Without one of these,
+        // a sequence of (x, y) clicks that deletes a record scores
+        // delete_actions: 0 because the classifier has nothing to match
+        // DELETE_HINT against. Persisted under the same keys we accepted
+        // them under (no normalisation) so users can grep the log for
+        // their original tags. The classifier in interaction_coverage.ts
+        // reads each of these fields into targetText() alongside
+        // selector / aria_label / etc.
+        if (params.intent)
+            inputArgs.intent = params.intent;
+        if (params.description)
+            inputArgs.description = params.description;
+        if (params.purpose)
+            inputArgs.purpose = params.purpose;
+        if (params.step)
+            inputArgs.step = params.step;
         // Post-action verification readback. Persisted alongside the
         // interaction so a downstream consumer (depth gate, dev report,
         // the agent on the next turn) can confirm the action actually
@@ -2660,6 +2709,78 @@ Returns: counts for attempted / succeeded / requeued events and the queue locati
         ]),
     };
 });
+server.tool("codeloop_version", `Return the running MCP server version, the latest published version, and whether an update is pending.
+
+Use this tool when:
+- The agent or the user is unsure whether the CodeLoop MCP server has picked up a recent fix.
+- A previous CodeLoop tool call returned an error that looks like it should have been fixed (e.g., a Zod schema rejection that you know was made optional in a later release).
+- The user explicitly asks "what CodeLoop version am I running?".
+
+Use this tool FIRST in any new chat session if you have reason to suspect the MCP child process is stale — Cursor / Claude Code keep one long-lived MCP server per workspace, so a session opened days ago may still be serving from an old version even though npm has shipped fixes since.
+
+Returns:
+- \`running_version\`: the version of THIS process. This is the source of truth — the agent should compare its expectations against this value, not against the npm package metadata.
+- \`latest_published_version\`: from the background update poller (may be null if the poll has not completed yet).
+- \`is_outdated\`: whether running < latest.
+- \`is_critical\`: whether the running version falls below any entry in the critical-fix floor list.
+- \`recommended_action\`: a one-line instruction for what to do next (call codeloop_apply_update, restart IDE, or no action).
+- \`how_to_update\`: human-readable steps to get to the latest version, tailored to the situation.
+
+No project_dir / workspace_root required — this tool is workspace-independent.`, {}, async () => {
+    const running = getRunningVersion();
+    const info = getUpdateInfo();
+    const isOutdated = info?.is_outdated ?? false;
+    const isCritical = info?.is_critical ?? false;
+    let recommendedAction;
+    let howToUpdate;
+    if (!running) {
+        recommendedAction = "diagnose_only";
+        howToUpdate = [
+            "Could not read the running MCP server's package.json — this is unusual. Check that the codeloop-mcp-server package files are intact.",
+        ];
+    }
+    else if (!info) {
+        recommendedAction = "no_action";
+        howToUpdate = [
+            `Currently running v${running}.`,
+            "The background update check has not completed yet (or has been disabled via CODELOOP_SKIP_UPDATE_CHECK=1). Try this tool again in a few seconds, or run `npm view codeloop-mcp-server version` in the user's terminal to compare manually.",
+        ];
+    }
+    else if (!isOutdated) {
+        recommendedAction = "no_action";
+        howToUpdate = [`Already on the latest version (v${running}). No action needed.`];
+    }
+    else if (isCritical) {
+        recommendedAction = "call_codeloop_apply_update_now";
+        howToUpdate = [
+            `Running v${running} is below a critical-fix floor. Latest is v${info.latest}.`,
+            `Reasons: ${info.critical_reasons.join("; ")}.`,
+            "Call `codeloop_apply_update` NOW. It returns the terminal commands to pre-warm the npx cache, schedules the MCP server to exit gracefully, and the IDE respawns it with the latest version automatically. Your next CodeLoop tool call will be served by the new version — no IDE restart required.",
+        ];
+    }
+    else {
+        recommendedAction = "call_codeloop_apply_update_when_convenient";
+        howToUpdate = [
+            `Running v${running}, latest is v${info.latest}.`,
+            "Not critical, but recommended. Call `codeloop_apply_update` to pick up the new version in-session, OR let the next IDE restart pick it up via `npx -y codeloop-mcp-server@latest`.",
+        ];
+    }
+    const result = {
+        running_version: running,
+        latest_published_version: info?.latest ?? null,
+        is_outdated: isOutdated,
+        is_critical: isCritical,
+        critical_reasons: info?.critical_reasons ?? [],
+        last_checked_at: info?.checked_at ?? null,
+        recommended_action: recommendedAction,
+        how_to_update: howToUpdate,
+    };
+    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: