react-native-sqlite-mcp 1.0.1 → 1.0.3

package/README.md

@@ -1,23 +1,70 @@
-# 🚀 Universal React Native SQLite MCP
+<div align="center">
 
-**TL;DR:** A Model Context Protocol (MCP) server that gives your favorite LLM (Claude, Cursor, Antigravity, etc.) X-ray vision into your local React Native SQLite databases. 
+# react-native-sqlite-mcp
 
-No more flying blind. No more manually exporting `.db` files from emulators to figure out why your app is broken. Just ask your AI: *"Hey, what does the `users` table look like on my Android emulator?"* and watch the magic happen. ✨
+Expose your React Native SQLite database to MCP-compatible tooling — with emulator support.
+
+<br />
+
+![npm version](https://img.shields.io/npm/v/react-native-sqlite-mcp?style=for-the-badge)
+![license](https://img.shields.io/github/license/MisterMur/react-native-sqlite-mcp?style=for-the-badge)
+![node](https://img.shields.io/badge/node-%3E%3D18-43853D?style=for-the-badge&logo=node.js)
+![react-native](https://img.shields.io/badge/React%20Native-supported-61DAFB?style=for-the-badge&logo=react)
+
+<br />
+
+![TypeScript](https://img.shields.io/badge/TypeScript-5.x-3178C6?style=for-the-badge&logo=typescript)
+![SQLite](https://img.shields.io/badge/SQLite-3-003B57?style=for-the-badge&logo=sqlite)
+![MCP](https://img.shields.io/badge/MCP-compatible-black?style=for-the-badge)
+
+</div>
 
 ---
 
-## 🤔 Why did I build this?
+## Overview
+
+SQLite MCP servers exist, but they all assume your database is a file sitting on your desktop or server. They open a path, read the file, done.
 
-Honestly? I was tired of jumping through hoops to inspect local databases while building React Native apps. Extracting SQLite files from an iOS Simulator or bypassing root permissions on an Android Emulator just to run a `SELECT *` was ruining my flow state. 
+That doesn't work for mobile. On iOS Simulator, SQLite databases are buried deep inside sandboxed app containers. On Android Emulator, they're behind `run-as` permission boundaries that require `adb` to access. No existing SQLite MCP server handles either of these.
 
-I wanted my AI assistant to just *know* what my database looked like and query it in real-time. So I built this bridge. It's mobile development less painful.
+I built this because I was tired of manually extracting `.db` files from emulators just to figure out why my app's local state was wrong.
 
+`react-native-sqlite-mcp` is a SQLite MCP server purpose-built for mobile emulators. It auto-discovers databases inside iOS Simulator and Android Emulator sandboxes, pulls them transparently, and exposes schema + query access to any MCP-compatible tool.
 
-## 📦 Quick Start (The Magic Way)
+---
 
-You don't even need to clone this repo. The easiest way to get rolling is via `npx`.
+## Why This Exists
 
-Toss this bad boy into your `mcp.json` (or your Claude/Cursor/agent settings):
+- Existing SQLite MCP servers can't reach databases inside iOS Simulator or Android Emulator sandboxes
+- Mobile MCP tooling focuses on UI automation, not the data layer
+- SQLite-backed state is critical in local-first React Native apps
+- There was no MCP bridge for inspecting emulator databases directly from your AI tooling
+
+This project fills that gap.
+
+---
+
+## How It Works
+
+```mermaid
+graph LR
+  subgraph Emulator
+    RN[React Native App] --> SQLite[(SQLite DB)]
+  end
+  SQLite -- "simctl / adb pull" --> MCP[MCP Server]
+  MCP -- "JSON-RPC stdio" --> AI[Claude / Cursor / Antigravity]
+```
+
+1. Auto-detects booted iOS Simulators (`xcrun simctl`) and Android Emulators (`adb`)
+2. Discovers SQLite databases inside sandboxed app containers
+3. Pulls database files transparently (iOS reads in-place, Android uses `run-as` + `adb pull`)
+4. Exposes schema and query access over the MCP stdio transport
+
+---
+
+## Quick Start
+
+Add this to your MCP config (`mcp.json`, `.cursor/mcp.json`, or `.gemini/settings.json`):
 
 ```json
 {
@@ -26,7 +73,7 @@ Toss this bad boy into your `mcp.json` (or your Claude/Cursor/agent settings):
       "command": "npx",
       "args": ["-y", "react-native-sqlite-mcp"],
       "env": {
-        "DB_NAME": "my_database.db",
+        "DB_NAME": "my_app.db",
         "ANDROID_BUNDLE_ID": "com.mycompany.myapp"
       }
     }
@@ -34,20 +81,87 @@ Toss this bad boy into your `mcp.json` (or your Claude/Cursor/agent settings):
 }
 ```
 
-Boom. You're connected. 🤝
+Restart your editor. Your AI can now query your emulator databases directly.
+
+---
+
+## Environment Variables
+
+| Variable | Required | Description |
+|---|---|---|
+| `DB_NAME` | No | Database filename to auto-sync on startup (e.g. `my_app.db`). Supports glob patterns (`*.db`). If omitted, auto-selects the first discovered database. |
+| `ANDROID_BUNDLE_ID` | No | Android app package name (e.g. `com.mycompany.app`). If omitted, scans all third-party packages on the emulator. |
+| `READ_ONLY` | No | Set to `true` to restrict `query_db` to SELECT, PRAGMA, and EXPLAIN statements only. Default: `false`. |
+| `MCP_LOG_LEVEL` | No | Log verbosity: `debug`, `info`, `warn`, `error`. Default: `info`. Logs go to stderr only. |
+
+---
+
+## Tools
 
-## 🛠️ Manual Installation (For the brave)
+### `list_databases`
 
-Prefer to tinker with the source code yourself? I respect it. 
+Scans for all SQLite databases on booted emulators/simulators.
+
+| Argument | Type | Description |
+|---|---|---|
+| `platform` | string | Optional. `ios` or `android`. If omitted, scans both. |
+| `bundleId` | string | Optional. Android-only app package name to narrow the search. |
+
+### `sync_database`
+
+Pulls a fresh copy of the database from the emulator so all subsequent queries use the latest data.
+
+| Argument | Type | Description |
+|---|---|---|
+| `dbName` | string | Optional. Database filename or glob pattern. Auto-selects if omitted. |
+| `bundleId` | string | Optional. Android-only app package name. |
+| `platform` | string | Optional. `ios` or `android`. |
+
+### `inspect_schema`
+
+Returns all tables, columns, and `CREATE TABLE` statements for the synced database.
+
+| Argument | Type | Description |
+|---|---|---|
+| `dbName` | string | Optional. Target a specific database. |
+| `platform` | string | Optional. `ios` or `android`. |
+
+### `read_table_contents`
+
+Returns rows from a table (`SELECT * FROM table LIMIT n`).
+
+| Argument | Type | Description |
+|---|---|---|
+| `tableName` | string | **Required.** The table to read. |
+| `limit` | number | Optional. Max rows to return. Default: `100`. |
+| `dbName` | string | Optional. Target a specific database. |
+| `platform` | string | Optional. `ios` or `android`. |
+
+### `query_db`
+
+Executes a raw SQL query and returns the result set.
+
+| Argument | Type | Description |
+|---|---|---|
+| `sql` | string | **Required.** The SQL statement to execute. |
+| `params` | array | Optional. Bind parameters for `?` placeholders. |
+| `dbName` | string | Optional. Target a specific database. |
+| `platform` | string | Optional. `ios` or `android`. |
+
+> When `READ_ONLY=true`, only `SELECT`, `PRAGMA`, and `EXPLAIN` statements are allowed.
+
+---
+
+## Manual Installation
 
 ```bash
-git clone https://github.com/your-username/react-native-sqlite-mcp.git
+git clone https://github.com/MisterMur/react-native-sqlite-mcp.git
 cd react-native-sqlite-mcp
 npm install
 npm run build
 ```
 
-Then point your MCP client to your local build:
+Point your MCP config at the local build:
 
 ```json
 {
@@ -56,49 +170,32 @@ Then point your MCP client to your local build:
       "command": "node",
       "args": ["/absolute/path/to/react-native-sqlite-mcp/dist/index.js"],
       "env": {
-        "DB_NAME": "my_database.db",
-        "ANDROID_BUNDLE_ID": "com.mycompany.myapp"
+        "DB_NAME": "my_app.db"
       }
     }
   }
 }
 ```
 
-## 🎛️ Environment Variables (The Knobs)
-
-- `DB_NAME`: The filename of your database (e.g., `my_app.db`). You can also use a glob pattern (`*.db`) if you're feeling adventurous.
-- `ANDROID_BUNDLE_ID`: *(Android Only)* The application ID/package name of your app (e.g., `com.mycompany.app`). 
-  - **Pro-Tip:** If you leave this out, the MCP will go rogue and scan *all* third-party apps on your emulator for SQLite databases. Use with caution/glee.
-
-## 🦸‍♂️ Features (What this bad boy can do)
-
-This MCP arms your AI with four super-powered tools:
-
-- 🕵️‍♂️ **`list_databases`**: Scours the device and returns a list of all available SQLite databases. Toss in `platform` ('ios' or 'android') to narrow the search.
-- 🔄 **`sync_database`**: Yanks a copy of a database from your active device into the MCP's working directory so the AI can inspect it to its heart's content. Leave the arguments blank, and it'll just grab the first default database it finds.
-- 🗺️ **`inspect_schema`**: The holy grail. Returns the `CREATE TABLE` and column info for your synced database. It literally gives the AI the map to your data.
-- 📖 **`read_table_contents`**: Dumps all rows from a specific table (capped at 100 rows so we don't blow up the context window). 
-- 🤖 **`query_db`**: Lets the AI fire raw SQL queries right at the database and get the results back. 
+---
 
-## ⚙️ How it Actually Works (Under the hood)
+## Limitations
 
-1. **Auto-Detect Platform**: It scans **both** iOS and Android environments simultaneously. It hunts down booted iOS Simulators using `simctl` and active Android Emulators using `adb`. 
-2. **Auto-Locate Database**: 
-  - **iOS:** We dive straight into the simulator's app sandbox. No root needed.
-  - **Android:** We do a sneaky `adb exec-out run-as com.pkg.name cat ...` to copy the database file, along with its `-wal` and `-shm` sidekicks, completely bypassing the strict root permission boundaries on debug profiles.
-3. **Platform Switching**: The server keeps one active database connection open. Want to switch from iOS to Android? The AI just calls `sync_database` for the other platform. Simple.
-4. **Execution**: It wraps all this up nicely so the LLM can learn your schema and query live data without bothering you.
+- Development environments only — not designed for production
+- iOS requires a booted Simulator with `xcrun simctl`
+- Android requires a booted Emulator with `adb` and a debuggable app (debug build)
+- Queries operate on a pulled snapshot, not a live connection
 
-## 🤝 Contributing (Yes, please!)
+---
 
-Got an idea to make this objectively cooler? Found a bug where it accidentally queried your smart fridge? 
+## Contributing
 
-I am **all in** on community contributions. Whether you're fixing a typo, optimizing the ADB scripts, or adding support for Windows Phone (please don't), I want your PRs.
+Issues and pull requests are welcome.
 
-Check out the [CONTRIBUTING.md](./CONTRIBUTING.md) guide to see how we party.
+If you're working in the local-first React Native space and hit edge cases, open an issue. This tool exists because that gap was real.
 
-## 📜 License
+---
 
-This project is licensed under the **MIT License**.
+## License
 
-See the [LICENSE](./LICENSE) file for the legal jargon.
+MIT

package/dist/db.js

@@ -1,89 +1,52 @@
-import sqlite3 from "sqlite3";
+import initSqlJs from "sql.js";
+import fs from "fs";
 import { logger } from "./logger.js";
-/**
- * Lightweight sqlite3 wrapper with Promise-based API.
- */
-export class Database {
-    db;
-    constructor(filename) {
-        this.db = new sqlite3.Database(filename);
-    }
-    all(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.all(sql, params, (err, rows) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(rows);
-            });
-        });
-    }
-    get(sql, params = []) {
-        return new Promise((resolve, reject) => {
-            this.db.get(sql, params, (err, row) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(row);
-            });
-        });
-    }
-    close() {
-        return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
+let SQL = null;
+async function getSqlJs() {
+    if (!SQL) {
+        SQL = await initSqlJs();
+        logger.debug("sql.js WASM engine initialized");
     }
+    return SQL;
 }
-const CACHE_TTL_MS = 60_000; // Close idle connections after 60s
+const CACHE_TTL_MS = 60_000;
 const connectionCache = new Map();
-function getCachedDb(dbPath) {
+async function getCachedDb(dbPath) {
     const existing = connectionCache.get(dbPath);
     if (existing) {
-        // Refresh the idle timer
         clearTimeout(existing.timer);
         existing.lastUsed = Date.now();
         existing.timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
         return existing.db;
     }
-    // Open a new connection
-    const db = new Database(dbPath);
+    const sqlJs = await getSqlJs();
+    const buffer = fs.readFileSync(dbPath);
+    const db = new sqlJs.Database(buffer);
     const timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
-    connectionCache.set(dbPath, { db, lastUsed: Date.now(), timer });
+    connectionCache.set(dbPath, { db, dbPath, lastUsed: Date.now(), timer });
     logger.debug(`Opened DB connection: ${dbPath}`);
     return db;
 }
-async function evictConnection(dbPath) {
+function evictConnection(dbPath) {
     const entry = connectionCache.get(dbPath);
     if (!entry)
         return;
     connectionCache.delete(dbPath);
     try {
-        await entry.db.close();
+        entry.db.close();
         logger.debug(`Closed idle DB connection: ${dbPath}`);
     }
     catch (e) {
         logger.warn(`Error closing DB: ${dbPath}`, { error: String(e) });
     }
 }
-/**
- * Close all cached connections. Called during graceful shutdown.
- */
 export async function closeAllConnections() {
     const paths = [...connectionCache.keys()];
     for (const p of paths) {
-        await evictConnection(p);
+        evictConnection(p);
     }
     logger.info(`Closed ${paths.length} cached DB connection(s)`);
 }
-// ---------------------------------------------------------------------------
-// Public query API
-// ---------------------------------------------------------------------------
-/** Query timeout — prevents stuck queries from blocking everything */
 const QUERY_TIMEOUT_MS = 30_000;
 function withTimeout(promise, ms, label) {
     return new Promise((resolve, reject) => {
@@ -95,26 +58,31 @@ function withTimeout(promise, ms, label) {
             .catch((err) => { clearTimeout(timer); reject(err); });
     });
 }
-/**
- * Executes a simple query on the database.
- */
+function runQuery(db, sql, params = []) {
+    const stmt = db.prepare(sql);
+    if (params.length > 0)
+        stmt.bind(params);
+    const results = [];
+    while (stmt.step()) {
+        results.push(stmt.getAsObject());
+    }
+    stmt.free();
+    return results;
+}
 export async function queryDb(dbPath, sql, params = []) {
-    const db = getCachedDb(dbPath);
-    return withTimeout(db.all(sql, params), QUERY_TIMEOUT_MS, sql.slice(0, 80));
+    const db = await getCachedDb(dbPath);
+    return withTimeout(Promise.resolve(runQuery(db, sql, params)), QUERY_TIMEOUT_MS, sql.slice(0, 80));
 }
-/**
- * Returns a detailed schema of all tables in the database.
- */
 export async function inspectSchema(dbPath) {
-    const db = getCachedDb(dbPath);
-    const tables = await withTimeout(db.all("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"), QUERY_TIMEOUT_MS, "inspect_schema:tables");
+    const db = await getCachedDb(dbPath);
+    const tables = runQuery(db, "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;");
     const schemaInfo = {};
     for (const table of tables) {
-        const columns = await db.all(`PRAGMA table_info("${table.name}");`);
-        const createSql = await db.get(`SELECT sql FROM sqlite_master WHERE type='table' AND name=?`, [table.name]);
+        const columns = runQuery(db, `PRAGMA table_info("${table.name}");`);
+        const createSqlRows = runQuery(db, `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`, [table.name]);
         schemaInfo[table.name] = {
             columns,
-            createSql: createSql?.sql
+            createSql: createSqlRows[0]?.sql
         };
     }
     return schemaInfo;

package/dist/index.js

@@ -5,6 +5,9 @@ import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextpro
 import { listDatabases, syncDatabase } from "./locator.js";
 import { inspectSchema, queryDb, closeAllConnections } from "./db.js";
 import { logger } from "./logger.js";
+import { createRequire } from "module";
+const require = createRequire(import.meta.url);
+const { version } = require("../package.json");
 // ---------------------------------------------------------------------------
 // Process-level guards — prevent silent crashes that cause EOF errors
 // ---------------------------------------------------------------------------
@@ -20,13 +23,17 @@ process.on("unhandledRejection", (reason) => {
         reason: String(reason),
     });
 });
+// ---------------------------------------------------------------------------
+// Config
+// ---------------------------------------------------------------------------
+const READ_ONLY = process.env.READ_ONLY === 'true' || process.env.READ_ONLY === '1';
 let activeDatabases = [];
 // ---------------------------------------------------------------------------
 // Server setup
 // ---------------------------------------------------------------------------
 const server = new Server({
     name: "react-native-sqlite-bridge",
-    version: "1.0.0",
+    version,
 }, {
     capabilities: {
         tools: {},
@@ -258,6 +265,12 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (!sql) {
                 throw new Error("Missing required argument: sql");
             }
+            if (READ_ONLY) {
+                const normalized = sql.trim().toUpperCase();
+                if (!normalized.startsWith("SELECT") && !normalized.startsWith("PRAGMA") && !normalized.startsWith("EXPLAIN")) {
+                    throw new Error("READ_ONLY mode is enabled. Only SELECT, PRAGMA, and EXPLAIN statements are allowed.");
+                }
+            }
             const results = await queryDb(activeDb.localPath, sql, params);
             return {
                 content: [

package/dist/locator.js

@@ -49,7 +49,7 @@ export async function listDatabases(bundleId, targetPlatform) {
             }
             return results;
         }
-        // Discover packages to scan
+        // if we have a specific bundleId-use it otherwise hunt
         let packagesToScan = [];
         if (bundleId) {
             packagesToScan = [bundleId];
@@ -76,12 +76,12 @@ export async function listDatabases(bundleId, targetPlatform) {
                 try {
                     await shell(`adb shell run-as ${pkg} ls -d ${baseDir}`, { timeout: 3_000, label: `adb-ls-${pkg}` });
                     let foundFiles = [];
-                    // Find .db / .sqlite / .sqlite3 files recursively
+                    // find .db / .sqlite / .sqlite3 files recursively
                     const findOut = await shell(`adb shell "run-as ${pkg} find ${baseDir} -type f \\( -name \\"*.db\\" -o -name \\"*.sqlite\\" -o -name \\"*.sqlite3\\" \\)"`, { timeout: 8_000, ignoreErrors: true, label: `adb-find-${pkg}` });
                     if (findOut) {
                         foundFiles.push(...findOut.split('\n').map(l => l.trim().replace(/\r/g, '')).filter(Boolean));
                     }
-                    // Also check for extensionless files in /databases
+                    // also check for extensionless files in /databases
                     const lsOut = await shell(`adb shell run-as ${pkg} ls -1p ${baseDir}/databases`, { timeout: 3_000, ignoreErrors: true, label: `adb-ls-dbs-${pkg}` });
                     if (lsOut) {
                         const lsFiles = lsOut.split('\n')
@@ -120,12 +120,6 @@ export async function listDatabases(bundleId, targetPlatform) {
     }
     return results;
 }
-/**
- * Finds the DB file based on platform and a provided/detected filename.
- * If dbNameGlob is empty/undefined, it will auto-select the first discovered database.
- * Prioritizes iOS (simctl), falls back to Android (adb).
- * Returns the local file path (either the iOS original or a pulled Android copy).
- */
 export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
     const locations = await listDatabases(bundleId, targetPlatform);
     if (locations.length === 0) {
@@ -176,7 +170,6 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
                 continue;
             }
             const [targetDbDir, targetPkg] = appDir.split("::");
-            // Force-stop is best-effort (ensures WAL is flushed)
             await shell(`adb shell am force-stop ${targetPkg}`, { timeout: 5_000, ignoreErrors: true, label: `adb-force-stop-${targetPkg}` });
             const tmpdir = fs.mkdtempSync(path.join(os.tmpdir(), "rn-sqlite-mcp-"));
             const safeLocalName = targetDbName.replace(/\//g, '_');

package/dist/logger.js

@@ -1,7 +1,3 @@
-/**
- * Structured logging utility for MCP servers.
- * ALL output goes to stderr to avoid polluting the stdio JSON-RPC transport.
- */
 const LOG_LEVELS = {
     debug: 0,
     info: 1,

package/dist/shell.js

@@ -1,8 +1,3 @@
-/**
- * Async shell execution wrapper.
- * Replaces all execSync usage to keep the Node.js event loop alive
- * so MCP stdio transport can continue processing heartbeats/messages.
- */
 import { exec as execCb } from "child_process";
 import { promisify } from "util";
 import { logger } from "./logger.js";
@@ -10,10 +5,6 @@ const execAsync = promisify(execCb);
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-/**
- * Execute a shell command asynchronously with timeout and retry support.
- * This is the core replacement for `execSync` — it does NOT block the event loop.
- */
 export async function shell(command, options = {}) {
     const { timeout = 10_000, retries = 0, retryDelay = 1_000, ignoreErrors = false, label, } = options;
     const tag = label || command.slice(0, 60);

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "react-native-sqlite-mcp",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Universal React Native SQLite MCP Server",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
     "react-native-sqlite-mcp": "dist/index.js"
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "build": "tsc",
     "start": "node dist/index.js",
@@ -23,11 +26,11 @@
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.0",
-    "sqlite3": "^5.1.7"
+    "sql.js": "^1.14.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.4",
-    "@types/sqlite3": "^3.1.11",
+    "@types/sql.js": "^1.4.9",
     "typescript": "^5.7.3"
   }
 }

package/CONTRIBUTING.md

@@ -1,35 +0,0 @@
-# Welcome to the Contributing Guide
-
-First off, thank you for considering contributing to the **Universal React Native SQLite MCP**! 
-
-Whether you're fixing a typo, optimizing an ADB command, or pointing out a glaring architecture flaw, your help is what makes open source awesome. I built this tool to fill a massive gap in the current MCP ecosystem around mobile development. There are plenty of SQLite tools out there, but none that seamlessly hook into your local emulators and simulators. And all the MCP's around mobile development are primarily UI focused. So hopefully this fills a niche. Let's make mobile dev less painful together!
-
-## The Vibe
-
-- **Keep it chill, but keep it working**: Have fun with the code and the docs, but let's make sure the core functionality is rock solid.
-- **Assume good intent**: We're all here to build cool stuff and learn. Be kind in your PRs and specific in your code reviews.
-- **Developer Experience (DX) is king**: This tool exists to make life easier. If a feature makes the tool harder to use or setup, we probably need to rethink it.
-
-## 🛠️ How to get started
-
-1. **Fork the repo** and clone it locally.
-2. **Install dependencies**: `npm install`
-3. **Make your changes**: Branch off `main` and do your thing.
-4. **Test it out locally**: Build it with `npm run build` and point your local MCP client to it to verify it actually works against an emulator/simulator.
-5. **Open a PR**: Give it a descriptive title and tell me what you fixed or added.
-
-## Found a Bug?
-
-Please open an issue! Tell me:
-- What you were trying to do.
-- What actually happened.
-- Are you on iOS, Android, or both? 
-- Any logs you have from your AI client.
-
-## Got a Feature Idea?
-
-Open an issue and let's chat about it before you spend hours coding it up. I'm totally open to new ideas (especially if they involve making the auto-discovery even smarter).
-
----
-
-Let's build something epic together.