@slack/radar-mcp 1.2.0 → 1.4.0

package/dist/shared/android.js

@@ -61,8 +61,9 @@ const ADB = resolveAdbPath();
 /**
  * Parse the output of `ps -A -o USER,NAME` to extract the Android user ID
  * for the debug build process. When multiple profiles are running, prefers
- * the work profile (user ID > 0) since that's the typical debugging target.
- * Returns "0" for primary user, "10" for work profile, etc.
+ * a secondary user (user ID > 0) since that's the typical debugging target.
+ * Returns "0" for the primary user, or the first secondary user id (commonly
+ * "10", which is often a work profile, but the id alone cannot prove that).
  */
 export function parseUserFromPsOutput(psOutput) {
     if (!psOutput || !psOutput.trim())
@@ -77,9 +78,9 @@ export function parseUserFromPsOutput(psOutput) {
     }
     if (userIds.length === 0)
         return "0";
-    // Prefer work profile (non-zero user ID) when multiple profiles are running
-    const workProfile = userIds.find((id) => id !== "0");
-    return workProfile ?? userIds[0];
+    // Prefer a secondary user (non-zero user ID) when multiple profiles are running
+    const secondaryUser = userIds.find((id) => id !== "0");
+    return secondaryUser ?? userIds[0];
 }
 export class AndroidTransport {
     platform = "android";
@@ -137,7 +138,7 @@ export class AndroidTransport {
         this.detectedUserId = null;
         this.radarEnabled = false;
         this.lastForwardError = null;
-        stopCapture();
+        // Capture has its own idle timer; not stopped on activation reset (see logcat-capture.ts).
     }
     isForwarded() {
         return this.portForwarded;
@@ -228,7 +229,7 @@ export class AndroidTransport {
                     const id = match[1];
                     profiles.push({
                         userId: id,
-                        label: id === "0" ? "Personal (user 0)" : `Work profile (user ${id})`,
+                        label: id === "0" ? "Personal (user 0)" : `Secondary (user ${id}, e.g. a work profile)`,
                     });
                 }
             }

package/dist/shared/constants.d.ts

@@ -4,3 +4,9 @@ export declare const RADAR_PORT = 8099;
 export declare const RADAR_HOST = "127.0.0.1";
 /** Max events to retain in each local SSE buffer. */
 export declare const MAX_LOCAL_BUFFER = 500;
+/**
+ * Default port for the web dashboard. Shared so the MCP `open_radar_dashboard`
+ * tool POSTs its spec to the same port the web server listens on; both honor the
+ * `SLACK_RADAR_WEB_PORT` env override.
+ */
+export declare const WEB_PORT_DEFAULT = 8100;

package/dist/shared/constants.js

@@ -4,3 +4,9 @@ export const RADAR_PORT = 8099;
 export const RADAR_HOST = "127.0.0.1";
 /** Max events to retain in each local SSE buffer. */
 export const MAX_LOCAL_BUFFER = 500;
+/**
+ * Default port for the web dashboard. Shared so the MCP `open_radar_dashboard`
+ * tool POSTs its spec to the same port the web server listens on; both honor the
+ * `SLACK_RADAR_WEB_PORT` env override.
+ */
+export const WEB_PORT_DEFAULT = 8100;

package/dist/shared/logcat-capture.d.ts

@@ -3,6 +3,9 @@ export interface CaptureState {
     child: ChildProcess | null;
     filePath: string | null;
     startedAt: number | null;
+    lastReadAt: number | null;
+    idleTimer: ReturnType<typeof setTimeout> | null;
+    captureIdleMs: number;
 }
 /**
  * Delete capture files older than GC_TTL_MS. Runs at session enable. Bounded
@@ -12,6 +15,18 @@ export declare function gcOldCaptures(dir?: string, now?: number): number;
 export declare function buildCaptureFilePath(now?: number): string;
 export declare function isCapturing(): boolean;
 export declare function getCaptureFilePath(): string | null;
+/**
+ * Override the default capture-idle timeout. Internal — not currently exposed
+ * to MCP callers; reserved for future tuning. Values <= 0, NaN, or past
+ * `MAX_SETTIMEOUT_MS` fall back to the default so the timer can never
+ * pathologically collapse to an immediate-fire.
+ */
+export declare function setCaptureIdleMs(ms: number): void;
+export declare function _getCaptureIdleMsForTest(): number;
+export declare function _hasIdleTimerForTest(): boolean;
+export declare function _rescheduleIdleTimerForTest(): void;
+export declare function _touchLastReadForTest(now?: number): void;
+export declare function _setStateForTest(patch: Partial<CaptureState>): void;
 /**
  * Start streaming logcat to a session-scoped file. Idempotent: a second call
  * while the first capture is live is a no-op. If a prior capture's child is

package/dist/shared/logcat-capture.js

@@ -17,10 +17,14 @@ const LOG_DIR = path.join(os.homedir(), ".slack-radar", "logs");
 const ROTATION_BYTES = 100 * 1024 * 1024;
 const ROTATION_KEEP_BYTES = 50 * 1024 * 1024;
 const GC_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const DEFAULT_CAPTURE_IDLE_MS = 15 * 60 * 1000;
 const state = {
     child: null,
     filePath: null,
     startedAt: null,
+    lastReadAt: null,
+    idleTimer: null,
+    captureIdleMs: DEFAULT_CAPTURE_IDLE_MS,
 };
 function ensureLogDir() {
     if (!fs.existsSync(LOG_DIR)) {
@@ -61,6 +65,88 @@ export function isCapturing() {
 export function getCaptureFilePath() {
     return state.filePath;
 }
+// Node's setTimeout treats values past 2^31-1 ms as 1 ms (fires immediately),
+// which would instantly kill capture. Clamp to the max safe value here.
+const MAX_SETTIMEOUT_MS = 2_147_483_647;
+/**
+ * Schedule (or reschedule) the capture-idle timer to fire when
+ * `state.captureIdleMs` elapses without a new read. Called on every
+ * successful `readRecentLogs` and at `startCapture` boot so the timer is
+ * always pointing at the most recent activity.
+ *
+ * The scheduled callback closes over the timer handle it created and only
+ * fires `stopCapture()` if the module's current `state.idleTimer` is
+ * still THAT same handle. This defends against the case where a previously
+ * scheduled (but not yet fired) callback gets queued to run AFTER a
+ * subsequent reschedule or `stopCapture` — without identity comparison it
+ * would incorrectly kill a freshly-rescheduled capture.
+ */
+function rescheduleIdleTimer() {
+    if (state.idleTimer)
+        clearTimeout(state.idleTimer);
+    const delay = Math.min(state.captureIdleMs, MAX_SETTIMEOUT_MS);
+    const thisTimer = setTimeout(() => {
+        // Identity check: if state was cleared or a newer timer replaced us,
+        // do nothing. This prevents a stale queued callback from tearing down
+        // a fresh capture.
+        if (state.idleTimer !== thisTimer)
+            return;
+        stopCapture();
+    }, delay);
+    state.idleTimer = thisTimer;
+    // Node timers keep the event loop alive. For a long-running MCP this is
+    // fine, but for short-lived callers we do not want the timer to be the
+    // last thing keeping the process alive.
+    if (typeof thisTimer.unref === "function")
+        thisTimer.unref();
+}
+// Record that a read of the capture file just happened. Keeps the capture
+// idle timer sliding forward so an actively-used capture does not time out.
+function touchLastRead(now = Date.now()) {
+    state.lastReadAt = now;
+    if (isCapturing())
+        rescheduleIdleTimer();
+}
+/**
+ * Override the default capture-idle timeout. Internal — not currently exposed
+ * to MCP callers; reserved for future tuning. Values <= 0, NaN, or past
+ * `MAX_SETTIMEOUT_MS` fall back to the default so the timer can never
+ * pathologically collapse to an immediate-fire.
+ */
+export function setCaptureIdleMs(ms) {
+    const valid = typeof ms === "number" && ms > 0 && ms <= MAX_SETTIMEOUT_MS;
+    state.captureIdleMs = valid ? ms : DEFAULT_CAPTURE_IDLE_MS;
+    if (isCapturing())
+        rescheduleIdleTimer();
+}
+// Test-only accessors so unit tests can assert on state that is otherwise
+// module-private. Must never be called from production code paths.
+export function _getCaptureIdleMsForTest() {
+    return state.captureIdleMs;
+}
+export function _hasIdleTimerForTest() {
+    return state.idleTimer !== null;
+}
+export function _rescheduleIdleTimerForTest() {
+    rescheduleIdleTimer();
+}
+export function _touchLastReadForTest(now) {
+    touchLastRead(now);
+}
+// Enforces the state-machine invariants the tests rely on so `Object.assign`
+// cannot silently produce an impossible configuration (e.g. an idle timer
+// pointing at a dead capture). Throws on misuse; callers that legitimately
+// want to clear state should pass matched pairs.
+export function _setStateForTest(patch) {
+    const next = { ...state, ...patch };
+    if (next.idleTimer !== null && next.child === null) {
+        throw new Error("_setStateForTest invariant: idleTimer must be null when child is null");
+    }
+    if (next.filePath !== null && next.child === null) {
+        throw new Error("_setStateForTest invariant: filePath must be null when child is null");
+    }
+    Object.assign(state, patch);
+}
 /**
  * Start streaming logcat to a session-scoped file. Idempotent: a second call
  * while the first capture is live is a no-op. If a prior capture's child is
@@ -90,6 +176,11 @@ export function startCapture(adbPath) {
             }
             if (state.child === child) {
                 state.child = null;
+                // Clear the idle timer: no capture to kill anymore.
+                if (state.idleTimer) {
+                    clearTimeout(state.idleTimer);
+                    state.idleTimer = null;
+                }
             }
         });
         child.on("error", () => {
@@ -103,11 +194,23 @@ export function startCapture(adbPath) {
                 state.child = null;
                 state.filePath = null;
                 state.startedAt = null;
+                state.lastReadAt = null;
+                // Clear the idle timer we created for this (now-dead) capture so it
+                // cannot fire against stale state.
+                if (state.idleTimer) {
+                    clearTimeout(state.idleTimer);
+                    state.idleTimer = null;
+                }
             }
         });
         state.child = child;
         state.filePath = filePath;
         state.startedAt = Date.now();
+        state.lastReadAt = state.startedAt;
+        // Capture-idle timer starts fresh with the new child. Activation may
+        // time out (5 min) long before this fires, but capture keeps running
+        // so reads into recent history remain possible.
+        rescheduleIdleTimer();
         // Child bring-up warmup is handled at the MCP handler boundary
         // (handleSessionEnable / handleActivateForUser add a small async delay
         // before returning). Doing it here would require either blocking the
@@ -127,9 +230,14 @@ export function startCapture(adbPath) {
 }
 export function stopCapture() {
     const child = state.child;
+    const timer = state.idleTimer;
     state.child = null;
     state.filePath = null;
     state.startedAt = null;
+    state.lastReadAt = null;
+    state.idleTimer = null;
+    if (timer)
+        clearTimeout(timer);
     if (child && child.exitCode === null) {
         try {
             child.kill("SIGTERM");
@@ -270,6 +378,16 @@ export function readRecentLogs(tag, limit, grep) {
     catch {
         return null;
     }
+    // Slide the capture-idle timer forward whenever a read hits a HEALTHY
+    // capture child. A freshly spawned child may have written zero bytes to
+    // the file if there is no device traffic yet — that is not a sign of
+    // death. `isCapturing()` checks the child process itself (spawned, not
+    // exited), which is the authoritative health signal. The `exit` /
+    // `error` handlers will null out the child if it dies, and those same
+    // handlers clear the idle timer so no stale callback can fire.
+    if (isCapturing()) {
+        touchLastRead();
+    }
     const lines = tail.split("\n").filter(Boolean);
     return filterLogLines(lines, tag, limit, grep);
 }

package/dist/shared/transport.d.ts

@@ -55,6 +55,15 @@ export interface DeviceTransport {
      * @returns Array of matching log lines
      */
     getRecentLogs(tag: string, limit: number, grep?: string): string[];
+    /**
+     * 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
+     * is typically null (single-user device) or a synthetic identifier.
+     *
+     * Required so snapshot tooling and other callers do not fall back to
+     * unchecked casts when asking "which profile did this capture?".
+     */
+    getActiveUserId(): string | null;
     /**
      * Returns the last error message from an `ensureForward()` failure, or null
      * if the last attempt succeeded or has not happened. Lets callers surface
@@ -88,10 +97,4 @@ export interface DeviceTransport {
      * @param timeoutMinutes Auto-shutdown timeout in minutes
      */
     activateForUser?(userId: string, timeoutMinutes: number): void;
-    /**
-     * Returns the currently active user ID, or null if not set. Surfaced in
-     * list_profiles output so callers can tell which profile the current
-     * session is targeting without making a second call. Optional.
-     */
-    getActiveUserId?(): string | null;
 }

package/dist/web/bin.js

@@ -1,35 +1,50 @@
 #!/usr/bin/env node
-import { createServer, WEB_PORT } from "./server.js";
 import { execSync } from "child_process";
-const server = createServer();
-server.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
-        console.error(`Port ${WEB_PORT} is already in use. Another instance may be running.\n` +
-            `Kill it with: lsof -ti :${WEB_PORT} | xargs kill\n` +
-            `Or set a different port: SLACK_RADAR_WEB_PORT=8101 slack-radar-web`);
-        process.exit(1);
-    }
-    throw err;
-});
-server.listen(WEB_PORT, () => {
-    const url = `http://localhost:${WEB_PORT}`;
-    console.log(`Slack Radar Web running at ${url}`);
-    try {
-        if (process.platform === "darwin") {
-            execSync(`open ${url}`, { stdio: "ignore" });
+import { createServer, WEB_PORT } from "./server.js";
+/**
+ * Start the web dashboard server, open the browser, and wire shutdown signals.
+ * Extracted so both the dedicated `slack-radar-web` bin and the default bin's
+ * `web` subcommand dispatcher launch the dashboard the same way.
+ */
+function startWebServer() {
+    const server = createServer();
+    server.on("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+            console.error(`Port ${WEB_PORT} is already in use. Another instance may be running.\n` +
+                `Kill it with: lsof -ti :${WEB_PORT} | xargs kill\n` +
+                `Or set a different port: SLACK_RADAR_WEB_PORT=8101 slack-radar web`);
+            process.exit(1);
+        }
+        throw err;
+    });
+    server.listen(WEB_PORT, () => {
+        const url = `http://localhost:${WEB_PORT}`;
+        console.log(`Slack Radar Web running at ${url}`);
+        // Auto-open the browser for the HUMAN launcher (`slack-radar web` / `slack-radar-web`),
+        // but NOT when spawned as a bridge child by the open_radar_dashboard MCP tool
+        // (SLACK_RADAR_NO_OPEN=1). The Claude Code session must not pop a browser window the user
+        // did not ask for — the same no-auto-open-browser rule the SERVER_INSTRUCTIONS state for
+        // /radar-ui. The tool returns the URL instead, for the Claude Code session to surface.
+        if (process.env.SLACK_RADAR_NO_OPEN)
+            return;
+        try {
+            if (process.platform === "darwin") {
+                execSync(`open ${url}`, { stdio: "ignore" });
+            }
+            else if (process.platform === "linux") {
+                execSync(`xdg-open ${url}`, { stdio: "ignore" });
+            }
         }
-        else if (process.platform === "linux") {
-            execSync(`xdg-open ${url}`, { stdio: "ignore" });
+        catch {
+            // Browser open is best-effort
         }
-    }
-    catch {
-        // Browser open is best-effort
-    }
-});
-function shutdown() {
-    console.log("\nShutting down…");
-    server.close(() => process.exit(0));
-    setTimeout(() => process.exit(0), 2000);
+    });
+    const shutdown = () => {
+        console.log("\nShutting down…");
+        server.close(() => process.exit(0));
+        setTimeout(() => process.exit(0), 2000);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
 }
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+startWebServer();