@daeda/mcp-pro 0.1.30 → 0.1.31

package/dist/index.js

@@ -1549,6 +1549,7 @@ var assertWritable = (masterLock) => {
   }
 };
 var escapeSqlString = (value) => value.replace(/'/g, "''");
+var escapeSqlIdentifier = (value) => `"${value.replace(/"/g, '""')}"`;
 var buildSqlPlaceholders = (count, startAt = 1) => Array.from({ length: count }, (_, index) => `$${index + startAt}`).join(",");
 var buildDatabaseCacheKey = (portalId, mode, encryptionKey) => `${portalId}:${mode}:${encryptionKey ?? ""}`;
 var makeAssociationStagingTableName = (seed = Date.now()) => `_staging_assoc_sync_${seed}`;
@@ -1733,7 +1734,7 @@ async function openDatabaseConnection(portalId, _encryptionKey, options2) {
     connection,
     mode,
     sourcePath,
-    replicaFingerprint: mode === "read_only" ? getReplicaFingerprint(portalId) : null
+    replicaFingerprint: null
   };
 }
 var OBJECT_CSV_COLUMNS = ["id", "properties", "last_synced"];
@@ -1798,13 +1799,24 @@ async function bulkAppend(connection, tableName, columns) {
 function cleanupDbArtifacts(filePath) {
   try {
     fs3.unlinkSync(filePath);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove file", filePath, error);
   }
   try {
     fs3.unlinkSync(`${filePath}.wal`);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove wal", `${filePath}.wal`, error);
   }
 }
+function logFsCleanupError(action, filePath, error) {
+  const code = error?.code;
+  if (code === "ENOENT") return;
+  console.error("[replica] Cleanup step failed", {
+    action,
+    filePath,
+    error: describeError(error)
+  });
+}
 function nextReplicaFileName(seed = Date.now()) {
   return `${REPLICA_VERSION_PREFIX2}${seed}-${process.pid}-${Math.random().toString(36).slice(2, 8)}${REPLICA_VERSION_SUFFIX2}`;
 }
@@ -1816,7 +1828,8 @@ function writeReplicaPointer(portalId, fileName) {
 `, "utf-8");
   try {
     fs3.unlinkSync(pointerPath);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove pointer", pointerPath, error);
   }
   fs3.renameSync(nextPointerPath, pointerPath);
 }
@@ -1832,8 +1845,51 @@ function cleanupStaleReplicaFiles(portalId, currentReplicaPath) {
       }
       cleanupDbArtifacts(path2.join(portalDir(portalId), entry));
     }
+  } catch (error) {
+    console.error("[replica] Failed stale replica cleanup", {
+      portalId,
+      currentReplicaPath,
+      error: describeError(error)
+    });
+  }
+}
+function getSourceDatabaseName(filePath) {
+  return path2.parse(filePath).name;
+}
+function getFileSnapshot(filePath) {
+  try {
+    const stats = fs3.statSync(filePath);
+    return {
+      exists: true,
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
   } catch {
+    return {
+      exists: false,
+      sizeBytes: null,
+      mtimeMs: null
+    };
+  }
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    const errnoError = error;
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      code: errnoError.code,
+      errno: errnoError.errno,
+      syscall: errnoError.syscall,
+      path: errnoError.path,
+      dest: errnoError.dest,
+      cause: errnoError.cause ? describeError(errnoError.cause) : void 0
+    };
   }
+  return {
+    value: String(error)
+  };
 }
 async function publishReplica({
   masterLock,
@@ -1844,11 +1900,87 @@ async function publishReplica({
   const liveDbPath = dbPath(portalId);
   const nextReplicaName = nextReplicaFileName();
   const nextReplicaPath = replicaVersionDbPath(portalId, nextReplicaName);
+  const nextReplicaTempPath = `${nextReplicaPath}.next`;
+  const sourceDatabaseName = getSourceDatabaseName(liveDbPath);
+  const targetDatabaseName = "portal_replica_next";
+  console.error("[replica] Publish starting", {
+    portalId,
+    liveDbPath,
+    nextReplicaPath,
+    nextReplicaTempPath,
+    liveDb: getFileSnapshot(liveDbPath)
+  });
   cleanupDbArtifacts(nextReplicaPath);
-  await handle.connection.run("CHECKPOINT");
-  fs3.copyFileSync(liveDbPath, nextReplicaPath);
-  writeReplicaPointer(portalId, nextReplicaName);
-  cleanupStaleReplicaFiles(portalId, nextReplicaPath);
+  cleanupDbArtifacts(nextReplicaTempPath);
+  try {
+    console.error("[replica] Checkpointing live database", {
+      portalId,
+      liveDbPath
+    });
+    await handle.connection.run("CHECKPOINT");
+    console.error("[replica] Building replica snapshot via DuckDB", {
+      portalId,
+      sourceDatabaseName,
+      targetDatabaseName,
+      nextReplicaTempPath
+    });
+    await handle.connection.run(
+      `ATTACH '${escapeSqlString(nextReplicaTempPath)}' AS ${escapeSqlIdentifier(targetDatabaseName)}`
+    );
+    try {
+      await handle.connection.run(
+        `COPY FROM DATABASE ${escapeSqlIdentifier(sourceDatabaseName)} TO ${escapeSqlIdentifier(targetDatabaseName)}`
+      );
+      await handle.connection.run(`CHECKPOINT ${escapeSqlIdentifier(targetDatabaseName)}`);
+    } finally {
+      await handle.connection.run(`DETACH ${escapeSqlIdentifier(targetDatabaseName)}`);
+    }
+    console.error("[replica] Verifying replica snapshot", {
+      portalId,
+      nextReplicaTempPath,
+      snapshot: getFileSnapshot(nextReplicaTempPath)
+    });
+    const verifyInstance = await DuckDBInstance.create(":memory:");
+    const verifyConnection = await verifyInstance.connect();
+    try {
+      await verifyConnection.run(
+        `ATTACH '${escapeSqlString(nextReplicaTempPath)}' AS portal_replica_verify (READ_ONLY)`
+      );
+      await verifyConnection.run("DETACH portal_replica_verify");
+    } finally {
+      try {
+        verifyConnection.closeSync();
+      } catch {
+      }
+      try {
+        verifyInstance.closeSync();
+      } catch {
+      }
+    }
+    fs3.renameSync(nextReplicaTempPath, nextReplicaPath);
+    console.error("[replica] Writing replica pointer", {
+      portalId,
+      nextReplicaName,
+      nextReplicaPath
+    });
+    writeReplicaPointer(portalId, nextReplicaName);
+    cleanupStaleReplicaFiles(portalId, nextReplicaPath);
+    console.error("[replica] Publish complete", {
+      portalId,
+      nextReplicaPath,
+      replica: getFileSnapshot(nextReplicaPath)
+    });
+  } catch (error) {
+    console.error("[replica] Publish failed", {
+      portalId,
+      liveDbPath,
+      nextReplicaPath,
+      nextReplicaTempPath,
+      error: describeError(error)
+    });
+    cleanupDbArtifacts(nextReplicaTempPath);
+    throw error;
+  }
 }
 async function ensureTable(connection, ddlStatements) {
   for (const statement of ddlStatements) {
@@ -2860,8 +2992,11 @@ var makeReplicaLive = (config = {}) => {
                       dirty: true
                     })),
                     Effect25.flatMap(
-                      () => logStderr3(
-                        `[replica] Failed to publish replica for portal ${portalId}: ${error.message}`
+                      () => Effect25.sync(
+                        () => console.error("[replica] Failed to publish replica", {
+                          portalId,
+                          error
+                        })
                       )
                     ),
                     Effect25.flatMap(() => Effect25.fail(error))
@@ -3933,26 +4068,64 @@ var setSelectedPortal = (portalId) => {
 // src/effects/read-connection.ts
 import { Effect as Effect31, pipe as pipe19 } from "effect";
 import fs6 from "fs";
-var getReadConnection = (portalId) => pipe19(
+var openLiveConnection = (portalId, cause) => Effect31.tryPromise({
+  try: async () => {
+    const handle = await getDatabaseConnection(portalId, null);
+    return handle.connection;
+  },
+  catch: (error) => new DatabaseError({
+    message: `Failed to open live fallback connection for portal ${portalId}`,
+    cause: { replicaError: cause, fallbackError: error }
+  })
+});
+var getReadConnection = (portalId, options2) => pipe19(
   Effect31.sync(() => replicaDbPath(portalId)),
-  Effect31.filterOrFail(
-    (dbFile) => fs6.existsSync(dbFile),
-    () => new DatabaseError({
-      message: `Read replica not found for portal ${portalId}. Has it been synced?`
-    })
-  ),
-  Effect31.flatMap(
-    () => Effect31.tryPromise({
+  Effect31.flatMap((dbFile) => {
+    if (!fs6.existsSync(dbFile)) {
+      if (options2?.allowLiveFallback === true && fs6.existsSync(dbPath(portalId))) {
+        console.error("[read-connection] Replica missing, falling back to live database", {
+          portalId,
+          replicaPath: dbFile,
+          livePath: dbPath(portalId)
+        });
+        return openLiveConnection(
+          portalId,
+          new DatabaseError({
+            message: `Read replica not found for portal ${portalId}. Has it been synced?`
+          })
+        );
+      }
+      return Effect31.fail(
+        new DatabaseError({
+          message: `Read replica not found for portal ${portalId}. Has it been synced?`
+        })
+      );
+    }
+    return Effect31.tryPromise({
       try: async () => {
         const handle = await getDatabaseConnection(portalId, null, { readOnly: true });
         return handle.connection;
       },
-      catch: (e) => new DatabaseError({
-        message: `Failed to open read connection for portal ${portalId}`,
-        cause: e
-      })
-    })
-  )
+      catch: (error) => error
+    });
+  }),
+  Effect31.catchAll((error) => {
+    if (!(options2?.allowLiveFallback === true) || !fs6.existsSync(dbPath(portalId))) {
+      return Effect31.fail(
+        error instanceof DatabaseError ? error : new DatabaseError({
+          message: `Failed to open read connection for portal ${portalId}`,
+          cause: error
+        })
+      );
+    }
+    console.error("[read-connection] Read-only replica open failed, falling back to live database", {
+      portalId,
+      replicaPath: replicaDbPath(portalId),
+      livePath: dbPath(portalId),
+      error
+    });
+    return openLiveConnection(portalId, error);
+  })
 );
 var closeReadConnection = (portalId) => Effect31.promise(() => evictDatabaseConnections(portalId));
 
@@ -5634,8 +5807,10 @@ var resolvePortalIds = (explicitPortalIds, selectedPortalId2, portals) => {
 
 // src/tools/query.ts
 var MAX_ROWS = 200;
-var runQueryForPortal = async (portalId, finalSql, autoCapped) => {
-  const conn = await Effect50.runPromise(getReadConnection(portalId));
+var runQueryForPortal = async (portalId, finalSql, autoCapped, allowLiveFallback) => {
+  const conn = await Effect50.runPromise(
+    getReadConnection(portalId, { allowLiveFallback })
+  );
   const start = performance.now();
   const reader = await conn.runAndReadAll(finalSql);
   const rows = reader.getRowObjects();
@@ -5711,7 +5886,8 @@ Example queries:
           const result = await runQueryForPortal(
             portalId,
             finalSql,
-            !hasExplicitLimit
+            !hasExplicitLimit,
+            deps.isMasterClient()
           );
           return {
             content: [{ type: "text", text: stringifyResult(result) }]
@@ -5732,7 +5908,8 @@ Example queries:
           keyedResults[String(portalId)] = await runQueryForPortal(
             portalId,
             finalSql,
-            !hasExplicitLimit
+            !hasExplicitLimit,
+            deps.isMasterClient()
           );
         } catch (e) {
           hadAnyErrors = true;
@@ -5952,8 +6129,10 @@ function openInBrowser(target) {
 
 // src/tools/chart.ts
 var MAX_ROWS2 = 200;
-var runQueryForPortal2 = async (portalId, sql) => {
-  const conn = await Effect51.runPromise(getReadConnection(portalId));
+var runQueryForPortal2 = async (portalId, sql, allowLiveFallback) => {
+  const conn = await Effect51.runPromise(
+    getReadConnection(portalId, { allowLiveFallback })
+  );
   const start = performance.now();
   const reader = await conn.runAndReadAll(sql);
   const rows = reader.getRowObjects();
@@ -6065,7 +6244,11 @@ SELECT json_extract_string(properties, '$.dealstage') as stage, COUNT(*) as coun
         const [portalId] = portalResolution.portalIds;
         try {
           await deps.ensureFresh(portalId);
-          const result = await runQueryForPortal2(portalId, finalSql);
+          const result = await runQueryForPortal2(
+            portalId,
+            finalSql,
+            deps.isMasterClient()
+          );
           if (result.rows.length === 0) {
             return {
               content: [{ type: "text", text: "Query returned no rows - nothing to chart." }],
@@ -6119,7 +6302,11 @@ SELECT json_extract_string(properties, '$.dealstage') as stage, COUNT(*) as coun
       for (const portalId of portalResolution.portalIds) {
         try {
           await deps.ensureFresh(portalId);
-          const result = await runQueryForPortal2(portalId, finalSql);
+          const result = await runQueryForPortal2(
+            portalId,
+            finalSql,
+            deps.isMasterClient()
+          );
           if (result.rows.length === 0) {
             hadErrors = true;
             keyedPortalResults[String(portalId)] = { error: "Query returned no rows - nothing to chart." };
@@ -6218,8 +6405,10 @@ async function buildConnectionSection(deps) {
     totalPortals: portals.length
   };
 }
-async function buildSchemaSection(portalId) {
-  const conn = await Effect52.runPromise(getReadConnection(portalId));
+async function buildSchemaSection(portalId, deps) {
+  const conn = await Effect52.runPromise(
+    getReadConnection(portalId, { allowLiveFallback: deps.isMasterClient() })
+  );
   const allPluginTableNames = new Set(getAllTableNames());
   const sectionResults = await Promise.all(
     getPlugins().map(async (plugin) => {
@@ -6290,7 +6479,7 @@ Use "all" to get everything at once.`,
           for (const portalId of portalResolution.portalIds) {
             try {
               await deps.ensureFresh(portalId);
-              schemaByPortal[String(portalId)] = await buildSchemaSection(portalId);
+              schemaByPortal[String(portalId)] = await buildSchemaSection(portalId, deps);
             } catch (e) {
               explicitSchemaHadErrors = true;
               const message = e instanceof Error ? e.message : String(e);
@@ -6301,7 +6490,7 @@ Use "all" to get everything at once.`,
         } else {
           const [portalId] = portalResolution.portalIds;
           await deps.ensureFresh(portalId);
-          result.schema = await buildSchemaSection(portalId);
+          result.schema = await buildSchemaSection(portalId, deps);
         }
       }
       return {
@@ -19994,17 +20183,20 @@ var mainProgram = Effect108.gen(function* () {
   };
   registerPortalSelection(server, { ws, config, handoffSelectedPortal });
   registerQueryTool(server, {
+    isMasterClient,
     getSelectedPortalId: getPortalId,
     getPortals,
     ensureFresh
   });
   registerChartTool(server, {
+    isMasterClient,
     getSelectedPortalId: getPortalId,
     getPortals,
     ensureFresh
   });
   registerStatusTool(server, {
     getConnectionState: () => Effect108.runSync(ws.getState()),
+    isMasterClient,
     getPortals,
     getSelectedPortalId: getPortalId,
     ensureFresh

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daeda/mcp-pro",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {