renovate-mcp 0.4.0 → 0.6.0

package/README.md

@@ -1,24 +1,43 @@
 # renovate-mcp
 
+[![npm](https://img.shields.io/npm/v/renovate-mcp.svg)](https://www.npmjs.com/package/renovate-mcp)
+[![CI](https://github.com/tibuntu/renovate-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/tibuntu/renovate-mcp/actions/workflows/ci.yml)
+[![Node ≥ 24](https://img.shields.io/node/v/renovate-mcp.svg)](https://nodejs.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+
 An MCP server for designing [Renovate](https://github.com/renovatebot/renovate) configurations interactively. Point it at a local repo and let an LLM help you read, validate, preview, and save `renovate.json`.
 
+## Contents
+
+- [What it does](#what-it-does)
+- [What this is NOT](#what-this-is-not)
+- [Requirements](#requirements)
+- [Install](#install)
+- [Example prompts](#example-prompts)
+- [Example session](#example-session)
+- [Development](#development)
+- [Release flow](#release-flow)
+- [Design notes](#design-notes)
+
 ## What it does
 
 Eight tools plus a preset reference:
 
-| Tool | What it does |
+| Tool | Purpose |
 | --- | --- |
-| `check_setup` | Report Renovate CLI + validator availability, versions, env overrides, and install hints. Also runs at server startup and embeds the result in the server's `instructions` when anything's missing. |
-| `read_config` | Locate and parse `renovate.json` / `renovate.json5` / `.renovaterc*` / `.github/renovate.json` / `.gitlab/renovate.json` / `package.json#renovate` in a repo — in Renovate's priority order. |
-| `resolve_config` | Expand every `extends` preset against the committed catalogue and return the fully resolved config (offline; no `renovate` invocation). Flags unresolvable entries with a reason. Opt in to fetching `github>` / `gitlab>` presets over HTTPS with `externalPresets: true` (auth via `RENOVATE_TOKEN`, or `GITHUB_TOKEN` / `GITLAB_TOKEN` as platform-specific fallbacks). For GitHub Enterprise or self-hosted GitLab, pass `endpoint` (API base URL) — and `platform` in addition to route `local>` presets through the same host. `bitbucket>`, `gitea>`, and npm presets remain in `presetsUnresolved` regardless. |
-| `preview_custom_manager` | Preview a `customManagers` (regex) entry against a local repo — offline, no `renovate` invocation. Shows which files match `fileMatch`, which lines match each `matchStrings` regex with named capture groups, and what dep info the template fields produce. Intended for fast regex iteration; run `dry_run` afterwards for full-fidelity confirmation. |
+| `check_setup` | Report Renovate CLI + validator availability, versions, and install hints. Also runs at startup. |
+| `read_config` | Locate and parse a repo's Renovate config (`renovate.json`, `renovate.json5`, `.renovaterc*`, `package.json#renovate`, …) in priority order. |
+| `resolve_config` | Expand every `extends` preset offline. Opt in to fetching `github>` / `gitlab>` presets over HTTPS with `externalPresets: true`. |
+| `preview_custom_manager` | Preview a `customManagers` (regex) entry against a local repo — shows file/line hits and extracted dep info. Offline. |
 | `validate_config` | Run `renovate-config-validator` against a file or inline object. |
-| `lint_config` | Semantic lint pass for Renovate-specific footguns schema validation misses — primarily malformed `/…/` regex patterns in `matchPackageNames` / `matchDepNames` / `matchSourceUrls` / `matchCurrentVersion`. Offline; does not shell out. Returns findings with JSON path, offending value, and a stable `ruleId` (`dead-regex-missing-slash`, `unwrapped-regex`) for suppression. Complements `validate_config`. |
-| `dry_run` | Run Renovate with `--platform=local --dry-run`, return the structured JSON report (no PRs, no pushes). Scans Renovate's logs for registry-auth failures (401/403/unauthorized/etc.) and surfaces them under `problems` so an empty-updates result isn't mistaken for "no updates available" when credentials were actually missing. Accepts an optional `hostRules` input for per-invocation private-registry credentials so callers don't have to restart the MCP server with new env vars (written to a mode-0600 temp file, passed via `--config-file`, cleaned up after the run; token/password values are scrubbed from any log output). |
-| `write_config` | Validate, then write a config to disk (temp-file → validate → atomic rename). Refuses to save invalid configs unless `force: true`. |
-| `renovate://presets` (resource) | Thin markdown index of every namespace (with preset counts) covering all 1000+ built-in presets. Snapshot from the installed `renovate` devDep. |
-| `renovate://presets/{namespace}` (resource template) | Markdown listing of every preset in a single namespace (e.g. `renovate://presets/config`). Fetch this instead of the full index when the LLM only cares about one namespace — cuts token cost by roughly 1/N where N is the number of namespaces. |
-| `renovate://preset/{name}` (resource template) | Expanded JSON body (description, extends, packageRules, …) for any single built-in preset. E.g. `renovate://preset/config:recommended`. |
+| `lint_config` | Semantic lint for Renovate-specific footguns schema validation misses (mostly malformed `/…/` regex patterns). Offline. |
+| `dry_run` | Run Renovate with `--dry-run` and return the structured JSON report. Defaults to `--platform=local` against `repoPath`; pass `platform` + `endpoint` + `token` + `repository` to run as a real GitHub/GitLab client (needed when the config extends `local>` presets on a private host). No PRs, no pushes. Emits MCP progress notifications during the run when the caller supplies a `progressToken`. |
+| `write_config` | Validate, then atomically write a config to disk. Refuses to save invalid configs unless `force: true`. |
+| `renovate://presets` (resource) | Markdown index of all 1000+ built-in presets grouped by namespace. |
+| `renovate://presets/{namespace}` (resource template) | Markdown listing for a single namespace (e.g. `renovate://presets/config`) — cheaper than the full index. |
+| `renovate://preset/{name}` (resource template) | Expanded JSON body for one preset (e.g. `renovate://preset/config:recommended`). |
+
+See [Design notes](#design-notes) for implementation details (timeouts, safety caps, auth scrubbing, merge semantics).
 
 ## What this is NOT
 
@@ -29,26 +48,30 @@ Eight tools plus a preset reference:
 
 ## Requirements
 
+**Required**
+
 - Node.js ≥ 24 (aligns with Renovate's own engine requirement).
-- Renovate available on your `PATH` — either a global install (`npm i -g renovate`) or a project-local install that exposes `renovate` and `renovate-config-validator` via `npm exec`. Only needed for `validate_config`, `dry_run`, and `write_config`; the offline tools (`read_config`, `resolve_config`, `preview_custom_manager`, `lint_config`) work without it.
-- Override binary locations with env vars if needed: `RENOVATE_BIN`, `RENOVATE_CONFIG_VALIDATOR_BIN`.
-- `RENOVATE_MCP_REQUIRE_CLI=false` suppresses the startup "partial availability" notice. Set this if you only intend to use the offline tools (`read_config`, `resolve_config`, `preview_custom_manager`) and don't want the missing-CLI notice in the server's MCP instructions.
-- Optional for `resolve_config` with `externalPresets: true`: `RENOVATE_TOKEN` (preferred — matches Renovate's own convention, where `RENOVATE_TOKEN` is the explicit Renovate-specific override), or `GITHUB_TOKEN` / `GITLAB_TOKEN` as platform-specific fallbacks, for fetching presets from private repos or to avoid rate limits. When both `RENOVATE_TOKEN` and a platform token are set, `RENOVATE_TOKEN` wins. For GitHub Enterprise / self-hosted GitLab, pass the `endpoint` tool input (and `platform` if you also want `local>` presets routed there); `RENOVATE_ENDPOINT` is **not** read.
-- Optional for `dry_run` against private package registries: whatever credentials Renovate itself would need at lookup time — e.g. `COMPOSER_AUTH` for private Packagist / Satis proxies, `NPM_TOKEN` or `.npmrc` for private npm, Docker registry credentials, or a `RENOVATE_HOST_RULES` JSON blob covering multiple hosts. Alternatively, encode these as `hostRules` directly in the Renovate config, or pass them per-call via the `hostRules` input on `dry_run` (no MCP server restart needed — useful while debugging an empty-updates result). Per-call `hostRules` are appended to any the repo's own config already declares. Values reach Renovate through the MCP tool-call transport as JSON, so the calling LLM sees them in its context; if that matters for a given token, use the env route instead. Without any of these Renovate's lookup step often returns 0 updates silently; `dry_run` will scan its logs for auth failures and surface them under `problems` in the output.
-- Any env vars the tools read (tokens, `COMPOSER_AUTH`, `RENOVATE_HOST_RULES`, binary overrides, …) must be set on the MCP server process itself — via the `env` key in `claude_desktop_config.json` / `.mcp.json`, not your shell, since the MCP server runs as a child of Claude and does not inherit shell env.
+- Renovate on your `PATH` — either a global install (`npm i -g renovate`) or a project-local install that exposes `renovate` + `renovate-config-validator` via `npm exec`. Only needed for `validate_config`, `dry_run`, and `write_config`; the offline tools (`read_config`, `resolve_config`, `preview_custom_manager`, `lint_config`) work without it.
+
+**Optional**
+
+- `RENOVATE_BIN` / `RENOVATE_CONFIG_VALIDATOR_BIN` — override binary locations.
+- `RENOVATE_MCP_REQUIRE_CLI=false` — suppress the startup "partial availability" notice when you only intend to use the offline tools.
+- `RENOVATE_TOKEN` (preferred) or `GITHUB_TOKEN` / `GITLAB_TOKEN` as platform-specific fallbacks — only needed by `resolve_config` with `externalPresets: true` for fetching presets from private repos or avoiding rate limits. `RENOVATE_TOKEN` wins when both are set. For GitHub Enterprise / self-hosted GitLab, pass the `endpoint` tool input (and `platform` to route `local>` presets through the same host); `RENOVATE_ENDPOINT` is **not** read.
+- Private-registry credentials for `dry_run` — whatever Renovate itself would need at lookup time (`COMPOSER_AUTH`, `NPM_TOKEN` / `.npmrc`, Docker registry creds, or a `RENOVATE_HOST_RULES` JSON blob). Alternatively encode these as `hostRules` in the Renovate config, or pass them per-call via the `hostRules` input on `dry_run` (no MCP restart needed). Per-call `hostRules` are appended to whatever the repo's own config declares. Values reach Renovate as JSON through the tool-call transport, so the calling LLM sees them in its context — prefer the env route if that matters. Without any of these, Renovate's lookup often returns 0 updates silently; `dry_run` scans its logs for auth failures and surfaces them under `problems`.
+
+> **Note:** all env vars (tokens, `COMPOSER_AUTH`, `RENOVATE_HOST_RULES`, binary overrides, …) must be set on the MCP server process itself — via the `env` key in `claude_desktop_config.json` / `.mcp.json`, not your shell — since the MCP server runs as a child of the client and does not inherit shell env.
 
 ## Install
 
-Once published to npm, no install is needed — `npx` will fetch it on demand. For local development, clone and build:
+`npx` fetches the [published package](https://www.npmjs.com/package/renovate-mcp) on demand — no manual install needed. For local development, clone and build first:
 
 ```bash
 npm install
 npm run build
 ```
 
-## Use with Claude Code
-
-Add to `.mcp.json` (project) or `~/.claude.json` (user):
+Add the following `mcpServers` entry to your client's config file:
 
 ```json
 {
@@ -61,33 +84,27 @@ Add to `.mcp.json` (project) or `~/.claude.json` (user):
 }
 ```
 
-For local development, swap to:
+For local development, swap to `"command": "node"` with `"args": ["/absolute/path/to/renovate-mcp/dist/index.js"]`.
 
-```json
-{
-  "mcpServers": {
-    "renovate": {
-      "command": "node",
-      "args": ["/absolute/path/to/renovate-mcp/dist/index.js"]
-    }
-  }
-}
-```
+### Claude Code
 
-## Use with Claude Desktop
+Config lives in `.mcp.json` (project-scoped) or `~/.claude.json` (user-scoped).
 
-Add to `~/Library/Application Support/Claude/claude_desktop_config.json`:
+### Claude Desktop
 
-```json
-{
-  "mcpServers": {
-    "renovate": {
-      "command": "npx",
-      "args": ["-y", "renovate-mcp"]
-    }
-  }
-}
-```
+Config lives in `~/Library/Application Support/Claude/claude_desktop_config.json`.
+
+### Other MCP clients
+
+Any client that can launch a stdio MCP server works — point it at the same command shown above.
+
+### Verify the wiring
+
+Restart your client and prompt it:
+
+> List the namespaces available under `renovate://presets`.
+
+A response listing namespaces like `config`, `docker`, `npm`, `helpers`, … confirms the server is reachable and the resource is exposed. If the client reports the tool or resource as unavailable, re-check the config file path and command.
 
 ## Example prompts
 
@@ -108,6 +125,7 @@ Once the server is wired up, try prompts like these. They're written for Claude
 
 - "Resolve my config with external presets enabled, fetching `gitlab>platform/renovate-presets` from our self-hosted GitLab at `https://gitlab.example.com/api/v4`. Route `local>` presets through the same host."
 - "Expand `github>acme/renovate-config//base` from our GitHub Enterprise at `https://github.acme.corp/api/v3`."
+- "Dry-run `devops/gitops` against our self-hosted GitLab at `https://gitlab.example.com/api/v4` — use `platform=gitlab` with my token so Renovate can fetch the `local>` presets the config extends."
 
 (Reminder: auth tokens must be set on the MCP server process — via the `env` key in `.mcp.json` / `claude_desktop_config.json`, not your shell.)
 
@@ -157,12 +175,13 @@ npm run build            # compile to dist/
 npm start                # run the built server over stdio
 npm test                 # vitest run (builds first)
 npm run test:watch       # vitest watch mode
+npm run test:coverage    # vitest run --coverage (writes coverage/ report)
 npm run generate:presets # regenerate src/data/presets.generated.ts from the renovate devDep
 ```
 
 The preset catalogue at `src/data/presets.generated.ts` is a committed snapshot of Renovate's built-in presets. Runtime code never imports the `renovate` package — only `scripts/generate-presets.mjs` does. Regenerate after bumping the `renovate` devDependency.
 
-CI runs `typecheck`, `build`, and `test` on Node 24 for every PR and push to `main` (see `.github/workflows/ci.yml`).
+CI runs `typecheck`, `build`, and `test:coverage` on Node 24 for every PR and push to `main` (see `.github/workflows/ci.yml`). Coverage is uploaded as a per-run artifact; no threshold is enforced yet.
 
 ## Release flow
 
@@ -184,9 +203,15 @@ Scope and non-goals are summarized in [What this is NOT](#what-this-is-not); thi
 - `validate_config`, `dry_run`, and `write_config` shell out to the Renovate CLI rather than importing Renovate as a library — this decouples our Node version from Renovate's (currently Node 24).
 - `resolve_config`, `preview_custom_manager`, and `lint_config` are fully in-process and never invoke the Renovate CLI, so they work without a Renovate install.
 - `lint_config` is a semantic lint pass that sits alongside `validate_config` rather than replacing it: schema validation catches structural bugs, the linter catches Renovate-specific footguns that schema validation declares valid — most commonly a pattern like `"matchPackageNames": ["/devops\\/pipelines\\/.+"]` where a trailing `/` is missing and Renovate silently degrades the value to an exact-string match that never hits. The ruleset is intentionally small (two rules: `dead-regex-missing-slash`, `unwrapped-regex`), scoped to the four regex-aware fields named in the proposal, and tuned to avoid false positives on benign exact strings containing a `.`. Rule IDs are stable so findings can be suppressed by callers.
-- `preview_custom_manager` honors `.gitignore` (including nested `.gitignore`s and `.git/info/exclude`) when walking the repo, so generated/vendored directories like `dist/`, `.next/`, `target/`, `__pycache__/` don't crowd out real hits against the `maxFilesScanned` cap. `node_modules/` and `.git/` are always skipped as a safety net even when no `.gitignore` is present.
+- `preview_custom_manager` honors `.gitignore` (including nested `.gitignore`s and `.git/info/exclude`) when walking the repo, so generated/vendored directories like `dist/`, `.next/`, `target/`, `__pycache__/` don't crowd out real hits against the `maxFilesWalked` cap. `node_modules/` and `.git/` are always skipped as a safety net even when no `.gitignore` is present.
+- `preview_custom_manager` exposes two separate safety caps so the warning text can name which one tripped: `maxFilesWalked` (default 2000) bounds the directory walk before any `fileMatch` testing, and `maxFilesMatched` (default 500) bounds the result set after `fileMatch` is applied. Previously a single `maxFilesScanned` conflated the two, leaving the user unable to tell whether to narrow `fileMatch` or widen the walk.
+- `preview_custom_manager` runs every user-supplied regex on a `worker_threads` worker with a wall-clock budget per operation (default 2 s, configurable via `matchTimeoutMs`). Catastrophic backtracking — e.g. `^(a+)+b$` against `aaaa…c`, or `(.*)*=` against a modestly sized file — would otherwise pin the MCP server's event loop indefinitely. On timeout the worker is terminated and a warning is appended identifying which `fileMatch[i]` or `matchStrings[i]` was aborted, so the user can simplify the pattern or raise the budget.
+- `preview_custom_manager` also stats each matched file before reading it and skips anything larger than `maxFileBytes` (default 5 MiB) with a warning, so a stray lockfile, generated artifact, or SQL dump caught by a loose `fileMatch` can't OOM the server. `maxHitsPerFile` already bounds output size; this guards input size.
 - `resolve_config` expands `extends` against a committed snapshot of Renovate's built-in presets (`src/data/presets.generated.ts`). External `github>` / `gitlab>` fetching is opt-in, uses each platform's contents API with a 10 s timeout, and caches results per call. The `endpoint` input swaps in a custom API base for GHE / self-hosted GitLab; `platform` additionally rewrites `local>` presets to be fetched against that endpoint.
 - `resolve_config` merges preset bodies with a close approximation of Renovate's own `mergeChildConfig` — arrays concat, objects recursively merge, scalars overwrite — not a bit-identical port. Rule-specific semantics for `hostRules`, `regexManagers` / `customManagers`, and certain boolean flags aren't modeled here. Every response carries `mergeQuality: "preview"` plus a human-readable `disclaimer` so callers can't miss the limitation; run `dry_run` for authoritative output.
 - When `resolve_config` encounters template tokens outside its supported subset, it records a structured entry in `warnings`: under-argument cases (`{{arg2}}` referenced when only one arg was passed) substitute an empty string, while non-positional tokens (`{{packageRules}}`, Handlebars helpers like `{{#if …}}`) pass through verbatim.
-- `dry_run` uses `--report-type=file` so we get a structured JSON report instead of scraping stdout. When a `hostRules` input is passed it's written to a mode-0600 temp file in `os.tmpdir()`, handed to Renovate via `--config-file=`, and deleted in a `finally` block. Token/password values are scrubbed from both the detected `problems` list and the `logTail` fallback before returning.
+- `dry_run` uses `--report-type=file` so we get a structured JSON report instead of scraping stdout. When a `hostRules` input is passed it's written to a mode-0600 temp file in `os.tmpdir()`, handed to Renovate via the `RENOVATE_CONFIG_FILE` env var (the CLI has no `--config-file` flag), and deleted in a `finally` block. Token/password values — including the platform `token` input — are scrubbed from the detected `problems` list and the `logTail` fallback before returning.
+- `dry_run` defaults to `--platform=local` so no host token is required, but that mode can't resolve `local>` presets (they have no platform context to expand against) and silently hides non-default-host GitHub/GitLab setups. Passing `platform` + `endpoint` + `token` + `repository` switches the run to a real platform client so the preset-fetch path works end-to-end; `--dry-run` is still set, so no PRs are opened. As a guard against the silent-failure mode, `dry_run` preflight-checks the repo's config: if it extends any `local>…` preset while the effective platform is `local`, the tool fails fast with specific remediation rather than spawning a Renovate run that would opaquely report `config-validation`.
+- `dry_run` returns a top-level `ok` boolean that is `false` whenever the CLI exited non-zero OR the structured report contains a validation/error-level problem (`level >= 40`, `message === "config-validation"`, or a non-empty `validationError` field). Renovate frequently writes exit-code 0 alongside report-level failures — trusting the exit code alone hides runs that did nothing.
+- `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.
 - `write_config` writes to a temp file, validates, then atomically renames — so a failed validation never leaves a broken config on disk.

package/dist/index.js

@@ -33,7 +33,7 @@ const requireCliRaw = process.env.RENOVATE_MCP_REQUIRE_CLI?.trim().toLowerCase()
 const suppressBanner = requireCliRaw === "false" || requireCliRaw === "0";
 const banner = suppressBanner ? null : startupBanner(setup);
 const instructions = banner ? [BASE_INSTRUCTIONS, "", banner].join("\n") : BASE_INSTRUCTIONS;
-const SERVER_VERSION = "0.4.0"; // x-release-please-version
+const SERVER_VERSION = "0.6.0"; // x-release-please-version
 const server = new McpServer({ name: "renovate-mcp", version: SERVER_VERSION }, { instructions });
 registerCheckSetup(server);
 registerReadConfig(server);

package/dist/lib/customManagerPreview.d.ts

@@ -36,11 +36,14 @@ export interface ExtractedDep {
     autoReplaceString?: string;
 }
 export interface PreviewOptions {
-    maxFilesScanned?: number;
+    maxFilesWalked?: number;
+    maxFilesMatched?: number;
     maxHitsPerFile?: number;
+    matchTimeoutMs?: number;
+    maxFileBytes?: number;
 }
 export interface PreviewResult {
-    filesScanned: number;
+    filesWalked: number;
     filesMatched: string[];
     hits: PreviewHit[];
     extractedDeps: ExtractedDep[];

package/dist/lib/customManagerPreview.js

@@ -1,8 +1,12 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
+import { Worker } from "node:worker_threads";
 import ignore from "ignore";
-const DEFAULT_MAX_FILES_SCANNED = 2000;
+const DEFAULT_MAX_FILES_WALKED = 2000;
+const DEFAULT_MAX_FILES_MATCHED = 500;
 const DEFAULT_MAX_HITS_PER_FILE = 100;
+const DEFAULT_MATCH_TIMEOUT_MS = 2000;
+const DEFAULT_MAX_FILE_BYTES = 5 * 1024 * 1024;
 const SKIP_DIRS = new Set([".git", "node_modules"]);
 const TEMPLATE_FIELD_MAP = [
     ["depNameTemplate", "depName"],
@@ -18,29 +22,67 @@ const TEMPLATE_FIELD_MAP = [
 ];
 export async function previewCustomManager(repoPath, manager, options = {}) {
     const warnings = [];
-    const maxFilesScanned = options.maxFilesScanned ?? DEFAULT_MAX_FILES_SCANNED;
+    const maxFilesWalked = options.maxFilesWalked ?? DEFAULT_MAX_FILES_WALKED;
+    const maxFilesMatched = options.maxFilesMatched ?? DEFAULT_MAX_FILES_MATCHED;
     const maxHitsPerFile = options.maxHitsPerFile ?? DEFAULT_MAX_HITS_PER_FILE;
+    const matchTimeoutMs = options.matchTimeoutMs ?? DEFAULT_MATCH_TIMEOUT_MS;
+    const maxFileBytes = options.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
     if (manager.matchStringsStrategy && manager.matchStringsStrategy !== "any") {
         warnings.push(`matchStringsStrategy='${manager.matchStringsStrategy}' is not yet supported by this preview tool; treating as 'any'. Run dry_run for full-fidelity behavior.`);
     }
-    const fileMatchRes = manager.fileMatch.map((s) => compileRegex(s));
-    const matchStringRes = manager.matchStrings.map((s) => compileRegex(s, "gm"));
-    const filesMatched = [];
-    let filesScanned = 0;
+    // Surface malformed user regexes eagerly, before we do any filesystem work.
+    // The Worker path otherwise reports these as generic worker errors.
+    for (const src of manager.fileMatch)
+        validateRegex(src);
+    for (const src of manager.matchStrings)
+        validateRegex(src);
+    // Walk first, then run fileMatch regexes in a worker so a pathological
+    // pattern can't pin the event loop on the path-testing phase.
+    const allPaths = [];
     for await (const rel of walk(repoPath)) {
-        if (filesScanned >= maxFilesScanned) {
-            warnings.push(`Stopped after scanning ${maxFilesScanned} files. Increase maxFilesScanned to widen the search.`);
+        if (allPaths.length >= maxFilesWalked) {
+            warnings.push(`Stopped walking the repo after ${maxFilesWalked} files; remaining files were never tested against fileMatch. Add ignores (or a .gitignore) to prune irrelevant directories, or raise maxFilesWalked.`);
             break;
         }
-        filesScanned++;
-        if (fileMatchRes.some((re) => re.test(rel))) {
-            filesMatched.push(rel);
+        allPaths.push(rel);
+    }
+    const filesWalked = allPaths.length;
+    const matchedSet = new Set();
+    for (let i = 0; i < manager.fileMatch.length; i++) {
+        const source = manager.fileMatch[i];
+        const res = await runTestInWorker(source, "", allPaths, matchTimeoutMs);
+        if (res.timedOut) {
+            warnings.push(`fileMatch[${i}] /${source}/ exceeded ${matchTimeoutMs}ms and was aborted; no paths were matched against this pattern. Simplify the regex (e.g. avoid nested quantifiers like (a+)+) or raise matchTimeoutMs.`);
+            continue;
         }
+        for (const p of res.paths)
+            matchedSet.add(p);
+    }
+    // Preserve walk order so output is stable.
+    const allFilesMatched = allPaths.filter((p) => matchedSet.has(p));
+    // Distinct from the walk cap: this caps the *result set*. A broad fileMatch
+    // regex over a large repo can produce thousands of hits; truncate with a
+    // dedicated warning so the user can tell which cap tripped.
+    const filesMatched = allFilesMatched.slice(0, maxFilesMatched);
+    if (allFilesMatched.length > maxFilesMatched) {
+        warnings.push(`fileMatch matched ${allFilesMatched.length} files; capped result set at maxFilesMatched=${maxFilesMatched}. Narrow fileMatch to target the intended paths, or raise maxFilesMatched.`);
     }
     const hits = [];
     const extractedDeps = [];
     for (const rel of filesMatched) {
         const abs = path.join(repoPath, rel);
+        let stat;
+        try {
+            stat = await fs.stat(abs);
+        }
+        catch (err) {
+            warnings.push(`Could not stat ${rel}: ${err.message}`);
+            continue;
+        }
+        if (stat.size > maxFileBytes) {
+            warnings.push(`${rel}: skipped, ${stat.size} bytes exceeds maxFileBytes=${maxFileBytes}. Tighten fileMatch to exclude it, or raise maxFileBytes.`);
+            continue;
+        }
         let content;
         try {
             content = await fs.readFile(abs, "utf8");
@@ -50,28 +92,34 @@ export async function previewCustomManager(repoPath, manager, options = {}) {
             continue;
         }
         let perFileHits = 0;
-        for (let i = 0; i < matchStringRes.length; i++) {
-            const re = matchStringRes[i];
-            // RegExp objects with the `g` flag are stateful — reset before iterating
-            // each file so that previous calls don't shift lastIndex.
-            re.lastIndex = 0;
-            for (const m of content.matchAll(re)) {
+        for (let i = 0; i < manager.matchStrings.length; i++) {
+            const source = manager.matchStrings[i];
+            const res = await runMatchAllInWorker(source, "gm", content, matchTimeoutMs);
+            if (res.timedOut) {
+                warnings.push(`${rel}: matchStrings[${i}] /${source}/ exceeded ${matchTimeoutMs}ms and was aborted; any matches in this file for this pattern were skipped. Simplify the regex (e.g. avoid nested quantifiers like (.*)*) or raise matchTimeoutMs.`);
+                continue;
+            }
+            for (const m of res.matches) {
                 if (perFileHits >= maxHitsPerFile) {
                     warnings.push(`${rel}: capped at ${maxHitsPerFile} hits. Increase maxHitsPerFile to see more.`);
                     break;
                 }
-                const groups = (m.groups ?? {});
-                const line = lineNumberAt(content, m.index ?? 0);
-                const matchStr = m[0];
-                hits.push({ file: rel, matchStringIndex: i, line, match: matchStr, groups });
-                extractedDeps.push(buildExtractedDep(rel, line, groups, manager));
+                const line = lineNumberAt(content, m.index);
+                hits.push({
+                    file: rel,
+                    matchStringIndex: i,
+                    line,
+                    match: m.match,
+                    groups: m.groups,
+                });
+                extractedDeps.push(buildExtractedDep(rel, line, m.groups, manager));
                 perFileHits++;
             }
             if (perFileHits >= maxHitsPerFile)
                 break;
         }
     }
-    return { filesScanned, filesMatched, hits, extractedDeps, warnings };
+    return { filesWalked, filesMatched, hits, extractedDeps, warnings };
 }
 function buildExtractedDep(file, line, groups, manager) {
     const dep = { file, line };
@@ -102,17 +150,9 @@ function buildExtractedDep(file, line, groups, manager) {
 function applyTemplate(tmpl, groups) {
     return tmpl.replace(/\{\{\s*([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\}\}/g, (_, name) => groups[name] ?? "");
 }
-function compileRegex(source, extraFlags = "") {
+function validateRegex(source) {
     try {
-        // De-duplicate flags in case the source already had `g`/`m`.
-        const seen = new Set();
-        const flags = (extraFlags).split("").filter((c) => {
-            if (seen.has(c))
-                return false;
-            seen.add(c);
-            return true;
-        }).join("");
-        return new RegExp(source, flags);
+        new RegExp(source);
     }
     catch (err) {
         throw new Error(`Invalid regex /${source}/: ${err.message}`);
@@ -126,6 +166,82 @@ function lineNumberAt(content, index) {
     }
     return line;
 }
+const WORKER_SOURCE = `
+const { parentPort, workerData } = require('node:worker_threads');
+try {
+  const { mode, pattern, flags } = workerData;
+  const re = new RegExp(pattern, flags);
+  if (mode === 'test') {
+    const out = [];
+    for (const p of workerData.paths) {
+      re.lastIndex = 0;
+      if (re.test(p)) out.push(p);
+    }
+    parentPort.postMessage({ ok: true, mode: 'test', paths: out });
+  } else {
+    const out = [];
+    for (const m of workerData.content.matchAll(re)) {
+      out.push({
+        index: m.index == null ? 0 : m.index,
+        match: m[0],
+        groups: m.groups == null ? {} : Object.assign({}, m.groups),
+      });
+    }
+    parentPort.postMessage({ ok: true, mode: 'matchAll', matches: out });
+  }
+} catch (err) {
+  parentPort.postMessage({ ok: false, error: err && err.message ? err.message : String(err) });
+}
+`;
+async function runWorker(request, timeoutMs) {
+    const worker = new Worker(WORKER_SOURCE, {
+        eval: true,
+        workerData: request,
+    });
+    let timer;
+    try {
+        return await new Promise((resolve, reject) => {
+            timer = setTimeout(() => resolve("timeout"), timeoutMs);
+            worker.once("message", (msg) => resolve(msg));
+            worker.once("error", (err) => reject(err));
+            worker.once("exit", (code) => {
+                if (code !== 0 && code !== 1) {
+                    // code 1 is the normal exit after terminate(); anything else is a
+                    // crash we haven't already captured via 'error'.
+                    reject(new Error(`Regex worker exited unexpectedly with code ${code}`));
+                }
+            });
+        });
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        // terminate() is idempotent and safe to call after the worker already exited.
+        await worker.terminate().catch(() => { });
+    }
+}
+async function runTestInWorker(pattern, flags, paths, timeoutMs) {
+    const response = await runWorker({ mode: "test", pattern, flags, paths }, timeoutMs);
+    if (response === "timeout")
+        return { timedOut: true };
+    if (!response.ok)
+        throw new Error(`Regex worker error: ${response.error}`);
+    if (response.mode !== "test") {
+        throw new Error(`Regex worker returned wrong mode: ${response.mode}`);
+    }
+    return { timedOut: false, paths: response.paths };
+}
+async function runMatchAllInWorker(pattern, flags, content, timeoutMs) {
+    const response = await runWorker({ mode: "matchAll", pattern, flags, content }, timeoutMs);
+    if (response === "timeout")
+        return { timedOut: true };
+    if (!response.ok)
+        throw new Error(`Regex worker error: ${response.error}`);
+    if (response.mode !== "matchAll") {
+        throw new Error(`Regex worker returned wrong mode: ${response.mode}`);
+    }
+    return { timedOut: false, matches: response.matches };
+}
 async function readMaybe(abs) {
     try {
         return await fs.readFile(abs, "utf8");

package/dist/lib/dryRunProgress.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pure helpers for the dry_run tool's progress-notification pipeline. Kept in
+ * their own module so the parsing + message-building logic can be unit-tested
+ * without spawning an MCP server.
+ *
+ * The mapping from Renovate's JSON log output to progress messages is
+ * intentionally best-effort — Renovate's log schema is not a stable API, so we
+ * only read the `msg` field when present and fall back to an elapsed-time
+ * message otherwise.
+ */
+/** Maximum length of a Renovate log `msg` copied into a progress update. */
+export declare const DEFAULT_MAX_LOG_MSG_LEN = 160;
+/**
+ * Parse a single stdout line as a Renovate JSON log entry and return its
+ * `msg` (trimmed and truncated) when present. Returns `undefined` for
+ * non-JSON lines, lines without a string `msg`, or empty messages.
+ */
+export declare function extractRenovateLogMsg(line: string, maxLen?: number): string | undefined;
+/**
+ * Build the message payload for a heartbeat-tick progress notification.
+ * Includes elapsed time and, when available, the most recently observed
+ * Renovate log `msg` so callers see *something* beyond "still running".
+ */
+export declare function buildDryRunHeartbeatMessage(elapsedMs: number, lastLogMsg: string | undefined): string;

package/dist/lib/dryRunProgress.js

@@ -0,0 +1,48 @@
+/**
+ * Pure helpers for the dry_run tool's progress-notification pipeline. Kept in
+ * their own module so the parsing + message-building logic can be unit-tested
+ * without spawning an MCP server.
+ *
+ * The mapping from Renovate's JSON log output to progress messages is
+ * intentionally best-effort — Renovate's log schema is not a stable API, so we
+ * only read the `msg` field when present and fall back to an elapsed-time
+ * message otherwise.
+ */
+/** Maximum length of a Renovate log `msg` copied into a progress update. */
+export const DEFAULT_MAX_LOG_MSG_LEN = 160;
+/**
+ * Parse a single stdout line as a Renovate JSON log entry and return its
+ * `msg` (trimmed and truncated) when present. Returns `undefined` for
+ * non-JSON lines, lines without a string `msg`, or empty messages.
+ */
+export function extractRenovateLogMsg(line, maxLen = DEFAULT_MAX_LOG_MSG_LEN) {
+    if (!line)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return undefined;
+    const msgVal = parsed.msg;
+    if (typeof msgVal !== "string")
+        return undefined;
+    const trimmed = msgVal.trim();
+    if (!trimmed)
+        return undefined;
+    return trimmed.slice(0, maxLen);
+}
+/**
+ * Build the message payload for a heartbeat-tick progress notification.
+ * Includes elapsed time and, when available, the most recently observed
+ * Renovate log `msg` so callers see *something* beyond "still running".
+ */
+export function buildDryRunHeartbeatMessage(elapsedMs, lastLogMsg) {
+    const seconds = Math.max(0, Math.round(elapsedMs / 1000));
+    return lastLogMsg
+        ? `Dry-run in progress (${seconds}s) — ${lastLogMsg}`
+        : `Dry-run in progress (${seconds}s elapsed)`;
+}

package/dist/lib/hostRulesConfig.d.ts

@@ -5,8 +5,10 @@ export type HostRule = Record<string, unknown>;
  * responsible for unlinking the file (in a `finally` block) once Renovate has
  * consumed it — we do not keep a reference here.
  *
- * Renovate merges CLI `--config-file` rules with any repo-level `hostRules`
- * (array concatenation, most-specific match wins), so callers can combine
+ * The caller points Renovate at this file via the `RENOVATE_CONFIG_FILE` env
+ * var (not a CLI flag — `--config-file` is not a real Renovate option).
+ * Renovate merges its rules with any repo-level `hostRules` via array
+ * concatenation (most-specific match wins), so callers can combine
  * per-invocation credentials with whatever the repo itself already declares.
  */
 export declare function writeHostRulesConfig(hostRules: HostRule[]): Promise<string>;

package/dist/lib/hostRulesConfig.js

@@ -8,8 +8,10 @@ import { randomUUID } from "node:crypto";
  * responsible for unlinking the file (in a `finally` block) once Renovate has
  * consumed it — we do not keep a reference here.
  *
- * Renovate merges CLI `--config-file` rules with any repo-level `hostRules`
- * (array concatenation, most-specific match wins), so callers can combine
+ * The caller points Renovate at this file via the `RENOVATE_CONFIG_FILE` env
+ * var (not a CLI flag — `--config-file` is not a real Renovate option).
+ * Renovate merges its rules with any repo-level `hostRules` via array
+ * concatenation (most-specific match wins), so callers can combine
  * per-invocation credentials with whatever the repo itself already declares.
  */
 export async function writeHostRulesConfig(hostRules) {
@@ -39,18 +41,23 @@ export function collectSecrets(hostRules) {
     }
     return [...out];
 }
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 /**
  * Replace every literal occurrence of any secret in `text` with `[REDACTED]`.
  * No-op when `secrets` is empty.
  */
 export function scrubSecrets(text, secrets) {
-    if (!secrets.length)
+    // Sort by length descending so that when one secret is a substring of
+    // another, the longer one wins the greedy regex alternation instead of
+    // being partially chewed up by the shorter one.
+    const alternatives = secrets
+        .filter((s) => s.length > 0)
+        .sort((a, b) => b.length - a.length)
+        .map(escapeRegex);
+    if (!alternatives.length)
         return text;
-    let result = text;
-    for (const secret of secrets) {
-        if (!secret)
-            continue;
-        result = result.split(secret).join("[REDACTED]");
-    }
-    return result;
+    const pattern = new RegExp(alternatives.join("|"), "g");
+    return text.replace(pattern, "[REDACTED]");
 }

package/dist/lib/presetResolver.d.ts

@@ -69,6 +69,12 @@ export interface ParsedPreset {
     subpath?: string;
     /** Optional `#ref` (branch/tag/commit) fragment. */
     ref?: string;
+    /**
+     * Set when parsing already determined the preset cannot be resolved — e.g.
+     * an unknown source prefix like `xyz>foo/bar`. `loadPresetBody` short-circuits
+     * to the unresolved list with this reason.
+     */
+    unresolvableReason?: string;
 }
 /**
  * Resolve a Renovate config by expanding every preset in `extends`. Built-in

package/dist/lib/presetResolver.js

@@ -118,6 +118,10 @@ function recordTemplateWarnings(entry, suppliedArgs, missingArgs, unknownTemplat
     }
 }
 async function loadPresetBody(parsed, ctx, unresolvedList) {
+    if (parsed.unresolvableReason) {
+        unresolvedList.push({ preset: parsed.original, reason: parsed.unresolvableReason });
+        return null;
+    }
     if (!parsed.source) {
         const preset = PRESETS[parsed.key];
         if (!preset) {
@@ -199,9 +203,15 @@ export function parsePreset(raw) {
     return { key, original, args };
 }
 function parseExternal(rest, original, args, sourceRaw) {
-    const source = (KNOWN_SOURCES.has(sourceRaw)
-        ? sourceRaw
-        : sourceRaw);
+    if (!KNOWN_SOURCES.has(sourceRaw)) {
+        return {
+            key: original,
+            original,
+            args,
+            unresolvableReason: `Unknown preset source: ${sourceRaw}`,
+        };
+    }
+    const source = sourceRaw;
     let spec = rest.slice(sourceRaw.length + 1);
     let ref;
     const hashIdx = spec.indexOf("#");

package/dist/lib/renovateCli.d.ts

@@ -8,6 +8,14 @@ export interface RunOptions {
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;
     stdin?: string;
+    /**
+     * Optional line-oriented observers. Invoked once per complete line (newline
+     * stripped) as data arrives, and once more on process close for any trailing
+     * non-empty fragment. Exceptions thrown by the callbacks are swallowed so a
+     * buggy observer can't crash the child-process pipeline.
+     */
+    onStdoutLine?: (line: string) => void;
+    onStderrLine?: (line: string) => void;
 }
 /**
  * Spawn a command and capture stdout/stderr. Never throws on non-zero exit —

package/dist/lib/renovateCli.js

@@ -13,6 +13,8 @@ export function run(cmd, args, opts = {}) {
         });
         let stdout = "";
         let stderr = "";
+        let stdoutLineBuf = "";
+        let stderrLineBuf = "";
         let timer;
         let killed = false;
         if (opts.timeoutMs) {
@@ -21,11 +23,31 @@ export function run(cmd, args, opts = {}) {
                 child.kill("SIGKILL");
             }, opts.timeoutMs);
         }
+        const emitLines = (chunk, buf, cb) => {
+            if (!cb)
+                return "";
+            const combined = buf + chunk;
+            const parts = combined.split(/\r?\n/);
+            const trailing = parts.pop() ?? "";
+            for (const line of parts) {
+                try {
+                    cb(line);
+                }
+                catch {
+                    // never let an observer crash the pipeline
+                }
+            }
+            return trailing;
+        };
         child.stdout.on("data", (d) => {
-            stdout += d.toString();
+            const chunk = d.toString();
+            stdout += chunk;
+            stdoutLineBuf = emitLines(chunk, stdoutLineBuf, opts.onStdoutLine);
         });
         child.stderr.on("data", (d) => {
-            stderr += d.toString();
+            const chunk = d.toString();
+            stderr += chunk;
+            stderrLineBuf = emitLines(chunk, stderrLineBuf, opts.onStderrLine);
         });
         child.on("error", (err) => {
             if (timer)
@@ -35,6 +57,23 @@ export function run(cmd, args, opts = {}) {
         child.on("close", (code) => {
             if (timer)
                 clearTimeout(timer);
+            // Flush trailing partial lines (output that didn't end with a newline).
+            if (stdoutLineBuf && opts.onStdoutLine) {
+                try {
+                    opts.onStdoutLine(stdoutLineBuf);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (stderrLineBuf && opts.onStderrLine) {
+                try {
+                    opts.onStderrLine(stderrLineBuf);
+                }
+                catch {
+                    // ignore
+                }
+            }
             if (killed) {
                 reject(new Error(`Command timed out after ${opts.timeoutMs}ms: ${cmd} ${args.join(" ")}`));
                 return;

package/dist/tools/dryRun.js

@@ -4,17 +4,94 @@ import { promises as fs } from "node:fs";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { run, resolveRenovateTool, formatMissingBinaryError } from "../lib/renovateCli.js";
+import { locateConfig } from "../lib/configLocations.js";
 import { detectLookupProblems } from "../lib/lookupProblems.js";
 import { collectSecrets, scrubSecrets, writeHostRulesConfig, } from "../lib/hostRulesConfig.js";
+import { extractRenovateLogMsg, buildDryRunHeartbeatMessage, } from "../lib/dryRunProgress.js";
 const hostRuleSchema = z
     .record(z.string(), z.unknown())
     .describe("A single Renovate hostRule (matchHost, hostType, username, password, token, …). Structure is not validated here — Renovate's own config loader checks it when the temp file is read.");
+/**
+ * Walk Renovate's JSON report looking for `problems` arrays and collect the
+ * ones that represent failed runs — not informational notices. Criteria:
+ *   - `level >= 40` (Renovate's bunyan-derived ERROR/FATAL bands), or
+ *   - `message === "config-validation"` (Renovate's canonical config-failure
+ *     marker — it can appear with lower levels but still means the run was
+ *     effectively a no-op), or
+ *   - the problem object has a `validationError` field (preset/extends
+ *     resolution failures carry their explanation here).
+ *
+ * The report shape isn't a stable Renovate API, so we walk defensively: any
+ * nested `problems` array anywhere in the tree is inspected.
+ */
+function collectReportErrors(report) {
+    const out = [];
+    const seen = new Set();
+    const visit = (node) => {
+        if (node === null || typeof node !== "object")
+            return;
+        if (seen.has(node))
+            return;
+        seen.add(node);
+        if (Array.isArray(node)) {
+            for (const entry of node)
+                visit(entry);
+            return;
+        }
+        const obj = node;
+        const problems = obj.problems;
+        if (Array.isArray(problems)) {
+            for (const raw of problems) {
+                if (!raw || typeof raw !== "object")
+                    continue;
+                const p = raw;
+                const level = typeof p.level === "number" ? p.level : 0;
+                const isErrorLevel = level >= 40;
+                const isConfigValidation = p.message === "config-validation";
+                const hasValidationError = typeof p.validationError === "string" && p.validationError.length > 0;
+                if (isErrorLevel || isConfigValidation || hasValidationError) {
+                    out.push(p);
+                }
+            }
+        }
+        for (const value of Object.values(obj))
+            visit(value);
+    };
+    visit(report);
+    return out;
+}
+/**
+ * Scan the repo's Renovate config for `extends` entries of the form
+ * `local>owner/repo[:preset]` and return them along with the config-file path
+ * they were found in. Returns `null` if no config is found (Renovate will
+ * handle that case itself with its usual error). Silently returns `null` on
+ * parse errors too — we don't want preflight to be stricter than Renovate's
+ * own config loader; any real problems will surface when Renovate runs.
+ */
+async function detectUnresolvableLocalPresets(repoPath) {
+    let located;
+    try {
+        located = await locateConfig(repoPath);
+    }
+    catch {
+        return null;
+    }
+    if (!located)
+        return null;
+    const extendsRaw = located.config.extends;
+    if (!Array.isArray(extendsRaw))
+        return null;
+    const presets = extendsRaw.filter((entry) => typeof entry === "string" && entry.startsWith("local>"));
+    return { relPath: located.relPath, presets };
+}
 export function registerDryRun(server) {
     server.registerTool("dry_run", {
         title: "Dry-run Renovate",
-        description: "Run Renovate in dry-run mode against a local repository to preview what it would do — no PRs opened, no git pushes. Uses --platform=local so no host token is required. Emits a structured JSON report of the updates Renovate would create.\n\nCredentials for private registries (e.g. `COMPOSER_AUTH` for Packagist/Satis proxies, `NPM_TOKEN` / `.npmrc` for npm, Docker registry creds, `RENOVATE_HOST_RULES` for anything else) must be set on the MCP server process itself — via the `env` key in `claude_desktop_config.json` / `.mcp.json`, not your shell, since the MCP server runs as a child of Claude and does not inherit shell env. Alternatively, encode credentials as `hostRules` in the Renovate config, or pass them per-call via the `hostRules` input on this tool (written to a mode-0600 temp file that is cleaned up after the run; token/password values are scrubbed from `logTail` and `problems`). Per-call `hostRules` are appended to any the repo's own config already declares. If a lookup can't auth to a registry, Renovate often reports 0 updates without a loud error; when that happens this tool surfaces detected auth failures under `problems` in the output so callers can distinguish a genuine \"no updates\" from a silent registry-auth failure.",
+        description: "Run Renovate in dry-run mode to preview what it would do — no PRs opened, no git pushes. Returns a structured JSON report plus a top-level `ok` boolean (false when the CLI failed OR the report records a validation/error-level problem, even if the exit code was 0).\n\nDefault mode runs `--platform=local` against the filesystem at `repoPath`. If your config extends `local>…` presets (or any preset hosted on a non-default GitHub/GitLab), pass `platform` (`github` or `gitlab`), `endpoint` (API base URL), `token`, and `repository` (`owner/repo`) to run as a real platform client that can actually fetch those presets — Renovate still runs with `--dry-run`, so no PRs are opened. The tool preflight-checks for `local>` presets under `--platform=local` and fails fast with remediation guidance rather than spawning a Renovate run that would fail opaquely with `config-validation`.\n\nCredentials for private registries (e.g. `COMPOSER_AUTH` for Packagist/Satis proxies, `NPM_TOKEN` / `.npmrc` for npm, Docker registry creds, `RENOVATE_HOST_RULES` for anything else) must be set on the MCP server process itself — via the `env` key in `claude_desktop_config.json` / `.mcp.json`, not your shell, since the MCP server runs as a child of Claude and does not inherit shell env. Alternatively, encode credentials as `hostRules` in the Renovate config, or pass them per-call via the `hostRules` input on this tool (written to a mode-0600 temp file that is cleaned up after the run; token/password values — including the platform `token` input — are scrubbed from `logTail` and `problems`). Per-call `hostRules` are appended to any the repo's own config already declares. If a lookup can't auth to a registry, Renovate often reports 0 updates without a loud error; when that happens this tool surfaces detected auth failures under `problems` in the output so callers can distinguish a genuine \"no updates\" from a silent registry-auth failure.",
         inputSchema: {
-            repoPath: z.string().describe("Absolute path to the repository root"),
+            repoPath: z
+                .string()
+                .describe("Absolute path to the repository root. Required for the default `platform=local` mode. When `platform` is overridden (e.g. `gitlab` / `github`), Renovate runs against the remote `repository` instead — `repoPath` is still used as the child's working directory but its manifest files are ignored."),
             dryRunMode: z
                 .enum(["extract", "lookup", "full"])
                 .default("full")
@@ -27,33 +104,143 @@ export function registerDryRun(server) {
                 .max(15 * 60_000)
                 .default(5 * 60_000)
                 .describe("Max wait time in ms (default 5 minutes, capped at 15)"),
+            platform: z
+                .enum(["local", "github", "gitlab"])
+                .optional()
+                .describe("Renovate platform to run as. Default `local` runs against the filesystem at `repoPath`. Set `github` or `gitlab` (with `endpoint` + `token` + `repository`) to run a full remote dry-run — this is what you need when your config extends `local>` presets that live on a private GitHub Enterprise / self-hosted GitLab. Still no PRs opened because `--dry-run` is always set."),
+            endpoint: z
+                .string()
+                .optional()
+                .describe("API base URL for the chosen platform (e.g. `https://gitlab.example.com/api/v4/` or `https://ghe.example.com/api/v3/`). Required with non-default GitHub/GitLab hosts. Ignored when `platform=local`."),
+            token: z
+                .string()
+                .optional()
+                .describe("Platform auth token. Scrubbed from any log output this tool returns. Ignored when `platform=local`."),
+            repository: z
+                .string()
+                .optional()
+                .describe("`owner/repo` identifier of the repository Renovate should operate on. Required when `platform` is not `local`. Ignored when `platform=local`."),
             hostRules: z
                 .array(hostRuleSchema)
                 .optional()
-                .describe("Optional per-invocation Renovate hostRules for private registry auth. Written to a mode-0600 temp file that is passed via --config-file and deleted after the run. Token/password values are scrubbed from any log output this tool returns. Appended to (not replacing) any hostRules declared in the repo's own config."),
+                .describe("Optional per-invocation Renovate hostRules for private registry auth. Written to a mode-0600 temp file that is passed via the RENOVATE_CONFIG_FILE env var and deleted after the run. Token/password values are scrubbed from any log output this tool returns. Appended to (not replacing) any hostRules declared in the repo's own config."),
         },
-    }, async ({ repoPath, dryRunMode, logLevel, timeoutMs, hostRules }) => {
+    }, async ({ repoPath, dryRunMode, logLevel, timeoutMs, platform, endpoint, token, repository, hostRules }, extra) => {
         const reportPath = path.join(tmpdir(), `renovate-mcp-report-${randomUUID()}.json`);
         const bin = resolveRenovateTool("renovate");
         const ruleList = hostRules ?? [];
+        const effectivePlatform = platform ?? "local";
+        const isRemotePlatform = effectivePlatform !== "local";
         const secrets = collectSecrets(ruleList);
+        if (token)
+            secrets.push(token);
         let hostRulesConfigPath;
+        if (isRemotePlatform && !repository) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `\`repository\` is required when \`platform\` is \`${effectivePlatform}\`. Pass the target repo as \`owner/repo\`, or unset \`platform\` to run against the local filesystem at \`repoPath\`.`,
+                    },
+                ],
+            };
+        }
+        // Preflight: if the repo's config extends any `local>…` preset and we're
+        // about to run with `--platform=local`, Renovate will fail opaquely with
+        // a generic "config-validation" error, because `local>` has no platform
+        // context to resolve against in local mode. Detect this up front and
+        // return an actionable message instead of spawning Renovate.
+        if (!isRemotePlatform) {
+            const unresolvable = await detectUnresolvableLocalPresets(repoPath);
+            if (unresolvable && unresolvable.presets.length > 0) {
+                const sample = unresolvable.presets.slice(0, 3).join(", ");
+                const more = unresolvable.presets.length > 3
+                    ? ` (+${unresolvable.presets.length - 3} more)`
+                    : "";
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: `\`${unresolvable.relPath}\` extends \`local>\` presets (${sample}${more}) that cannot be resolved under \`--platform=local\` — Renovate has no platform context to expand them against, so the run would fail with an opaque \`config-validation\` error.\n\n` +
+                                `To fix: pass \`platform\` (e.g. \`gitlab\` or \`github\`), \`endpoint\`, \`token\`, and \`repository\` so Renovate runs as a real platform client and can fetch the preset. Alternatively, rewrite the \`extends\` entries from \`local>…\` to \`gitlab>…\` / \`github>…\` in your config.`,
+                        },
+                    ],
+                };
+            }
+        }
+        // Hybrid progress reporter: a heartbeat tick every HEARTBEAT_MS keeps
+        // MCP clients informed during long runs, and each tick enriches its
+        // message with the latest Renovate JSON-log `msg` we saw (best-effort —
+        // we don't couple tightly to Renovate's log schema). Skips all work if
+        // the caller didn't supply a progressToken.
+        const progressToken = extra?._meta?.progressToken;
+        const sendNotification = extra?.sendNotification;
+        const progressEnabled = progressToken !== undefined && typeof sendNotification === "function";
+        const HEARTBEAT_MS = 5_000;
+        const startedAt = Date.now();
+        let progressCounter = 0;
+        let lastLogMsg;
+        let heartbeat;
+        const emit = (message) => {
+            if (!progressEnabled)
+                return;
+            progressCounter += 1;
+            void sendNotification({
+                method: "notifications/progress",
+                params: {
+                    progressToken,
+                    progress: progressCounter,
+                    message: scrubSecrets(message, secrets),
+                },
+            }).catch(() => undefined);
+        };
         try {
             const args = [
-                "--platform=local",
+                `--platform=${effectivePlatform}`,
                 `--dry-run=${dryRunMode}`,
                 "--report-type=file",
                 `--report-path=${reportPath}`,
             ];
+            const childEnv = {
+                LOG_LEVEL: logLevel,
+                LOG_FORMAT: "json",
+            };
+            if (isRemotePlatform) {
+                if (endpoint)
+                    args.push(`--endpoint=${endpoint}`);
+                args.push(`--repository=${repository}`);
+                if (token)
+                    childEnv.RENOVATE_TOKEN = token;
+            }
             if (ruleList.length > 0) {
                 hostRulesConfigPath = await writeHostRulesConfig(ruleList);
-                args.push(`--config-file=${hostRulesConfigPath}`);
+                // Renovate reads this config file via the RENOVATE_CONFIG_FILE env
+                // var, not a CLI flag — `--config-file` is not a real Renovate flag
+                // and passing it crashes the CLI with "unknown option".
+                childEnv.RENOVATE_CONFIG_FILE = hostRulesConfigPath;
+            }
+            if (progressEnabled) {
+                emit(`Starting Renovate dry-run (${dryRunMode})`);
+                heartbeat = setInterval(() => emit(buildDryRunHeartbeatMessage(Date.now() - startedAt, lastLogMsg)), HEARTBEAT_MS);
             }
             const result = await run(bin, args, {
                 cwd: repoPath,
-                env: { LOG_LEVEL: logLevel, LOG_FORMAT: "json" },
+                env: childEnv,
                 timeoutMs,
+                onStdoutLine: progressEnabled
+                    ? (line) => {
+                        const msg = extractRenovateLogMsg(line);
+                        if (msg)
+                            lastLogMsg = msg;
+                    }
+                    : undefined,
             });
+            if (heartbeat) {
+                clearInterval(heartbeat);
+                heartbeat = undefined;
+            }
             let report = null;
             try {
                 const raw = await fs.readFile(reportPath, "utf8");
@@ -62,7 +249,15 @@ export function registerDryRun(server) {
             catch {
                 // no report produced (e.g., renovate errored before writing)
             }
+            const reportErrors = collectReportErrors(report);
             const summary = {
+                // `ok` collapses the three failure modes (spawn error, non-zero
+                // exit, in-report validation/error-level problems) into a single
+                // field so callers don't need to know which one fired. Renovate
+                // frequently writes a report with exitCode=0 while its `problems`
+                // array records a validation/config failure — judging only by
+                // exitCode hides those runs.
+                ok: result.exitCode === 0 && reportErrors.length === 0,
                 exitCode: result.exitCode,
                 hasReport: report !== null,
                 report,
@@ -73,6 +268,9 @@ export function registerDryRun(server) {
             if (problems.length > 0) {
                 summary.problems = problems;
             }
+            if (reportErrors.length > 0) {
+                summary.reportErrors = reportErrors;
+            }
             // 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) {
@@ -83,6 +281,11 @@ export function registerDryRun(server) {
                     .join("\n");
                 summary.logTail = tail;
             }
+            if (progressEnabled) {
+                emit(report
+                    ? `Dry-run complete (exit ${result.exitCode})`
+                    : `Dry-run finished without a report (exit ${result.exitCode})`);
+            }
             return {
                 content: [
                     {
@@ -90,7 +293,7 @@ export function registerDryRun(server) {
                         text: JSON.stringify(summary, null, 2),
                     },
                 ],
-                isError: result.exitCode !== 0,
+                isError: !summary.ok,
             };
         }
         catch (err) {
@@ -105,6 +308,8 @@ export function registerDryRun(server) {
             };
         }
         finally {
+            if (heartbeat)
+                clearInterval(heartbeat);
             await fs.unlink(reportPath).catch(() => undefined);
             if (hostRulesConfigPath) {
                 await fs.unlink(hostRulesConfigPath).catch(() => undefined);

package/dist/tools/previewCustomManager.js

@@ -35,13 +35,20 @@ export function registerPreviewCustomManager(server) {
         inputSchema: {
             repoPath: z.string().describe("Absolute path to the repository root"),
             manager: managerSchema.describe("A single Renovate customManagers entry. NOTE: `fileMatch` is an array of REGEX strings matched against POSIX-style relative paths (not globs)."),
-            maxFilesScanned: z
+            maxFilesWalked: z
                 .number()
                 .int()
                 .positive()
                 .max(100_000)
                 .optional()
-                .describe("Safety cap on files walked (default 2000)"),
+                .describe("Safety cap on files visited during the directory walk before any fileMatch testing (default 2000). Raise this when the repo is large; prefer narrowing via `.gitignore` first."),
+            maxFilesMatched: z
+                .number()
+                .int()
+                .positive()
+                .max(100_000)
+                .optional()
+                .describe("Safety cap on the number of files included in the result after fileMatch is applied (default 500). Raise this only if the fileMatch regex is intentionally broad."),
             maxHitsPerFile: z
                 .number()
                 .int()
@@ -49,8 +56,22 @@ export function registerPreviewCustomManager(server) {
                 .max(10_000)
                 .optional()
                 .describe("Safety cap on matches per file (default 100)"),
+            matchTimeoutMs: z
+                .number()
+                .int()
+                .positive()
+                .max(60_000)
+                .optional()
+                .describe("Wall-clock budget per regex operation, in milliseconds (default 2000). User-supplied patterns run in a worker thread so catastrophic backtracking can't pin the server; this cap decides how long we wait before aborting a single pattern and emitting a warning."),
+            maxFileBytes: z
+                .number()
+                .int()
+                .positive()
+                .max(1024 * 1024 * 1024)
+                .optional()
+                .describe("Per-file size cap in bytes (default 5242880 = 5 MiB). Files whose size exceeds this are skipped with a warning instead of being read into memory — protects against OOM when fileMatch catches a lockfile, generated artifact, or other oversized file."),
         },
-    }, async ({ repoPath, manager, maxFilesScanned, maxHitsPerFile }) => {
+    }, async ({ repoPath, manager, maxFilesWalked, maxFilesMatched, maxHitsPerFile, matchTimeoutMs, maxFileBytes, }) => {
         if (manager.customType !== "regex") {
             return {
                 isError: true,
@@ -64,8 +85,11 @@ export function registerPreviewCustomManager(server) {
         }
         try {
             const result = await previewCustomManager(repoPath, manager, {
-                maxFilesScanned,
+                maxFilesWalked,
+                maxFilesMatched,
                 maxHitsPerFile,
+                matchTimeoutMs,
+                maxFileBytes,
             });
             return {
                 content: [

package/dist/tools/writeConfig.js

@@ -58,52 +58,58 @@ export function registerWriteConfig(server) {
         const tmp = `${target}.renovate-mcp-tmp`;
         await fs.mkdir(path.dirname(target), { recursive: true });
         await fs.writeFile(tmp, payload);
-        let valid = false;
-        let validationOutput = "";
-        let validatorMissing = false;
         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;
-        }
-        catch (err) {
-            validatorMissing = true;
-            validationOutput = formatMissingBinaryError("renovate-config-validator", err);
-        }
-        if (!valid && !force) {
-            await fs.unlink(tmp).catch(() => undefined);
+            let valid = false;
+            let validationOutput = "";
+            let validatorMissing = false;
+            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;
+            }
+            catch (err) {
+                validatorMissing = true;
+                validationOutput = formatMissingBinaryError("renovate-config-validator", err);
+            }
+            if (!valid && !force) {
+                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),
+                        },
+                    ],
+                };
+            }
+            await fs.rename(tmp, target);
             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.",
+                            wrote: true,
+                            path: rel,
+                            bytes: payload.length,
+                            valid,
+                            validationOutput: valid ? undefined : validationOutput,
                         }, null, 2),
                     },
                 ],
             };
         }
-        await fs.rename(tmp, target);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        wrote: true,
-                        path: rel,
-                        bytes: payload.length,
-                        valid,
-                        validationOutput: valid ? undefined : validationOutput,
-                    }, null, 2),
-                },
-            ],
-        };
+        finally {
+            // No-op when rename already moved tmp (ENOENT); otherwise cleans up on
+            // validation failure or a mid-flight rename error (see #57).
+            await fs.unlink(tmp).catch(() => undefined);
+        }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "renovate-mcp",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "MCP server for designing Renovate configurations interactively.",
   "type": "module",
   "bin": {
@@ -20,6 +20,8 @@
     "pretest": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
+    "pretest:coverage": "npm run build",
+    "test:coverage": "vitest run --coverage",
     "generate:presets": "node scripts/generate-presets.mjs",
     "prepack": "npm run build && chmod +x dist/index.js"
   },
@@ -56,6 +58,7 @@
   },
   "devDependencies": {
     "@types/node": "^24.0.0",
+    "@vitest/coverage-v8": "^4.1.0",
     "renovate": "^43.139.5",
     "typescript": "^6.0.0",
     "vitest": "^4.1.0"