@slack/radar-mcp 1.6.0 → 1.8.0

package/dist/mcp/tools.js

@@ -20,9 +20,10 @@ export const SERVER_INSTRUCTIONS = [
     '- "why isn\'t this loading" / "this is broken" -> screenshot + get_recent_network_calls(status_code=400 or 500)',
     '- "watch what happens when I..." -> clear_buffers then wait_for_events (DO NOT filter unless the user specifies a type)',
     '- "did that clog fire" / "check analytics" -> get_recent_clogs(name="...")',
+    '- "why is this slow" / "how long did X take" / "show me the traces" / "check performance" -> get_recent_traces(name="...") then get_trace_detail',
     '- "what API call was that" -> get_recent_network_calls then get_network_call_detail',
     '- "did I get X" / "did X happen" -> search(query="X") across ALL buffers, not just one',
-    '- "check the debug logs" -> get_recent_logs(tag="...")',
+    '- "check the debug logs" -> get_recent_logs (tag is OPTIONAL: pass tag="FKDebug" to filter, or omit it for all recent lines)',
     '- "save this" / "file this as a bug" / "share this" / "bundle this" / "attach to ticket" / "give me a repro" / "snapshot this" / "preserve this" / "hold this state" / "save what you just saw" -> capture_snapshot',
     "",
     "Key behaviors:",
@@ -101,10 +102,10 @@ export const SERVER_INSTRUCTIONS = [
     "When capture_snapshot returns, tell the user:",
     "  1. The result.zip_path if non-null (the single shareable file). Fall back to",
     "     result.path (a directory) if zip_path is null.",
-    "  2. A one-line summary of counts (network/rtm/clogs/log_lines/screenshot).",
+    "  2. A one-line summary of counts (network/rtm/clogs/traces/log_lines/screenshot).",
     "  3. Print this EXACT sentence as the privacy line, verbatim — no paraphrase, no",
     "     compression, no skipping even under time pressure:",
-    '     "Privacy: bundle.json contains raw API request/response bodies (including auth headers), RTM message content, user IDs, and clog payloads. Review before sharing externally."',
+    '     "Privacy: bundle.json contains raw API request/response bodies (including auth headers), RTM message content, user IDs, clog payloads, and performance trace spans. Review before sharing externally."',
     "  4. If result.log_lines_truncated is true, say: 'you got fewer log lines than",
     "     requested because the 1 MB read cap was the limiting factor.'",
     "  5. If the user's original ask was 'file this as a bug' / 'attach to ticket' /",
@@ -203,6 +204,30 @@ export const TOOL_DEFINITIONS = [
         },
         annotations: { readOnlyHint: true },
     },
+    {
+        name: "get_recent_traces",
+        description: "Get recent performance trace summaries (one row per completed span from the app's telemetry pipeline). Returns trace name, span name, and duration. Use get_trace_detail for the full span, including its tags and the parent/trace ids.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", description: "Max number of traces to return (default: 50)" },
+                name: { type: "string", description: "Filter by trace name or span name substring" },
+            },
+        },
+        annotations: { readOnlyHint: true },
+    },
+    {
+        name: "get_trace_detail",
+        description: "Get full details of a specific performance trace by ID: trace and span names, the trace and parent ids, start/end/duration, and the span tags.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "number", description: "The trace ID from get_recent_traces" },
+            },
+            required: ["id"],
+        },
+        annotations: { readOnlyHint: true },
+    },
     {
         name: "wait_for_events",
         description: "Wait for matching events to arrive in real-time via the SSE stream.",
@@ -211,7 +236,7 @@ export const TOOL_DEFINITIONS = [
             properties: {
                 event_type: { type: "string", description: "RTM event type to wait for" },
                 channel: { type: "string", description: "Filter by channel ID" },
-                source: { type: "string", description: "Wait for network calls or RTM events (default: both)" },
+                source: { type: "string", description: "Limit to one stream: network, rtm, clog, log, or trace (default: all)" },
                 timeout_ms: { type: "number", description: "Max time to wait in ms (default: 30000)" },
                 idle_timeout_ms: { type: "number", description: "Resolve after this many ms of silence (default: 3000)" },
             },
@@ -220,7 +245,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "search",
-        description: "Search across all captured network calls and RTM events.",
+        description: "Search across all captured network calls, RTM events, clogs, and performance traces.",
         inputSchema: {
             type: "object",
             properties: {
@@ -239,15 +264,14 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "get_recent_logs",
-        description: "Get recent device logs for the Slack debug build, filtered by tag. Reads the app's own log buffer first (the DEBUG-and-above Timber lines the in-app Log Viewer shows, this app only), and falls back to an adb logcat snapshot when that buffer cannot be read. For native crashes, VERBOSE lines, or non-Slack processes, use adb logcat directly.",
+        description: "Get recent device logs for the Slack debug build. Reads the app's own log buffer first (the DEBUG-and-above Timber lines the in-app Log Viewer shows, this app only), and falls back to an adb logcat snapshot when that buffer cannot be read. The result includes a `source` field (app_buffer / logcat_capture / logcat_ring) so you can tell a real empty result from a fallback. Leave `tag` out to get all recent lines. For native crashes, VERBOSE lines, or non-Slack processes, use adb logcat directly.",
         inputSchema: {
             type: "object",
             properties: {
-                tag: { type: "string", description: "Substring to filter log lines by (matched anywhere in the line, not an exact tag-column match)" },
-                limit: { type: "number", description: "Max number of lines to return (default: 50)" },
+                tag: { type: "string", description: "Optional substring to filter log lines by (matched anywhere in the line, not an exact tag-column match). Omit to return all recent lines." },
+                limit: { type: "number", description: "Max number of lines to return (default: 50, capped at 1000)" },
                 grep: { type: "string", description: "Optional text to grep within the filtered output" },
             },
-            required: ["tag"],
         },
         annotations: { readOnlyHint: true },
     },
@@ -278,7 +302,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "capture_snapshot",
-        description: "Bundle the current Radar state into a single on-disk artifact for sharing. Writes four files to ~/.slack-radar/snapshots/snapshot-<ts>/: bundle.json (network + RTM + clog buffers, up to 1000 items each — a bulk export, much larger than point queries like get_network_call_detail), logcat.tail.log (last N lines of the active capture), screenshot.png (current screen), and README.txt (receiver-facing explainer). Use when the user says 'save this', 'file this as a bug', 'share this', 'bundle this up', 'attach to a ticket', 'make me a repro', or otherwise wants a shareable reproducible handoff. PRIVACY: bundle.json contains raw API request/response bodies including auth headers, RTM message content, user/team/channel IDs, and clog payloads — review before sharing externally.",
+        description: "Bundle the current Radar state into a single on-disk artifact for sharing. Writes four files to ~/.slack-radar/snapshots/snapshot-<ts>/: bundle.json (network + RTM + clog + trace buffers, up to 1000 items each — a bulk export, much larger than point queries like get_network_call_detail), logcat.tail.log (last N lines of the active capture), screenshot.png (current screen), and README.txt (receiver-facing explainer). Use when the user says 'save this', 'file this as a bug', 'share this', 'bundle this up', 'attach to a ticket', 'make me a repro', or otherwise wants a shareable reproducible handoff. PRIVACY: bundle.json contains raw API request/response bodies including auth headers, RTM message content, user/team/channel IDs, clog payloads, and performance trace spans — review before sharing externally.",
         inputSchema: {
             type: "object",
             properties: {

package/dist/shared/android.d.ts

@@ -1,4 +1,4 @@
-import type { DeviceTransport } from "./transport.js";
+import type { DeviceTransport, LogResult } from "./transport.js";
 /**
  * Resolve the adb binary. MCP servers spawned from GUI launchers (Spotlight,
  * Raycast, Dock) do not inherit the user's shell PATH, so a bare `adb` call
@@ -44,7 +44,7 @@ export declare class AndroidTransport implements DeviceTransport {
     screenshot(fullRes: boolean): string;
     recordScreen(durationS: number): string;
     getAppState(): string;
-    getRecentLogs(tag: string, limit: number, grep?: string): string[];
+    getRecentLogs(tag: string, limit: number, grep?: string): LogResult;
     listProfiles(): {
         userId: string;
         label: string;

package/dist/shared/android.js

@@ -1,4 +1,4 @@
-import { execSync } from "child_process";
+import { execSync, execFileSync } from "child_process";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -209,7 +209,7 @@ export class AndroidTransport {
         // sandbox -- matching how the DB browser threads its user.
         const appLog = readDebugLogBuffer(ADB, this.resolveActiveUser());
         if (appLog !== null) {
-            return filterLogLines(appLog, tag, limit, grep);
+            return { lines: filterLogLines(appLog, tag, limit, grep), source: "app_buffer" };
         }
         // Fallback: read from the session capture file so lines cannot have been
         // evicted from the device ring buffer between enable and now.
@@ -220,20 +220,25 @@ export class AndroidTransport {
             rotateCaptureIfNeeded(ADB);
             const lines = readRecentLogs(tag, limit, grep);
             if (lines !== null)
-                return lines;
+                return { lines, source: "logcat_capture" };
         }
         // Fallback: device ring buffer snapshot. Used when capture is not running
-        // (activate() was skipped, child died, or the file was deleted).
-        let cmd = `${ADB} logcat -d | grep -F "${tag}" | tail -${limit}`;
-        if (grep) {
-            cmd = `${ADB} logcat -d | grep -F "${tag}" | grep -i "${grep.replace(/"/g, '\\"')}" | tail -${limit}`;
-        }
-        const output = execSync(cmd, {
+        // (activate() was skipped, child died, or the file was deleted). No shell:
+        // dump the ring with execFileSync (argv, so a tag/grep with a backtick,
+        // $(...), or trailing backslash cannot break out of a command string) and do
+        // the tag/grep/limit filtering in pure JS via the same filterLogLines the
+        // other two sources use. An empty tag means "no filter" (includes("") is
+        // true), so the whole tail is returned.
+        const output = execFileSync(ADB, ["logcat", "-d"], {
             timeout: 10000,
-            shell: "/bin/zsh",
             encoding: "utf-8",
+            maxBuffer: 64 * 1024 * 1024,
         });
-        return output.trim().split("\n").filter(Boolean);
+        const lines = output.split("\n").filter(Boolean);
+        return {
+            lines: filterLogLines(lines, tag, limit, grep),
+            source: "logcat_ring",
+        };
     }
     listProfiles() {
         if (!ADB)

package/dist/shared/db.d.ts

@@ -77,6 +77,19 @@ export declare function pullDatabase(name: string, user?: string | null, force?:
  * (1) and (2), not from the open mode.
  */
 export declare function assertReadOnlyQuery(sql: string): void;
+/**
+ * True for EXPLAIN / EXPLAIN QUERY PLAN, which sqlite3 prints as a text table (ignoring -json).
+ * Leading-token match; assertReadOnlyQuery gates the same leading keyword, so both reject on
+ * comment-prefixed queries before this routing matters.
+ */
+export declare function isExplainQuery(sql: string): boolean;
+/**
+ * sqlite3 ignores -json for EXPLAIN (prints text table instead of JSON).
+ * Shape it into row objects so the web grid renders the plan readably.
+ */
+export declare function parseExplainOutput(out: string): {
+    plan: string;
+}[];
 /**
  * Run a read-only query against a (lazily pulled) local copy. The query is gated by
  * assertReadOnlyQuery (see there for the full read-only/exfil rationale). Surfaces sqlite's

package/dist/shared/db.js

@@ -353,6 +353,24 @@ export function assertReadOnlyQuery(sql) {
         throw new Error("that function/statement is not allowed (read-only, no file access)");
     }
 }
+/**
+ * True for EXPLAIN / EXPLAIN QUERY PLAN, which sqlite3 prints as a text table (ignoring -json).
+ * Leading-token match; assertReadOnlyQuery gates the same leading keyword, so both reject on
+ * comment-prefixed queries before this routing matters.
+ */
+export function isExplainQuery(sql) {
+    return /^\s*explain\b/i.test(sql);
+}
+/**
+ * sqlite3 ignores -json for EXPLAIN (prints text table instead of JSON).
+ * Shape it into row objects so the web grid renders the plan readably.
+ */
+export function parseExplainOutput(out) {
+    return out
+        .split("\n")
+        .filter((line) => line.trim().length > 0)
+        .map((line) => ({ plan: line }));
+}
 /**
  * Run a read-only query against a (lazily pulled) local copy. The query is gated by
  * assertReadOnlyQuery (see there for the full read-only/exfil rationale). Surfaces sqlite's
@@ -365,6 +383,12 @@ export async function queryDatabase(name, sql, user) {
     const local = localPath(name, u);
     if (!fs.existsSync(local))
         await pullDatabase(name, u);
+    // EXPLAIN / EXPLAIN QUERY PLAN are read-query-shaped (they pass the gate) but sqlite3 IGNORES
+    // -json for them: it prints a fixed-width opcode/plan TEXT table, not JSON, so JSON.parse below
+    // would throw "Unexpected token" and the user sees a confusing parse error for a query that
+    // actually ran. Handle them as text: one result row per output line under a single column, so
+    // the existing grid renders the plan readably instead of choking.
+    const explain = isExplainQuery(sql);
     let out;
     try {
         // Open the pulled copy NORMALLY (not `immutable`, not `-readonly`): pullDatabase brought
@@ -375,14 +399,15 @@ export async function queryDatabase(name, sql, user) {
         // is touched. `-safe` is the load-bearing read-only/exfil control (blocks ATTACH/readfile/
         // writefile/load_extension at the engine level) and holds in normal mode too. The path is
         // URI-encoded so spaces/specials are safe. Async exec so a large query does not block the
-        // event loop.
+        // event loop. -json for normal queries; plain text for EXPLAIN (sqlite ignores -json there).
         const uri = `file:${encodeURI(local)}`;
-        const r = await execFileP(sqliteBin(), ["-safe", "-json", uri, sql], {
+        const args = explain ? ["-safe", uri, sql] : ["-safe", "-json", uri, sql];
+        const r = await execFileP(sqliteBin(), args, {
             timeout: 15000,
             maxBuffer: SQLITE_MAX_BUFFER,
             encoding: "utf8",
         });
-        out = String(r.stdout) || "[]";
+        out = String(r.stdout) || (explain ? "" : "[]");
     }
     catch (e) {
         const err = e;
@@ -390,6 +415,8 @@ export async function queryDatabase(name, sql, user) {
         const m = stderr.match(/(no such table:.*|no such column:.*|near ".*|syntax error.*|.*error.*)/i);
         throw new Error(m ? m[0].trim() : stderr.split("\n")[0] || "query failed");
     }
+    if (explain)
+        return parseExplainOutput(out);
     return JSON.parse(out);
 }
 /** Size in bytes of a pulled local copy for the given user, or 0 if not pulled. */

package/dist/shared/screen.d.ts

@@ -130,6 +130,16 @@ export declare function startLive(fps: number): LiveCast | null;
 /** Attach an HTTP response as a viewer of the live cast (after the multipart headers are written). */
 export declare function addViewer(L: LiveCast, res: NodeJS.WritableStream): void;
 export declare function removeViewer(res: NodeJS.WritableStream): void;
+/**
+ * Tear down the live cast when nothing is keeping it alive: no viewers AND no active
+ * recording. Either a viewer leaving or a recording stopping can be the last thing
+ * holding the cast, so both paths call this. The close-while-recording case needs it:
+ * the browser aborts the <img> (dropping the last viewer) BEFORE its record/stop POST
+ * resolves, so the viewer-leave finds recording still set and cannot reap; the cast
+ * would then run forever (screenrecord + ffmpeg) once the recording ends. Reaping again
+ * after stopRecording closes that gap.
+ */
+export declare function reapLiveIfIdle(): void;
 export declare function getLive(): LiveCast | null;
 export declare function lastFrame(): Buffer | null;
 export declare function primeIfNeeded(): Promise<void>;

package/dist/shared/screen.js

@@ -461,7 +461,19 @@ export function removeViewer(res) {
     if (!scLive)
         return;
     scLive.viewers.delete(res);
-    if (!scLive.viewers.size && !scLive.recording) {
+    reapLiveIfIdle();
+}
+/**
+ * Tear down the live cast when nothing is keeping it alive: no viewers AND no active
+ * recording. Either a viewer leaving or a recording stopping can be the last thing
+ * holding the cast, so both paths call this. The close-while-recording case needs it:
+ * the browser aborts the <img> (dropping the last viewer) BEFORE its record/stop POST
+ * resolves, so the viewer-leave finds recording still set and cannot reap; the cast
+ * would then run forever (screenrecord + ffmpeg) once the recording ends. Reaping again
+ * after stopRecording closes that gap.
+ */
+export function reapLiveIfIdle() {
+    if (scLive && !scLive.viewers.size && !scLive.recording) {
         cleanupLive(scLive);
         scLive = null;
     }

package/dist/shared/stream.d.ts

@@ -6,7 +6,7 @@ export interface RadarEvent {
     [key: string]: unknown;
 }
 export interface ParsedSSE {
-    type: "network" | "rtm";
+    type: "network" | "rtm" | "clog" | "log" | "trace";
     event: RadarEvent;
 }
 export declare const localNetworkBuffer: RadarEvent[];

package/dist/shared/transport.d.ts

@@ -6,6 +6,13 @@
  * device-specific operations. The MCP server and tool handlers
  * interact only through this interface.
  */
+/** Which underlying source served a getRecentLogs result. */
+export type LogSource = "app_buffer" | "logcat_capture" | "logcat_ring";
+/** Lines plus the source that produced them. */
+export interface LogResult {
+    lines: string[];
+    source: LogSource;
+}
 export interface DeviceTransport {
     /** Human-readable platform name (e.g. "android", "ios"). */
     readonly platform: string;
@@ -47,14 +54,15 @@ export interface DeviceTransport {
      */
     getAppState(): string;
     /**
-     * Get recent log entries filtered by tag.
+     * Get recent log entries, optionally filtered by tag.
      *
-     * @param tag Log tag to filter by
+     * @param tag Log tag to filter by. Empty string returns every line (no tag filter).
      * @param limit Max number of lines
      * @param grep Optional text to further filter
-     * @returns Array of matching log lines
+     * @returns The matching lines plus which source served them, so the caller can tell a
+     *   true-empty result from a silent fallback to an inferior source.
      */
-    getRecentLogs(tag: string, limit: number, grep?: string): string[];
+    getRecentLogs(tag: string, limit: number, grep?: string): LogResult;
     /**
      * Returns the currently active user ID, or null if none is set. On Android
      * this is the profile (e.g. "0" for personal, "10" for work); on iOS it