@daeda/mcp-pro 0.1.25 → 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 {
+    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 {
-    fs2.unlinkSync(`${filePath}.wal`);
+    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,77 +2405,105 @@ var buildCappedSelectSql = (sql, maxRows) => {
 };
 
 // src/layers/MasterLockLive.ts
-import { createRequire } from "module";
-import path2 from "path";
-import { mkdir, open } from "fs/promises";
+import path3 from "path";
 import { Effect as Effect24, Layer as Layer2, Ref, pipe as pipe13 } from "effect";
-var PROMOTION_POLL_MS = 3e3;
-var lockFilePath = () => path2.join(PORTALS_DIR(), "master.lock");
-var loadOsLockModule = () => {
+
+// src/layers/MasterLockDependencies.ts
+import { createRequire } from "module";
+import { mkdir } from "fs/promises";
+var loadProperLockfileModule = () => {
   const requireFromHere = createRequire(import.meta.url);
-  return requireFromHere("os-lock");
+  return requireFromHere("proper-lockfile");
 };
-var resolveDependencies = (config = {}) => ({
+var resolveMasterLockDependencies = (config, defaults) => ({
   ensurePortalsDir: config.ensurePortalsDir ?? (async (dirPath) => {
     await mkdir(dirPath, { recursive: true });
   }),
-  openLockFile: config.openLockFile ?? ((filePath) => open(filePath, "a+")),
-  lock: config.lock ?? loadOsLockModule().lock,
-  unlock: config.unlock ?? loadOsLockModule().unlock,
+  acquireLock: config.acquireLock ?? (async (dirPath, options2) => {
+    const release = await loadProperLockfileModule().lock(dirPath, options2);
+    return { release };
+  }),
   setInterval: config.setInterval ?? ((callback, ms) => setInterval(callback, ms)),
   clearInterval: config.clearInterval ?? ((timer) => clearInterval(timer)),
   log: config.log ?? ((message) => console.error(message)),
-  promotionPollMs: config.promotionPollMs ?? PROMOTION_POLL_MS
+  promotionPollMs: config.promotionPollMs ?? defaults.promotionPollMs
 });
+
+// src/layers/MasterLockLive.ts
+var PROMOTION_POLL_MS = 3e3;
+var LOCK_STALE_MS = 5e3;
+var LOCK_UPDATE_MS = 2500;
+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;
-  return code === "EACCES" || code === "EAGAIN" || code === "EBUSY";
+  return code === "ELOCKED";
 };
 var ensurePortalsDir = (runtime) => Effect24.tryPromise({
   try: () => runtime.deps.ensurePortalsDir(PORTALS_DIR()),
   catch: (cause) => new Error(`Failed to create portals directory: ${String(cause)}`)
 });
-var closeHandle = (runtime, handle) => Effect24.tryPromise({
+var releaseLease = (runtime, lease) => Effect24.tryPromise({
   try: async () => {
-    try {
-      await runtime.deps.unlock(handle.fd);
-    } catch {
-    }
-    try {
-      await handle.close();
-    } catch {
-    }
+    await lease.release();
   },
-  catch: (cause) => new Error(`Failed to close master lock handle: ${String(cause)}`)
+  catch: (cause) => new Error(`Failed to release master lock lease: ${String(cause)}`)
+});
+var acquireLockOptions = (runtime) => ({
+  lockfilePath: lockFilePath(),
+  retries: 0,
+  stale: LOCK_STALE_MS,
+  update: LOCK_UPDATE_MS,
+  realpath: true,
+  onCompromised: (error) => {
+    Effect24.runFork(
+      pipe13(
+        handleCompromisedLease(runtime, error),
+        Effect24.catchAll(() => Effect24.void)
+      )
+    );
+  }
 });
+var handleCompromisedLease = (runtime, error) => pipe13(
+  Ref.get(runtime.releasedRef),
+  Effect24.flatMap((released) => {
+    if (released) return Effect24.void;
+    return pipe13(
+      Ref.getAndSet(runtime.lockLeaseRef, null),
+      Effect24.flatMap((lease) => {
+        if (lease === null) return Effect24.void;
+        return pipe13(
+          logMessage(
+            runtime,
+            `[master-lock] master lease compromised: ${error.message}`
+          ),
+          Effect24.flatMap(() => Ref.set(runtime.connectionTypeRef, "READ_ONLY")),
+          Effect24.flatMap(() => startPromotionPolling(runtime))
+        );
+      })
+    );
+  })
+);
 var tryAcquireMasterLock = (runtime) => pipe13(
-  Ref.get(runtime.lockHandleRef),
-  Effect24.flatMap((existingHandle) => {
-    if (existingHandle !== null) {
+  Ref.get(runtime.lockLeaseRef),
+  Effect24.flatMap((existingLease) => {
+    if (existingLease !== null) {
       return Ref.get(runtime.connectionTypeRef);
     }
     return pipe13(
       ensurePortalsDir(runtime),
       Effect24.flatMap(
         () => Effect24.tryPromise({
-          try: () => runtime.deps.openLockFile(lockFilePath()),
-          catch: (cause) => new Error(`Failed to open master lock file: ${String(cause)}`)
-        })
-      ),
-      Effect24.flatMap(
-        (handle) => Effect24.tryPromise({
           try: async () => {
             try {
-              await runtime.deps.lock(handle.fd, {
-                exclusive: true,
-                immediate: true
-              });
-              return { connectionType: "MASTER", handle };
+              const lease = await runtime.deps.acquireLock(
+                PORTALS_DIR(),
+                acquireLockOptions(runtime)
+              );
+              return { connectionType: "MASTER", lease };
             } catch (error) {
-              await handle.close();
               if (isLockConflictError(error)) {
-                return { connectionType: "READ_ONLY", handle: null };
+                return { connectionType: "READ_ONLY", lease: null };
               }
               throw error;
             }
@@ -2408,10 +2512,21 @@ var tryAcquireMasterLock = (runtime) => pipe13(
         })
       ),
       Effect24.flatMap(
-        ({ connectionType, handle }) => pipe13(
-          Ref.set(runtime.connectionTypeRef, connectionType),
-          Effect24.flatMap(() => Ref.set(runtime.lockHandleRef, handle)),
-          Effect24.as(connectionType)
+        ({ connectionType, lease }) => pipe13(
+          Ref.get(runtime.releasedRef),
+          Effect24.flatMap((released) => {
+            if (!released || lease === null) {
+              return pipe13(
+                Ref.set(runtime.connectionTypeRef, connectionType),
+                Effect24.flatMap(() => Ref.set(runtime.lockLeaseRef, lease)),
+                Effect24.as(connectionType)
+              );
+            }
+            return pipe13(
+              releaseLease(runtime, lease),
+              Effect24.flatMap(() => Effect24.succeed("READ_ONLY"))
+            );
+          })
         )
       )
     );
@@ -2426,9 +2541,12 @@ var stopPromotionPolling = (runtime) => pipe13(
   )
 );
 var tryPromoteToMaster = (runtime) => pipe13(
-  Ref.get(runtime.promotingRef),
-  Effect24.flatMap((promoting) => {
-    if (promoting) return Effect24.void;
+  Effect24.all({
+    promoting: Ref.get(runtime.promotingRef),
+    released: Ref.get(runtime.releasedRef)
+  }),
+  Effect24.flatMap(({ promoting, released }) => {
+    if (promoting || released) return Effect24.void;
     return pipe13(
       Ref.set(runtime.promotingRef, true),
       Effect24.flatMap(
@@ -2478,20 +2596,26 @@ var startPromotionPolling = (runtime) => pipe13(
   })
 );
 var releaseRuntime = (runtime) => pipe13(
-  stopPromotionPolling(runtime),
-  Effect24.flatMap(() => Ref.getAndSet(runtime.lockHandleRef, null)),
+  Ref.set(runtime.releasedRef, true),
+  Effect24.flatMap(() => stopPromotionPolling(runtime)),
+  Effect24.flatMap(() => Ref.getAndSet(runtime.lockLeaseRef, null)),
   Effect24.flatMap(
-    (handle) => handle === null ? Effect24.void : closeHandle(runtime, handle)
+    (lease) => lease === null ? Effect24.void : releaseLease(runtime, lease)
   ),
   Effect24.flatMap(() => Ref.set(runtime.connectionTypeRef, "READ_ONLY"))
 );
 var makeRuntime = (config = {}) => pipe13(
   Effect24.all({
-    deps: Effect24.sync(() => resolveDependencies(config)),
+    deps: Effect24.sync(
+      () => resolveMasterLockDependencies(config, {
+        promotionPollMs: PROMOTION_POLL_MS
+      })
+    ),
     connectionTypeRef: Ref.make("READ_ONLY"),
-    lockHandleRef: Ref.make(null),
+    lockLeaseRef: Ref.make(null),
     promotionTimerRef: Ref.make(null),
-    promotingRef: Ref.make(false)
+    promotingRef: Ref.make(false),
+    releasedRef: Ref.make(false)
   }),
   Effect24.tap(
     (runtime) => pipe13(
@@ -2952,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";
@@ -3008,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;
@@ -3090,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();
   }
@@ -3109,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}`);
@@ -3120,7 +3244,7 @@ var downloadToTempFile = (url, objectType) => pipe16(
       }
       await pipeline(
         Readable.fromWeb(response.body),
-        fs3.createWriteStream(tempFile)
+        fs4.createWriteStream(tempFile)
       );
       return tempFile;
     },
@@ -3132,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(
@@ -3153,7 +3277,7 @@ var validateGzipFile = (filePath) => Effect27.try({
 });
 var cleanupTempFile = (filePath) => Effect27.sync(() => {
   try {
-    fs3.unlinkSync(filePath);
+    fs4.unlinkSync(filePath);
   } catch {
   }
 });
@@ -3161,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 = {
@@ -3232,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);
@@ -3270,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`
   );
@@ -3323,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`
                 );
@@ -3421,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 {
       }
     }
@@ -3517,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";
@@ -3700,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?`
     })
@@ -3726,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: [],
@@ -3754,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)));
   },
@@ -3763,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));
   },
@@ -3771,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 })
 });
@@ -4037,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 {
       }
     })
@@ -5973,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";
@@ -5984,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();
@@ -16421,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;
@@ -16494,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.25",
+  "version": "0.1.27",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {
@@ -35,8 +35,8 @@
     "@modelcontextprotocol/sdk": "^1.25.3",
     "effect": "3.19.15",
     "fflate": "^0.8.2",
-    "os-lock": "^2.0.0",
     "papaparse": "^5.5.3",
+    "proper-lockfile": "^4.1.2",
     "zod": "^3.23.8"
   },
   "devDependencies": {
@@ -49,6 +49,6 @@
   },
   "trustedDependencies": [
     "fs-ext",
-    "os-lock"
+    "proper-lockfile"
   ]
 }