@slack/radar-mcp 1.4.0 → 1.5.0

package/dist/web/server.js

@@ -6,10 +6,36 @@ import { spawn } from "child_process";
 import { fileURLToPath } from "url";
 import { AndroidTransport, resolveAdbPath } from "../shared/android.js";
 import { RADAR_HOST, RADAR_PORT, WEB_PORT_DEFAULT } from "../shared/constants.js";
+import { cleanupPulledDatabases, initializeDatabasePath, listDatabases, pullDatabase, pulledSize, queryDatabase, resetDbState, } from "../shared/db.js";
+import { LogSession } from "./log-session.js";
 import { BLANK_SPEC, coerceSpec, validateSpec } from "./spec.js";
+import { screenCapabilities, grantScreenConsent, hasScreenConsent, detectDisplay, displayNote, captureScreenshot, startLive, addViewer, removeViewer, primeIfNeeded, startRecording, stopRecording, recordingPath, resetScreenState, registerScreenCleanup, resolveFfmpeg, ffmpegInstallHint, SCREEN_BOUNDARY, } from "../shared/screen.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WEB_PORT = Number(process.env.SLACK_RADAR_WEB_PORT ?? WEB_PORT_DEFAULT);
 const INDEX_PATH = path.join(__dirname, "public", "index.html");
+// Backpressure ceiling for an SSE connection's unwritten log frames. If a
+// client's socket buffer is already this deep (slow/backgrounded tab), new log
+// frames are dropped for that connection rather than queued without bound. ~4 MB
+// is far above a healthy localhost client's transient buffer but well under a
+// memory problem; a dropped frame is recovered on the client's next reconnect
+// replay. Only the log fan-out is bounded this way — the device proxy stream is
+// already paced by the upstream socket.
+const MAX_SSE_WRITABLE_BYTES = 4 * 1024 * 1024;
+/**
+ * Decide whether to drop a log frame under backpressure. LIVE frames are dropped
+ * when the connection's unwritten buffer is already past the cap (an unbounded
+ * queue to a slow/backgrounded tab). REPLAY frames are NEVER dropped: replay is a
+ * bounded one-time send of the whole ring and IS the connection's purpose; it runs
+ * synchronously so writableLength climbs monotonically, and dropping past the cap
+ * would silently cut the newest history and reintroduce the reconnect log-loss
+ * this feature fixes. Exported pure so the replay-exemption is unit-testable
+ * without a socket. `cap` defaults to the live ceiling.
+ */
+export function shouldDropLogFrame(replay, writableLength, cap = MAX_SSE_WRITABLE_BYTES) {
+    if (replay)
+        return false;
+    return writableLength > cap;
+}
 // The active dashboard spec is session-scoped runtime state, NOT source. It lives
 // under the user's home data dir (never inside the repo / published tarball) so it
 // cannot be accidentally committed. The path is scoped by port so two dashboards
@@ -19,6 +45,26 @@ const INDEX_PATH = path.join(__dirname, "public", "index.html");
 const SPEC_DIR = path.join(os.homedir(), ".slack-radar");
 const SPEC_PATH = path.join(SPEC_DIR, `web-spec-${WEB_PORT}.json`);
 const transport = new AndroidTransport();
+// One session-long logcat capture shared across every dashboard stream
+// connection. The device cannot replay logcat history to us, so the dashboard
+// keeps its own bounded session ring here and replays it to each newly opened
+// stream — this is what makes a tab switch (which reopens /stream) show the full
+// log history instead of only lines that arrive after the reconnect, matching
+// how Android Studio retains logcat for the whole session. Spawn + parse are
+// injected so the capture logic is unit-testable without a real `adb logcat`.
+const logSession = new LogSession(() => spawn(resolveAdbPath() ?? "adb", ["logcat", "-v", "threadtime", "-T", "1"], {
+    stdio: ["ignore", "pipe", "ignore"],
+}), (line) => parseLogcat(line));
+// Kill the persistent logcat child on process exit so it does not orphan when the
+// dashboard is spawned and later terminated by the open_radar_dashboard MCP tool.
+logSession.registerCleanup();
+// By design the capture is NOT stopped when the last log stream disconnects (e.g.
+// switching to the Network tab): it keeps filling the session ring so returning to
+// a log tab — even much later — still shows the full history, the way Android
+// Studio retains logcat for the whole session. The cost is a logcat reader running
+// while no log tab is open; memory stays bounded by the ring cap and by the
+// per-connection backpressure guard in handleStream (a stalled client drops frames
+// rather than buffering without limit).
 function writeSpec(spec) {
     try {
         fs.mkdirSync(SPEC_DIR, { recursive: true });
@@ -59,7 +105,17 @@ function initialSpec() {
     }
 }
 writeSpec(initialSpec());
+// Initialize the database path with the web server port, so concurrent dashboards
+// on different ports do not collide in tmpdir.
+initializeDatabasePath(WEB_PORT);
+// Pulled DB copies are plaintext message stores; never let them linger across runs.
+// Clean on start, and on the process signals the bin wires for shutdown.
+cleanupPulledDatabases();
+for (const sig of ["SIGINT", "SIGTERM", "exit"]) {
+    process.once(sig, cleanupPulledDatabases);
+}
 export function createServer() {
+    registerScreenCleanup(); // tear down any live screen cast on process exit/signals
     const server = http.createServer((req, res) => {
         const url = req.url ?? "";
         if (url === "/" || url === "/index.html") {
@@ -94,6 +150,18 @@ export function createServer() {
             handleDetail(req, res);
             return;
         }
+        if (url.startsWith("/dbs") && req.method === "GET") {
+            handleDbList(req, res);
+            return;
+        }
+        if (url.startsWith("/dbtables") && req.method === "GET") {
+            handleDbTables(req, res);
+            return;
+        }
+        if (url.startsWith("/dbquery") && req.method === "GET") {
+            handleDbQuery(req, res);
+            return;
+        }
         if (url === "/_control/profiles" && req.method === "GET") {
             listProfiles(res);
             return;
@@ -104,6 +172,10 @@ export function createServer() {
             activateRadar(res, userId);
             return;
         }
+        if (url.startsWith("/screen/")) {
+            handleScreen(req, res);
+            return;
+        }
         if (url.startsWith("/api/")) {
             proxyToRadar(req, res);
             return;
@@ -177,6 +249,16 @@ async function handleSetSpec(req, res) {
  * forward/proxy base as the rest of the server.
  */
 function handleHealth(res) {
+    // A probe can fire BOTH an "end" and an "error"/"timeout" (partial response then socket
+    // drop), so guard the response to exactly one write. Without this the second sendJson
+    // does a second writeHead -> ERR_HTTP_HEADERS_SENT -> uncaught -> the whole server dies.
+    let replied = false;
+    const reply = (device) => {
+        if (replied)
+            return;
+        replied = true;
+        sendJson(res, 200, { device, screen: screenCapabilities() });
+    };
     const probe = http.request({
         host: RADAR_HOST,
         port: RADAR_PORT,
@@ -185,12 +267,13 @@ function handleHealth(res) {
         timeout: 2500,
     }, (up) => {
         up.resume();
-        up.on("end", () => sendJson(res, 200, { device: up.statusCode === 200 }));
+        up.on("end", () => reply(up.statusCode === 200));
+        up.on("error", () => reply(false));
     });
-    probe.on("error", () => sendJson(res, 200, { device: false }));
+    probe.on("error", () => reply(false));
     probe.on("timeout", () => {
         probe.destroy();
-        sendJson(res, 200, { device: false });
+        reply(false);
     });
     probe.end();
 }
@@ -202,6 +285,10 @@ function handleHealth(res) {
  */
 function handleEnable(res) {
     transport.resetState();
+    // A reconnect may be a different device / re-armed profile, so drop the cached DB user
+    // set + sqlite path; the next /dbs re-detects the profiles fresh.
+    resetDbState();
+    resetScreenState(); // re-detect the active display + clear any stale cast on re-arm
     const forwarded = transport.ensureForward();
     if (!forwarded) {
         const reason = transport.getLastForwardError?.() ?? null;
@@ -221,7 +308,15 @@ function handleEnable(res) {
         });
         return;
     }
-    // Verify by pinging the device the same way /health does.
+    // Verify by pinging the device the same way /health does. Reply exactly once (an "end"
+    // and an "error"/"timeout" can both fire) to avoid a double writeHead crashing the server.
+    let replied = false;
+    const reply = (enabled) => {
+        if (replied)
+            return;
+        replied = true;
+        sendJson(res, 200, { enabled });
+    };
     const probe = http.request({
         host: RADAR_HOST,
         port: RADAR_PORT,
@@ -230,12 +325,13 @@ function handleEnable(res) {
         timeout: 2500,
     }, (up) => {
         up.resume();
-        up.on("end", () => sendJson(res, 200, { enabled: up.statusCode === 200 }));
+        up.on("end", () => reply(up.statusCode === 200));
+        up.on("error", () => reply(false));
     });
-    probe.on("error", () => sendJson(res, 200, { enabled: false }));
+    probe.on("error", () => reply(false));
     probe.on("timeout", () => {
         probe.destroy();
-        sendJson(res, 200, { enabled: false });
+        reply(false);
     });
     probe.end();
 }
@@ -354,6 +450,229 @@ function handleDetail(req, res) {
     });
     upstream.end();
 }
+// --- On-device SQLite browser (source: "db") ---
+//
+// These delegate to shared/db.ts (run-as + host sqlite3, read-only). Each computes its
+// payload+status BEFORE writing headers so a throw still yields a clean JSON error rather
+// than a half-written response. Errors come back as 200 {error} for the list/tables views
+// (so the UI renders the message in-place) and 400 {error} for a rejected query.
+// The Android user whose store the DB browser targets. Prefer an explicit ?user= (the UI's
+// profile switcher, when a dual-profile device exists), else the profile the dashboard is
+// bound to. Threaded through every db call so list / pull / query never disagree on profile.
+function dbUser(req) {
+    const u = new URL(req.url ?? "", `http://localhost:${WEB_PORT}`);
+    const explicit = u.searchParams.get("user");
+    if (explicit !== null)
+        return explicit;
+    // No explicit pick: default to the profile the debug build is actually running as
+    // (resolveActiveUser prefers the non-zero/secondary profile Radar binds to), not user 0.
+    try {
+        return transport.resolveActiveUser();
+    }
+    catch {
+        return undefined; // let db.ts fall back to its first available user
+    }
+}
+function handleDbList(req, res) {
+    try {
+        sendJson(res, 200, listDatabases(dbUser(req)));
+    }
+    catch (e) {
+        sendJson(res, 200, { error: e.message, names: [], availableUsers: [] });
+    }
+}
+async function handleDbTables(req, res) {
+    const u = new URL(req.url ?? "", `http://localhost:${WEB_PORT}`);
+    const db = u.searchParams.get("db") ?? "";
+    const user = dbUser(req);
+    const force = u.searchParams.get("refresh") === "1";
+    let payload;
+    let status;
+    try {
+        await pullDatabase(db, user, force);
+        const tableRows = (await queryDatabase(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name", user));
+        // Row counts: awaited serially against the already-pulled LOCAL copy (each is fast and
+        // keeps the event loop free between calls; 91 parallel sqlite procs would spike).
+        const tables = [];
+        for (const t of tableRows) {
+            let rows = "?";
+            try {
+                rows = (await queryDatabase(db, `SELECT COUNT(*) c FROM "${t.name}"`, user))[0].c;
+            }
+            catch {
+                // a view or virtual table may not count; leave "?"
+            }
+            tables.push({ name: t.name, rows });
+        }
+        payload = { db, sizeBytes: pulledSize(db, user), tables };
+        status = 200;
+    }
+    catch (e) {
+        payload = { error: e.message };
+        status = 200; // surfaced in the tables pane, not a transport error
+    }
+    sendJson(res, status, payload);
+}
+async function handleDbQuery(req, res) {
+    const u = new URL(req.url ?? "", `http://localhost:${WEB_PORT}`);
+    const db = u.searchParams.get("db") ?? "";
+    const sql = u.searchParams.get("sql") ?? "";
+    let payload;
+    let status;
+    try {
+        payload = { rows: await queryDatabase(db, sql, dbUser(req)) };
+        status = 200;
+    }
+    catch (e) {
+        payload = { error: String(e.message).split("\n")[0] };
+        status = 400;
+    }
+    sendJson(res, status, payload);
+}
+/**
+ * Screen overlay routes. The live screen shows real DMs and message content, so the
+ * stream and record routes are gated behind an explicit per-process consent (granted
+ * by POST /screen/consent from the in-UI consent panel). The gate is enforced HERE,
+ * server-side, not just in the browser, so a direct request cannot bypass it.
+ *
+ * /screen/caps        capabilities (ffmpeg/scrcpy present, install hint, consent state)
+ * /screen/consent     POST: grant consent for this server process
+ * /screen/shot        full-resolution PNG screenshot (pure screencap; works without ffmpeg)
+ * /screen/stream      multipart/x-mixed-replace MJPEG live cast (needs ffmpeg + consent)
+ * /screen/record/start|stop   record the live cast to mp4 (needs ffmpeg + consent)
+ * /screen/download    download a finished recording
+ * /screen/redetect    re-detect the active display
+ */
+function handleScreen(req, res) {
+    const url = req.url ?? "";
+    // Capabilities + consent state. Always available; drives the overlay's degrade UI.
+    if (url.startsWith("/screen/caps")) {
+        sendJson(res, 200, { ...screenCapabilities(), consent: hasScreenConsent() });
+        return;
+    }
+    // Grant consent for this process. Required before any pixels are mirrored.
+    if (url === "/screen/consent" && req.method === "POST") {
+        grantScreenConsent();
+        sendJson(res, 200, { consent: true });
+        return;
+    }
+    // Screenshot: pure screencap, no ffmpeg. Still consent-gated — it is the live screen.
+    if (url.startsWith("/screen/shot")) {
+        if (!hasScreenConsent()) {
+            sendJson(res, 403, { error: "screen consent required" });
+            return;
+        }
+        void (async () => {
+            await detectDisplay();
+            const png = await captureScreenshot();
+            if (!png) {
+                sendJson(res, 502, { error: "screencap failed; is the device awake and connected?" });
+                return;
+            }
+            res.writeHead(200, {
+                "Content-Type": "image/png",
+                "Content-Disposition": `attachment; filename="radar-screen-${Date.now()}.png"`,
+            });
+            res.end(png);
+        })();
+        return;
+    }
+    // Live MJPEG stream. Needs consent AND ffmpeg.
+    if (url.startsWith("/screen/stream")) {
+        if (!hasScreenConsent()) {
+            sendJson(res, 403, { error: "screen consent required" });
+            return;
+        }
+        if (!resolveFfmpeg()) {
+            sendJson(res, 501, { error: "ffmpeg not installed", installHint: ffmpegInstallHint() });
+            return;
+        }
+        const fps = Number(new URL(url, `http://localhost:${WEB_PORT}`).searchParams.get("fps")) || 20;
+        void (async () => {
+            await detectDisplay();
+            const L = startLive(fps);
+            if (!L) {
+                sendJson(res, 501, { error: "ffmpeg not installed", installHint: ffmpegInstallHint() });
+                return;
+            }
+            res.writeHead(200, {
+                "Content-Type": `multipart/x-mixed-replace; boundary=${SCREEN_BOUNDARY}`,
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            });
+            addViewer(L, res);
+            req.on("close", () => removeViewer(res));
+            void primeIfNeeded();
+        })();
+        return;
+    }
+    if (url === "/screen/record/start" && req.method === "POST") {
+        if (!hasScreenConsent()) {
+            sendJson(res, 403, { error: "screen consent required" });
+            return;
+        }
+        void (async () => {
+            await detectDisplay();
+            if (!startLive(20)) {
+                sendJson(res, 501, { error: "ffmpeg not installed", installHint: ffmpegInstallHint() });
+                return;
+            }
+            const p = startRecording();
+            sendJson(res, 200, { ok: p !== null, file: p ? path.basename(p) : null });
+        })();
+        return;
+    }
+    if (url === "/screen/record/stop" && req.method === "POST") {
+        void (async () => {
+            const p = await stopRecording();
+            const file = p ? path.basename(p) : null;
+            let sizeBytes = 0;
+            if (p) {
+                try {
+                    sizeBytes = fs.statSync(p).size;
+                }
+                catch {
+                    sizeBytes = 0;
+                }
+            }
+            sendJson(res, 200, {
+                ok: true,
+                file,
+                sizeBytes,
+                download: file ? "/screen/download?f=" + encodeURIComponent(file) : null,
+            });
+        })();
+        return;
+    }
+    if (url.startsWith("/screen/download")) {
+        // A recording is device-screen content, so gate download on consent too — a fresh
+        // (unconsented) process must not serve a prior session's screen recording.
+        if (!hasScreenConsent()) {
+            sendJson(res, 403, { error: "screen consent required" });
+            return;
+        }
+        const f = new URL(url, `http://localhost:${WEB_PORT}`).searchParams.get("f") ?? "";
+        const p = recordingPath(f);
+        if (!p) {
+            res.writeHead(404);
+            res.end("Not found");
+            return;
+        }
+        res.writeHead(200, {
+            "Content-Type": "video/mp4",
+            "Content-Disposition": `attachment; filename="${path.basename(p)}"`,
+        });
+        fs.createReadStream(p).pipe(res);
+        return;
+    }
+    if (url === "/screen/redetect") {
+        resetScreenState();
+        void detectDisplay().then(() => sendJson(res, 200, { display: displayNote() }));
+        return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+}
 // Logcat line parsing for the host-side log merge. Format:
 // "MM-DD HH:MM:SS.mmm  PID  TID  L Tag: message"
 const LOG_LINE_RE = /^(\d\d-\d\d \d\d:\d\d:\d\d\.\d+)\s+(\d+)\s+(\d+)\s+([VDIWEF])\s+([^:]*?):\s?(.*)$/;
@@ -437,10 +756,13 @@ export function parseLogcat(line, resolvePkg = packageForPid) {
  * Every other retry it rebuilds the adb forward (the real cause of recurring
  * "unreachable"), reusing AndroidTransport rather than shelling adb directly.
  *
- * When the active spec wants logs (source "log" or "all"), it also spawns a
- * host-side `adb logcat -v threadtime -T 1` and merges parsed lines as
- * `type: "log"` frames. The adb binary is resolved via resolveAdbPath() so GUI
- * launchers without the user's PATH still work.
+ * When the active spec wants logs (source "log" or "all"), the handler subscribes
+ * to the shared session-long logSession: it is first replayed the entire retained
+ * ring buffer (so a tab switch shows full history), then receives live lines as
+ * they arrive. The logcat process itself is persistent and shared across all
+ * /stream clients, so tab switches never drop history AND the active tab keeps
+ * streaming live. The adb binary is resolved via resolveAdbPath() so GUI launchers
+ * without the user's PATH still work.
  */
 function handleStream(req, res) {
     res.writeHead(200, {
@@ -457,6 +779,24 @@ function handleStream(req, res) {
         lastState = state;
         res.write(`data: ${JSON.stringify({ type: "_status", event: { state, msg } })}\n\n`);
     };
+    // Keep the persistent logcat capture armed for the life of this connection.
+    // start() is idempotent, so it is safe to call both on initial setup and from
+    // the device-proxy reconnect path: when the device sleeps/unplugs, `adb logcat`
+    // exits and LogSession clears its child, and without a re-arm the live log feed
+    // would stay dead (until a tab switch) while network/rtm/clog self-heal via the
+    // proxy retry loop. Calling this on reconnect heals logs on the same path.
+    const spec = loadSpec();
+    const wantsLogs = spec.source === "log" || spec.source === "all";
+    const armLogcat = () => {
+        if (!wantsLogs || closed)
+            return;
+        const ok = logSession.start();
+        if (!ok) {
+            // Spawn failed (e.g. no adb on PATH). The capture is a named session-scoped
+            // thing now, so surface the reason rather than showing silent emptiness.
+            announce("waiting", "device logs unavailable (adb not found?)");
+        }
+    };
     let retries = 0;
     // One scheduled reconnect per attempt. up.on("end"), up.on("error"), and
     // upstream.on("error") can all fire for the same attempt; without this guard each
@@ -493,6 +833,10 @@ function handleStream(req, res) {
             method: "GET",
         }, (up) => {
             announce("connected", "device stream connected");
+            // Re-arm logs on the same path the device proxy heals on: if the device
+            // dropped and came back, `adb logcat` had exited; restart it (idempotent)
+            // so the live log feed resumes without needing a browser reconnect.
+            armLogcat();
             up.on("data", (c) => res.write(c));
             up.on("end", () => {
                 announce("waiting", "device stream ended, retrying…");
@@ -514,53 +858,60 @@ function handleStream(req, res) {
         if (!closed)
             res.write(": hb\n\n");
     }, 15000);
-    // Host-side logcat merge for log/all sources. -T 1 streams only NEW lines;
-    // without it logcat replays the entire existing buffer on connect and floods
-    // the browser.
-    let logcat = null;
-    const spec = loadSpec();
-    const wantsLogs = spec.source === "log" || spec.source === "all";
-    const adb = resolveAdbPath();
-    if (wantsLogs && adb) {
-        try {
-            refreshPidMap(); // warm PID->package so the first log rows resolve their app
-            logcat = spawn(adb, ["logcat", "-v", "threadtime", "-T", "1"], {
-                stdio: ["ignore", "pipe", "ignore"],
-            });
-            let lineBuf = "";
-            logcat.stdout?.on("data", (c) => {
-                lineBuf += c.toString();
-                let nl;
-                while ((nl = lineBuf.indexOf("\n")) >= 0) {
-                    const line = lineBuf.slice(0, nl);
-                    lineBuf = lineBuf.slice(nl + 1);
-                    const ev = parseLogcat(line);
-                    if (ev && !closed) {
-                        res.write(`data: ${JSON.stringify({ type: "log", event: ev })}\n\n`);
-                    }
-                }
-            });
-            logcat.on("error", () => { });
-        }
-        catch {
-            logcat = null;
-        }
+    // Host-side logcat merge for log/all sources. Subscribe to the shared,
+    // session-long logSession: it replays the full retained ring buffer to this
+    // connection first (so a tab switch shows complete history), then delivers
+    // live lines. Both replayed and live frames are written to THIS response, so
+    // the tab you are watching keeps streaming in real time. The logcat process
+    // is persistent and shared, so a tab switch only adds/removes a listener — it
+    // never tears down the capture or loses lines in a reconnect gap.
+    let unsubscribeLogs = null;
+    if (wantsLogs) {
+        refreshPidMap(); // warm PID->package so the first log rows resolve their app
+        armLogcat(); // idempotent start; surfaces a status frame if spawn fails
+        unsubscribeLogs = logSession.subscribe((ev, replay) => {
+            if (closed)
+                return;
+            // Backpressure guard: if this client is slow or its tab is backgrounded
+            // (an EventSource stays subscribed when backgrounded), res.write() queues
+            // unwritten bytes in Node's writable buffer without bound. The ring is
+            // bounded but that per-connection buffer is not, so a stalled consumer
+            // would grow host memory for the whole (now persistent) session. When the
+            // socket buffer is already deep, DROP this frame rather than buffer it —
+            // the client replays the full ring on its next reconnect and catches up.
+            //
+            // EXEMPT replay: the replay burst is a bounded one-time send of the whole
+            // ring (~10 MB worst case at the 20000-frame cap) and IS the connection's
+            // purpose. It runs synchronously oldest->newest, so the I/O phase cannot
+            // drain between writes and writableLength climbs monotonically; gating it
+            // on the 4 MB cap would silently drop the NEWEST history past ~4 MB and
+            // reintroduce the very "log count shrinks on reconnect" loss this feature
+            // fixes. The guard is only meant for the unbounded LIVE queue.
+            if (shouldDropLogFrame(replay, res.writableLength))
+                return;
+            // Tag replayed history with replay:true so the client counts it as history
+            // (live=false) and does NOT fire alerts on it. The client's own cache is
+            // capped (count + TTL) while the server ring is larger, so on a long
+            // session the client can evict frames the ring still holds; without this
+            // flag those replayed-on-reconnect frames would look new and re-fire
+            // `alert {at:N}` and re-count. The flag makes replay alert-safe regardless.
+            const frame = replay
+                ? { type: "log", event: ev, replay: true }
+                : { type: "log", event: ev };
+            res.write(`data: ${JSON.stringify(frame)}\n\n`);
+        });
     }
     req.on("close", () => {
         closed = true;
         clearInterval(heartbeat);
+        if (unsubscribeLogs)
+            unsubscribeLogs(); // detach listener; capture stays up
         try {
             upstream?.destroy();
         }
         catch {
             // already torn down
         }
-        try {
-            logcat?.kill();
-        }
-        catch {
-            // already dead
-        }
     });
 }
 function listProfiles(res) {

package/dist/web/spec.d.ts

@@ -5,12 +5,17 @@
  * and the same validate/coerce pass runs on every push so a malformed spec surfaces
  * an error instead of rendering silent zeros.
  *
- * Scope note: this port covers the STREAMING sources only. The on-device SQLite
- * browser (`source: "db"`) from the original PoC is intentionally omitted here and
- * tracked as a separate change; `SOURCES` therefore does not include "db".
+ * Most sources are live STREAMS (network/rtm/clog/log/all). `db` is the odd one out:
+ * a read-only, point-in-time SQLite BROWSER over the on-device databases, with no viz /
+ * series / match (it has its own list -> tables -> query-grid view). The coerce and
+ * validate passes short-circuit for `db` accordingly.
  */
-/** Streaming sources the dashboard can read. "all" is the unified timeline. */
-export declare const SOURCES: readonly ["rtm", "network", "clog", "log", "all"];
+/**
+ * Sources the dashboard can read. The first five are live streams; "all" is their unified
+ * timeline. "db" is a read-only on-device SQLite browser (a point-in-time snapshot, not a
+ * stream) and is handled as a distinct view.
+ */
+export declare const SOURCES: readonly ["rtm", "network", "clog", "log", "all", "db"];
 export type Source = (typeof SOURCES)[number];
 /** Widgets a spec may compose. */
 export declare const VIZ: readonly ["counter", "rate", "sparkline", "feed", "inspector", "graph"];
@@ -62,6 +67,9 @@ export interface Spec {
     extract?: Extract;
     highlight?: Highlight;
     alert?: Alert;
+    db?: string;
+    table?: string;
+    sql?: string;
     [key: string]: unknown;
 }
 /** The empty dashboard. Rendered until a spec is pushed. */

package/dist/web/spec.js

@@ -5,12 +5,17 @@
  * and the same validate/coerce pass runs on every push so a malformed spec surfaces
  * an error instead of rendering silent zeros.
  *
- * Scope note: this port covers the STREAMING sources only. The on-device SQLite
- * browser (`source: "db"`) from the original PoC is intentionally omitted here and
- * tracked as a separate change; `SOURCES` therefore does not include "db".
+ * Most sources are live STREAMS (network/rtm/clog/log/all). `db` is the odd one out:
+ * a read-only, point-in-time SQLite BROWSER over the on-device databases, with no viz /
+ * series / match (it has its own list -> tables -> query-grid view). The coerce and
+ * validate passes short-circuit for `db` accordingly.
  */
-/** Streaming sources the dashboard can read. "all" is the unified timeline. */
-export const SOURCES = ["rtm", "network", "clog", "log", "all"];
+/**
+ * Sources the dashboard can read. The first five are live streams; "all" is their unified
+ * timeline. "db" is a read-only on-device SQLite browser (a point-in-time snapshot, not a
+ * stream) and is handled as a distinct view.
+ */
+export const SOURCES = ["rtm", "network", "clog", "log", "all", "db"];
 /** Widgets a spec may compose. */
 export const VIZ = [
     "counter",
@@ -45,6 +50,9 @@ export function coerceSpec(input) {
     if (!isRecord(input))
         return BLANK_SPEC;
     const s = input;
+    // The DB browser has no match/viz/series to repair; leave its db/table/sql untouched.
+    if (s.source === "db")
+        return s;
     if (typeof s.match === "string") {
         // "all" mixes types whose summary fields differ, so a single field guess
         // would wrongly exclude other types; treat a bare-string match on "all"
@@ -90,6 +98,16 @@ export function validateSpec(s) {
     if (!spec.source || !SOURCES.includes(spec.source)) {
         return `source must be one of ${SOURCES.join("|")}`;
     }
+    // The DB browser is a distinct view: no viz/series/match. Only its optional deep-link
+    // fields are constrained (each must be a string when present).
+    if (spec.source === "db") {
+        for (const k of ["db", "table", "sql"]) {
+            if (spec[k] !== undefined && typeof spec[k] !== "string") {
+                return `${k} must be a string`;
+            }
+        }
+        return null;
+    }
     if (spec.match !== undefined && !isRecord(spec.match)) {
         return "match must be an object";
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@slack/radar-mcp",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "MCP server and web dashboard for on-device debugging of the Slack Android app via ADB",
   "type": "module",
   "main": "dist/mcp/index.js",