@slack/radar-mcp 1.5.0 → 1.7.0

package/README.md

@@ -45,9 +45,10 @@ Opens `http://localhost:8100` automatically. Set `SLACK_RADAR_WEB_PORT` to use a
 * **RTM** — real-time websocket events
 * **Clogs** — analytics events, click one to see its payload
 * **Logs** — device logcat, filtered to the Slack app (switch app or clear the filter)
+* **Database** — read-only browser for the on-device SQLite stores (pick a database, then a table, or run a read-only query). See the data-handling note below.
 * **Custom** — a tab Claude builds on request. Ask a Claude Code session in your terminal for a view the pre-built tabs do not cover (e.g. "graph calls per second and flag the slow ones"); it authors the view via the `open_radar_dashboard` tool and it appears here. Persists until you refresh the page.
 
-Each tab has a counter, rate, sparkline, graph, a filter / sort / pause feed, and a payload inspector. Switching tabs replays what you have already seen this session (the browser caches it, bounded by count and age) so the view does not reset to empty. ADB forwarding and device activation are handled for you; a reconnect control re-arms after a device sleep.
+Each tab has a rate, sparkline, graph, a filter / sort / pause feed, and a payload inspector. Switching tabs replays what you have already seen this session (the browser caches it, bounded by count and age) so the view does not reset to empty. ADB forwarding and device activation are handled for you; a reconnect control re-arms after a device sleep. The dashboard follows your system light/dark setting by default; the theme toggle in the header overrides it and is remembered.
 
 ### Screen overlay
 
@@ -89,7 +90,7 @@ Radar starts **disabled** each session. All tools except `ping` return an error
 | `wait_for_events` | Block until matching events arrive via SSE stream. Idle-timeout based, not polling. |
 | `search` | Full-text search across network, RTM, and clog buffers. |
 | `get_app_state` | Current Activity/Fragment state via `dumpsys`. Shows visible screen, parameters, tab state. |
-| `get_recent_logs` | Logcat entries filtered by tag. For Timber debug logs (`FKDebug`, `SlackRadar`, etc.). |
+| `get_recent_logs` | Recent device logs, optionally filtered by tag (omit `tag` for all lines). Reads the app's own debug log buffer first, falling back to logcat; the result's `source` field (`app_buffer` / `logcat_capture` / `logcat_ring`) names which one served it. For Timber debug logs (`FKDebug`, `SlackRadar`, etc.). |
 | `screenshot` | Capture device screen as PNG. 720px default, `full_res=true` for full resolution. |
 | `record_screen` | Record short screen video (MP4). Default 5s, max 30s. |
 | `clear_buffers` | Clear all captured network calls and RTM events from device and local buffers. |
@@ -146,7 +147,7 @@ This tool captures unredacted network traffic from your debug Slack build, inclu
 * RTM WebSocket payloads (every sent and received message)
 * Analytics (clog) events serialized as JSON
 * Screenshots and short screen recordings on demand
-* Logcat entries filtered by tag
+* Device logs (the app's own debug buffer, with a logcat fallback), optionally filtered by tag
 
 Auth tokens and session cookies will appear in captured data. Captured data flows to your MCP client (Claude Code), which may send relevant portions to the configured AI provider per its own data handling policy.
 
@@ -185,4 +186,4 @@ The MCP server auto-detects the Android user ID via `ps` and targets the broadca
 Restart your Claude Code session. MCP servers are registered at session start.
 
 **Port already in use (web dashboard)**
-Another instance may be running. Kill it with `lsof -ti :8100 | xargs kill` or set a different port with `SLACK_RADAR_WEB_PORT=8101 npx @slack/radar-mcp web`.
+If a Radar dashboard is already running on the port, launching again just opens it. If the port is held by another program, run Radar on a different port with `SLACK_RADAR_WEB_PORT=8101 npx @slack/radar-mcp web`.

package/dist/mcp/api-paths.d.ts

@@ -0,0 +1 @@
+export declare function buildApiPath(name: string, args: Record<string, unknown>): string | null;

package/dist/mcp/api-paths.js

@@ -0,0 +1,108 @@
+// Maps an MCP tool name + its args to the device HTTP path the MCP server proxies it to.
+// Extracted from index.ts (where it was nested inside runMcpServer, so unreachable by a unit
+// test) into its own module so the device-route contract for EVERY proxied tool -- network,
+// rtm, clog, trace, search, and the detail-by-id variants -- is pinned by a table test
+// (tests/api-paths.test.mjs). Pure: no I/O, no device, just string building.
+//
+// The arg shapes here are the query-param subset each tool sends; they intentionally duplicate
+// the (wider) handler arg interfaces in index.ts rather than couple this pure module to them.
+// Build the device path for a detail-by-id tool. The MCP SDK casts args without enforcing the
+// JSON Schema (no zod), so `id` can arrive as a string carrying "/" or ".." even though the
+// schema says number. All four detail tools (network/rtm/clog/trace) read the device's OWN
+// forwarded server with no shell/fs, so the blast radius is small, but an un-encoded id is still
+// a path-traversal smell. Accept only a non-negative integer id; anything else returns null
+// (the caller reports "unknown tool"/no path rather than firing a malformed device request).
+function detailPath(resource, id) {
+    let n;
+    if (typeof id === "number") {
+        n = id;
+    }
+    else if (typeof id === "string" && /^\d+$/.test(id.trim())) {
+        // a clean digit string only -- Number("") and Number(" ") are 0 and Number("1/../x") is NaN,
+        // but "1e3"/"0x10"/"  5  " would also coerce; the \d+ test rejects all of those outright.
+        n = Number(id.trim());
+    }
+    else {
+        return null;
+    }
+    if (!Number.isInteger(n) || n < 0)
+        return null;
+    return `/api/${resource}/${n}`;
+}
+export function buildApiPath(name, args) {
+    switch (name) {
+        case "get_recent_network_calls": {
+            const a = args;
+            const params = new URLSearchParams();
+            if (a?.limit)
+                params.set("limit", String(a.limit));
+            if (a?.url_filter)
+                params.set("url_filter", a.url_filter);
+            if (a?.status_code)
+                params.set("status_code", String(a.status_code));
+            const qs = params.toString();
+            return `/api/network${qs ? "?" + qs : ""}`;
+        }
+        case "get_network_call_detail": {
+            const a = args;
+            return detailPath("network", a.id);
+        }
+        case "get_recent_rtm_events": {
+            const a = args;
+            const params = new URLSearchParams();
+            if (a?.limit)
+                params.set("limit", String(a.limit));
+            if (a?.event_type)
+                params.set("event_type", a.event_type);
+            if (a?.direction)
+                params.set("direction", a.direction);
+            if (a?.channel)
+                params.set("channel", a.channel);
+            const qs = params.toString();
+            return `/api/rtm${qs ? "?" + qs : ""}`;
+        }
+        case "get_rtm_event_detail": {
+            const a = args;
+            return detailPath("rtm", a.id);
+        }
+        case "get_recent_clogs": {
+            const a = args;
+            const params = new URLSearchParams();
+            if (a?.limit)
+                params.set("limit", String(a.limit));
+            if (a?.name)
+                params.set("name", a.name);
+            const qs = params.toString();
+            return `/api/clogs${qs ? "?" + qs : ""}`;
+        }
+        case "get_clog_detail": {
+            const a = args;
+            return detailPath("clogs", a.id);
+        }
+        case "get_recent_traces": {
+            const a = args;
+            const params = new URLSearchParams();
+            // Default the limit when absent: traces can be large and an omitted limit would otherwise
+            // rely on an unverified device-side default and stream an unbounded result into the model
+            // context. 50 matches the other recent-* tools' practical page size.
+            params.set("limit", String(a?.limit && a.limit > 0 ? a.limit : 50));
+            if (a?.name)
+                params.set("name", a.name);
+            return `/api/traces?${params.toString()}`;
+        }
+        case "get_trace_detail": {
+            const a = args;
+            return detailPath("traces", a.id);
+        }
+        case "search": {
+            const a = args;
+            const params = new URLSearchParams();
+            params.set("q", a.query);
+            if (a?.limit)
+                params.set("limit", String(a.limit));
+            return `/api/search?${params.toString()}`;
+        }
+        default:
+            return null;
+    }
+}

package/dist/mcp/db-tools.d.ts

@@ -0,0 +1,46 @@
+/**
+ * MCP tool handlers for the on-device SQLite browser.
+ *
+ * These expose the same read-only DB access the web dashboard already has (src/web/server.ts),
+ * but over MCP so terminal Claude can inspect the device store during a debugging session
+ * without opening the dashboard. All the work lives in shared/db.ts; these handlers are thin
+ * wrappers that resolve the bound profile and shape the result for MCP.
+ *
+ * Read-only is enforced in shared/db.ts: the copy-based design (the device file is `cat`'d to
+ * a throwaway local copy and never written back) plus `sqlite3 -safe` (blocks ATTACH/readfile/
+ * writefile/load_extension at the engine level) plus the single-statement read-only gate
+ * (assertReadOnlyQuery). NOTE: the copy is opened WITHOUT `-readonly` on purpose, so SQLite
+ * replays the WAL sidecar; the read-only guarantee does not depend on the open mode. This
+ * handler calls assertReadOnlyQuery() up front so a bad query is rejected BEFORE the device
+ * pull, and results are capped by both row count and serialized bytes (see capQueryRows) so
+ * neither a `SELECT *` nor a one-row `group_concat` dump can stream the whole plaintext store
+ * into the model context.
+ */
+import type { DeviceTransport } from "../shared/transport.js";
+/**
+ * Bound a result set for the model context by BOTH row count and serialized bytes. Pure (no
+ * I/O) so it is unit-testable without a device. Returns the rows to actually return plus the
+ * honest counters. truncated is true if EITHER ceiling trips. A single row larger than the
+ * byte budget cannot be split, so it is dropped (returnedRows 0) rather than blowing the
+ * budget — the note says so, and total_rows still reports the true count so the model knows
+ * data exists and can re-query a narrower projection.
+ */
+export declare function capQueryRows(rows: unknown[]): {
+    rows: unknown[];
+    rowCount: number;
+    totalRows: number;
+    truncated: boolean;
+    note?: string;
+};
+export declare function handleListDatabases(transport: DeviceTransport): {
+    data: unknown;
+    isError: boolean;
+};
+export declare function handleListTables(transport: DeviceTransport, db: string, refresh?: boolean): Promise<{
+    data: unknown;
+    isError: boolean;
+}>;
+export declare function handleQueryDatabase(transport: DeviceTransport, db: string, sql: string, refresh?: boolean): Promise<{
+    data: unknown;
+    isError: boolean;
+}>;

package/dist/mcp/db-tools.js

@@ -0,0 +1,160 @@
+/**
+ * MCP tool handlers for the on-device SQLite browser.
+ *
+ * These expose the same read-only DB access the web dashboard already has (src/web/server.ts),
+ * but over MCP so terminal Claude can inspect the device store during a debugging session
+ * without opening the dashboard. All the work lives in shared/db.ts; these handlers are thin
+ * wrappers that resolve the bound profile and shape the result for MCP.
+ *
+ * Read-only is enforced in shared/db.ts: the copy-based design (the device file is `cat`'d to
+ * a throwaway local copy and never written back) plus `sqlite3 -safe` (blocks ATTACH/readfile/
+ * writefile/load_extension at the engine level) plus the single-statement read-only gate
+ * (assertReadOnlyQuery). NOTE: the copy is opened WITHOUT `-readonly` on purpose, so SQLite
+ * replays the WAL sidecar; the read-only guarantee does not depend on the open mode. This
+ * handler calls assertReadOnlyQuery() up front so a bad query is rejected BEFORE the device
+ * pull, and results are capped by both row count and serialized bytes (see capQueryRows) so
+ * neither a `SELECT *` nor a one-row `group_concat` dump can stream the whole plaintext store
+ * into the model context.
+ */
+import { assertReadOnlyQuery, listDatabases, pullDatabase, queryDatabase, pulledSize, } from "../shared/db.js";
+/**
+ * Caps on what query_database streams into the MODEL CONTEXT. The on-device store holds tens
+ * of thousands of plaintext message/PII rows; an unbounded result would dump the whole store
+ * into the transcript (db.ts only bounds the raw sqlite output at 64MB).
+ *
+ * Two independent ceilings, because bounding rows alone is not enough: a single
+ * `SELECT group_concat(text) FROM messages` collapses the entire table into ONE row whose
+ * lone column is every message body — that sails past a row-count cap untouched. So we cap
+ * BOTH the row count AND the serialized byte size of the returned payload.
+ *
+ * The web dashboard is intentionally exempt (handleDbQuery in web/server.ts returns the
+ * uncapped set): it renders to a consenting local human behind a privacy banner, not into an
+ * LLM transcript, so a large render is a UI annoyance, not the context/PII harm this guards.
+ * (It does not paginate; the exemption is about WHO consumes the rows, not how they are shown.)
+ */
+const MAX_QUERY_ROWS = 500;
+const MAX_QUERY_BYTES = 256 * 1024; // serialized cap on rows returned to the model (~256KB)
+/**
+ * Bound a result set for the model context by BOTH row count and serialized bytes. Pure (no
+ * I/O) so it is unit-testable without a device. Returns the rows to actually return plus the
+ * honest counters. truncated is true if EITHER ceiling trips. A single row larger than the
+ * byte budget cannot be split, so it is dropped (returnedRows 0) rather than blowing the
+ * budget — the note says so, and total_rows still reports the true count so the model knows
+ * data exists and can re-query a narrower projection.
+ */
+export function capQueryRows(rows) {
+    const total = rows.length;
+    const byCount = rows.length > MAX_QUERY_ROWS ? rows.slice(0, MAX_QUERY_ROWS) : rows.slice();
+    // Then trim by serialized size: keep prefix rows until the JSON budget is hit. Measure UTF-8
+    // BYTES (Buffer.byteLength), not String.length: the MCP layer emits this payload as UTF-8 over
+    // stdio, and .length counts UTF-16 code units, so an emoji/CJK row (surrogate pairs: 2 code
+    // units, 4 UTF-8 bytes) would otherwise pass at up to ~2x the real wire size.
+    const kept = [];
+    let bytes = 0;
+    for (const r of byCount) {
+        const sz = Buffer.byteLength(JSON.stringify(r) ?? "", "utf8");
+        if (kept.length > 0 && bytes + sz > MAX_QUERY_BYTES)
+            break;
+        kept.push(r);
+        bytes += sz;
+        if (bytes > MAX_QUERY_BYTES)
+            break; // a single oversized first row trips here; dropped below
+    }
+    // If even the first kept row blew the budget, drop it: do not stream a >256KB blob.
+    const overBudget = kept.length === 1 && bytes > MAX_QUERY_BYTES;
+    const finalRows = overBudget ? [] : kept;
+    const truncated = finalRows.length < total;
+    let note;
+    if (overBudget) {
+        note = `first row alone exceeds the ${Math.round(MAX_QUERY_BYTES / 1024)}KB response budget; returned no rows. Select fewer/narrower columns (avoid group_concat/blob dumps).`;
+    }
+    else if (truncated) {
+        note = `result truncated to ${finalRows.length} of ${total} rows (row or byte budget); narrow with WHERE/LIMIT or fewer columns.`;
+    }
+    return { rows: finalRows, rowCount: finalRows.length, totalRows: total, truncated, note };
+}
+/** Resolve the Android profile Radar is bound to. Returns undefined so db.ts falls back to its first available user. */
+function resolveUser(transport) {
+    try {
+        return transport.resolveActiveUser();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function handleListDatabases(transport) {
+    try {
+        const { user, availableUsers, names } = listDatabases(resolveUser(transport));
+        return { data: { user, available_users: availableUsers, databases: names }, isError: false };
+    }
+    catch (e) {
+        return { data: { error: e.message, databases: [] }, isError: true };
+    }
+}
+export async function handleListTables(transport, db, refresh = false) {
+    if (!db)
+        return { data: { error: "db is required" }, isError: true };
+    const user = resolveUser(transport);
+    try {
+        // force=refresh re-pulls the live device copy; default reuses the cached pull so a
+        // multi-MB store is not re-streamed on every call.
+        await pullDatabase(db, user, refresh);
+        const tableRows = (await queryDatabase(db, "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name", user));
+        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 cleanly; leave "?"
+            }
+            tables.push({ name: t.name, rows });
+        }
+        return { data: { db, size_bytes: pulledSize(db, user), tables }, isError: false };
+    }
+    catch (e) {
+        return { data: { error: e.message, tables: [] }, isError: true };
+    }
+}
+export async function handleQueryDatabase(transport, db, sql, refresh = false) {
+    if (!db)
+        return { data: { error: "db is required" }, isError: true };
+    if (!sql)
+        return { data: { error: "sql is required" }, isError: true };
+    // Gate the SQL BEFORE the device pull: a rejected write/exfil query must not trigger a
+    // multi-MB `exec-out cat` first. queryDatabase re-checks, so this is an early-out, not the
+    // sole boundary. Running device-free, it also makes the read-only gate unit-testable here.
+    try {
+        assertReadOnlyQuery(sql);
+    }
+    catch (e) {
+        return { data: { error: e.message, rows: [] }, isError: true };
+    }
+    const user = resolveUser(transport);
+    try {
+        // force=refresh re-pulls the live device copy; default reuses the cached pull. Pass
+        // refresh:true when the device state may have changed since the first query this session.
+        await pullDatabase(db, user, refresh);
+        const rows = await queryDatabase(db, sql, user);
+        // Cap what goes into the model context by BOTH row count and serialized bytes: the store
+        // is plaintext PII and a broad SELECT (or a group_concat that collapses the table into one
+        // huge row) would otherwise dump it into the transcript. See capQueryRows.
+        const capped = capQueryRows(rows);
+        return {
+            data: {
+                db,
+                sql,
+                row_count: capped.rowCount,
+                total_rows: capped.totalRows,
+                truncated: capped.truncated,
+                ...(capped.note ? { note: capped.note } : {}),
+                rows: capped.rows,
+            },
+            isError: false,
+        };
+    }
+    catch (e) {
+        return { data: { error: e.message, rows: [] }, isError: true };
+    }
+}

package/dist/mcp/index.js

@@ -12,7 +12,11 @@ import { RADAR_HOST, RADAR_PORT, WEB_PORT_DEFAULT } from "../shared/constants.js
 import { stopCapture } from "../shared/logcat-capture.js";
 import { connectStream, destroyStream, waitForEvents, clearLocalBuffers, isStreamConnected, localNetworkBuffer, localRtmBuffer, setTransport, } from "../shared/stream.js";
 import { buildBufferPath, createSnapshot } from "./snapshot.js";
+import { clampLogLimit, shapeLogsResult } from "./logs-result.js";
+import { handleListDatabases, handleListTables, handleQueryDatabase, } from "./db-tools.js";
+import { cleanupPulledDatabases, initializeDatabasePath, resetDbState, } from "../shared/db.js";
 import { TOOL_DEFINITIONS, SERVER_INSTRUCTIONS, sessionGate } from "./tools.js";
+import { buildApiPath } from "./api-paths.js";
 // --- Subcommand + bin-name dispatch ---
 //
 // One entrypoint, two front doors, chosen so each invocation does the obvious thing:
@@ -164,7 +168,8 @@ async function openDashboardSpec(spec) {
     return r.json;
 }
 if (wantsWeb) {
-    await import("../web/bin.js");
+    const { startWebServer } = await import("../web/bin.js");
+    startWebServer();
 }
 else {
     await runMcpServer();
@@ -183,9 +188,42 @@ async function runMcpServer() {
     }
     const device = createTransport();
     setTransport(device);
+    // Scope pulled-DB copies to THIS process by pid, then clean them on exit (mirrors the web
+    // server's lifecycle). The DB tools write plaintext message-store copies to a 0600 tmp dir;
+    // pid-scoping keeps two concurrent Radar MCP servers from sharing a dir and clobbering each
+    // other's live pulls (a fixed port would collide, since every MCP uses the same RADAR_PORT).
+    // A hard crash leaks this process's dir until the OS sweeps tmp; the files stay 0600 in a
+    // 0700 dir, so that is a bounded exposure, not a cross-user leak.
+    initializeDatabasePath(process.pid);
+    cleanupPulledDatabases();
+    for (const sig of ["SIGINT", "SIGTERM", "exit"]) {
+        process.once(sig, cleanupPulledDatabases);
+    }
     let sessionEnabled = false;
+    // Host-side ceiling on a proxied device response. radarRequest forwards the device body straight
+    // into the model context, so an unbounded response (large trace/clog payloads) could flood it.
+    // When the cap trips we stop reading, tear the socket down, and return a truncation marker
+    // rather than a partial JSON blob the parser would choke on. 1MB is generous for a point query;
+    // bulk exports go through capture_snapshot, not this path.
+    const MAX_RADAR_RESPONSE_BYTES = 1024 * 1024;
     function radarRequest(requestPath) {
         return new Promise((resolve, reject) => {
+            // settled-guard: req.destroy() on the cap path fires "error" (ECONNRESET) AFTER we have
+            // already resolved the truncation, so every settle goes through these wrappers and the
+            // second one is a no-op. Without this the abort would reject an already-resolved promise.
+            let settled = false;
+            const done = (r) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(r);
+            };
+            const fail = (e) => {
+                if (settled)
+                    return;
+                settled = true;
+                reject(e);
+            };
             const req = http.get({
                 host: RADAR_HOST,
                 port: RADAR_PORT,
@@ -193,22 +231,36 @@ async function runMcpServer() {
                 timeout: 10000,
             }, (res) => {
                 let data = "";
+                let bytes = 0;
                 res.on("data", (chunk) => {
+                    if (settled)
+                        return;
+                    bytes += chunk.length; // byte length, not String.length (UTF-8 over the wire)
+                    if (bytes > MAX_RADAR_RESPONSE_BYTES) {
+                        // Resolve the truncation NOW (not on "end" — req.destroy() aborts the response so
+                        // "end" never fires; it surfaces as an "error" the settled-guard then swallows).
+                        done({
+                            error: `Device response exceeded the ${Math.round(MAX_RADAR_RESPONSE_BYTES / 1024)}KB response budget and was dropped to protect the model context. Narrow the query (lower limit, add a name/filter), or use capture_snapshot for a bulk export.`,
+                            _truncated: true,
+                        });
+                        req.destroy();
+                        return;
+                    }
                     data += chunk;
                 });
                 res.on("end", () => {
                     try {
-                        resolve(JSON.parse(data));
+                        done(JSON.parse(data));
                     }
                     catch {
-                        resolve({ raw: data });
+                        done({ raw: data });
                     }
                 });
             });
-            req.on("error", reject);
+            req.on("error", fail);
             req.on("timeout", () => {
                 req.destroy();
-                reject(new Error("Request timed out"));
+                fail(new Error("Request timed out"));
             });
         });
     }
@@ -260,6 +312,10 @@ async function runMcpServer() {
     async function handleSessionEnable(args) {
         const timeout = args?.timeout_minutes || 5;
         sessionEnabled = true;
+        // A re-enable may be a different device or a re-armed profile, so drop the cached DB
+        // user set + sqlite path; the next DB tool call re-detects the profiles fresh. Mirrors
+        // the web server's handleEnable (server.ts), which resets for the same reason.
+        resetDbState();
         const forwarded = device.ensureForward();
         if (!forwarded) {
             sessionEnabled = false;
@@ -409,18 +465,14 @@ async function runMcpServer() {
     }
     function handleGetRecentLogs(args) {
         try {
-            const lines = device.getRecentLogs(args.tag, args.limit || 50, args.grep);
-            // Surface the capture file path so the model knows which on-disk file
-            // produced these lines. Helps avoid cross-session staleness (e.g. the
-            // model remembering an earlier profile's logs after a profile switch).
-            const sourceFile = device.getCaptureFilePath?.() ?? null;
-            return textResult({
-                tag: args.tag,
-                lines,
-                count: lines.length,
-                source_file: sourceFile,
-                source: sourceFile ? "capture" : "adb_logcat_d",
-            });
+            const tag = args.tag ?? "";
+            const limit = clampLogLimit(args.limit);
+            const result = device.getRecentLogs(tag, limit, args.grep);
+            // shapeLogsResult preserves the source label (app_buffer / logcat_capture / logcat_ring)
+            // that getRecentLogs returns, so the caller can tell a true-empty result from a silent
+            // fallback to an inferior source (0 lines from app_buffer means the tag is really absent;
+            // 0 from logcat_ring may mean the better source was unreachable).
+            return textResult(shapeLogsResult(tag, result));
         }
         catch (e) {
             return textResult({ error: `Log query failed: ${e.message}`, lines: [] }, true);
@@ -499,70 +551,8 @@ async function runMcpServer() {
             }, true);
         }
     }
-    function buildApiPath(name, args) {
-        switch (name) {
-            case "get_recent_network_calls": {
-                const a = args;
-                const params = new URLSearchParams();
-                if (a?.limit)
-                    params.set("limit", String(a.limit));
-                if (a?.url_filter)
-                    params.set("url_filter", a.url_filter);
-                if (a?.status_code)
-                    params.set("status_code", String(a.status_code));
-                const qs = params.toString();
-                return `/api/network${qs ? "?" + qs : ""}`;
-            }
-            case "get_network_call_detail": {
-                const a = args;
-                return `/api/network/${a.id}`;
-            }
-            case "get_recent_rtm_events": {
-                const a = args;
-                const params = new URLSearchParams();
-                if (a?.limit)
-                    params.set("limit", String(a.limit));
-                if (a?.event_type)
-                    params.set("event_type", a.event_type);
-                if (a?.direction)
-                    params.set("direction", a.direction);
-                if (a?.channel)
-                    params.set("channel", a.channel);
-                const qs = params.toString();
-                return `/api/rtm${qs ? "?" + qs : ""}`;
-            }
-            case "get_rtm_event_detail": {
-                const a = args;
-                return `/api/rtm/${a.id}`;
-            }
-            case "get_recent_clogs": {
-                const a = args;
-                const params = new URLSearchParams();
-                if (a?.limit)
-                    params.set("limit", String(a.limit));
-                if (a?.name)
-                    params.set("name", a.name);
-                const qs = params.toString();
-                return `/api/clogs${qs ? "?" + qs : ""}`;
-            }
-            case "get_clog_detail": {
-                const a = args;
-                return `/api/clogs/${a.id}`;
-            }
-            case "search": {
-                const a = args;
-                const params = new URLSearchParams();
-                params.set("q", a.query);
-                if (a?.limit)
-                    params.set("limit", String(a.limit));
-                return `/api/search?${params.toString()}`;
-            }
-            default:
-                return null;
-        }
-    }
     // --- MCP Server ---
-    const server = new Server({ name: "slack-radar", version: "1.5.0" }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+    const server = new Server({ name: "slack-radar", version: "1.7.0" }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: TOOL_DEFINITIONS,
     }));
@@ -617,6 +607,20 @@ async function runMcpServer() {
         if (name === "ping") {
             return handlePing(toolArgs);
         }
+        if (name === "list_databases") {
+            const { data, isError } = handleListDatabases(device);
+            return textResult(data, isError);
+        }
+        if (name === "list_tables") {
+            const { db, refresh } = toolArgs;
+            const { data, isError } = await handleListTables(device, db ?? "", refresh === true);
+            return textResult(data, isError);
+        }
+        if (name === "query_database") {
+            const { db, sql, refresh } = toolArgs;
+            const { data, isError } = await handleQueryDatabase(device, db ?? "", sql ?? "", refresh === true);
+            return textResult(data, isError);
+        }
         const apiPath = buildApiPath(name, toolArgs);
         if (apiPath === null) {
             return textResult(`Unknown tool: ${name}`, true);

package/dist/mcp/logs-result.d.ts

@@ -0,0 +1,9 @@
+import type { LogResult } from "../shared/transport.js";
+export interface LogsToolResult {
+    tag: string;
+    lines: string[];
+    count: number;
+    source?: string;
+}
+export declare function clampLogLimit(limit: number | undefined): number;
+export declare function shapeLogsResult(tag: string, result: LogResult): LogsToolResult;

package/dist/mcp/logs-result.js

@@ -0,0 +1,15 @@
+// Clamp the requested line count. With tag optional, a no-tag call returns the whole buffer
+// (thousands of lines, ~1.5MB), so an unbounded limit would flood the model context with
+// potentially PII-bearing log lines. 1000 is a generous ceiling for a debug read; default 50.
+export function clampLogLimit(limit) {
+    return Math.min(Math.max(limit || 50, 1), 1000);
+}
+// Shape the device result into the tool payload, preserving the source label verbatim.
+export function shapeLogsResult(tag, result) {
+    return {
+        tag,
+        lines: result.lines,
+        count: result.lines.length,
+        source: result.source,
+    };
+}