react-native-sqlite-mcp 1.0.0 → 1.0.1

package/dist/locator.js

@@ -1,18 +1,18 @@
-import { execSync } from "child_process";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { shell } from "./shell.js";
+import { logger } from "./logger.js";
 export async function listDatabases(bundleId, targetPlatform) {
     const results = [];
     if (!targetPlatform || targetPlatform === 'ios') {
         try {
-            const udidStr = execSync("xcrun simctl list devices booted | awk -F '[()]' '/Booted/{print $2; exit}'", { stdio: ['pipe', 'pipe', 'ignore'], timeout: 3000 }).toString().trim();
+            const udidStr = await shell("xcrun simctl list devices booted | awk -F '[()]' '/Booted/{print $2; exit}'", { timeout: 5_000, label: "xcrun-simctl-booted" });
             if (udidStr) {
                 const appDataDir = `${process.env.HOME}/Library/Developer/CoreSimulator/Devices/${udidStr}/data/Containers/Data/Application`;
                 if (fs.existsSync(appDataDir)) {
                     try {
-                        const findCmd = `find "${appDataDir}" -type f \\( -name "*.db" -o -name "*.sqlite" -o -name "*.sqlite3" \\) -maxdepth 7 -print`;
-                        const found = execSync(findCmd, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 10000 }).toString().trim();
+                        const found = await shell(`find "${appDataDir}" -type f \\( -name "*.db" -o -name "*.sqlite" -o -name "*.sqlite3" \\) -maxdepth 7 -print`, { timeout: 15_000, label: "ios-find-dbs" });
                         if (found) {
                             results.push({
                                 platform: 'ios',
@@ -22,7 +22,7 @@ export async function listDatabases(bundleId, targetPlatform) {
                         }
                     }
                     catch (e) {
-                        console.error("iOS find failed", e);
+                        logger.warn("iOS find failed", { error: String(e) });
                     }
                 }
             }
@@ -38,7 +38,7 @@ export async function listDatabases(bundleId, targetPlatform) {
     }
     if (!targetPlatform || targetPlatform === 'android') {
         try {
-            execSync("adb get-state", { stdio: ['pipe', 'pipe', 'ignore'], timeout: 3000 });
+            await shell("adb get-state", { timeout: 5_000, label: "adb-get-state" });
         }
         catch (e) {
             if (targetPlatform === 'android') {
@@ -49,14 +49,14 @@ export async function listDatabases(bundleId, targetPlatform) {
             }
             return results;
         }
-        // if we have a specific bundleId-use it otherwise hunt
+        // Discover packages to scan
         let packagesToScan = [];
         if (bundleId) {
             packagesToScan = [bundleId];
         }
         else {
             try {
-                const packagesStr = execSync("adb shell pm list packages -3", { stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 }).toString().trim();
+                const packagesStr = await shell("adb shell pm list packages -3", { timeout: 8_000, label: "adb-list-packages", retries: 1, retryDelay: 1_000 });
                 packagesToScan = packagesStr.split('\n')
                     .map(line => line.replace('package:', '').trim())
                     .filter(Boolean);
@@ -74,18 +74,16 @@ export async function listDatabases(bundleId, targetPlatform) {
             const baseDirs = [`/data/user/0/${pkg}`, `/data/data/${pkg}`];
             for (const baseDir of baseDirs) {
                 try {
-                    execSync(`adb shell run-as ${pkg} ls -d ${baseDir}`, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 2000 });
+                    await shell(`adb shell run-as ${pkg} ls -d ${baseDir}`, { timeout: 3_000, label: `adb-ls-${pkg}` });
                     let foundFiles = [];
-                    try {
-                        const findCmd = `adb shell "run-as ${pkg} find ${baseDir} -type f \\( -name \\"*.db\\" -o -name \\"*.sqlite\\" -o -name \\"*.sqlite3\\" \\)"`;
-                        const findOut = execSync(findCmd, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 }).toString().trim();
-                        if (findOut) {
-                            foundFiles.push(...findOut.split('\n').map(l => l.trim().replace(/\r/g, '')).filter(Boolean));
-                        }
+                    // 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));
                     }
-                    catch (e) { }
-                    try {
-                        const lsOut = execSync(`adb shell run-as ${pkg} ls -1p ${baseDir}/databases`, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 2000 }).toString().trim();
+                    // 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')
                             .map(l => l.trim().replace(/\r/g, ''))
                             .filter(Boolean)
@@ -95,7 +93,6 @@ export async function listDatabases(bundleId, targetPlatform) {
                             .map(f => `${baseDir}/databases/${f}`);
                         foundFiles.push(...lsFiles);
                     }
-                    catch (e) { }
                     // Deduplicate
                     foundFiles = [...new Set(foundFiles)];
                     if (foundFiles.length > 0) {
@@ -106,7 +103,7 @@ export async function listDatabases(bundleId, targetPlatform) {
                     }
                 }
                 catch (e) {
-                    console.error(`Failed to list databases for app: ${pkg}`);
+                    logger.debug(`Failed to list databases for app: ${pkg}`);
                 }
             }
         }
@@ -130,7 +127,6 @@ export async function listDatabases(bundleId, targetPlatform) {
  * Returns the local file path (either the iOS original or a pulled Android copy).
  */
 export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
-    // First, discover available databases
     const locations = await listDatabases(bundleId, targetPlatform);
     if (locations.length === 0) {
         if (targetPlatform) {
@@ -144,13 +140,12 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
             continue;
         let targetDbNames = [];
         if (!dbNameGlob) {
-            // Auto-select: find the first .db or .sqlite file in this location
             const preferred = loc.databases.find(d => d.endsWith('.db') || d.endsWith('.sqlite'));
             if (preferred) {
                 targetDbNames.push(preferred);
             }
             else if (loc.databases.length > 0) {
-                targetDbNames.push(loc.databases[0]); // fallback to first file
+                targetDbNames.push(loc.databases[0]);
             }
         }
         else {
@@ -163,32 +158,26 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
             if (platform === 'ios') {
                 if (!appDir)
                     continue;
-                // Find the exact path of the targetDbName
-                const findCmd = `find "${appDir}" -type f -name "${targetDbName}" -maxdepth 7 -print | head -n 1`;
                 try {
-                    const found = execSync(findCmd, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 }).toString().trim();
+                    const found = await shell(`find "${appDir}" -type f -name "${targetDbName}" -maxdepth 7 -print | head -n 1`, { timeout: 8_000, label: `ios-find-${targetDbName}` });
                     if (found && fs.existsSync(found)) {
-                        console.error(`Located iOS DB at: ${found}`);
+                        logger.info(`Located iOS DB at: ${found}`);
                         synced.push({ localPath: found, dbName: targetDbName, platform: 'ios' });
                     }
                 }
                 catch (e) {
-                    console.error(`Failed to locate full path for iOS DB: ${targetDbName}`);
+                    logger.warn(`Failed to locate full path for iOS DB: ${targetDbName}`);
                 }
                 continue;
             }
             // --- Android Logic ---
             if (!appDir || !appDir.includes("::")) {
-                console.error(`Invalid Android appDir format: ${appDir}`);
+                logger.warn(`Invalid Android appDir format: ${appDir}`);
                 continue;
             }
             const [targetDbDir, targetPkg] = appDir.split("::");
-            try {
-                execSync(`adb shell am force-stop ${targetPkg}`, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 3000 });
-            }
-            catch (e) {
-                console.error(`Failed to force-stop app: ${targetPkg}`);
-            }
+            // 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, '_');
             const localDb = path.join(tmpdir, safeLocalName);
@@ -197,13 +186,13 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
             const remoteMain = `${targetDbDir}/${targetDbName}`;
             const remoteWal = `${remoteMain}-wal`;
             const remoteShm = `${remoteMain}-shm`;
-            const pullOne = (remote, local) => {
+            const pullOne = async (remote, local) => {
                 try {
                     const remoteBase = path.basename(remote);
                     const tmpRemote = `/data/local/tmp/${targetPkg}_${remoteBase}_${Date.now()}`;
-                    execSync(`adb shell "run-as '${targetPkg}' cat '${remote}' > '${tmpRemote}'"`, { stdio: 'ignore', timeout: 5000 });
-                    execSync(`adb pull '${tmpRemote}' '${local}'`, { stdio: 'ignore', timeout: 5000 });
-                    execSync(`adb shell rm '${tmpRemote}'`, { stdio: 'ignore', timeout: 3000 });
+                    await shell(`adb shell "run-as '${targetPkg}' cat '${remote}' > '${tmpRemote}'"`, { timeout: 10_000, retries: 1, retryDelay: 1_000, label: `adb-cat-${remoteBase}` });
+                    await shell(`adb pull '${tmpRemote}' '${local}'`, { timeout: 10_000, label: `adb-pull-${remoteBase}` });
+                    await shell(`adb shell rm '${tmpRemote}'`, { timeout: 5_000, ignoreErrors: true, label: `adb-rm-tmp-${remoteBase}` });
                     return fs.existsSync(local) && fs.statSync(local).size > 0;
                 }
                 catch (e) {
@@ -212,13 +201,14 @@ export async function syncDatabase(dbNameGlob, bundleId, targetPlatform) {
                     return false;
                 }
             };
-            if (!pullOne(remoteMain, localDb)) {
-                console.error(`Failed to pull main DB file from Android: ${remoteMain}`);
+            if (!(await pullOne(remoteMain, localDb))) {
+                logger.warn(`Failed to pull main DB file from Android: ${remoteMain}`);
                 continue;
             }
-            pullOne(remoteWal, localWal);
-            pullOne(remoteShm, localShm);
-            console.error(`Pulled Android DB to local temp: ${localDb}`);
+            // WAL and SHM are best-effort
+            await pullOne(remoteWal, localWal);
+            await pullOne(remoteShm, localShm);
+            logger.info(`Pulled Android DB to local temp: ${localDb}`);
             synced.push({ localPath: localDb, dbName: targetDbName, platform: 'android' });
         }
     }

package/dist/logger.js

@@ -0,0 +1,33 @@
+/**
+ * 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,
+    warn: 2,
+    error: 3,
+};
+const minLevel = process.env.MCP_LOG_LEVEL || 'info';
+function shouldLog(level) {
+    return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+function log(level, message, meta) {
+    if (!shouldLog(level))
+        return;
+    const parts = [`[${formatTimestamp()}]`, `[${level.toUpperCase()}]`, message];
+    if (meta && Object.keys(meta).length > 0) {
+        parts.push(JSON.stringify(meta));
+    }
+    // CRITICAL: Always stderr — stdout is reserved for MCP JSON-RPC
+    process.stderr.write(parts.join(' ') + '\n');
+}
+export const logger = {
+    debug: (msg, meta) => log('debug', msg, meta),
+    info: (msg, meta) => log('info', msg, meta),
+    warn: (msg, meta) => log('warn', msg, meta),
+    error: (msg, meta) => log('error', msg, meta),
+};

package/dist/shell.js

@@ -0,0 +1,57 @@
+/**
+ * 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";
+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);
+    for (let attempt = 0; attempt <= retries; attempt++) {
+        try {
+            if (attempt > 0) {
+                const delay = retryDelay * Math.pow(2, attempt - 1);
+                logger.debug(`Retry ${attempt}/${retries} for "${tag}" after ${delay}ms`);
+                await sleep(delay);
+            }
+            logger.debug(`Executing: "${tag}"`, { timeout, attempt });
+            const result = await execAsync(command, {
+                timeout,
+                maxBuffer: 10 * 1024 * 1024, // 10MB — large schema dumps
+                env: { ...process.env },
+            });
+            return result.stdout.trim();
+        }
+        catch (error) {
+            const isLastAttempt = attempt >= retries;
+            if (error.killed) {
+                logger.warn(`Command timed out after ${timeout}ms: "${tag}"`);
+            }
+            else {
+                logger.debug(`Command failed: "${tag}"`, {
+                    code: error.code,
+                    stderr: error.stderr?.slice(0, 200),
+                });
+            }
+            if (isLastAttempt) {
+                if (ignoreErrors) {
+                    logger.debug(`Ignoring error for "${tag}"`);
+                    return "";
+                }
+                throw new Error(`Shell command failed: ${tag}\n${error.message || error.stderr || "Unknown error"}`);
+            }
+        }
+    }
+    // Unreachable, but TypeScript needs it
+    return "";
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-sqlite-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Universal React Native SQLite MCP Server",
   "main": "dist/index.js",
   "type": "module",

package/src/db.ts

@@ -1,4 +1,5 @@
 import sqlite3 from "sqlite3";
+import { logger } from "./logger.js";
 
 export class Database {
   private db: sqlite3.Database;
@@ -35,51 +36,96 @@ export class Database {
   }
 }
 
-/**
- * Executes a simple query on the database.
- */
-export async function queryDb(dbPath: string, sql: string, params: any[] = []): Promise<any[]> {
+interface CachedConnection {
+  db: Database;
+  lastUsed: number;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+const CACHE_TTL_MS = 60_000; // close idle connections after 60s
+const connectionCache = new Map<string, CachedConnection>();
+
+function getCachedDb(dbPath: string): Database {
+  const existing = connectionCache.get(dbPath);
+
+  if (existing) {
+    clearTimeout(existing.timer);
+    existing.lastUsed = Date.now();
+    existing.timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
+    return existing.db;
+  }
+
   const db = new Database(dbPath);
+  const timer = setTimeout(() => evictConnection(dbPath), CACHE_TTL_MS);
+
+  connectionCache.set(dbPath, { db, lastUsed: Date.now(), timer });
+  logger.debug(`Opened DB connection: ${dbPath}`);
+  return db;
+}
+
+async function evictConnection(dbPath: string): Promise<void> {
+  const entry = connectionCache.get(dbPath);
+  if (!entry) return;
+
+  connectionCache.delete(dbPath);
   try {
-    return await db.all(sql, params);
-  } finally {
-    await db.close();
+    await entry.db.close();
+    logger.debug(`Closed idle DB connection: ${dbPath}`);
+  } catch (e) {
+    logger.warn(`Error closing DB: ${dbPath}`, { error: String(e) });
+  }
+}
+
+export async function closeAllConnections(): Promise<void> {
+  const paths = [...connectionCache.keys()];
+  for (const p of paths) {
+    await evictConnection(p);
   }
+  logger.info(`Closed ${paths.length} cached DB connection(s)`);
+}
+
+const QUERY_TIMEOUT_MS = 30_000;
+
+function withTimeout<T>(promise: Promise<T>, ms: number, label: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      reject(new Error(`Query timed out after ${ms}ms: ${label}`));
+    }, ms);
+
+    promise
+      .then((result) => { clearTimeout(timer); resolve(result); })
+      .catch((err) => { clearTimeout(timer); reject(err); });
+  });
+}
+
+export async function queryDb(dbPath: string, sql: string, params: any[] = []): Promise<any[]> {
+  const db = getCachedDb(dbPath);
+  return withTimeout(db.all(sql, params), QUERY_TIMEOUT_MS, sql.slice(0, 80));
 }
 
-/**
- * Returns a detailed schema of all tables in the database.
- */
 export async function inspectSchema(dbPath: string): Promise<any> {
-  const db = new Database(dbPath);
-  try {
-    // Get all table names
-    const tables = await db.all<{ name: string }>(
-      "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"
+  const db = getCachedDb(dbPath);
+
+  const tables = await withTimeout(
+    db.all<{ name: string }>("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name;"),
+    QUERY_TIMEOUT_MS,
+    "inspect_schema:tables"
+  );
+
+  const schemaInfo: Record<string, any> = {};
+
+  for (const table of tables) {
+    const columns = await db.all(`PRAGMA table_info("${table.name}");`);
+    const createSql = await db.get<{ sql: string }>(
+      `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`,
+      [table.name]
     );
 
-    const schemaInfo: Record<string, any> = {};
-
-    for (const table of tables) {
-      // For each table, get column definitions
-      const columns = await db.all(
-        `PRAGMA table_info("${table.name}");`
-      );
-      
-      // Get table creation SQL
-      const createSql = await db.get<{ sql: string }>(
-        `SELECT sql FROM sqlite_master WHERE type='table' AND name=?`, 
-        [table.name]
-      );
-
-      schemaInfo[table.name] = {
-        columns,
-        createSql: createSql?.sql
-      };
-    }
-
-    return schemaInfo;
-  } finally {
-    await db.close();
+    schemaInfo[table.name] = {
+      columns,
+      createSql: createSql?.sql
+    };
   }
+
+  return schemaInfo;
 }