react-native-sqlite-mcp 1.0.0 → 1.0.1

package/src/locator.ts

@@ -1,7 +1,8 @@
-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 interface DatabaseLocation {
   platform: 'ios' | 'android';
@@ -14,13 +15,19 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
 
   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',
@@ -29,7 +36,7 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
               });
             }
           } catch (e) {
-            console.error("iOS find failed", e);
+            logger.warn("iOS find failed", { error: String(e) });
           }
         }
       } else if (targetPlatform === 'ios') {
@@ -44,7 +51,7 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
 
   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') {
         throw new Error("No booted Android Emulator found or adb is unresponsive.");
@@ -52,7 +59,7 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
       if (results.length === 0) {
         throw new Error("No booted iOS Simulator or Android Emulator device found.");
       }
-      return results; 
+      return results;
     }
 
     // if we have a specific bundleId-use it otherwise hunt
@@ -61,7 +68,10 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
       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);
@@ -78,76 +88,76 @@ export async function listDatabases(bundleId?: string, targetPlatform?: 'ios' |
 
     for (const pkg of packagesToScan) {
       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: string[] = [];
-          
-          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));
-            }
-          } catch (e) {}
-          
-           try {
-            const lsOut = execSync(`adb shell run-as ${pkg} ls -1p ${baseDir}/databases`, { stdio: ['pipe', 'pipe', 'ignore'], timeout: 2000 }).toString().trim();
+
+          // 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
+          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)
               .filter(f => !f.endsWith('/'))
               .filter(f => !f.endsWith('-journal') && !f.endsWith('-wal') && !f.endsWith('-shm'))
-              .filter(f => !f.includes('.')) 
+              .filter(f => !f.includes('.'))
               .map(f => `${baseDir}/databases/${f}`);
-             foundFiles.push(...lsFiles);
-           } catch (e) {}
+            foundFiles.push(...lsFiles);
+          }
 
           // Deduplicate
           foundFiles = [...new Set(foundFiles)];
 
           if (foundFiles.length > 0) {
-             const displayFiles = foundFiles.map(f => f.replace(`${baseDir}/`, ''));
-             
-             allAndroidDatabases.push(...displayFiles);
-             lastSuccessfulAppDir = `${baseDir}::${pkg}`;
-             break;
+            const displayFiles = foundFiles.map(f => f.replace(`${baseDir}/`, ''));
+            allAndroidDatabases.push(...displayFiles);
+            lastSuccessfulAppDir = `${baseDir}::${pkg}`;
+            break;
           }
         } catch (e) {
-          console.error(`Failed to list databases for app: ${pkg}`);
+          logger.debug(`Failed to list databases for app: ${pkg}`);
         }
       }
     }
 
     if (allAndroidDatabases.length > 0) {
-       results.push({
+      results.push({
         platform: 'android',
         appDir: lastSuccessfulAppDir,
         databases: allAndroidDatabases
       });
     } else if (targetPlatform === 'android') {
-       throw new Error(`Android Emulator is booted, but no SQLite databases were found in any debuggable third-party packages.`);
+      throw new Error(`Android Emulator is booted, but no SQLite databases were found in any debuggable third-party packages.`);
     }
   }
-  
+
   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?: string, bundleId?: string, targetPlatform?: 'ios' | 'android'): Promise<{ localPath: string, dbName: string, platform: 'ios' | 'android' }[]> {
-  // First, discover available databases
   const locations = await listDatabases(bundleId, targetPlatform);
 
   if (locations.length === 0) {
     if (targetPlatform) {
-       throw new Error(`No SQLite databases found for platform '${targetPlatform}'.`);
+      throw new Error(`No SQLite databases found for platform '${targetPlatform}'.`);
     }
     throw new Error(`No SQLite databases found on any platform.`);
   }
@@ -156,16 +166,14 @@ export async function syncDatabase(dbNameGlob?: string, bundleId?: string, targe
 
   for (const loc of locations) {
     if (targetPlatform && loc.platform !== targetPlatform) continue;
-    
     let targetDbNames: string[] = [];
 
     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 {
       const globRegex = new RegExp('^' + dbNameGlob.replace(/\*/g, '.*') + '$');
@@ -178,34 +186,34 @@ export async function syncDatabase(dbNameGlob?: string, bundleId?: string, targe
       // --- iOS Logic ---
       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}`);
-      }
+
+      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, '_');
@@ -217,16 +225,24 @@ export async function syncDatabase(dbNameGlob?: string, bundleId?: string, targe
       const remoteWal = `${remoteMain}-wal`;
       const remoteShm = `${remoteMain}-shm`;
 
-   
-      const pullOne = (remote: string, local: string) => {
+      const pullOne = async (remote: string, local: string): Promise<boolean> => {
         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) {
           if (fs.existsSync(local)) fs.unlinkSync(local);
@@ -234,15 +250,16 @@ export async function syncDatabase(dbNameGlob?: string, bundleId?: string, targe
         }
       };
 
-      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);
+      // WAL and SHM are best-effort
+      await pullOne(remoteWal, localWal);
+      await pullOne(remoteShm, localShm);
 
-      console.error(`Pulled Android DB to local temp: ${localDb}`);
+      logger.info(`Pulled Android DB to local temp: ${localDb}`);
       synced.push({ localPath: localDb, dbName: targetDbName, platform: 'android' });
     }
   }

package/src/logger.ts

@@ -0,0 +1,37 @@
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+
+const LOG_LEVELS: Record<LogLevel, number> = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+};
+
+const minLevel: LogLevel = (process.env.MCP_LOG_LEVEL as LogLevel) || 'info';
+
+function shouldLog(level: LogLevel): boolean {
+  return LOG_LEVELS[level] >= LOG_LEVELS[minLevel];
+}
+
+function formatTimestamp(): string {
+  return new Date().toISOString();
+}
+
+function log(level: LogLevel, message: string, meta?: Record<string, unknown>): void {
+  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: string, meta?: Record<string, unknown>) => log('debug', msg, meta),
+  info: (msg: string, meta?: Record<string, unknown>) => log('info', msg, meta),
+  warn: (msg: string, meta?: Record<string, unknown>) => log('warn', msg, meta),
+  error: (msg: string, meta?: Record<string, unknown>) => log('error', msg, meta),
+};

package/src/shell.ts

@@ -0,0 +1,81 @@
+import { exec as execCb } from "child_process";
+import { promisify } from "util";
+import { logger } from "./logger.js";
+
+const execAsync = promisify(execCb);
+
+export interface ShellOptions {
+  timeout?: number;
+  retries?: number;
+  retryDelay?: number;
+  ignoreErrors?: boolean;
+  label?: string;
+}
+
+export interface ShellResult {
+  stdout: string;
+  stderr: string;
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function shell(
+  command: string,
+  options: ShellOptions = {}
+): Promise<string> {
+  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: any) {
+      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 "";
+}