leakcanary-mcp-fix 1.0.2

package/CLAUDE.md

@@ -0,0 +1,111 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+LeakCanary MCP Server is a Kotlin/JVM MCP (Model Context Protocol) server that automates Android memory leak detection. It reads LeakCanary output from `adb logcat` (primary) or the app's stored LeakCanary database (fallback), parses leak traces, classifies root causes, assigns priority, suggests fixes, and tracks leak history. Communication with AI clients (Cursor, VS Code, Android Studio) is via STDIO JSON-RPC.
+
+## Build & Run Commands
+
+```bash
+# Build the fat JAR (includes all dependencies)
+./gradlew shadowJar
+# Output: build/libs/leakcanary-mcp-server-all.jar
+
+# Run the server directly
+java -jar build/libs/leakcanary-mcp-server-all.jar
+
+# Build only (compile check)
+./gradlew build
+
+# Clean build
+./gradlew clean shadowJar
+```
+
+There are no tests in this project currently.
+
+## Architecture
+
+**Entry point:** `Main.kt` creates a `Server`, registers 12 tools, and starts a `StdioServerTransport`.
+
+**Source root:** `src/main/kotlin/com/leakcanary/mcp/`
+
+**Data flow:** ADB (logcat or app storage) -> Parser -> Analyzer -> Tool response (JSON)
+
+### Key Layers
+
+- **`adb/AdbExecutor`** — Singleton that shells out to `adb` via `ProcessBuilder`. Auto-resolves adb path from `ANDROID_HOME`, `ANDROID_SDK_ROOT`, common SDK locations, or PATH. Provides `captureLeakLogs()`, `captureFullLogs()`, `listDevices()`, `clearLogcat()`, and `runShellCommand()`.
+
+- **`adb/AppStorageReader`** — Reads LeakCanary's persisted leak data directly from the app's internal SQLite database (`databases/leaks.db` or `databases/leakcanary`). Pulls the DB to the host via `adb shell run-as <package> cat databases/<db>`. Primary method: deserializes the `HeapAnalysisSuccess` Java objects stored as BLOBs in the `heap_analysis.object` column using shark library — this provides full reference chains, retained sizes, leak status per node, GC roots, and heap metadata. Falls back to SQL-based queries if BLOB deserialization fails. Also provides `discoverLeakCanaryApps()` to scan all third-party packages for LeakCanary databases. Returns `StoredLeakResult` with traces and optional `HeapSummary`. Requires debuggable app.
+
+- **`parser/LeakTraceParser`** — State-machine parser for LeakCanary's ASCII box-drawing format (unicode chars: `┬───`, `├─`, `│ ↓`, `╰→`). Extracts `LeakTrace` objects with signature, GC root, reference chain nodes, retained size, and leak status.
+
+- **`parser/HeapSummaryParser`** — Parses the METADATA section from logcat for heap stats (class count, instance count, bitmap info, device info).
+
+- **`analyzer/LeakAnalyzer`** — Classifies leaks by pattern (SINGLETON_LEAK, LISTENER_LEAK, CONTEXT_LEAK, LIBRARY_LEAK, VIEWMODEL_LEAK, HANDLER_LEAK) using heuristics on the reference chain text. Assigns priority: P0 (>20MB), P1 (>5MB), P2 (rest).
+
+- **`analyzer/FixSuggester`** — Generates classification-specific fix suggestions (e.g., singleton -> use applicationContext, listener -> unregister in onDestroy).
+
+- **`history/LeakHistoryStore`** — Persists leak records to `~/.leakcanary-mcp/history.json`. Tracks first/last seen timestamps and occurrence count per signature.
+
+- **`tools/*`** — Each file registers one MCP tool on the `Server` via extension function `Server.register*Tool()`. 12 tools total: `detect_leaks`, `list_leaks`, `search_leak`, `get_heap_summary`, `get_leak_history`, `analyze_leak`, `suggest_fixes`, `clear_leaks`, `list_devices`, `leak_diff`, `get_device_memory`, `export_report`.
+
+- **`tools/LeakSource.kt`** — Three-tier fetch strategy used by most tools. Tries logcat first; if empty and `package_name` provided, reads from app storage; if empty and no `package_name`, auto-discovers LeakCanary apps on the device. Returns a `LeakFetchResult` with the data source indicator and any discovered apps.
+
+- **`tools/PackageFilter.kt`** — Multi-app support utilities. Extracts app package names from leak traces, detects when multiple apps have leaks, filters traces by package, and builds a user-facing prompt listing detected apps. `filterByPackageIfNeeded()` skips filtering when data comes from app storage (since class names are simple, not fully qualified).
+
+- **`tools/DeduplicateLeaks.kt`** — Groups duplicate leak traces by signature, keeps the richest trace as representative, and tracks occurrence count within a single scan.
+
+- **`model/*`** — `@Serializable` data classes: `LeakTrace`, `LeakNode`, `LeakStatus`, `HeapSummary`, `LeakReport`, `LeakSummary`, `LeakHistoryEntry`.
+
+### Adding a New MCP Tool
+
+1. Create `tools/NewTool.kt` with a `Server.registerNewTool()` extension function
+2. Use `addTool(name, description, inputSchema) { request -> ... }` to define the tool
+3. Register it in `Main.kt` by calling `server.registerNewTool()`
+4. Use `fetchLeakTraces()` from `LeakSource.kt` for the two-tier data strategy
+5. Use `deduplicateTraces()` if the tool lists multiple leaks
+
+### Database-First Data Strategy
+
+Tools use `fetchLeakTraces()` from `LeakSource.kt` which:
+
+1. **App database (primary):** `AppStorageReader.readStoredLeaks()` — pulls the app's LeakCanary SQLite DB to the host and deserializes `HeapAnalysisSuccess` BLOBs via shark library. Provides full reference chains, retained sizes, leak status per node, GC roots, heap metadata. Returns `StoredLeakResult` with traces and `HeapSummary`.
+2. **Logcat (fallback):** `AdbExecutor.captureLeakLogs()` — used when DB is not accessible (app not debuggable, package unknown)
+3. **Auto-discovery:** `AppStorageReader.discoverLeakCanaryApps()` — scans all third-party packages when no `package_name` is provided. If one app is found, reads its leaks directly. If multiple are found, returns `discoveredApps` so the tool can prompt the user to choose.
+
+The BLOB deserialization falls back to SQL-based queries (limited data, no reference chains) if deserialization fails, and then to logcat. Responses include a `[Data source: ...]` note when data comes from app storage.
+
+### Multi-App Support
+
+When a device has multiple LeakCanary-enabled apps, `adb logcat -s LeakCanary` returns leaks from all apps mixed together. The server handles this via `tools/PackageFilter.kt`:
+
+- **Detection:** `detectAppPackages()` extracts unique app packages from leaking class names.
+- **Prompting:** If multiple packages found and no `package_name` provided, `buildMultiAppPrompt()` lists detected apps.
+- **Filtering:** `filterByPackage()` keeps only traces matching the given package.
+- **Scope:** 8 of 12 tools support this: `detect_leaks`, `list_leaks`, `search_leak`, `analyze_leak`, `suggest_fixes`, `leak_diff`, `export_report`, and indirectly `get_device_memory` (requires `package_name`).
+
+### Important Constraints
+
+- **No stdout for debugging.** The server uses STDIO transport (stdin/stdout for JSON-RPC). Any `println()` or `System.out` usage will corrupt the MCP protocol. Use `System.err` for debug logging if needed.
+- **All model classes must be `@Serializable`** (kotlinx-serialization). The `@Serializable` annotation and `kotlinx.serialization.json.Json` are used throughout for encoding tool responses.
+- **ADB must be available** at runtime. The server resolves the `adb` binary path lazily on first use and caches it.
+- **App storage fallback requires debuggable apps.** `run-as` only works on debug builds. Release builds cannot be read this way.
+- **App storage class names are simple, not fully qualified.** When reading from the LeakCanary database, `class_simple_name` is used (e.g., `HomeActivity` not `com.myapp.ui.HomeActivity`). Package filtering must be skipped for app storage data — this is handled by `filterByPackageIfNeeded()` in `PackageFilter.kt`.
+
+## Tech Stack
+
+- Kotlin 2.2 / JVM 17
+- Gradle Kotlin DSL with Shadow plugin (fat JAR)
+- MCP Kotlin SDK 0.8.3 (`io.modelcontextprotocol:kotlin-sdk`)
+- shark 2.14 (`com.squareup.leakcanary:shark`) for BLOB deserialization
+- kotlinx-serialization-json for all JSON encoding
+- Ktor server (CIO) as transitive dependency of MCP SDK
+- STDIO transport (stdin/stdout JSON-RPC)
+
+## Prerequisites
+
+- Java 17+
+- `adb` installed (Android SDK Platform-Tools)
+- Connected Android device/emulator with LeakCanary in the debug build

package/README.md

@@ -0,0 +1,239 @@
+# LeakCanary MCP Server
+
+A standalone **Kotlin/JVM MCP server** that automates Android memory leak detection using [LeakCanary](https://square.github.io/leakcanary/) and `adb logcat`. It parses leak traces, classifies root causes, assigns priority levels, suggests fixes, and tracks leak history across sessions -- all exposed as MCP tools for use in **Cursor**, **VS Code**, and **Android Studio**.
+
+---
+
+## Prerequisites
+
+- **Java 17+** installed and available on PATH
+- **adb** installed (Android SDK Platform-Tools) -- the server auto-detects `adb` from `ANDROID_HOME`, `ANDROID_SDK_ROOT`, or common SDK install locations
+- An Android device or emulator connected via USB/WiFi with **LeakCanary** integrated in the debug build
+
+---
+
+**Repository Link**: [https://github.com/ravisharma46/Leak-Canary-Mcp-Server.git](https://github.com/ravisharma46/Leak-Canary-Mcp-Server.git)
+
+## Quick Install (Recommended)
+
+The fastest and most universally compatible way to use the MCP server across **Windows, macOS, and Linux**. It requires zero path configuration.
+
+Add this directly to your **`~/.cursor/mcp.json`**:
+
+```json
+{
+  "mcpServers": {
+    "leakcanary": {
+      "command": "npx",
+      "args": ["-y", "leakcanary-mcp-fix"]
+    }
+  }
+}
+```
+
+Restart Cursor and the 12 tools will appear in the MCP tools panel.
+
+---
+
+## Setup in VS Code
+
+Make sure you have [GitHub Copilot](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot) extension installed with **Agent mode** enabled (VS Code 1.99+).
+
+**Option A — Workspace level** (`.vscode/mcp.json` in your project root):
+
+```json
+{
+  "servers": {
+    "leakcanary": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "leakcanary-mcp-fix"]
+    }
+  }
+}
+```
+
+**Option B — User level** (VS Code `settings.json`):
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "leakcanary": {
+        "type": "stdio",
+        "command": "npx",
+        "args": ["-y", "leakcanary-mcp-fix"]
+      }
+    }
+  }
+}
+```
+
+Open **Copilot Chat → Agent mode** and the LeakCanary tools will be available.
+
+---
+
+## Setup in Android Studio
+
+Android Studio supports MCP servers through the **Gemini** plugin (Android Studio Meerkat 2024.3+ or later).
+
+1. Open **Settings → Tools → AI Assistant → MCP Servers**
+2. Click **+ Add** and configure:
+
+```json
+{
+  "mcpServers": {
+    "leakcanary": {
+      "command": "npx",
+      "args": ["-y", "leakcanary-mcp-fix"]
+    }
+  }
+}
+```
+
+Alternatively, add a `mcp.json` file in the `.idea` folder of your project:
+
+```json
+{
+  "mcpServers": {
+    "leakcanary": {
+      "command": "npx",
+      "args": ["-y", "leakcanary-mcp-fix"]
+    }
+  }
+}
+```
+
+Restart Android Studio and the tools will appear under **Gemini → MCP Tools**.
+
+> **Note:** All setups use `npx` to dynamically execute the wrapper. The wrapper auto-downloads and updates the server JAR for you on each run.
+
+---
+
+## Database-First Data Strategy
+
+The server reads leak data **directly from the app's LeakCanary SQLite database** as the primary source, not from `adb logcat`. This means leak data is always available -- even after reboots, logcat buffer clears, or the next day.
+
+### How it works
+
+1. **Primary: App Database (BLOB deserialization)** -- Pulls the app's `leaks.db` to the host and deserializes the `HeapAnalysisSuccess` Java objects stored as BLOBs using the [shark](https://github.com/square/leakcanary/tree/main/shark) library. This provides the **full analysis** -- complete reference chains, retained sizes, leak status per node, GC roots, heap metadata, and device info. Identical quality to what you see in the LeakCanary app.
+2. **Fallback: Logcat** -- If the database isn't accessible (app not debuggable, not installed, etc.), falls back to reading `adb logcat -s LeakCanary`.
+3. **Auto-Discovery** -- When **no `package_name` is provided**, the server automatically scans all installed apps on the device to find ones with a LeakCanary database. If multiple apps are found, it prompts you to choose. If only one app is found, it reads leaks directly.
+
+This means you can just say **"list all leaks"** without knowing any package names -- the server will find your LeakCanary-enabled apps and show you what's available.
+
+---
+
+## MCP Tools (12 total)
+
+### Leak Detection & Analysis
+
+| Tool | Description |
+|------|-------------|
+| `detect_leaks` | Capture LeakCanary logs, parse all leak traces, classify/prioritize, and return a full structured report. Falls back to app storage when logcat is empty. |
+| `list_leaks` | List all detected leaks in a deduplicated compact summary with occurrence counts. Falls back to app storage when logcat is empty. |
+| `search_leak` | Search for leaks by class name or keyword (e.g. "SearchHistoryManager"). Falls back to app storage when logcat is empty. |
+| `analyze_leak` | Deep-dive a specific leak by its signature hash -- full reference chain, root cause, severity. Falls back to app storage when logcat is empty. |
+| `suggest_fixes` | Generate actionable fix steps for a leak based on its pattern (singleton, listener, context, etc.). Falls back to app storage when logcat is empty. |
+
+### Memory & Device Info
+
+| Tool | Description |
+|------|-------------|
+| `get_heap_summary` | Extract heap-level statistics (class count, instance count, heap size, bitmap stats, device info) |
+| `get_device_memory` | Get live memory stats for an app (PSS, Java Heap, Native Heap, Code, Stack, Graphics) via `dumpsys meminfo` |
+| `list_devices` | List all connected Android devices and emulators with their connection state |
+
+### History, Diff & Reporting
+
+| Tool | Description |
+|------|-------------|
+| `get_leak_history` | Query persisted leak records across sessions with optional filters (signature, date, limit) |
+| `leak_diff` | Compare current leaks against previous scans -- shows NEW, RECURRING, and RESOLVED leaks |
+| `export_report` | Generate a shareable Markdown leak report with priority summary, reference chains, and history |
+| `clear_leaks` | Clear the logcat buffer so the next scan only shows newly detected leaks |
+
+---
+
+## Usage Examples
+
+Once the MCP server is active, you can ask the AI agent in natural language:
+
+- **"Detect memory leaks on my connected device"** -- runs `detect_leaks`, returns a full prioritized report
+- **"List all memory leaks"** -- runs `list_leaks`, returns a deduplicated summary with occurrence counts
+- **"Check memory leak in SearchHistoryManager"** -- runs `search_leak`, filters leaks matching the class name
+- **"Show me the heap summary"** -- runs `get_heap_summary`, returns heap stats
+- **"How much memory is my app using?"** -- runs `get_device_memory`, returns live PSS/heap stats
+- **"Analyze the leak with signature 42ac34ed..."** -- runs `analyze_leak`, returns a deep-dive of that specific leak
+- **"How do I fix the leak with signature 48c887..."** -- runs `suggest_fixes`, returns actionable fix steps
+- **"Show me leak history from the last week"** -- runs `get_leak_history` with a date filter
+- **"What leaks are new since last scan?"** -- runs `leak_diff`, shows new/recurring/resolved leaks
+- **"Export a leak report"** -- runs `export_report`, generates a Markdown file for sharing
+- **"Clear leaks and start fresh"** -- runs `clear_leaks`, resets the logcat buffer
+- **"What devices are connected?"** -- runs `list_devices`, shows all adb devices
+
+### Auto-discovery & multi-app support
+
+When you ask for leaks **without specifying an app**, the server automatically discovers all debuggable apps on the device that have a LeakCanary database:
+
+```
+No LeakCanary output found in logcat, but I found apps with LeakCanary
+databases on the device.
+
+Please specify which app to analyze by providing the 'package_name' parameter:
+  1. com.myapp.debug (15 leaks)
+  2. com.otherapp.debug (2 leaks)
+  3. com.myapp.man.preprod (2 leaks)
+
+Example: use package_name="com.myapp.debug" to see its leaks.
+```
+
+You can then specify the app:
+- **"List leaks for com.myapp.debug"** -- reads stored leaks from that app's database
+- **"Detect leaks for com.otherapp.debug"** -- analyzes leaks for the other app
+
+If only **one** app has LeakCanary on the device, the server skips the prompt and shows leaks directly -- no extra parameters needed.
+
+### Persistent leak reading
+
+The logcat buffer clears over time (reboot, buffer rotation, next day). The server handles this transparently:
+
+- **With `package_name`:** Reads leaks directly from the app's LeakCanary SQLite database
+- **Without `package_name`:** Auto-discovers apps with LeakCanary and prompts you to choose
+
+The database is pulled to the host and queried locally with `sqlite3`, so it works even on devices that don't have `sqlite3` installed. Requires the app to be a debug build (for `run-as` access).
+
+### Multi-device support
+
+If you have multiple devices connected, pass the `device_id` parameter:
+- **"Detect leaks on device emulator-5554"** -- the tool will use `adb -s emulator-5554`
+- **"What devices are connected?"** -- runs `list_devices` to see all available device IDs
+
+---
+
+## Tech Stack
+
+| Component | Technology |
+|-----------|-----------|
+| Language | Kotlin 2.2 / JVM 17 |
+| MCP SDK | [io.modelcontextprotocol:kotlin-sdk:0.8.3](https://github.com/modelcontextprotocol/kotlin-sdk) |
+| Leak Analysis | [shark:2.14](https://github.com/square/leakcanary/tree/main/shark) (LeakCanary's heap analysis library) |
+| Serialization | kotlinx-serialization-json |
+| Transport | STDIO (stdin/stdout JSON-RPC) |
+| Build | Gradle Kotlin DSL + Shadow plugin (fat JAR) |
+| History storage | Local JSON file (`~/.leakcanary-mcp/history.json`) |
+| Report export | Markdown files (`~/.leakcanary-mcp/reports/`) |
+
+---
+
+## License
+
+This project is for internal use at Todo App.
+
+---
+
+## Author
+
+Developed by **Ravi Kumar**
+
+🙏 If you like LeakCanary MCP Server you can show support by starring ⭐ this repository.

package/RELEASE.md

@@ -0,0 +1,48 @@
+# Release Instructions
+
+How to publish a new version of the LeakCanary MCP Server. Developers using the launcher script will auto-update on their next run.
+
+---
+
+## 1. Build the fat JAR
+
+```bash
+./gradlew shadowJar
+```
+
+This produces:
+```
+build/libs/leakcanary-mcp-server-all.jar
+```
+
+## 2. Create a GitHub release
+
+Choose a semantic version tag (e.g. `v1.0.0`, `v1.1.0`, `v2.0.0`):
+
+```bash
+gh release create vX.X.X \
+  --repo ravisharma46/Leak-Canary-Mcp-Server \
+  --title "vX.X.X" \
+  --notes "Release notes here" \
+  build/libs/leakcanary-mcp-server-all.jar
+```
+
+This creates the release and uploads the JAR as a release asset in one step.
+
+## 3. Publish to NPM (Optional but Recommended)
+
+For users to get the latest version via the `npx` wrapper, update the `package.json` version to match your new GitHub release, then publish to NPM:
+
+```bash
+# Update version in package.json
+npm version patch # or minor, or major
+
+# Publish to NPM registry
+npm publish --access public
+```
+
+---
+
+## How auto-update works
+
+The Node.js wrapper (`bin/index.js` published to NPM) polls the GitHub releases API on each run. If the GitHub tag has changed since the last download, it pulls the new JAR automatically entirely independently from NPM versioning. (Meaning even if you don't publish to NPM, the wrapper evaluates the latest GitHub release anyway).

package/bin/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+const https = require('https');
+
+const REPO = "ravisharma46/Leak-Canary-Mcp-Server";
+const ASSET_NAME = "leakcanary-mcp-server-all.jar";
+const INSTALL_DIR = path.join(os.homedir(), '.leakcanary-mcp');
+const JAR_PATH = path.join(INSTALL_DIR, 'server.jar');
+const VERSION_FILE = path.join(INSTALL_DIR, 'version');
+
+// Helpers for logging specifically to stderr, to keep stdout entirely clean for JSON-RPC MCP
+function logError(msg) { console.error(`\x1b[31mERROR: ${msg}\x1b[0m`); }
+function logWarn(msg)  { console.error(`\x1b[33mWARN:  ${msg}\x1b[0m`); }
+function logInfo(msg)  { console.error(`\x1b[32mINFO:  ${msg}\x1b[0m`); }
+
+// 1. Initial Checks
+try {
+    execSync('java -version', { stdio: 'ignore' });
+} catch (e) {
+    logError("Java not found. Please install Java 17+ to use this MCP server.");
+    process.exit(1);
+}
+
+try {
+    execSync('adb version', { stdio: 'ignore' });
+} catch (e) {
+    logWarn("adb not found. Leak detection requires a connected Android device with adb.");
+}
+
+if (!fs.existsSync(INSTALL_DIR)) {
+    fs.mkdirSync(INSTALL_DIR, { recursive: true });
+}
+
+// 2. Fetch and Download Engine
+function fetchJson(url) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'NodeJS LeakCanary-MCP Installer' } }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return resolve(fetchJson(res.headers.location));
+            }
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => resolve(JSON.parse(data)));
+        });
+        req.on('error', reject);
+    });
+}
+
+function downloadToFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: { 'User-Agent': 'NodeJS LeakCanary-MCP Installer', 'Accept': 'application/octet-stream' } }, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                return resolve(downloadToFile(res.headers.location, dest)); // follow redirect
+            }
+            if (res.statusCode !== 200) {
+                return reject(new Error(`Download failed with status ${res.statusCode}`));
+            }
+            const file = fs.createWriteStream(dest);
+            res.pipe(file);
+            file.on('finish', () => { file.close(resolve); });
+        });
+        req.on('error', reject);
+    });
+}
+
+async function downloadBinary() {
+    try {
+        const release = await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
+        if (!release.tag_name) throw new Error("Could not fetch latest release format.");
+        
+        const latestVersion = release.tag_name;
+        
+        let currentVersion = "";
+        if (fs.existsSync(VERSION_FILE)) {
+            currentVersion = fs.readFileSync(VERSION_FILE, 'utf8').trim();
+        }
+        
+        if (currentVersion !== latestVersion || !fs.existsSync(JAR_PATH)) {
+            logInfo(currentVersion ? `Updating from ${currentVersion} to ${latestVersion} ...` : `First run — downloading LeakCanary MCP Server ${latestVersion} ...`);
+            
+            const asset = release.assets.find(a => a.name === ASSET_NAME);
+            if (!asset) throw new Error(`Could not find ${ASSET_NAME} in release ${latestVersion}`);
+            
+            logInfo(`Downloading ${ASSET_NAME} ...`);
+            
+            const tempFile = path.join(INSTALL_DIR, `temp-${ASSET_NAME}`);
+            await downloadToFile(asset.browser_download_url, tempFile);
+            
+            // Atomically replace JAR
+            fs.renameSync(tempFile, JAR_PATH);
+            fs.writeFileSync(VERSION_FILE, latestVersion);
+            logInfo(`Downloaded ${latestVersion} successfully.`);
+        }
+    } catch (err) {
+        if (!fs.existsSync(JAR_PATH)) {
+            logError(`Failed to fetch and no cached JAR exists. ${err.message}`);
+            process.exit(1);
+        } else {
+            // It's perfectly fine if offline or ratelimited, just use the cached fallback
+            logWarn(`Update check failed. Using cached JAR. (${err.message})`);
+        }
+    }
+}
+
+async function startServer() {
+    await downloadBinary();
+    logInfo("LeakCanary MCP ready! Starting JSON-RPC transport...");
+    
+    // Spawn the loaded jar, inheriting only the necessary streams
+    const child = spawn('java', ['-jar', JAR_PATH], { 
+        stdio: 'inherit',
+        env: process.env
+    });
+    
+    child.on('error', (err) => {
+        logError(`Failed to start Java process: ${err.message}`);
+        process.exit(1);
+    });
+    child.on('exit', (code) => {
+         process.exit(code || 0);
+    });
+}
+
+startServer();

package/build.gradle.kts

@@ -0,0 +1,39 @@
+plugins {
+    kotlin("jvm") version "2.2.0"
+    kotlin("plugin.serialization") version "2.2.0"
+    id("com.gradleup.shadow") version "9.0.0-beta4"
+    application
+}
+
+group = "com.leakcanary.mcp"
+version = "1.0.0"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation("io.modelcontextprotocol:kotlin-sdk:0.12.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
+    implementation("io.ktor:ktor-server-core:3.0.3")
+    implementation("io.ktor:ktor-server-cio:3.0.3")
+    implementation("org.slf4j:slf4j-nop:2.0.16")
+    // LeakCanary's shark library for deserializing heap analysis BLOBs from the app's database
+    implementation("com.squareup.leakcanary:shark:2.14")
+}
+
+application {
+    mainClass.set("com.leakcanary.mcp.MainKt")
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+tasks.shadowJar {
+    archiveBaseName.set("leakcanary-mcp-server")
+    archiveClassifier.set("all")
+    archiveVersion.set("")
+    mergeServiceFiles()
+}

package/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.11.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/gradle.properties

@@ -0,0 +1,2 @@
+kotlin.code.style=official
+org.gradle.jvmargs=-Xmx1024m