react-native-sqlite-mcp 1.0.0 → 1.0.2

package/dist/index.js

@@ -3,8 +3,27 @@ import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import { listDatabases, syncDatabase } from "./locator.js";
-import { inspectSchema, queryDb } from "./db.js";
+import { inspectSchema, queryDb, closeAllConnections } from "./db.js";
+import { logger } from "./logger.js";
+// ---------------------------------------------------------------------------
+// Process-level guards — prevent silent crashes that cause EOF errors
+// ---------------------------------------------------------------------------
+process.on("uncaughtException", (error) => {
+    logger.error("Uncaught exception (process kept alive)", {
+        message: error.message,
+        stack: error.stack?.slice(0, 500),
+    });
+    // Do NOT call process.exit() — keep the MCP server alive
+});
+process.on("unhandledRejection", (reason) => {
+    logger.error("Unhandled promise rejection (process kept alive)", {
+        reason: String(reason),
+    });
+});
 let activeDatabases = [];
+// ---------------------------------------------------------------------------
+// Server setup
+// ---------------------------------------------------------------------------
 const server = new Server({
     name: "react-native-sqlite-bridge",
     version: "1.0.0",
@@ -13,6 +32,13 @@ const server = new Server({
         tools: {},
     },
 });
+// MCP-level transport error handler
+server.onerror = (error) => {
+    logger.error("MCP transport error", { message: String(error) });
+};
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
@@ -24,18 +50,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         dbName: {
                             type: "string",
-                            description: "The name of the database file or a glob pattern (e.g., 'my_app.db' or '*.db'). Optional. If omitted, it will select the first discovered database."
+                            description: "The name of the database file or a glob pattern (e.g., 'my_app.db' or '*.db'). Optional. If omitted, it will select the first discovered database.",
                         },
                         bundleId: {
                             type: "string",
-                            description: "(Android only) The application bundle ID (e.g., 'com.example.app'). Not required for iOS."
+                            description: "(Android only) The application bundle ID (e.g., 'com.example.app'). Not required for iOS.",
                         },
                         platform: {
                             type: "string",
-                            description: "Optional. Explicitly target 'ios' or 'android'."
-                        }
-                    }
-                }
+                            description: "Optional. Explicitly target 'ios' or 'android'.",
+                        },
+                    },
+                },
             },
             {
                 name: "list_databases",
@@ -45,14 +71,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         bundleId: {
                             type: "string",
-                            description: "(Android only) The application bundle ID (e.g., 'com.example.app'). Not required for iOS."
+                            description: "(Android only) The application bundle ID (e.g., 'com.example.app'). Not required for iOS.",
                         },
                         platform: {
                             type: "string",
-                            description: "Optional. Explicitly target 'ios' or 'android'."
-                        }
-                    }
-                }
+                            description: "Optional. Explicitly target 'ios' or 'android'.",
+                        },
+                    },
+                },
             },
             {
                 name: "inspect_schema",
@@ -62,15 +88,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         dbName: {
                             type: "string",
-                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects."
+                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects.",
                         },
                         platform: {
                             type: "string",
-                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects."
-                        }
+                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects.",
+                        },
                     },
-                    required: []
-                }
+                    required: [],
+                },
             },
             {
                 name: "read_table_contents",
@@ -80,23 +106,23 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         tableName: {
                             type: "string",
-                            description: "The name of the table to read."
+                            description: "The name of the table to read.",
                         },
                         limit: {
                             type: "number",
-                            description: "Optional limit to the number of rows returned. Defaults to 100."
+                            description: "Optional limit to the number of rows returned. Defaults to 100.",
                         },
                         dbName: {
                             type: "string",
-                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects."
+                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects.",
                         },
                         platform: {
                             type: "string",
-                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects."
-                        }
+                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects.",
+                        },
                     },
-                    required: ["tableName"]
-                }
+                    required: ["tableName"],
+                },
             },
             {
                 name: "query_db",
@@ -106,41 +132,41 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     properties: {
                         sql: {
                             type: "string",
-                            description: "The raw SQL SELECT string to execute."
+                            description: "The raw SQL SELECT string to execute.",
                         },
                         params: {
                             type: "array",
                             description: "Optional arguments to bind to the SQL query. Use this to safely substitute ? placeholders in your SQL string (e.g. ['value', 42]).",
                             items: {
-                                type: ["string", "number", "boolean", "null"],
-                                description: "A single bound parameter value."
-                            }
+                                description: "A single bound parameter value.",
+                            },
                         },
                         dbName: {
                             type: "string",
-                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects."
+                            description: "Optional. Target a specific database name. If omitted, uses the active DB or auto-selects.",
                         },
                         platform: {
                             type: "string",
-                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects."
-                        }
+                            description: "Optional. Explicitly target 'ios' or 'android'. If omitted, uses the active DB or auto-selects.",
+                        },
                     },
-                    required: ["sql"]
-                }
-            }
-        ]
+                    required: ["sql"],
+                },
+            },
+        ],
     };
 });
-// Helper to sanitize platform input if any
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
 function cleanPlatform(raw) {
     if (!raw)
         return undefined;
-    const cleaned = raw.replace(/['"]/g, '').trim().toLowerCase();
-    if (cleaned === 'ios' || cleaned === 'android')
+    const cleaned = raw.replace(/['"]/g, "").trim().toLowerCase();
+    if (cleaned === "ios" || cleaned === "android")
         return cleaned;
-    return undefined; // If they pass garbage, just let locator try both
+    return undefined;
 }
-// Helper to ensure database is synced based on provided args
 async function ensureDbState(args) {
     const reqDbName = args?.dbName;
     const reqPlatform = cleanPlatform(args?.platform);
@@ -150,21 +176,24 @@ async function ensureDbState(args) {
         const envBundle = process.env.ANDROID_BUNDLE_ID;
         activeDatabases = await syncDatabase(envDb, envBundle, reqPlatform);
     }
-    // Filter based on explicit requirements
     let candidates = activeDatabases;
     if (reqPlatform)
-        candidates = candidates.filter(db => db.platform === reqPlatform);
+        candidates = candidates.filter((db) => db.platform === reqPlatform);
     if (reqDbName)
-        candidates = candidates.filter(db => db.dbName === reqDbName);
-    if (candidates.length === 1) {
+        candidates = candidates.filter((db) => db.dbName === reqDbName);
+    if (candidates.length === 1)
         return candidates[0];
-    }
     if (candidates.length === 0) {
-        throw new Error(`No synced databases match the criteria (platform: ${reqPlatform || 'any'}, dbName: ${reqDbName || 'any'}). Try calling sync_database first.`);
+        throw new Error(`No synced databases match the criteria (platform: ${reqPlatform || "any"}, dbName: ${reqDbName || "any"}). Try calling sync_database first.`);
     }
-    const matches = candidates.map(c => `[${c.platform}] ${c.dbName}`).join(", ");
+    const matches = candidates
+        .map((c) => `[${c.platform}] ${c.dbName}`)
+        .join(", ");
     throw new Error(`Multiple databases match the criteria. Please specify 'platform' or 'dbName'. Matches: ${matches}`);
 }
+// ---------------------------------------------------------------------------
+// Tool handlers
+// ---------------------------------------------------------------------------
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
@@ -173,7 +202,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const platform = cleanPlatform(args?.platform);
             const results = await listDatabases(bundleId, platform);
             return {
-                content: [{ type: "text", text: JSON.stringify(results, null, 2) }]
+                content: [
+                    { type: "text", text: JSON.stringify(results, null, 2) },
+                ],
             };
         }
         if (name === "sync_database") {
@@ -181,20 +212,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const bundleId = args?.bundleId;
             const platform = cleanPlatform(args?.platform);
             const results = await syncDatabase(dbName, bundleId, platform);
-            activeDatabases = results; // Replace the active list
+            activeDatabases = results;
             let msg = "Successfully synced databases:\n";
             for (const res of results) {
                 msg += `- Platform: ${res.platform} | DB: ${res.dbName}\n  Path: ${res.localPath}\n`;
             }
-            return {
-                content: [{ type: "text", text: msg }]
-            };
+            return { content: [{ type: "text", text: msg }] };
         }
         if (name === "inspect_schema") {
             const activeDb = await ensureDbState(args);
             const schema = await inspectSchema(activeDb.localPath);
             return {
-                content: [{ type: "text", text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName}]\n` + JSON.stringify(schema, null, 2) }]
+                content: [
+                    {
+                        type: "text",
+                        text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName}]\n` +
+                            JSON.stringify(schema, null, 2),
+                    },
+                ],
             };
         }
         if (name === "read_table_contents") {
@@ -207,7 +242,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const sql = `SELECT * FROM "${tableName}" LIMIT ?`;
             const results = await queryDb(activeDb.localPath, sql, [limit]);
             return {
-                content: [{ type: "text", text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName} | Table: ${tableName} | Limit: ${limit}]\n` + JSON.stringify(results, null, 2) }]
+                content: [
+                    {
+                        type: "text",
+                        text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName} | Table: ${tableName} | Limit: ${limit}]\n` +
+                            JSON.stringify(results, null, 2),
+                    },
+                ],
             };
         }
         if (name === "query_db") {
@@ -219,29 +260,54 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             }
             const results = await queryDb(activeDb.localPath, sql, params);
             return {
-                content: [{ type: "text", text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName}]\n` + JSON.stringify(results, null, 2) }]
+                content: [
+                    {
+                        type: "text",
+                        text: `[Active Platform: ${activeDb.platform} | DB: ${activeDb.dbName}]\n` +
+                            JSON.stringify(results, null, 2),
+                    },
+                ],
             };
         }
         throw new Error(`Unknown tool: ${name}`);
     }
     catch (error) {
+        logger.error(`Tool "${name}" failed`, { message: error.message });
         return {
             content: [
                 {
                     type: "text",
-                    text: `Error: ${error.message}`
-                }
+                    text: `Error: ${error.message}`,
+                },
             ],
-            isError: true
+            isError: true,
         };
     }
 });
+// ---------------------------------------------------------------------------
+// Graceful shutdown
+// ---------------------------------------------------------------------------
+async function shutdown(signal) {
+    logger.info(`Received ${signal}, shutting down gracefully...`);
+    try {
+        await closeAllConnections();
+    }
+    catch (e) {
+        logger.error("Error during shutdown", { error: String(e) });
+    }
+    process.exit(0);
+}
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
 async function run() {
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error("Universal React Native SQLite MCP Server running on stdio");
+    logger.info("Universal React Native SQLite MCP Server running on stdio");
 }
 run().catch((error) => {
-    console.error("Server error:", error);
+    logger.error("Server startup error", { message: error.message, stack: error.stack });
     process.exit(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') {
@@ -56,7 +56,7 @@ export async function listDatabases(bundleId, targetPlatform) {
         }
         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}`);
                 }
             }
         }
@@ -123,14 +120,7 @@ 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) {
-    // First, discover available databases
     const locations = await listDatabases(bundleId, targetPlatform);
     if (locations.length === 0) {
         if (targetPlatform) {
@@ -144,13 +134,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 +152,25 @@ 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}`);
-            }
+            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 +179,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 +194,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,29 @@
+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,48 @@
+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));
+}
+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.2",
   "description": "Universal React Native SQLite MCP Server",
   "main": "dist/index.js",
   "type": "module",
@@ -23,11 +23,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"
   }
 }