@sensaiorg/adapter-android 0.1.0

package/dist/tools/logcat.js

@@ -0,0 +1,216 @@
+"use strict";
+/**
+ * Logcat Tools - Read and filter Android system logs.
+ *
+ * Provides:
+ * - get_logcat: Filtered log retrieval with level/tag/grep/since/maxLines
+ * - get_crash_info: Extract crash reports (JS exceptions, native crashes, ANRs)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLogcatTools = registerLogcatTools;
+const zod_1 = require("zod");
+const logcat_parser_js_1 = require("../util/logcat-parser.js");
+/** Tags commonly associated with React Native errors. */
+const RN_ERROR_TAGS = [
+    "ReactNativeJS",
+    "ReactNative",
+    "hermes",
+    "HermesVM",
+    "com.facebook.react",
+];
+/** Tags for native Android crashes. */
+const CRASH_TAGS = [
+    "AndroidRuntime",
+    "FATAL",
+    "DEBUG",
+    "tombstoned",
+    "crash_dump",
+];
+function registerLogcatTools(server, cm) {
+    /**
+     * get_logcat - Retrieve filtered Android logs.
+     */
+    server.tool("get_logcat", "Get Android logcat entries with optional filtering by log level, tag, text pattern, and time range. Returns structured log entries.", {
+        level: zod_1.z
+            .enum(["V", "D", "I", "W", "E", "F"])
+            .optional()
+            .describe("Minimum log level (V=verbose, D=debug, I=info, W=warn, E=error, F=fatal)"),
+        tag: zod_1.z.string().optional().describe("Filter by tag (case-insensitive substring)"),
+        since: zod_1.z.string().optional().describe("Only logs since this time (e.g., '5s', '1m', '30m', '1h')"),
+        grep: zod_1.z.string().optional().describe("Regex pattern to filter log messages"),
+        maxLines: zod_1.z.number().optional().describe("Maximum number of entries to return (default: 200)"),
+        packageOnly: zod_1.z.boolean().optional().describe("Only show logs from the target package"),
+        deduplicate: zod_1.z.boolean().optional().describe("Collapse consecutive identical messages into '[repeated Nx] message' (default: true)"),
+    }, async (params) => {
+        try {
+            const maxLines = params.maxLines ?? 200;
+            const shouldDeduplicate = params.deduplicate !== false; // default: true
+            const targetPackage = process.env.TARGET_PACKAGE ?? "com.emudebug.target";
+            // Build logcat command
+            const cmdParts = ["logcat", "-d", "-v", "threadtime"];
+            // Time filter
+            if (params.since) {
+                cmdParts.push("-T", `'${params.since}'`);
+            }
+            // Package filter via PID
+            let pid = null;
+            if (params.packageOnly) {
+                try {
+                    const pidOutput = await cm.adb.shell(`pidof ${targetPackage}`);
+                    pid = pidOutput.trim();
+                }
+                catch {
+                    // Package might not be running
+                }
+            }
+            const raw = await cm.adb.shell(cmdParts.join(" "), 15_000);
+            let entries = (0, logcat_parser_js_1.parseLogcat)(raw);
+            // Apply filters
+            if (pid) {
+                entries = entries.filter((e) => e.pid === pid);
+            }
+            if (params.level) {
+                entries = (0, logcat_parser_js_1.filterByLevel)(entries, params.level);
+            }
+            if (params.tag) {
+                entries = (0, logcat_parser_js_1.filterByTag)(entries, params.tag);
+            }
+            if (params.grep) {
+                entries = (0, logcat_parser_js_1.filterByGrep)(entries, params.grep);
+            }
+            // Deduplicate consecutive identical messages
+            let deduplicatedCount = 0;
+            if (shouldDeduplicate && entries.length > 0) {
+                const deduped = [];
+                let repeatCount = 1;
+                for (let i = 0; i < entries.length; i++) {
+                    const next = entries[i + 1];
+                    if (next && entries[i].message === next.message && entries[i].tag === next.tag) {
+                        repeatCount++;
+                        deduplicatedCount++;
+                    }
+                    else {
+                        if (repeatCount > 1) {
+                            deduped.push({
+                                ...entries[i],
+                                message: `[repeated ${repeatCount}x] ${entries[i].message}`,
+                            });
+                        }
+                        else {
+                            deduped.push(entries[i]);
+                        }
+                        repeatCount = 1;
+                    }
+                }
+                entries = deduped;
+            }
+            // Limit results (take most recent)
+            const limited = entries.slice(-maxLines);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            totalMatches: entries.length,
+                            returned: limited.length,
+                            truncated: entries.length > maxLines,
+                            deduplicated: deduplicatedCount,
+                            entries: limited,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error reading logcat: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    /**
+     * get_crash_info - Extract crash reports from logs.
+     */
+    server.tool("get_crash_info", "Extract crash information from Android logs: JavaScript exceptions (React Native), native crashes (tombstones), and ANRs. Focuses on the target app.", {
+        since: zod_1.z.string().optional().describe("Only crashes since this time (e.g., '5m', '1h')"),
+        includeAllApps: zod_1.z.boolean().optional().describe("Include crashes from all apps, not just the target"),
+    }, async (params) => {
+        try {
+            const targetPackage = process.env.TARGET_PACKAGE ?? "com.emudebug.target";
+            // Get recent logcat
+            const cmdParts = ["logcat", "-d", "-v", "threadtime"];
+            if (params.since) {
+                cmdParts.push("-T", `'${params.since}'`);
+            }
+            const raw = await cm.adb.shell(cmdParts.join(" "), 15_000);
+            const allEntries = (0, logcat_parser_js_1.parseLogcat)(raw);
+            // Find target app PID(s) for filtering
+            let targetPids = new Set();
+            if (!params.includeAllApps) {
+                try {
+                    const pidOutput = await cm.adb.shell(`pidof ${targetPackage}`);
+                    pidOutput.trim().split(/\s+/).forEach((p) => targetPids.add(p));
+                }
+                catch {
+                    // If no PID found, we'll still look for tagged entries
+                }
+            }
+            // Extract JS exceptions (React Native)
+            const jsErrors = allEntries.filter((e) => {
+                const isRnTag = RN_ERROR_TAGS.some((t) => e.tag.includes(t));
+                const isError = e.level === "E" || e.level === "F";
+                const isTargetPid = targetPids.size === 0 || targetPids.has(e.pid);
+                return isRnTag && isError && (params.includeAllApps || isTargetPid);
+            });
+            // Extract native crashes
+            const nativeCrashes = allEntries.filter((e) => {
+                const isCrashTag = CRASH_TAGS.some((t) => e.tag.includes(t));
+                const isError = e.level === "E" || e.level === "F";
+                return isCrashTag && isError;
+            });
+            // Extract ANRs
+            const anrs = allEntries.filter((e) => e.tag === "ActivityManager" && e.message.includes("ANR in"));
+            // Check for ANR traces file
+            let anrTraces = "";
+            if (anrs.length > 0) {
+                try {
+                    anrTraces = await cm.adb.shell("cat /data/anr/traces.txt | head -100");
+                }
+                catch {
+                    anrTraces = "(ANR traces not accessible without root)";
+                }
+            }
+            const result = {
+                summary: {
+                    jsExceptions: jsErrors.length,
+                    nativeCrashes: nativeCrashes.length,
+                    anrs: anrs.length,
+                },
+                jsExceptions: jsErrors.map(logcat_parser_js_1.formatEntry),
+                nativeCrashes: nativeCrashes.map(logcat_parser_js_1.formatEntry),
+                anrs: anrs.map(logcat_parser_js_1.formatEntry),
+                anrTraces: anrTraces || undefined,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(result) }],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting crash info: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=logcat.js.map

package/dist/tools/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../../src/tools/network.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAG5E,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAiInF"}

package/dist/tools/network.js

@@ -0,0 +1,123 @@
+"use strict";
+/**
+ * Network Tool - Inspect HTTP network traffic from the target app.
+ *
+ * Supports two modes:
+ * - "history": Retrieve past network requests (from agent buffer)
+ * - "capture": Start/stop live capture with filters
+ *
+ * Phase 1 fallback: parse logcat for OkHttp/Retrofit logging.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNetworkTools = registerNetworkTools;
+const zod_1 = require("zod");
+const logcat_parser_js_1 = require("../util/logcat-parser.js");
+function registerNetworkTools(server, cm) {
+    server.tool("get_network", "Inspect HTTP network traffic from the target app. In 'history' mode, returns recent requests. In 'capture' mode, starts/stops live capture. Supports URL and status code filtering.", {
+        mode: zod_1.z
+            .enum(["history", "capture_start", "capture_stop"])
+            .describe("history = past requests, capture_start = begin live capture, capture_stop = end and return captured"),
+        urlFilter: zod_1.z.string().optional().describe("Only include requests matching this URL pattern (substring)"),
+        statusFilter: zod_1.z
+            .number()
+            .optional()
+            .describe("Only include responses with this HTTP status code"),
+        maxEntries: zod_1.z.number().optional().describe("Maximum entries to return (default: 50)"),
+        includeBody: zod_1.z.boolean().optional().describe("Include request/response bodies (default: false, can be large)"),
+    }, async (params) => {
+        const maxEntries = params.maxEntries ?? 50;
+        // Phase 2: full network interception via agent
+        if (cm.agent.isConnected()) {
+            try {
+                const result = await cm.agent.call("getNetwork", {
+                    mode: params.mode,
+                    urlFilter: params.urlFilter,
+                    statusFilter: params.statusFilter,
+                    maxEntries,
+                    includeBody: params.includeBody ?? false,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }],
+                };
+            }
+            catch (err) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Agent network error: ${err instanceof Error ? err.message : String(err)}. Falling back to logcat.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+        }
+        // Phase 1: parse logcat for network-related logs
+        if (params.mode === "capture_start" || params.mode === "capture_stop") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "agent_not_connected",
+                            message: "Live network capture requires the on-device agent (Phase 2). " +
+                                "Use mode='history' to see network logs from logcat.",
+                        }),
+                    },
+                ],
+            };
+        }
+        try {
+            // Look for OkHttp, Retrofit, and generic HTTP logs
+            const raw = await cm.adb.shell("logcat -d -v threadtime", 15_000);
+            let entries = (0, logcat_parser_js_1.parseLogcat)(raw);
+            // Filter for network-related tags
+            const networkTags = ["OkHttp", "Retrofit", "HttpURLConnection", "NetworkClient", "API", "Volley"];
+            entries = entries.filter((e) => networkTags.some((tag) => e.tag.includes(tag)) ||
+                e.message.includes("HTTP") ||
+                e.message.includes("http://") ||
+                e.message.includes("https://"));
+            // Apply URL filter
+            if (params.urlFilter) {
+                entries = (0, logcat_parser_js_1.filterByGrep)(entries, params.urlFilter);
+            }
+            // Apply status filter by searching for the status code in the message
+            if (params.statusFilter) {
+                entries = entries.filter((e) => e.message.includes(String(params.statusFilter)));
+            }
+            const limited = entries.slice(-maxEntries);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            phase1Mode: true,
+                            note: "Network data extracted from logcat. For full request/response inspection " +
+                                "with headers and bodies, install the on-device agent (Phase 2). " +
+                                "Ensure your app uses OkHttp logging interceptor for better logcat data.",
+                            totalMatches: entries.length,
+                            returned: limited.length,
+                            entries: limited.map((e) => ({
+                                timestamp: e.timestamp,
+                                tag: e.tag,
+                                message: e.message,
+                            })),
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (err) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error getting network data: ${err instanceof Error ? err.message : String(err)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=network.js.map

package/dist/tools/performance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../src/tools/performance.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAgC5E,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CA8HvF"}

package/dist/tools/performance.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Performance Tool - Monitor app performance metrics.
+ *
+ * Collects FPS, memory usage, CPU usage, and (via agent) React Native
+ * bridge metrics. Phase 1 uses ADB dumpsys; Phase 2 adds real-time
+ * frame timing and bridge throughput.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPerformanceTools = registerPerformanceTools;
+const zod_1 = require("zod");
+/** Parse `dumpsys meminfo <package>` output. */
+function parseMeminfo(raw) {
+    const parseLine = (label) => {
+        const re = new RegExp(`${label}[:\\s]+(\\d+)`, "i");
+        const match = raw.match(re);
+        return match ? parseInt(match[1], 10) : 0;
+    };
+    return {
+        totalPss: parseLine("TOTAL PSS"),
+        javaHeap: parseLine("Java Heap"),
+        nativeHeap: parseLine("Native Heap"),
+        code: parseLine("Code"),
+        stack: parseLine("Stack"),
+        graphics: parseLine("Graphics"),
+        summary: raw.split("\n").slice(0, 20).join("\n"),
+    };
+}
+function registerPerformanceTools(server, cm) {
+    server.tool("get_performance", "Get performance metrics for the target app: memory usage, CPU, frame rate (FPS), and bridge metrics. Uses ADB dumpsys in Phase 1; on-device agent provides real-time FPS and bridge throughput in Phase 2.", {
+        metrics: zod_1.z
+            .array(zod_1.z.enum(["fps", "memory", "cpu", "bridge"]))
+            .optional()
+            .describe("Which metrics to collect (default: all)"),
+        durationSec: zod_1.z
+            .number()
+            .optional()
+            .describe("Duration for FPS/CPU sampling in seconds (default: 2, max: 10)"),
+    }, async (params) => {
+        const metrics = params.metrics ?? ["fps", "memory", "cpu", "bridge"];
+        const targetPackage = process.env.TARGET_PACKAGE ?? "com.emudebug.target";
+        const durationSec = Math.min(params.durationSec ?? 2, 10);
+        // Phase 2: agent provides rich metrics
+        if (cm.agent.isConnected()) {
+            try {
+                const result = await cm.agent.call("getPerformance", {
+                    metrics,
+                    durationSec,
+                });
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result) }],
+                };
+            }
+            catch {
+                // Fall through to ADB
+            }
+        }
+        // Phase 1: ADB-based metrics
+        const result = {};
+        // Memory via dumpsys
+        if (metrics.includes("memory")) {
+            try {
+                const raw = await cm.adb.shell(`dumpsys meminfo ${targetPackage}`);
+                result.memory = parseMeminfo(raw);
+            }
+            catch (err) {
+                result.memory = {
+                    error: `Failed to get memory info: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+        // CPU via top (single snapshot)
+        if (metrics.includes("cpu")) {
+            try {
+                const raw = await cm.adb.shell(`top -b -n 1 -d ${durationSec} | grep -i "${targetPackage}"`);
+                const lines = raw.trim().split("\n").filter(Boolean);
+                const cpuEntries = lines.map((line) => {
+                    const parts = line.trim().split(/\s+/);
+                    return {
+                        pid: parts[0],
+                        cpu: parts.length > 8 ? parts[8] : "?",
+                        mem: parts.length > 9 ? parts[9] : "?",
+                        raw: line.trim(),
+                    };
+                });
+                result.cpu = { processes: cpuEntries };
+            }
+            catch (err) {
+                result.cpu = {
+                    error: `Failed to get CPU info: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+        // FPS via dumpsys gfxinfo
+        if (metrics.includes("fps")) {
+            try {
+                // Reset gfxinfo, wait, then read
+                await cm.adb.shell(`dumpsys gfxinfo ${targetPackage} reset`);
+                // Brief wait for frame data to accumulate
+                await new Promise((r) => setTimeout(r, durationSec * 1000));
+                const raw = await cm.adb.shell(`dumpsys gfxinfo ${targetPackage}`);
+                // Parse frame stats
+                const totalFramesMatch = raw.match(/Total frames rendered:\s*(\d+)/);
+                const jankyMatch = raw.match(/Janky frames:\s*(\d+)/);
+                const p50Match = raw.match(/50th percentile:\s*(\d+)ms/);
+                const p90Match = raw.match(/90th percentile:\s*(\d+)ms/);
+                const p95Match = raw.match(/95th percentile:\s*(\d+)ms/);
+                const p99Match = raw.match(/99th percentile:\s*(\d+)ms/);
+                const totalFrames = totalFramesMatch ? parseInt(totalFramesMatch[1], 10) : 0;
+                const jankyFrames = jankyMatch ? parseInt(jankyMatch[1], 10) : 0;
+                result.fps = {
+                    totalFrames,
+                    jankyFrames,
+                    jankyPercentage: totalFrames > 0 ? ((jankyFrames / totalFrames) * 100).toFixed(1) + "%" : "N/A",
+                    percentiles: {
+                        p50: p50Match ? `${p50Match[1]}ms` : "N/A",
+                        p90: p90Match ? `${p90Match[1]}ms` : "N/A",
+                        p95: p95Match ? `${p95Match[1]}ms` : "N/A",
+                        p99: p99Match ? `${p99Match[1]}ms` : "N/A",
+                    },
+                    sampleDurationSec: durationSec,
+                    note: "For real-time FPS monitoring, install the on-device agent (Phase 2).",
+                };
+            }
+            catch (err) {
+                result.fps = {
+                    error: `Failed to get FPS data: ${err instanceof Error ? err.message : String(err)}`,
+                };
+            }
+        }
+        // Bridge metrics require agent
+        if (metrics.includes("bridge")) {
+            result.bridge = {
+                note: "React Native bridge metrics require the on-device agent (Phase 2). " +
+                    "Use get_rn_bridge for logcat-based bridge inspection.",
+            };
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+        };
+    });
+}
+//# sourceMappingURL=performance.js.map

package/dist/tools/recording.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recording.d.ts","sourceRoot":"","sources":["../../src/tools/recording.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAS5E,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAuGrF"}

package/dist/tools/recording.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Recording Tools - Screen recording for Android devices.
+ *
+ * Provides:
+ * - start_recording: Begin screen recording
+ * - stop_recording: Stop and retrieve recording as base64 MP4
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRecordingTools = registerRecordingTools;
+const zod_1 = require("zod");
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+/** Track active recording state. */
+let recordingActive = false;
+const DEVICE_RECORDING_PATH = "/sdcard/sensai_recording.mp4";
+function registerRecordingTools(server, cm) {
+    /**
+     * start_recording - Begin screen recording on the Android device.
+     */
+    server.tool("start_recording", "Start recording the Android device screen. Recording runs in the background. Use stop_recording to finish and retrieve the video. Max duration 180 seconds.", {
+        maxDurationSec: zod_1.z.number().optional().describe("Maximum recording duration in seconds (default: 60, max: 180)"),
+    }, async ({ maxDurationSec }) => {
+        if (recordingActive) {
+            return {
+                content: [{ type: "text", text: JSON.stringify({ error: "Recording already in progress. Call stop_recording first." }) }],
+                isError: true,
+            };
+        }
+        const duration = Math.min(maxDurationSec ?? 60, 180);
+        try {
+            // Remove any leftover recording file
+            await cm.adb.shell(`rm -f ${DEVICE_RECORDING_PATH}`).catch(() => { });
+            // Start recording in background (screenrecord exits after duration or when killed)
+            // We run it detached so it doesn't block
+            cm.adb.shell(`screenrecord --time-limit ${duration} ${DEVICE_RECORDING_PATH}`).catch(() => {
+                // Recording finished or was killed — expected
+                recordingActive = false;
+            });
+            recordingActive = true;
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ ok: true, maxDurationSec: duration, path: DEVICE_RECORDING_PATH }),
+                    }],
+            };
+        }
+        catch (err) {
+            recordingActive = false;
+            return {
+                content: [{ type: "text", text: `start_recording failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+    /**
+     * stop_recording - Stop the active recording and retrieve the video file.
+     */
+    server.tool("stop_recording", "Stop the active screen recording and retrieve the MP4 video. Returns the video as base64 data, or saves to a local path if specified.", {
+        savePath: zod_1.z.string().optional().describe("Local path to save the MP4 file (optional). If not provided, returns base64."),
+    }, async ({ savePath }) => {
+        try {
+            // Kill screenrecord process (this causes it to finalize the MP4)
+            await cm.adb.shell("pkill -SIGINT screenrecord").catch(() => { });
+            // Wait for file to be finalized
+            await new Promise(r => setTimeout(r, 1500));
+            recordingActive = false;
+            // Pull the file from device
+            const localPath = savePath ?? (0, node_path_1.join)((0, node_os_1.tmpdir)(), `sensai-recording-${Date.now()}.mp4`);
+            await cm.adb.pull(DEVICE_RECORDING_PATH, localPath);
+            // Clean up device file
+            await cm.adb.shell(`rm -f ${DEVICE_RECORDING_PATH}`).catch(() => { });
+            if (savePath) {
+                // User wants it saved to a path
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ ok: true, savedTo: localPath }),
+                        }],
+                };
+            }
+            // Return as base64
+            const data = await (0, promises_1.readFile)(localPath);
+            await (0, promises_1.unlink)(localPath).catch(() => { });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ ok: true, format: "mp4", sizeBytes: data.length, base64: data.toString("base64") }),
+                    }],
+            };
+        }
+        catch (err) {
+            recordingActive = false;
+            return {
+                content: [{ type: "text", text: `stop_recording failed: ${err instanceof Error ? err.message : String(err)}` }],
+                isError: true,
+            };
+        }
+    });
+}
+//# sourceMappingURL=recording.js.map

package/dist/tools/rn-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rn-tools.d.ts","sourceRoot":"","sources":["../../src/tools/rn-tools.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAoB5E,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,iBAAiB,GAAG,IAAI,CAgH9E"}