renovate-mcp 0.9.4 → 0.10.0

package/README.md

@@ -274,3 +274,4 @@ Scope and non-goals are summarized in [What this is NOT](#what-this-is-not); thi
 - `dry_run` emits MCP progress notifications only when the caller's `tools/call` includes `_meta.progressToken` — no-op otherwise, so legacy clients see zero overhead. A 5-second heartbeat ticks while the child runs; each tick's message is best-effort enriched with the latest Renovate JSON-log `msg` seen on stdout. Notifications are also emitted at start and completion. We deliberately don't couple to Renovate's log schema beyond reading `msg`, since that schema isn't a stable API.
 - `dry_run_diff` is stateless on purpose: both reports are passed as inputs, no per-repo state is kept on the server. Updates are keyed by `(manager, packageFile, depName)` so a version bump on the same dep shows up once under `changed` rather than twice as `removed + added`. Compared per identity: `newValue`, `newVersion`, `updateType`, `branchName`, `groupName`, `schedule`. Either input can be the raw Renovate report or the full `dry_run` summary (with the `report` key) — the tool unwraps `report` automatically.
 - `write_config` writes to a temp file, validates, then atomically renames — so a failed validation never leaves a broken config on disk. The `force: true` escape hatch is gated behind a separate `confirmForce: "YES_OVERRIDE_VALIDATION"` literal: a single boolean is too easy for a prompt-injected agent to flip, but emitting an unusual sentinel string is a deliberate step that's harder to navigate accidentally.
+- `check_setup` and the shell-out tools (`validate_config`, `write_config`, `dry_run`) detect Renovate runtime conditions that degrade the tool silently — currently the bundled `re2` native module failing to load (typically after a Node major-version upgrade leaves a prebuilt `re2.node` compiled against the old ABI). When the WARN appears in Renovate's stderr, the tool response carries a `warnings: [{ kind: "re2-unusable", … }]` entry alongside its normal output and `check_setup` aggregates the same warning into `SetupStatus.warnings` plus the startup `instructions` banner. Renovate keeps running on JavaScript `RegExp` so calls don't fail, but regex-heavy operations (custom managers, validation, lookups) are noticeably slower; the fix hint is `cd $(npm root -g)/renovate && npm rebuild re2` (or reinstall Renovate). This is passive detection only — the server doesn't rebuild anything itself.

package/dist/lib/renovateCli.d.ts

@@ -1,7 +1,15 @@
+import { type RuntimeWarning } from "./runtimeWarnings.js";
 export interface RunResult {
     stdout: string;
     stderr: string;
     exitCode: number;
+    /**
+     * Renovate runtime conditions detected from stderr that the caller benefits
+     * from knowing about even though the run itself may have succeeded (e.g. RE2
+     * native-module dlopen failure causing a silent slow-path fallback). Always
+     * present — empty array when nothing was detected.
+     */
+    runtimeWarnings: RuntimeWarning[];
 }
 export interface RunOptions {
     cwd?: string;

package/dist/lib/renovateCli.js

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { detectRuntimeWarnings } from "./runtimeWarnings.js";
 /**
  * Spawn a command and capture stdout/stderr. Never throws on non-zero exit —
  * caller inspects exitCode. Throws only for spawn errors (ENOENT etc.) and
@@ -78,7 +79,12 @@ export function run(cmd, args, opts = {}) {
                 reject(new Error(`Command timed out after ${opts.timeoutMs}ms: ${cmd} ${args.join(" ")}`));
                 return;
             }
-            resolve({ stdout, stderr, exitCode: code ?? -1 });
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                runtimeWarnings: detectRuntimeWarnings(stderr),
+            });
         });
         if (opts.stdin != null) {
             child.stdin.end(opts.stdin);

package/dist/lib/runtimeWarnings.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Detect Renovate runtime warnings emitted to stderr that callers benefit from
+ * knowing about even though Renovate itself keeps running. Currently the only
+ * detected condition is the RE2 native-module dlopen failure: when the bundled
+ * `re2.node` was compiled against a different Node ABI than the one currently
+ * running, Renovate logs a single WARN and silently falls back to JavaScript
+ * `RegExp`. The fallback is functional but significantly slower for
+ * regex-heavy operations (custom managers, validation, lookups), and the
+ * degradation is otherwise invisible to MCP callers.
+ *
+ * Mirrors the parsing pattern in `lookupProblems.ts`: line-by-line scan,
+ * try-JSON-then-plain-text per line, dedupe, and cap the output. We also keep
+ * the parser narrow on purpose — Renovate emits many benign WARNs during
+ * normal runs (preset deprecations, etc.) and a generic capture would leak
+ * them into our responses.
+ */
+export type RuntimeWarningKind = "re2-unusable";
+export interface RuntimeWarning {
+    kind: RuntimeWarningKind;
+    message: string;
+    detail?: string;
+    fix: string;
+}
+export declare function detectRuntimeWarnings(stderr: string): RuntimeWarning[];
+export declare function dedupeRuntimeWarnings(warnings: RuntimeWarning[]): RuntimeWarning[];

package/dist/lib/runtimeWarnings.js

@@ -0,0 +1,106 @@
+/**
+ * Detect Renovate runtime warnings emitted to stderr that callers benefit from
+ * knowing about even though Renovate itself keeps running. Currently the only
+ * detected condition is the RE2 native-module dlopen failure: when the bundled
+ * `re2.node` was compiled against a different Node ABI than the one currently
+ * running, Renovate logs a single WARN and silently falls back to JavaScript
+ * `RegExp`. The fallback is functional but significantly slower for
+ * regex-heavy operations (custom managers, validation, lookups), and the
+ * degradation is otherwise invisible to MCP callers.
+ *
+ * Mirrors the parsing pattern in `lookupProblems.ts`: line-by-line scan,
+ * try-JSON-then-plain-text per line, dedupe, and cap the output. We also keep
+ * the parser narrow on purpose — Renovate emits many benign WARNs during
+ * normal runs (preset deprecations, etc.) and a generic capture would leak
+ * them into our responses.
+ */
+const MAX_DETAIL_LENGTH = 300;
+const MAX_WARNINGS = 10;
+const RE2_FIX_HINT = "The RE2 native module bundled with Renovate failed to load (likely after a Node version upgrade). Renovate is falling back to JavaScript `RegExp`, which is significantly slower for regex-heavy operations. To restore vectorized regex: `cd $(npm root -g)/renovate && npm rebuild re2`, or reinstall Renovate (`npm i -g renovate`). If `RENOVATE_BIN` points at a project-local install, run `npm rebuild re2` in that project instead.";
+const RE2_MESSAGE = "Renovate's RE2 native module is unusable; falling back to JavaScript `RegExp` (slower).";
+function truncate(s) {
+    if (s.length <= MAX_DETAIL_LENGTH)
+        return s;
+    return `${s.slice(0, MAX_DETAIL_LENGTH - 1)}…`;
+}
+function isRe2DlopenFailure(err) {
+    if (!err || typeof err !== "object")
+        return null;
+    const obj = err;
+    const code = typeof obj.code === "string" ? obj.code : undefined;
+    const message = typeof obj.message === "string" ? obj.message : undefined;
+    if (code !== "ERR_DLOPEN_FAILED")
+        return null;
+    if (!message || !/re2\.node/.test(message))
+        return null;
+    return { detail: truncate(message) };
+}
+export function detectRuntimeWarnings(stderr) {
+    if (!stderr)
+        return [];
+    const warnings = [];
+    const seen = new Set();
+    const pushRe2 = (detail) => {
+        if (seen.has("re2-unusable"))
+            return;
+        if (warnings.length >= MAX_WARNINGS)
+            return;
+        seen.add("re2-unusable");
+        const w = { kind: "re2-unusable", message: RE2_MESSAGE, fix: RE2_FIX_HINT };
+        if (detail)
+            w.detail = detail;
+        warnings.push(w);
+    };
+    for (const rawLine of stderr.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        if (warnings.length >= MAX_WARNINGS)
+            break;
+        if (line.startsWith("{")) {
+            try {
+                const parsed = JSON.parse(line);
+                if (parsed && typeof parsed === "object") {
+                    const msg = typeof parsed.msg === "string" ? parsed.msg : "";
+                    if (msg.includes("RE2 not usable")) {
+                        const detail = parsed.err && typeof parsed.err === "object" && parsed.err !== null
+                            ? typeof parsed.err.message === "string"
+                                ? truncate(parsed.err.message)
+                                : undefined
+                            : undefined;
+                        pushRe2(detail);
+                        continue;
+                    }
+                    const re2Err = isRe2DlopenFailure(parsed.err);
+                    if (re2Err) {
+                        pushRe2(re2Err.detail);
+                        continue;
+                    }
+                }
+            }
+            catch {
+                // fall through to plain-text matching below
+            }
+        }
+        if (/\bRE2 not usable\b/.test(line)) {
+            pushRe2();
+            continue;
+        }
+        if (/\bERR_DLOPEN_FAILED\b/.test(line) && /re2\.node/.test(line)) {
+            pushRe2(truncate(line));
+            continue;
+        }
+    }
+    return warnings;
+}
+export function dedupeRuntimeWarnings(warnings) {
+    const seen = new Set();
+    const out = [];
+    for (const w of warnings) {
+        if (seen.has(w.kind))
+            continue;
+        seen.add(w.kind);
+        out.push(w);
+    }
+    return out;
+}

package/dist/lib/setupCheck.d.ts

@@ -1,3 +1,4 @@
+import { type RuntimeWarning } from "./runtimeWarnings.js";
 export type RenovateBinary = "renovate" | "renovate-config-validator";
 export interface BinaryStatus {
     tool: RenovateBinary;
@@ -5,6 +6,11 @@ export interface BinaryStatus {
     found: boolean;
     version?: string;
     error?: string;
+    /**
+     * Runtime warnings parsed from this binary's `--version` stderr (e.g. RE2
+     * dlopen failure). Present only when at least one warning was detected.
+     */
+    runtimeWarnings?: RuntimeWarning[];
 }
 export type DryRunPlatform = "local" | "github" | "gitlab";
 export interface PlatformContext {
@@ -36,6 +42,13 @@ export interface SetupStatus {
     platformContext: PlatformContext;
     ok: boolean;
     hints: string[];
+    /**
+     * Deduped union of `runtimeWarnings` from every binary's `--version` probe.
+     * Distinct from `hints`: hints are "things you need to install / fix to use
+     * this server"; warnings are "Renovate is running but degraded." Empty array
+     * when nothing was detected.
+     */
+    warnings: RuntimeWarning[];
 }
 export declare function checkSetup(): Promise<SetupStatus>;
 /**
@@ -56,7 +69,9 @@ export declare function unavailableTools(status: SetupStatus): string[];
 /**
  * Concise startup banner appended to the server's MCP `instructions` so the
  * LLM is primed to treat CLI-missing as a partial-availability signal rather
- * than a setup error. Returns `null` when every tool is available.
+ * than a setup error. Also emits a banner — independent of binary availability
+ * — when Renovate runtime warnings are detected (e.g. RE2 dlopen failure
+ * causing a slow-path fallback). Returns `null` when nothing needs surfacing.
  */
 export declare function startupBanner(status: SetupStatus): string | null;
 export declare function describeSetup(status: SetupStatus): string;

package/dist/lib/setupCheck.js

@@ -1,4 +1,5 @@
 import { run, resolveRenovateTool } from "./renovateCli.js";
+import { dedupeRuntimeWarnings } from "./runtimeWarnings.js";
 const DRY_RUN_PLATFORMS = ["local", "github", "gitlab"];
 const VERSION_TIMEOUT_MS = 10_000;
 const INSTALL_HINT = "Install Renovate globally with `npm i -g renovate`, or set RENOVATE_BIN / RENOVATE_CONFIG_VALIDATOR_BIN to existing binaries.";
@@ -6,12 +7,14 @@ async function checkBinary(tool) {
     const command = resolveRenovateTool(tool);
     try {
         const result = await run(command, ["--version"], { timeoutMs: VERSION_TIMEOUT_MS });
+        const runtimeWarnings = result.runtimeWarnings.length ? result.runtimeWarnings : undefined;
         if (result.exitCode !== 0) {
             return {
                 tool,
                 command,
                 found: false,
                 error: (result.stderr || result.stdout).trim() || `exit code ${result.exitCode}`,
+                runtimeWarnings,
             };
         }
         return {
@@ -19,6 +22,7 @@ async function checkBinary(tool) {
             command,
             found: true,
             version: result.stdout.trim() || undefined,
+            runtimeWarnings,
         };
     }
     catch (err) {
@@ -48,6 +52,10 @@ export async function checkSetup() {
     if (!renovateConfigValidator.found) {
         hints.push(`renovate-config-validator not reachable at \`${renovateConfigValidator.command}\`. ${INSTALL_HINT}`);
     }
+    const warnings = dedupeRuntimeWarnings([
+        ...(renovate.runtimeWarnings ?? []),
+        ...(renovateConfigValidator.runtimeWarnings ?? []),
+    ]);
     return {
         node: process.version,
         renovate,
@@ -56,6 +64,7 @@ export async function checkSetup() {
         platformContext: inspectPlatformContext(process.env),
         ok: renovate.found && renovateConfigValidator.found,
         hints,
+        warnings,
     };
 }
 /**
@@ -139,21 +148,34 @@ export function unavailableTools(status) {
 /**
  * Concise startup banner appended to the server's MCP `instructions` so the
  * LLM is primed to treat CLI-missing as a partial-availability signal rather
- * than a setup error. Returns `null` when every tool is available.
+ * than a setup error. Also emits a banner — independent of binary availability
+ * — when Renovate runtime warnings are detected (e.g. RE2 dlopen failure
+ * causing a slow-path fallback). Returns `null` when nothing needs surfacing.
  */
 export function startupBanner(status) {
     const unavailable = unavailableTools(status);
-    if (unavailable.length === 0)
-        return null;
-    const unavailList = unavailable.map((n) => `\`${n}\``).join(", ");
-    const offlineList = OFFLINE_TOOLS.map((n) => `\`${n}\``).join(", ");
-    return [
-        "Partial availability:",
-        `  Renovate CLI not found — only blocks: ${unavailList}.`,
-        `  Offline tools (${offlineList}) still work; do not flag this as a setup problem when the task only needs those.`,
-        "  Install Renovate (`npm i -g renovate`) before calling the blocked tools, or call `check_setup` for a full diagnostic.",
-        "  Set `RENOVATE_MCP_REQUIRE_CLI=false` to suppress this notice if you have consciously chosen the offline subset.",
-    ].join("\n");
+    const sections = [];
+    if (unavailable.length > 0) {
+        const unavailList = unavailable.map((n) => `\`${n}\``).join(", ");
+        const offlineList = OFFLINE_TOOLS.map((n) => `\`${n}\``).join(", ");
+        sections.push([
+            "Partial availability:",
+            `  Renovate CLI not found — only blocks: ${unavailList}.`,
+            `  Offline tools (${offlineList}) still work; do not flag this as a setup problem when the task only needs those.`,
+            "  Install Renovate (`npm i -g renovate`) before calling the blocked tools, or call `check_setup` for a full diagnostic.",
+            "  Set `RENOVATE_MCP_REQUIRE_CLI=false` to suppress this notice if you have consciously chosen the offline subset.",
+        ].join("\n"));
+    }
+    if (status.warnings.length > 0) {
+        const lines = ["Renovate runtime warnings:"];
+        for (const w of status.warnings) {
+            lines.push(`  - ${w.message}`);
+            lines.push(`    Fix: ${w.fix}`);
+        }
+        lines.push("  These do not block tool calls. Surface this if a user reports unexpectedly slow runs.");
+        sections.push(lines.join("\n"));
+    }
+    return sections.length === 0 ? null : sections.join("\n\n");
 }
 export function describeSetup(status) {
     const lines = [];
@@ -187,6 +209,16 @@ export function describeSetup(status) {
         for (const h of status.hints)
             lines.push(`  - ${h}`);
     }
+    if (status.warnings.length > 0) {
+        lines.push("");
+        lines.push("Warnings:");
+        for (const w of status.warnings) {
+            lines.push(`  - ${w.message}`);
+            if (w.detail)
+                lines.push(`    Detail: ${w.detail}`);
+            lines.push(`    Fix: ${w.fix}`);
+        }
+    }
     return lines.join("\n");
 }
 function formatBinary(s) {

package/dist/lib/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SERVER_VERSION = "0.9.4";
+export declare const SERVER_VERSION = "0.10.0";
 export type BuildMode = "local" | "released";
 export interface VersionInfo {
     version: string;

package/dist/lib/version.js

@@ -1,5 +1,5 @@
 import { fileURLToPath } from "node:url";
-export const SERVER_VERSION = "0.9.4"; // x-release-please-version
+export const SERVER_VERSION = "0.10.0"; // x-release-please-version
 // "released" = the server is running from a `node_modules/` install (global
 // `npm i -g`, project-local `npm i`, or `npx renovate-mcp`). Anything else —
 // most commonly an MCP config of `{"command": "node", "args": [".../dist/index.js"]}`

package/dist/tools/dryRun.js

@@ -337,6 +337,9 @@ export function registerDryRun(server) {
             if (reportErrors.length > 0) {
                 summary.reportErrors = reportErrors;
             }
+            if (result.runtimeWarnings.length > 0) {
+                summary.warnings = result.runtimeWarnings;
+            }
             // If no structured report, surface the last bit of stderr so Claude can
             // debug without blowing up the context with Renovate's verbose logs.
             if (!report) {

package/dist/tools/validateConfig.js

@@ -45,11 +45,15 @@ export function registerValidateConfig(server) {
             const result = await run(bin, args, { timeoutMs: 30_000 });
             const valid = result.exitCode === 0;
             const output = (result.stdout + result.stderr).trim();
+            const payload = { valid, output };
+            if (result.runtimeWarnings.length > 0) {
+                payload.warnings = result.runtimeWarnings;
+            }
             return {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify({ valid, output }, null, 2),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
                 isError: !valid,

package/dist/tools/writeConfig.js

@@ -84,46 +84,54 @@ export function registerWriteConfig(server) {
             let valid = false;
             let validationOutput = "";
             let validatorMissing = false;
+            let runtimeWarnings = [];
             try {
                 const bin = resolveRenovateTool("renovate-config-validator");
                 const v = await run(bin, [tmp], { timeoutMs: 30_000 });
                 validationOutput = (v.stdout + v.stderr).trim();
                 valid = v.exitCode === 0;
+                runtimeWarnings = v.runtimeWarnings;
             }
             catch (err) {
                 validatorMissing = true;
                 validationOutput = formatMissingBinaryError("renovate-config-validator", err);
             }
             if (!valid && !force) {
+                const failPayload = {
+                    wrote: false,
+                    reason: validatorMissing ? "validator-unavailable" : "validation-failed",
+                    validationOutput,
+                    hint: validatorMissing
+                        ? "Install renovate-config-validator (or set RENOVATE_CONFIG_VALIDATOR_BIN), then retry. Pass force=true to skip validation entirely."
+                        : "Pass force=true to write anyway.",
+                };
+                if (runtimeWarnings.length > 0)
+                    failPayload.warnings = runtimeWarnings;
                 return {
                     isError: true,
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({
-                                wrote: false,
-                                reason: validatorMissing ? "validator-unavailable" : "validation-failed",
-                                validationOutput,
-                                hint: validatorMissing
-                                    ? "Install renovate-config-validator (or set RENOVATE_CONFIG_VALIDATOR_BIN), then retry. Pass force=true to skip validation entirely."
-                                    : "Pass force=true to write anyway.",
-                            }, null, 2),
+                            text: JSON.stringify(failPayload, null, 2),
                         },
                     ],
                 };
             }
             await fs.rename(tmp, target);
+            const okPayload = {
+                wrote: true,
+                path: rel,
+                bytes: payload.length,
+                valid,
+                validationOutput: valid ? undefined : validationOutput,
+            };
+            if (runtimeWarnings.length > 0)
+                okPayload.warnings = runtimeWarnings;
             return {
                 content: [
                     {
                         type: "text",
-                        text: JSON.stringify({
-                            wrote: true,
-                            path: rel,
-                            bytes: payload.length,
-                            valid,
-                            validationOutput: valid ? undefined : validationOutput,
-                        }, null, 2),
+                        text: JSON.stringify(okPayload, null, 2),
                     },
                 ],
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "renovate-mcp",
-  "version": "0.9.4",
+  "version": "0.10.0",
   "description": "MCP server for designing Renovate configurations interactively.",
   "type": "module",
   "bin": {