letfixit 0.1.0

package/.env.example

@@ -0,0 +1,33 @@
+# ── Cloud AI fallback keys (optional — Nemotron runs locally by default) ──────
+# Get a free Groq key at console.groq.com — fastest cloud fallback
+GROQ_API_KEY=
+GEMINI_API_KEY=
+CLAUDE_API_KEY=
+
+# ── Local AI ───────────────────────────────────────────────────────────────────
+ENABLE_LOCAL_AI=true
+LOCAL_AI_PORT=8080
+
+# ── Dashboard ──────────────────────────────────────────────────────────────────
+DASHBOARD_PORT=8081
+
+# ── Flutter VM Service ─────────────────────────────────────────────────────────
+# Set this to skip the port prompt on `npm start`.
+# Run Flutter with: flutter run --vm-service-port=8181 --disable-service-auth-codes
+FLUTTER_VM_URL=
+
+# ── Ultron n0-beta model download (encrypted chunks) ───────────────────────────
+# Decryption passphrase for the model chunks. NEVER commit this — set it locally
+# and store it as a GitHub Actions secret for CI releases. Without it, `npm run
+# setup` skips the automatic download and prints instructions.
+PARITYFIX_MODEL_KEY=
+# Optional: path to a chunk manifest (defaults to config/model.manifest.json).
+PARITYFIX_MODEL_MANIFEST=
+# Optional: max size per encrypted chunk in MB (default 300). Only affects the
+# maintainer's `npm run encrypt-model` step — install reads whatever the manifest lists.
+PARITYFIX_CHUNK_MB=300
+
+# ── Team model cache (optional, legacy setup.sh path) ──────────────────────────
+# Upload the model to Google Drive, share publicly (Anyone → Viewer), then paste
+# the file ID here. Used by ./setup.sh (HuggingFace fallback path).
+GDRIVE_MODEL_ID=

package/README.md

@@ -0,0 +1,226 @@
+# ParityFix v0.1.0 — AI-based realtime performance analysis & suggestions
+
+A lightweight developer tool that connects to a running Flutter or Android app, collects real-time performance data, analyzes it with configurable rules, and shows AI-powered suggestions on a local dashboard at `http://localhost:7000`.
+
+**Smart, low-CPU AI:** widgets are pre-scored deterministically in code first — only the genuinely expensive or ambiguous ones are escalated to the local LLM. Cheap widgets are auto-cleared without ever touching the model, and the local model is capped to half your CPU cores, so realtime profiling stays responsive.
+
+---
+
+## Install & model setup
+
+**From npm (published):**
+```bash
+npm install -g letfixit      # or: npx letfixit
+export PARITYFIX_MODEL_KEY=…  # the decryption passphrase (enables the local model)
+letfixit                     # branded startup → "Ultron n0-beta initializing…" → analyze menu
+```
+
+**From source (clone):**
+```bash
+npm install        # runs postinstall → sets up the local model automatically
+npm start          # branded startup → "Ultron n0-beta initializing…" → analyze menu
+```
+
+The chunk manifest ships inside the package, so installs only need `PARITYFIX_MODEL_KEY`
+to fetch + decrypt the weights. Without it, ParityFix still runs (cloud-fallback AI, or
+no suggestions) — the model download is skipped, never fatal.
+
+The local model — **Ultron n0-beta** — ships as **N AES-256-GCM-encrypted chunks of ≤300 MB each** (a ~2.6 GB model → ~10 chunks). Chunks can live on **multiple hosts** (each chunk has a primary `url` + optional `mirrors`), and downloads are **resumable** — a dropped connection continues from where it left off (HTTP Range), tries mirrors in order, and retries per chunk. On install, ParityFix downloads them (live progress bar), verifies each SHA-256, decrypts, merges, verifies the full-model checksum, and finalizes `bin/ultron/ultron-n0-beta.gguf`, then prints the model info + a short reliability disclaimer.
+
+Chunk size is configurable via `PARITYFIX_CHUNK_MB` (default 300) at encrypt time.
+
+Setup is **non-fatal**: if the chunk manifest or key isn't configured it prints instructions and continues (you can still use cloud fallback or `./setup.sh`). Retry any time with `npm run setup`.
+
+**Two things must be present for the automatic download:**
+- `config/model.manifest.json` — chunk URLs + IVs/checksums. Copy `config/model.manifest.example.json` and fill it in.
+- `PARITYFIX_MODEL_KEY` — the decryption passphrase (env var). **Never commit it.**
+
+**Maintainers — producing a release** (from a source `.gguf`):
+```bash
+PARITYFIX_MODEL_KEY='your-strong-passphrase' npm run encrypt-model -- path/to/model.gguf
+# → dist/model-chunks/chunk.{0,1,2}.enc + model.manifest.json
+# Upload the chunks (Drive / GitHub Release), paste their URLs into the manifest,
+# copy it to config/model.manifest.json, and store the key as a GitHub Actions secret.
+```
+
+> **Security note:** a decryption key shipped inside a public package is only obfuscation, not real protection. The key is kept out of the repo (env var + CI secret); for true gating you'd deliver it from a backend at install time. The chunking + encryption here raises the bar and keeps the weights off the public repo, which is the practical goal for now.
+
+---
+
+## Flutter Quick Start
+
+**1. Add the package** to your `pubspec.yaml`:
+```yaml
+dependencies:
+  perf_analyzer:
+    path: /path/to/perf_analyzer/adapters/flutter
+```
+
+**2. Start the bridge server** (run once, keep it running):
+```bash
+npm start
+```
+
+**3. Call `start()` in your `main()`**:
+```dart
+import 'package:perf_analyzer/perf_analyzer.dart';
+
+Future<void> main() async {
+  WidgetsFlutterBinding.ensureInitialized();
+  await PerfAnalyzer.start();
+  runApp(const MyApp());
+}
+```
+
+**4. Launch your app** with the VM service flag:
+```bash
+flutter run --enable-vmservice
+```
+
+Open `http://localhost:7000` — data starts flowing immediately.
+
+---
+
+## Android Quick Start
+
+**1. Add the dependency** to your app `build.gradle`:
+```groovy
+dependencies {
+    implementation project(':perf_analyzer')
+}
+```
+
+**2. Start the bridge server**:
+```bash
+npm start
+```
+
+**3. Initialize in your `Application` class**:
+```kotlin
+class MyApp : Application() {
+    override fun onCreate() {
+        super.onCreate()
+        PerfAnalyzer.start(this)
+    }
+}
+```
+
+**4. (Optional) Add the OkHttp interceptor** to capture API calls:
+```kotlin
+val client = OkHttpClient.Builder()
+    .addInterceptor(PerfInterceptor())
+    .build()
+```
+
+---
+
+## Android native — live debug monitor (over adb, no SDK)
+
+The Android counterpart to Flutter's live dashboard: attach to a **running app over adb** and stream metrics in real time — **no in-app SDK, no code changes**. Great for a debug build you're actively exercising.
+
+**Requirements:** `adb` on PATH + a device/emulator with USB debugging enabled, and the app already running (or about to be).
+
+**Run it:**
+```bash
+npm start        # then choose option 2 — "Android native — live debug monitor"
+```
+
+Pick the device, confirm the package (the currently-foreground app is offered as the default), then open the dashboard and flip the platform toggle to **Android**. Live panels populate from:
+- **Frames** — `dumpsys gfxinfo <pkg> framestats` parsed into real per-frame timings → FPS strip, frame-time chart (build vs raster), jank.
+- **Memory** — `dumpsys meminfo <pkg>` (TOTAL PSS) → live memory chart.
+- **Errors** — `logcat --pid=<pid> *:E` → crashes/exceptions in the error feed (FATAL EXCEPTION / ANR flagged critical).
+
+The passive rule engine runs on this stream too, so jank / memory-growth / crash-pattern findings appear live in the Junk Feed. (API calls need the OkHttp interceptor — see the SDK section — since adb can't observe them.)
+
+---
+
+## Connected Device Performance Test (Android & iOS — no debug build needed)
+
+Profile **any installed app** on a mobile plugged into the laptop — no SDK integration, no debuggable build. The laptop drives a launch → perform-flow → restart loop and analyzes GPU / render / raster.
+
+- **Android** — reads the OS-side `dumpsys` counters (`gfxinfo`, `meminfo`, `cpuinfo`) Android keeps for every process. Captures render (jank, frame percentiles), memory (PSS), and CPU.
+- **iOS** (physical device via `xcrun devicectl`, or the Simulator via `xcrun simctl`) — records an Instruments **Core Animation** trace per iteration (`xcrun xctrace`) and derives FPS → frame-time percentiles + jank. Memory/CPU show **n/a** (the render template doesn't carry them).
+
+**Requirements:**
+- Android: `adb` on PATH (platform-tools) + a device with **USB debugging** enabled & authorized. (`ADB_PATH` in `.env` overrides the adb location.)
+- iOS: Xcode command-line tools (`xcrun`); a paired device or a booted Simulator.
+
+**Run it:**
+```bash
+npm start        # then choose option 2 — "Connected Device Performance Test"
+```
+
+The flow:
+1. Pick a device — Android + iOS devices/simulators are merged into one list, tagged by platform.
+2. Enter the app **bundle id** (`com.example.app` / `com.example.MyApp`) and a **module name** (`Login Flow`).
+3. Choose iteration count (default **8**). Each iteration the app launches, **you perform the flow**, then press **Enter** to capture — stats are reset per run. The app is force-stopped/restarted between runs.
+4. Metrics are **scored in code** (0–100; the overall renormalizes over whichever of render/memory/CPU were captured), issues detected, and — only if issues exist — the **local LLM** suggests concrete platform-specific fixes.
+5. A self-contained **HTML report** (Chart.js charts, score, suggestions, metrics table) is written to `server/reports/` and opened in your browser. Also served at `http://localhost:8081/reports/<file>`.
+
+> **iOS note:** the `xctrace` capture + trace-export parsing follows the Xcode 15+ CLI but hasn't been validated against live hardware from this build — the export schema varies by Xcode version, so `parseFpsExport()` in `ios_bridge.js` is the most likely spot to need a small tweak on your machine. If a trace yields no FPS data, iOS metrics degrade to `n/a` and the report still renders.
+
+---
+
+## AI Config (all optional)
+
+Copy `.env.example` to `.env` and fill in the keys you have. All are optional — the dashboard works without any AI configured.
+
+```env
+GROQ_API_KEY=gsk_...
+GEMINI_API_KEY=AIza...
+CLAUDE_API_KEY=sk-ant-...
+ENABLE_LOCAL_AI=true
+LOCAL_AI_PORT=8080
+```
+
+AI routing order: **SmolLM2 (local)** → **Groq** → **Gemini** → **Claude**. The first available provider wins.
+
+---
+
+## Local AI Setup (SmolLM2 360M — zero dependencies)
+
+`./setup.sh` handles everything automatically. It downloads a single self-contained [llamafile](https://github.com/Mozilla-Ocho/llamafile) (~350MB, once) to `bin/smollm/smollm2.llamafile`. No external runtimes, no Homebrew, no CUDA drivers needed.
+
+```bash
+./setup.sh   # downloads SmolLM2 if not present
+npm start    # starts SmolLM2 on :8080 + bridge server on :7000
+```
+
+`npm start` auto-spawns the llamafile in the background and kills it on `Ctrl+C`.
+
+To skip local AI entirely, set `ENABLE_LOCAL_AI=false` in `.env` — the server will route directly to your configured cloud API key.
+
+---
+
+## Dashboard Panels
+
+| Panel | Platform | What it shows |
+|---|---|---|
+| **FPS Strip** | Both | Rolling 60-frame bar chart, current FPS, jank count |
+| **Memory Monitor** | Both | Heap over time (line chart), growth rate badge |
+| **Error Feed** | Both | Exceptions and crashes, newest first |
+| **API Monitor** | Both | Endpoint, method, payload size, duration, status |
+| **Rebuild Tracker** | Flutter | Widget rebuild counts/s, sorted by frequency |
+| **Overdraw Map** | Android | View invalidation heatmap |
+| **AI Suggestion Cards** | Both | CAUSE / FIX / CODE / GAIN per finding |
+
+---
+
+## V0 Limitations
+
+- Flutter adapter requires `--enable-vmservice` flag (not for production builds).
+- Android WebSocket adapter uses `javax.websocket` — add the dependency manually for apps targeting API < 26.
+- Local AI quality depends on quantization; cloud APIs give better suggestions.
+- No persistence — findings reset when the server restarts.
+- iOS not yet supported.
+
+---
+
+## V1 Roadmap
+
+- [ ] iOS adapter (Xcode Instruments bridge)
+- [ ] Persistent SQLite finding history
+- [ ] pub.dev / Maven Central release
+- [ ] `flutter pub run perf_analyzer` CLI setup command
+- [ ] CI integration — fail build on critical findings
+- [ ] Flame chart overlay for frame deep-dives

package/adapters/android/build.gradle

@@ -0,0 +1,28 @@
+plugins {
+    id 'com.android.library'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace 'dev.perfanalyzer'
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 21
+        targetSdk 34
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+}
+
+dependencies {
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3'
+    compileOnly 'com.squareup.okhttp3:okhttp:4.12.0'
+}

package/adapters/android/src/main/kotlin/dev/perfanalyzer/ChoreographerAdapter.kt

@@ -0,0 +1,43 @@
+package dev.perfanalyzer
+
+import android.view.Choreographer
+import org.json.JSONObject
+
+class ChoreographerAdapter(private val onEvent: (JSONObject) -> Unit) : Choreographer.FrameCallback {
+    private var lastFrameTimeNanos: Long = 0
+    private var running = false
+
+    fun start() {
+        running = true
+        Choreographer.getInstance().postFrameCallback(this)
+    }
+
+    fun stop() {
+        running = false
+    }
+
+    override fun doFrame(frameTimeNanos: Long) {
+        if (!running) return
+
+        if (lastFrameTimeNanos != 0L) {
+            val durationMs = (frameTimeNanos - lastFrameTimeNanos) / 1_000_000.0
+            val severity = when {
+                durationMs > 33 -> "critical"
+                durationMs > 16.6 -> "high"
+                else -> "low"
+            }
+            val event = JSONObject().apply {
+                put("platform", "android")
+                put("event", "frame")
+                put("timestamp", System.currentTimeMillis())
+                put("severity", severity)
+                put("type", "frame")
+                put("durationMs", durationMs)
+            }
+            onEvent(event)
+        }
+
+        lastFrameTimeNanos = frameTimeNanos
+        Choreographer.getInstance().postFrameCallback(this)
+    }
+}

package/adapters/android/src/main/kotlin/dev/perfanalyzer/LogcatReader.kt

@@ -0,0 +1,64 @@
+package dev.perfanalyzer
+
+import android.util.Log
+import org.json.JSONObject
+import java.io.BufferedReader
+import java.io.InputStreamReader
+
+class LogcatReader(private val onEvent: (JSONObject) -> Unit) {
+    private val tag = "PerfAnalyzer.LogcatReader"
+    private var process: Process? = null
+    private var thread: Thread? = null
+    private var running = false
+
+    fun start() {
+        running = true
+        thread = Thread {
+            try {
+                process = Runtime.getRuntime().exec(arrayOf("logcat", "-v", "time", "-s", "AndroidRuntime:E", "*:F"))
+                val reader = BufferedReader(InputStreamReader(process!!.inputStream))
+                var line: String?
+                while (running && reader.readLine().also { line = it } != null) {
+                    line?.let { parseLine(it) }
+                }
+            } catch (e: Exception) {
+                Log.w(tag, "Logcat reader stopped: ${e.message}")
+            }
+        }
+        thread!!.isDaemon = true
+        thread!!.start()
+    }
+
+    fun stop() {
+        running = false
+        process?.destroy()
+        thread?.interrupt()
+    }
+
+    private fun parseLine(line: String) {
+        val isException = line.contains("Exception") || line.contains("FATAL EXCEPTION")
+        val isError = line.contains("Error:") && !line.contains("No error")
+        if (!isException && !isError) return
+
+        val fatal = line.contains("FATAL")
+        val className = extractClassName(line)
+        val message = line.trim()
+
+        val event = JSONObject().apply {
+            put("type", "error")
+            put("platform", "android")
+            put("timestamp", System.currentTimeMillis())
+            put("severity", if (fatal) "critical" else "high")
+            put("fatal", fatal)
+            put("className", className)
+            put("message", message.take(200))
+        }
+
+        onEvent(event)
+    }
+
+    private fun extractClassName(line: String): String {
+        val exceptionPattern = Regex("""([A-Za-z.]+Exception|[A-Za-z.]+Error)""")
+        return exceptionPattern.find(line)?.value?.substringAfterLast('.') ?: "UnknownError"
+    }
+}

package/adapters/android/src/main/kotlin/dev/perfanalyzer/MemoryObserver.kt

@@ -0,0 +1,46 @@
+package dev.perfanalyzer
+
+import android.os.Debug
+import org.json.JSONObject
+import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledFuture
+import java.util.concurrent.TimeUnit
+
+class MemoryObserver(private val onEvent: (JSONObject) -> Unit) {
+    private val scheduler = Executors.newSingleThreadScheduledExecutor()
+    private var future: ScheduledFuture<*>? = null
+
+    fun start() {
+        future = scheduler.scheduleAtFixedRate({
+            val memInfo = Debug.MemoryInfo()
+            Debug.getMemoryInfo(memInfo)
+
+            val totalPss = memInfo.totalPss
+            val dalvikHeap = memInfo.dalvikPss
+            val nativeHeap = memInfo.nativePss
+
+            val severity = when {
+                totalPss > 300_000 -> "critical"
+                totalPss > 150_000 -> "high"
+                else -> "low"
+            }
+
+            val event = JSONObject().apply {
+                put("type", "memory")
+                put("platform", "android")
+                put("timestamp", System.currentTimeMillis())
+                put("severity", severity)
+                put("totalPss", totalPss)
+                put("dalvikHeap", dalvikHeap)
+                put("nativeHeap", nativeHeap)
+            }
+
+            onEvent(event)
+        }, 0, 2, TimeUnit.SECONDS)
+    }
+
+    fun stop() {
+        future?.cancel(false)
+        scheduler.shutdown()
+    }
+}

package/adapters/android/src/main/kotlin/dev/perfanalyzer/OkHttpInterceptor.kt

@@ -0,0 +1,53 @@
+package dev.perfanalyzer
+
+import okhttp3.Interceptor
+import okhttp3.Response
+import org.json.JSONObject
+
+class PerfInterceptor : Interceptor {
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request()
+        val start = System.currentTimeMillis()
+
+        val requestBodySize = try {
+            val copy = request.newBuilder().build()
+            val buffer = okio.Buffer()
+            copy.body?.writeTo(buffer)
+            buffer.size
+        } catch (_: Exception) {
+            0L
+        }
+
+        val response = chain.proceed(request)
+        val durationMs = System.currentTimeMillis() - start
+
+        val responseBody = response.body
+        val responseBytes = responseBody?.bytes() ?: ByteArray(0)
+        val responseBodySize = responseBytes.size.toLong()
+
+        val severity = when {
+            responseBodySize > 512000 -> "high"
+            durationMs > 500 -> "medium"
+            else -> "low"
+        }
+
+        val event = JSONObject().apply {
+            put("type", "api")
+            put("platform", "android")
+            put("timestamp", System.currentTimeMillis())
+            put("severity", severity)
+            put("url", request.url.toString())
+            put("method", request.method)
+            put("requestBodySize", requestBodySize)
+            put("responseBodySize", responseBodySize)
+            put("durationMs", durationMs)
+            put("statusCode", response.code)
+        }
+
+        PerfAnalyzer.sendEvent(event)
+
+        return response.newBuilder()
+            .body(okhttp3.ResponseBody.create(responseBody?.contentType(), responseBytes))
+            .build()
+    }
+}

package/adapters/android/src/main/kotlin/dev/perfanalyzer/PerfAnalyzer.kt

@@ -0,0 +1,100 @@
+package dev.perfanalyzer
+
+import android.app.Application
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import org.json.JSONObject
+import java.net.URI
+import javax.websocket.*
+
+data class PerfConfig(
+    val groqKey: String? = null,
+    val geminiKey: String? = null,
+    val claudeKey: String? = null,
+    val port: Int = 7000,
+    val enableLocalAI: Boolean = true
+)
+
+object PerfAnalyzer {
+    private const val TAG = "PerfAnalyzer"
+    private var ws: Session? = null
+    private var config: PerfConfig = PerfConfig()
+    private var choreographerAdapter: ChoreographerAdapter? = null
+    private var memoryObserver: MemoryObserver? = null
+    private var logcatReader: LogcatReader? = null
+    private val mainHandler = Handler(Looper.getMainLooper())
+    private var running = false
+
+    fun start(context: Application, config: PerfConfig = PerfConfig()) {
+        if (running) return
+        running = true
+        PerfAnalyzer.config = config
+
+        connectWebSocket()
+
+        choreographerAdapter = ChoreographerAdapter { event -> sendEvent(event) }
+        mainHandler.post { choreographerAdapter!!.start() }
+
+        memoryObserver = MemoryObserver { event -> sendEvent(event) }
+        memoryObserver!!.start()
+
+        logcatReader = LogcatReader { event -> sendEvent(event) }
+        logcatReader!!.start()
+
+        Log.i(TAG, "🔍 Perf Analyzer connected")
+        Log.i(TAG, "📊 Dashboard → http://localhost:${config.port}")
+    }
+
+    fun stop() {
+        running = false
+        choreographerAdapter?.stop()
+        memoryObserver?.stop()
+        logcatReader?.stop()
+        ws?.close()
+        ws = null
+    }
+
+    internal fun sendEvent(event: JSONObject) {
+        try {
+            val session = ws
+            if (session != null && session.isOpen) {
+                session.basicRemote.sendText(event.toString())
+            }
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to send event: ${e.message}")
+        }
+    }
+
+    private fun connectWebSocket() {
+        Thread {
+            try {
+                val container = ContainerProvider.getWebSocketContainer()
+                val uri = URI("ws://localhost:7001")
+                ws = container.connectToServer(object : Endpoint() {
+                    override fun onOpen(session: Session, config: EndpointConfig) {
+                        Log.i(TAG, "WebSocket connected to bridge")
+                    }
+
+                    override fun onClose(session: Session, closeReason: CloseReason) {
+                        Log.w(TAG, "WebSocket closed: $closeReason")
+                        if (running) {
+                            Thread.sleep(3000)
+                            connectWebSocket()
+                        }
+                    }
+
+                    override fun onError(session: Session, thr: Throwable) {
+                        Log.e(TAG, "WebSocket error: ${thr.message}")
+                    }
+                }, ClientEndpointConfig.Builder.create().build(), uri)
+            } catch (e: Exception) {
+                Log.e(TAG, "WebSocket connection failed: ${e.message}")
+                if (running) {
+                    Thread.sleep(3000)
+                    connectWebSocket()
+                }
+            }
+        }.start()
+    }
+}

package/adapters/flutter/lib/perf_analyzer.dart

@@ -0,0 +1,73 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:web_socket_channel/web_socket_channel.dart';
+import 'src/universal_event.dart';
+import 'src/vm_service_adapter.dart';
+import 'src/frame_observer.dart';
+import 'src/rebuild_observer.dart';
+import 'src/network_observer.dart';
+
+export 'src/universal_event.dart';
+export 'src/network_observer.dart' show PerfHttpClient;
+
+class PerfAnalyzer {
+  static VMServiceAdapter? _vmAdapter;
+  static FrameObserver? _frameObserver;
+  static RebuildObserver? _rebuildObserver;
+  static NetworkObserver? _networkObserver;
+  static WebSocketChannel? _channel;
+  static final List<StreamSubscription> _subs = [];
+
+  static Future<void> start({PerfConfig config = const PerfConfig()}) async {
+    final uri = Uri.parse('ws://127.0.0.1:${config.port}/ws');
+    _channel = WebSocketChannel.connect(uri);
+
+    void send(UniversalEvent event) {
+      try {
+        _channel?.sink.add(jsonEncode(event.toJson()));
+      } catch (_) {}
+    }
+
+    _vmAdapter = VMServiceAdapter();
+    try {
+      await _vmAdapter!.connect();
+    } catch (e) {
+      print('⚠️  VM Service unavailable: $e');
+    }
+
+    _frameObserver = FrameObserver(_vmAdapter!);
+    _rebuildObserver = RebuildObserver(_vmAdapter!);
+    _networkObserver = NetworkObserver();
+
+    _subs.add(_frameObserver!.events.listen(send));
+    _subs.add(_rebuildObserver!.events.listen(send));
+    _subs.add(_networkObserver!.events.listen(send));
+
+    // Also forward raw VM events for memory and error events
+    _subs.add(_vmAdapter!.eventStream
+        .where((e) => e.event != 'frame' && e.event != 'rebuild')
+        .listen(send));
+
+    // ignore: avoid_print
+    print('🔍 Perf Analyzer connected');
+    // ignore: avoid_print
+    print('📊 Dashboard → http://localhost:${config.port}');
+  }
+
+  static void stop() {
+    for (final sub in _subs) {
+      sub.cancel();
+    }
+    _subs.clear();
+    _frameObserver?.dispose();
+    _rebuildObserver?.dispose();
+    _networkObserver?.dispose();
+    _vmAdapter?.dispose();
+    _channel?.sink.close();
+    _frameObserver = null;
+    _rebuildObserver = null;
+    _networkObserver = null;
+    _vmAdapter = null;
+    _channel = null;
+  }
+}