@daeda/mcp-pro 0.1.26 → 0.1.27

package/dist/index.js

@@ -1268,15 +1268,54 @@ var WebSocketService = class extends Context9.Tag("WebSocketService")() {
 import { Effect as Effect22, Layer } from "effect";
 
 // src/paths.ts
+import fs from "fs";
 import os from "os";
 import path from "path";
+var LEGACY_REPLICA_DB_FILENAME = "hubspot.replica.duckdb";
+var REPLICA_POINTER_FILENAME = "hubspot.replica.current";
+var REPLICA_VERSION_PREFIX = "hubspot.replica.";
+var REPLICA_VERSION_SUFFIX = ".duckdb";
 var defaultDataRoot = () => process.env.MCP_CLIENT_DATA_ROOT ?? path.join(os.homedir(), ".daeda-mcp");
 var _dataRoot = defaultDataRoot();
 var DATA_ROOT = () => _dataRoot;
 var PORTALS_DIR = () => path.join(_dataRoot, "portals");
 var portalDir = (portalId) => path.join(PORTALS_DIR(), String(portalId));
 var dbPath = (portalId) => path.join(portalDir(portalId), "hubspot.duckdb");
-var replicaDbPath = (portalId) => path.join(portalDir(portalId), "hubspot.replica.duckdb");
+var legacyReplicaDbPath = (portalId) => path.join(portalDir(portalId), LEGACY_REPLICA_DB_FILENAME);
+var replicaPointerPath = (portalId) => path.join(portalDir(portalId), REPLICA_POINTER_FILENAME);
+var replicaVersionDbPath = (portalId, filename) => path.join(portalDir(portalId), path.basename(filename));
+var readReplicaPointer = (portalId) => {
+  try {
+    const raw = fs.readFileSync(replicaPointerPath(portalId), "utf-8").trim();
+    if (raw.length === 0 || raw !== path.basename(raw)) {
+      return null;
+    }
+    return raw;
+  } catch {
+    return null;
+  }
+};
+var readLatestReplicaVersion = (portalId) => {
+  try {
+    const versions = fs.readdirSync(portalDir(portalId)).filter(
+      (entry) => entry.startsWith(REPLICA_VERSION_PREFIX) && entry.endsWith(REPLICA_VERSION_SUFFIX)
+    ).sort((left, right) => right.localeCompare(left));
+    return versions[0] ?? null;
+  } catch {
+    return null;
+  }
+};
+var replicaDbPath = (portalId) => {
+  const currentReplicaFile = readReplicaPointer(portalId);
+  if (currentReplicaFile !== null) {
+    return replicaVersionDbPath(portalId, currentReplicaFile);
+  }
+  const latestReplicaVersion = readLatestReplicaVersion(portalId);
+  if (latestReplicaVersion !== null) {
+    return replicaVersionDbPath(portalId, latestReplicaVersion);
+  }
+  return legacyReplicaDbPath(portalId);
+};
 var stateFilePath = () => path.join(_dataRoot, "client_state.json");
 var DOWNLOADS_DIR = () => path.join(_dataRoot, "downloads");
 var HUBSPOT_NORMALIZED_DOWNLOADS_DIR = () => path.join(DOWNLOADS_DIR(), "hubspot-normalized");
@@ -1286,7 +1325,7 @@ var CHARTS_DIR = () => path.join(_dataRoot, "charts");
 var chartFilePath = (filename) => path.join(CHARTS_DIR(), filename);
 
 // src/layers/ConfigLayerLive.ts
-import * as fs from "fs";
+import * as fs2 from "fs";
 
 // src/types.ts
 import { z as z12 } from "zod";
@@ -1342,7 +1381,7 @@ var ConfigLive = Layer.succeed(
     load: () => Effect22.try({
       try: () => {
         const file = stateFilePath();
-        const raw = fs.existsSync(file) ? fs.readFileSync(file, "utf-8") : null;
+        const raw = fs2.existsSync(file) ? fs2.readFileSync(file, "utf-8") : null;
         if (!raw) return { selectedPortalId: null };
         return ClientStateSchema.parse(JSON.parse(raw));
       },
@@ -1353,8 +1392,8 @@ var ConfigLive = Layer.succeed(
     ),
     save: (state) => Effect22.try({
       try: () => {
-        fs.mkdirSync(DATA_ROOT(), { recursive: true });
-        fs.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2), "utf-8");
+        fs2.mkdirSync(DATA_ROOT(), { recursive: true });
+        fs2.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2), "utf-8");
       },
       catch: (error) => new ConfigWriteError({ path: stateFilePath(), cause: error })
     }).pipe(
@@ -1373,7 +1412,8 @@ import {
   VARCHAR
 } from "@duckdb/node-api";
 import { Effect as Effect23 } from "effect";
-import fs2 from "fs";
+import fs3 from "fs";
+import path2 from "path";
 
 // src/pure/schema.ts
 var VALID_TABLE_NAME = /^[a-z][a-z0-9_]*$/;
@@ -1529,10 +1569,12 @@ var CHUNK_SIZE = 2048;
 var CSV_REJECT_SAMPLE_LIMIT = 5;
 var PLUGIN_ERROR_KEY = (name) => `plugin_error:${name}`;
 var SCHEMA_VERSION_KEY = (name) => `schema_version:plugin:${name}`;
+var REPLICA_VERSION_PREFIX2 = "hubspot.replica.";
+var REPLICA_VERSION_SUFFIX2 = ".duckdb";
 var databaseConnectionCache = /* @__PURE__ */ new Map();
 function getReplicaFingerprint(portalId) {
   try {
-    const stats = fs2.statSync(replicaDbPath(portalId));
+    const stats = fs3.statSync(replicaDbPath(portalId));
     return {
       mtimeMs: stats.mtimeMs,
       size: stats.size
@@ -1548,6 +1590,7 @@ function sameReplicaFingerprint(left, right) {
 }
 function shouldRefreshHandle(portalId, handle) {
   if (handle.mode !== "read_only") return false;
+  if (handle.sourcePath !== getDatabaseFilePath(portalId, "read_only")) return true;
   return !sameReplicaFingerprint(handle.replicaFingerprint, getReplicaFingerprint(portalId));
 }
 async function closeDatabaseHandle(handle) {
@@ -1571,7 +1614,10 @@ function getDatabaseFilePath(portalId, mode) {
 async function openDatabaseConnection(portalId, _encryptionKey, options2) {
   const mode = resolveConnectionMode(options2);
   const sourcePath = getDatabaseFilePath(portalId, mode);
-  fs2.mkdirSync(portalDir(portalId), { recursive: true });
+  fs3.mkdirSync(portalDir(portalId), { recursive: true });
+  if (mode === "read_only" && !fs3.existsSync(sourcePath)) {
+    throw new Error(`Replica database not found for portal ${portalId}: ${sourcePath}`);
+  }
   const instance = await DuckDBInstance.create(sourcePath);
   const connection = await instance.connect();
   return {
@@ -1643,11 +1689,41 @@ async function bulkAppend(connection, tableName, columns) {
 }
 function cleanupDbArtifacts(filePath) {
   try {
-    fs2.unlinkSync(filePath);
+    fs3.unlinkSync(filePath);
   } catch {
   }
   try {
-    fs2.unlinkSync(`${filePath}.wal`);
+    fs3.unlinkSync(`${filePath}.wal`);
+  } catch {
+  }
+}
+function nextReplicaFileName(seed = Date.now()) {
+  return `${REPLICA_VERSION_PREFIX2}${seed}-${process.pid}-${Math.random().toString(36).slice(2, 8)}${REPLICA_VERSION_SUFFIX2}`;
+}
+function writeReplicaPointer(portalId, fileName) {
+  const pointerPath = replicaPointerPath(portalId);
+  const nextPointerPath = `${pointerPath}.next`;
+  cleanupDbArtifacts(nextPointerPath);
+  fs3.writeFileSync(nextPointerPath, `${path2.basename(fileName)}
+`, "utf-8");
+  try {
+    fs3.unlinkSync(pointerPath);
+  } catch {
+  }
+  fs3.renameSync(nextPointerPath, pointerPath);
+}
+function isManagedReplicaFile(fileName) {
+  return fileName === path2.basename(legacyReplicaDbPath(0)) || fileName.startsWith(REPLICA_VERSION_PREFIX2) && fileName.endsWith(REPLICA_VERSION_SUFFIX2);
+}
+function cleanupStaleReplicaFiles(portalId, currentReplicaPath) {
+  const currentFile = path2.basename(currentReplicaPath);
+  try {
+    for (const entry of fs3.readdirSync(portalDir(portalId))) {
+      if (!isManagedReplicaFile(entry) || entry === currentFile) {
+        continue;
+      }
+      cleanupDbArtifacts(path2.join(portalDir(portalId), entry));
+    }
   } catch {
   }
 }
@@ -1658,13 +1734,13 @@ async function publishReplica({
   assertWritable(masterLock);
   const handle = await getDatabaseConnection(portalId, null);
   const liveDbPath = dbPath(portalId);
-  const replicaPath = replicaDbPath(portalId);
-  const nextReplicaPath = `${replicaPath}.next`;
+  const nextReplicaName = nextReplicaFileName();
+  const nextReplicaPath = replicaVersionDbPath(portalId, nextReplicaName);
   cleanupDbArtifacts(nextReplicaPath);
   await handle.connection.run("CHECKPOINT");
-  cleanupDbArtifacts(replicaPath);
-  fs2.copyFileSync(liveDbPath, nextReplicaPath);
-  fs2.renameSync(nextReplicaPath, replicaPath);
+  fs3.copyFileSync(liveDbPath, nextReplicaPath);
+  writeReplicaPointer(portalId, nextReplicaName);
+  cleanupStaleReplicaFiles(portalId, nextReplicaPath);
 }
 async function ensureTable(connection, ddlStatements) {
   for (const statement of ddlStatements) {
@@ -2188,7 +2264,7 @@ async function loadPluginPayload(source) {
   if (source.kind === "payload") {
     return source.payload;
   }
-  const raw = await fs2.promises.readFile(source.jsonPath, "utf8");
+  const raw = await fs3.promises.readFile(source.jsonPath, "utf8");
   return JSON.parse(raw);
 }
 async function applyDiffBatch({
@@ -2329,7 +2405,7 @@ var buildCappedSelectSql = (sql, maxRows) => {
 };
 
 // src/layers/MasterLockLive.ts
-import path2 from "path";
+import path3 from "path";
 import { Effect as Effect24, Layer as Layer2, Ref, pipe as pipe13 } from "effect";
 
 // src/layers/MasterLockDependencies.ts
@@ -2357,7 +2433,7 @@ var resolveMasterLockDependencies = (config, defaults) => ({
 var PROMOTION_POLL_MS = 3e3;
 var LOCK_STALE_MS = 5e3;
 var LOCK_UPDATE_MS = 2500;
-var lockFilePath = () => path2.join(PORTALS_DIR(), "master.lock");
+var lockFilePath = () => path3.join(PORTALS_DIR(), "master.lock");
 var logMessage = (runtime, message) => Effect24.sync(() => runtime.deps.log(message));
 var isLockConflictError = (error) => {
   const code = error?.code;
@@ -3000,8 +3076,8 @@ import { Effect as Effect29, Layer as Layer5, pipe as pipe18 } from "effect";
 
 // src/effects/csv-parser.ts
 import { Effect as Effect27, pipe as pipe16 } from "effect";
-import * as path3 from "path";
-import * as fs3 from "fs";
+import * as path4 from "path";
+import * as fs4 from "fs";
 import { PassThrough, Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { createGunzip } from "zlib";
@@ -3056,7 +3132,7 @@ var hasMagicBytes = (bytes, magic) => bytes.length >= magic.length && magic.ever
 var isCsvEntry = (name) => name.endsWith(".csv") || name.endsWith(".tsv");
 var openZipCsvReadable = (filePath) => new Promise((resolve, reject) => {
   const output = new PassThrough();
-  const source = fs3.createReadStream(filePath);
+  const source = fs4.createReadStream(filePath);
   const unzipper = new Unzip();
   let settled = false;
   let foundCsv = false;
@@ -3138,18 +3214,18 @@ var openZipCsvReadable = (filePath) => new Promise((resolve, reject) => {
   source.on("error", fail);
 });
 var openCsvReadableFile = async (filePath) => {
-  const fd = await fs3.promises.open(filePath, "r");
+  const fd = await fs4.promises.open(filePath, "r");
   const header = Buffer.alloc(4);
   try {
     const { bytesRead } = await fd.read(header, 0, header.length, 0);
     const bytes = new Uint8Array(header.subarray(0, bytesRead));
     if (hasMagicBytes(bytes, GZIP_MAGIC)) {
-      return fs3.createReadStream(filePath).pipe(createGunzip());
+      return fs4.createReadStream(filePath).pipe(createGunzip());
     }
     if (hasMagicBytes(bytes, ZIP_MAGIC)) {
       return openZipCsvReadable(filePath);
     }
-    return fs3.createReadStream(filePath);
+    return fs4.createReadStream(filePath);
   } finally {
     await fd.close();
   }
@@ -3157,8 +3233,8 @@ var openCsvReadableFile = async (filePath) => {
 var downloadToTempFile = (url, objectType) => pipe16(
   Effect27.tryPromise({
     try: async () => {
-      fs3.mkdirSync(tempDir(), { recursive: true });
-      const tempFile = path3.join(tempDir(), `${objectType}_${Date.now()}.csv.gz`);
+      fs4.mkdirSync(tempDir(), { recursive: true });
+      const tempFile = path4.join(tempDir(), `${objectType}_${Date.now()}.csv.gz`);
       const response = await fetch(url);
       if (!response.ok) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -3168,7 +3244,7 @@ var downloadToTempFile = (url, objectType) => pipe16(
       }
       await pipeline(
         Readable.fromWeb(response.body),
-        fs3.createWriteStream(tempFile)
+        fs4.createWriteStream(tempFile)
       );
       return tempFile;
     },
@@ -3180,16 +3256,16 @@ var GZIP_MAGIC_1 = 139;
 var MIN_GZIP_SIZE = 20;
 var validateGzipFile = (filePath) => Effect27.try({
   try: () => {
-    const stat = fs3.statSync(filePath);
+    const stat = fs4.statSync(filePath);
     if (stat.size < MIN_GZIP_SIZE) {
       throw new Error(`File too small (${stat.size} bytes), minimum ${MIN_GZIP_SIZE}`);
     }
     const header = Buffer.alloc(2);
-    const fd = fs3.openSync(filePath, "r");
+    const fd = fs4.openSync(filePath, "r");
     try {
-      fs3.readSync(fd, header, 0, 2, 0);
+      fs4.readSync(fd, header, 0, 2, 0);
     } finally {
-      fs3.closeSync(fd);
+      fs4.closeSync(fd);
     }
     if (header[0] !== GZIP_MAGIC_0 || header[1] !== GZIP_MAGIC_1) {
       throw new Error(
@@ -3201,7 +3277,7 @@ var validateGzipFile = (filePath) => Effect27.try({
 });
 var cleanupTempFile = (filePath) => Effect27.sync(() => {
   try {
-    fs3.unlinkSync(filePath);
+    fs4.unlinkSync(filePath);
   } catch {
   }
 });
@@ -3209,8 +3285,8 @@ var cleanupTempFile = (filePath) => Effect27.sync(() => {
 // src/effects/hubspot-file-processing.ts
 import { Effect as Effect28, pipe as pipe17 } from "effect";
 import Papa3 from "papaparse";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import { createGzip } from "zlib";
 var normalizedTempDir = () => HUBSPOT_NORMALIZED_DOWNLOADS_DIR();
 var EXPORT_NAME_TO_OBJECT_TYPE = {
@@ -3280,7 +3356,7 @@ var finalizeStream = async (stream) => {
   await waitForStream(stream);
 };
 var createTempWriter = async (filePath, header) => {
-  const stream = fs4.createWriteStream(filePath);
+  const stream = fs5.createWriteStream(filePath);
   const gzip = createGzip();
   gzip.pipe(stream);
   await writeChunk(gzip, header);
@@ -3318,9 +3394,9 @@ var createObjectRow = (id, properties, lastSynced) => [
   escapeCsv(lastSynced)
 ].join(",") + "\n";
 var normalizeHubSpotExportFileInternal = async (sourcePath, objectType) => {
-  await fs4.promises.mkdir(normalizedTempDir(), { recursive: true });
+  await fs5.promises.mkdir(normalizedTempDir(), { recursive: true });
   const runId = `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
-  const objectPath = path4.join(
+  const objectPath = path5.join(
     normalizedTempDir(),
     `${sanitizeFileSegment(objectType)}-${runId}-objects.csv.gz`
   );
@@ -3371,7 +3447,7 @@ var normalizeHubSpotExportFileInternal = async (sourcePath, objectType) => {
               for (const mapping of mappings) {
                 associationHeaders.add(mapping.idsHeader);
                 if (mapping.labelsHeader) associationHeaders.add(mapping.labelsHeader);
-                const assocPath = path4.join(
+                const assocPath = path5.join(
                   normalizedTempDir(),
                   `${sanitizeFileSegment(objectType)}-${runId}-assoc-${sanitizeFileSegment(mapping.toObjectType)}.csv.gz`
                 );
@@ -3469,12 +3545,12 @@ var normalizeHubSpotExportFileInternal = async (sourcePath, objectType) => {
       }
     }
     try {
-      fs4.unlinkSync(objectWriter.path);
+      fs5.unlinkSync(objectWriter.path);
     } catch {
     }
     for (const writer of associationWriters.values()) {
       try {
-        fs4.unlinkSync(writer.path);
+        fs5.unlinkSync(writer.path);
       } catch {
       }
     }
@@ -3565,7 +3641,7 @@ var FileDownloadLive = Layer5.succeed(FileDownloadService, {
 
 // src/layers/PortalDataLive.ts
 import { Cause, Effect as Effect33, Layer as Layer7, pipe as pipe21 } from "effect";
-import fs7 from "fs";
+import fs8 from "fs";
 
 // src/effects/artifact-queue.ts
 import { Effect as Effect30 } from "effect";
@@ -3748,11 +3824,11 @@ var setSelectedPortal = (portalId) => {
 
 // src/effects/read-connection.ts
 import { Effect as Effect31, pipe as pipe19 } from "effect";
-import fs5 from "fs";
+import fs6 from "fs";
 var getReadConnection = (portalId) => pipe19(
   Effect31.sync(() => replicaDbPath(portalId)),
   Effect31.filterOrFail(
-    (dbFile) => fs5.existsSync(dbFile),
+    (dbFile) => fs6.existsSync(dbFile),
     () => new DatabaseError({
       message: `Read replica not found for portal ${portalId}. Has it been synced?`
     })
@@ -3774,7 +3850,7 @@ var closeReadConnection = (portalId) => Effect31.promise(() => evictDatabaseConn
 
 // src/layers/PortalFileStateLive.ts
 import { Effect as Effect32, Layer as Layer6, pipe as pipe20 } from "effect";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 var EMPTY_STATE = () => ({
   artifacts: [],
   plugins: [],
@@ -3802,7 +3878,7 @@ var normalizeLegacyState = (legacy) => ({
 var readLegacyFromDisk = (portalId) => Effect32.try({
   try: () => {
     const file = legacyPortalStatePath(portalId);
-    const raw = fs6.existsSync(file) ? fs6.readFileSync(file, "utf-8") : null;
+    const raw = fs7.existsSync(file) ? fs7.readFileSync(file, "utf-8") : null;
     if (!raw) return null;
     return normalizeLegacyState(SyncedArtifactsSchema.parse(JSON.parse(raw)));
   },
@@ -3811,7 +3887,7 @@ var readLegacyFromDisk = (portalId) => Effect32.try({
 var readFromDisk = (portalId) => Effect32.try({
   try: () => {
     const file = portalDataPath(portalId);
-    const raw = fs6.existsSync(file) ? fs6.readFileSync(file, "utf-8") : null;
+    const raw = fs7.existsSync(file) ? fs7.readFileSync(file, "utf-8") : null;
     if (!raw) return null;
     return PortalDataStateSchema.parse(JSON.parse(raw));
   },
@@ -3819,8 +3895,8 @@ var readFromDisk = (portalId) => Effect32.try({
 });
 var writeToDisk = (portalId, state) => Effect32.try({
   try: () => {
-    fs6.mkdirSync(portalDir(portalId), { recursive: true });
-    fs6.writeFileSync(portalDataPath(portalId), JSON.stringify(state, null, 2), "utf-8");
+    fs7.mkdirSync(portalDir(portalId), { recursive: true });
+    fs7.writeFileSync(portalDataPath(portalId), JSON.stringify(state, null, 2), "utf-8");
   },
   catch: (cause) => new ConfigWriteError({ path: portalDataPath(portalId), cause })
 });
@@ -4085,11 +4161,11 @@ var recoverCorruptedDatabase = (portalId) => pipe21(
     () => Effect33.sync(() => {
       const file = dbPath(portalId);
       try {
-        fs7.unlinkSync(file);
+        fs8.unlinkSync(file);
       } catch {
       }
       try {
-        fs7.unlinkSync(`${file}.wal`);
+        fs8.unlinkSync(`${file}.wal`);
       } catch {
       }
     })
@@ -6021,7 +6097,7 @@ SELECT json_extract_string(properties, '$.dealstage') as stage, COUNT(*) as coun
 
 // src/tools/status.ts
 import { z as z17 } from "zod";
-import fs8 from "fs";
+import fs9 from "fs";
 import { Effect as Effect52 } from "effect";
 function formatBytes(bytes) {
   if (bytes === 0) return "0 B";
@@ -6032,8 +6108,8 @@ function formatBytes(bytes) {
 }
 function getDbFileSize(portalId) {
   const db = dbPath(portalId);
-  if (!fs8.existsSync(db)) return null;
-  return fs8.statSync(db).size;
+  if (!fs9.existsSync(db)) return null;
+  return fs9.statSync(db).size;
 }
 async function buildConnectionSection(deps) {
   const selectedPortalId2 = deps.getSelectedPortalId();
@@ -16469,7 +16545,7 @@ var resolveDiffFlow = (portalId, selectedPortalId2) => selectedPortalId2 === por
 var shouldSubscribeAfterDiffComplete = (portalId, selectedPortalId2, success) => success && selectedPortalId2 === portalId;
 
 // src/effects/ensure-fresh.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import { Effect as Effect107, pipe as pipe87 } from "effect";
 var DEFAULT_MAX_AGE_MS = 3e5;
 var DEFAULT_QUEUE_DRAIN_TIMEOUT_MS = 12e4;
@@ -16542,7 +16618,7 @@ var makeEnsureFresh = (deps, options2) => createEnsureFresh(
   {
     getSelectedPortalId: deps.getSelectedPortalId,
     waitForPortalDrain,
-    hasLocalDatabase: (portalId) => fs9.existsSync(dbPath(portalId)),
+    hasLocalDatabase: (portalId) => fs10.existsSync(dbPath(portalId)),
     getFreshnessCheckedAt: (portalId) => Effect107.runPromise(
       pipe87(
         deps.portalData.getMetadata(portalId, LAST_DIFF_CHECKED_AT_KEY),

package/package.json

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