copilot-money-mcp 1.3.0 → 1.4.0

package/README.md

@@ -331,6 +331,39 @@ COPILOT_CACHE_TTL_MINUTES=0 copilot-money-mcp
 
 You can also manually refresh the cache using the `refresh_database` tool.
 
+### Decode Timeout
+
+For large databases (500MB+), you may need to increase the decode timeout. The default is 90 seconds (90,000ms).
+
+**Via environment variable:**
+```bash
+DECODE_TIMEOUT_MS=600000 copilot-money-mcp
+```
+
+**Via CLI flag:**
+```bash
+copilot-money-mcp --timeout 600000
+```
+
+**In Claude Desktop config** (with increased Node.js memory for 1GB+ databases):
+```json
+{
+  "mcpServers": {
+    "copilot-money": {
+      "command": "node",
+      "args": [
+        "--max-old-space-size=4096",
+        "/path/to/copilot-money-mcp/dist/cli.js",
+        "--db-path",
+        "/path/to/your/database",
+        "--timeout",
+        "600000"
+      ]
+    }
+  }
+}
+```
+
 ## Known Limitations
 
 ### Local Cache Size
@@ -359,6 +392,14 @@ If you see "Database not available":
 3. Verify `.ldb` files exist in the directory
 4. Provide custom path: `copilot-money-mcp --db-path /path/to/database`
 
+### Decode Worker Timed Out (Large Databases)
+
+If you see "Decode worker timed out after Xms":
+1. Your database may be too large for the default 90-second timeout
+2. Increase the timeout: `copilot-money-mcp --timeout 300000` (5 minutes)
+3. For databases over 1GB, also increase Node.js memory: `node --max-old-space-size=4096 dist/cli.js --timeout 300000`
+4. Set via environment variable: `DECODE_TIMEOUT_MS=600000`
+
 ### No Transactions Found
 
 - Copilot Money may not have synced yet - open the app and wait for sync

package/dist/cli.js

@@ -29527,7 +29527,17 @@ function processUserAccount(fields, docId, collection) {
     userAccountData.order = order;
   return userAccountData;
 }
-function decodeAllCollectionsIsolated(dbPath, timeoutMs = 30000) {
+function getDecodeTimeoutMs() {
+  const envValue = process.env.DECODE_TIMEOUT_MS;
+  if (envValue !== undefined) {
+    const ms = parseInt(envValue, 10);
+    if (!isNaN(ms) && ms > 0) {
+      return ms;
+    }
+  }
+  return 90000;
+}
+function decodeAllCollectionsIsolated(dbPath, timeoutMs = getDecodeTimeoutMs()) {
   return new Promise((resolve, reject) => {
     const selfUrl = import.meta.url;
     const workerExt = selfUrl.endsWith(".ts") ? ".ts" : ".js";
@@ -30812,12 +30822,14 @@ class CopilotDatabase {
   _loadingAllCollections = null;
   _allCollectionsLoaded = false;
   _cacheLoadedAt = null;
-  constructor(dbPath) {
+  decodeTimeoutMs;
+  constructor(dbPath, decodeTimeoutMs) {
     if (dbPath) {
       this.dbPath = dbPath;
     } else {
       this.dbPath = findCopilotDatabase();
     }
+    this.decodeTimeoutMs = decodeTimeoutMs;
   }
   requireDbPath() {
     if (!this.dbPath) {
@@ -30901,7 +30913,7 @@ class CopilotDatabase {
       await this._loadingAllCollections;
       return;
     }
-    this._loadingAllCollections = decodeAllCollectionsIsolated(this.requireDbPath());
+    this._loadingAllCollections = decodeAllCollectionsIsolated(this.requireDbPath(), this.decodeTimeoutMs);
     try {
       const result = await this._loadingAllCollections;
       this._transactions = result.transactions;
@@ -32742,8 +32754,8 @@ class CopilotMoneyServer {
   db;
   tools;
   server;
-  constructor(dbPath) {
-    this.db = new CopilotDatabase(dbPath);
+  constructor(dbPath, decodeTimeoutMs) {
+    this.db = new CopilotDatabase(dbPath, decodeTimeoutMs);
     this.tools = new CopilotMoneyTools(this.db);
     this.server = new Server({
       name: "copilot-money-mcp",
@@ -32860,8 +32872,8 @@ class CopilotMoneyServer {
     });
   }
 }
-async function runServer(dbPath) {
-  const server = new CopilotMoneyServer(dbPath);
+async function runServer(dbPath, decodeTimeoutMs) {
+  const server = new CopilotMoneyServer(dbPath, decodeTimeoutMs);
   await server.run();
 }
 
@@ -32870,11 +32882,22 @@ function parseArgs() {
   const args = process.argv.slice(2);
   let dbPath;
   let verbose = false;
+  let timeoutMs;
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--db-path" && i + 1 < args.length) {
       dbPath = args[i + 1];
       i++;
+    } else if (arg === "--timeout" && i + 1 < args.length) {
+      const rawValue = args[i + 1];
+      const ms = parseInt(rawValue, 10);
+      if (!isNaN(ms) && ms > 0) {
+        timeoutMs = ms;
+      } else {
+        console.error(`Invalid --timeout value: ${rawValue} (must be a positive integer in milliseconds)`);
+        process.exit(1);
+      }
+      i++;
     } else if (arg === "--verbose" || arg === "-v") {
       verbose = true;
     } else if (arg === "--help" || arg === "-h") {
@@ -32886,17 +32909,19 @@ Usage:
 
 Options:
   --db-path <path>    Path to LevelDB database (default: Copilot Money's default location)
+  --timeout <ms>      Decode timeout in milliseconds (default: 90000 = 90 seconds)
   --verbose, -v       Enable verbose logging
   --help, -h          Show this help message
 
 Environment:
+  DECODE_TIMEOUT_MS   Override decode timeout (same as --timeout flag)
   The server uses stdio transport and logs to stderr.
   Claude Desktop will communicate with it via stdin/stdout.
 `);
       process.exit(0);
     }
   }
-  return { dbPath, verbose };
+  return { dbPath, verbose, timeoutMs };
 }
 function configureLogging(verbose) {
   const originalError = console.error;
@@ -32912,7 +32937,7 @@ function configureLogging(verbose) {
   }
 }
 async function main() {
-  const { dbPath, verbose } = parseArgs();
+  const { dbPath, verbose, timeoutMs } = parseArgs();
   configureLogging(verbose);
   try {
     if (verbose) {
@@ -32923,7 +32948,7 @@ async function main() {
         console.log("Using default Copilot Money database location");
       }
     }
-    await runServer(dbPath);
+    await runServer(dbPath, timeoutMs);
   } catch (error48) {
     console.error("Server error:", error48);
     process.exit(1);

package/dist/decode-worker.js

@@ -804,7 +804,7 @@ __export(exports_core2, {
   safeDecode: () => safeDecode,
   registry: () => registry,
   regexes: () => exports_regexes,
-  process: () => process,
+  process: () => process2,
   prettifyError: () => prettifyError,
   parseAsync: () => parseAsync,
   parse: () => parse,
@@ -11268,7 +11268,7 @@ function initializeContext(params) {
     external: params?.external ?? undefined
   };
 }
-function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
+function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a2;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
@@ -11305,7 +11305,7 @@ function process(schema, ctx, _params = { path: [], schemaPath: [] }) {
     if (parent) {
       if (!result.ref)
         result.ref = parent;
-      process(parent, ctx, params);
+      process2(parent, ctx, params);
       ctx.seen.get(parent).isParent = true;
     }
   }
@@ -11581,14 +11581,14 @@ function isTransforming(_schema, _ctx) {
 }
 var createToJSONSchemaMethod = (schema, processors = {}) => (params) => {
   const ctx = initializeContext({ ...params, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
 var createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
   const { libraryOptions, target } = params ?? {};
   const ctx = initializeContext({ ...libraryOptions ?? {}, target, io, processors });
-  process(schema, ctx);
+  process2(schema, ctx);
   extractDefs(ctx, schema);
   return finalize(ctx, schema);
 };
@@ -11839,7 +11839,7 @@ var arrayProcessor = (schema, ctx, _json, params) => {
   if (typeof maximum === "number")
     json.maxItems = maximum;
   json.type = "array";
-  json.items = process(def.element, ctx, { ...params, path: [...params.path, "items"] });
+  json.items = process2(def.element, ctx, { ...params, path: [...params.path, "items"] });
 };
 var objectProcessor = (schema, ctx, _json, params) => {
   const json = _json;
@@ -11848,7 +11848,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
   json.properties = {};
   const shape = def.shape;
   for (const key in shape) {
-    json.properties[key] = process(shape[key], ctx, {
+    json.properties[key] = process2(shape[key], ctx, {
       ...params,
       path: [...params.path, "properties", key]
     });
@@ -11871,7 +11871,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
     if (ctx.io === "output")
       json.additionalProperties = false;
   } else if (def.catchall) {
-    json.additionalProperties = process(def.catchall, ctx, {
+    json.additionalProperties = process2(def.catchall, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11880,7 +11880,7 @@ var objectProcessor = (schema, ctx, _json, params) => {
 var unionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
   const isExclusive = def.inclusive === false;
-  const options = def.options.map((x, i) => process(x, ctx, {
+  const options = def.options.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, isExclusive ? "oneOf" : "anyOf", i]
   }));
@@ -11892,11 +11892,11 @@ var unionProcessor = (schema, ctx, json, params) => {
 };
 var intersectionProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const a = process(def.left, ctx, {
+  const a = process2(def.left, ctx, {
     ...params,
     path: [...params.path, "allOf", 0]
   });
-  const b = process(def.right, ctx, {
+  const b = process2(def.right, ctx, {
     ...params,
     path: [...params.path, "allOf", 1]
   });
@@ -11913,11 +11913,11 @@ var tupleProcessor = (schema, ctx, _json, params) => {
   json.type = "array";
   const prefixPath = ctx.target === "draft-2020-12" ? "prefixItems" : "items";
   const restPath = ctx.target === "draft-2020-12" ? "items" : ctx.target === "openapi-3.0" ? "items" : "additionalItems";
-  const prefixItems = def.items.map((x, i) => process(x, ctx, {
+  const prefixItems = def.items.map((x, i) => process2(x, ctx, {
     ...params,
     path: [...params.path, prefixPath, i]
   }));
-  const rest = def.rest ? process(def.rest, ctx, {
+  const rest = def.rest ? process2(def.rest, ctx, {
     ...params,
     path: [...params.path, restPath, ...ctx.target === "openapi-3.0" ? [def.items.length] : []]
   }) : null;
@@ -11957,7 +11957,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
   const keyBag = keyType._zod.bag;
   const patterns = keyBag?.patterns;
   if (def.mode === "loose" && patterns && patterns.size > 0) {
-    const valueSchema = process(def.valueType, ctx, {
+    const valueSchema = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "patternProperties", "*"]
     });
@@ -11967,12 +11967,12 @@ var recordProcessor = (schema, ctx, _json, params) => {
     }
   } else {
     if (ctx.target === "draft-07" || ctx.target === "draft-2020-12") {
-      json.propertyNames = process(def.keyType, ctx, {
+      json.propertyNames = process2(def.keyType, ctx, {
         ...params,
         path: [...params.path, "propertyNames"]
       });
     }
-    json.additionalProperties = process(def.valueType, ctx, {
+    json.additionalProperties = process2(def.valueType, ctx, {
       ...params,
       path: [...params.path, "additionalProperties"]
     });
@@ -11987,7 +11987,7 @@ var recordProcessor = (schema, ctx, _json, params) => {
 };
 var nullableProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  const inner = process(def.innerType, ctx, params);
+  const inner = process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
     seen.ref = def.innerType;
@@ -11998,20 +11998,20 @@ var nullableProcessor = (schema, ctx, json, params) => {
 };
 var nonoptionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var defaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.default = JSON.parse(JSON.stringify(def.defaultValue));
 };
 var prefaultProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   if (ctx.io === "input")
@@ -12019,7 +12019,7 @@ var prefaultProcessor = (schema, ctx, json, params) => {
 };
 var catchProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   let catchValue;
@@ -12033,32 +12033,32 @@ var catchProcessor = (schema, ctx, json, params) => {
 var pipeProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
   const innerType = ctx.io === "input" ? def.in._zod.def.type === "transform" ? def.out : def.in : def.out;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
 var readonlyProcessor = (schema, ctx, json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
   json.readOnly = true;
 };
 var promiseProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var optionalProcessor = (schema, ctx, _json, params) => {
   const def = schema._zod.def;
-  process(def.innerType, ctx, params);
+  process2(def.innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = def.innerType;
 };
 var lazyProcessor = (schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
-  process(innerType, ctx, params);
+  process2(innerType, ctx, params);
   const seen = ctx.seen.get(schema);
   seen.ref = innerType;
 };
@@ -12110,7 +12110,7 @@ function toJSONSchema(input, params) {
     const defs = {};
     for (const entry of registry2._idmap.entries()) {
       const [_, schema] = entry;
-      process(schema, ctx2);
+      process2(schema, ctx2);
     }
     const schemas = {};
     const external = {
@@ -12133,7 +12133,7 @@ function toJSONSchema(input, params) {
     return { schemas };
   }
   const ctx = initializeContext({ ...params, processors: allProcessors });
-  process(input, ctx);
+  process2(input, ctx);
   extractDefs(ctx, input);
   return finalize(ctx, input);
 }
@@ -12179,7 +12179,7 @@ class JSONSchemaGenerator {
     });
   }
   process(schema, _params = { path: [], schemaPath: [] }) {
-    return process(schema, this.ctx, _params);
+    return process2(schema, this.ctx, _params);
   }
   emit(schema, _params) {
     if (_params) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilot-money-mcp",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "MCP server for Copilot Money - AI-powered personal finance queries using local data",
   "keywords": [
     "mcp",