actual-mcp-server 0.22.44 → 0.22.46

package/README.md

@@ -836,7 +836,7 @@ The software is provided **as-is**, without warranty of any kind. The author acc
 
 ---
 
-**Version:** 0.22.44 | **Tool Count:** 84 (verified LibreChat-compatible)
+**Version:** 0.22.46 | **Tool Count:** 84 (verified LibreChat-compatible)
 
 ## Sponsor
 

package/dist/src/index.js

@@ -105,7 +105,9 @@ const KNOWN_FLAGS = new Set([
     '--http', '--stdio', '--test-actual-connection', '--test-mcp-client',
     '--debug', '--help', '-h', '--version', '-v',
 ]);
-const unknownFlags = argsEarly.filter(a => a.startsWith('-') && !KNOWN_FLAGS.has(a));
+// A bare `--` is the conventional end-of-options marker that `node script.js -- --flag` passes
+// through (the npm `dev` and `test:mcp-client` launchers did, #565); it is not an option.
+const unknownFlags = argsEarly.filter(a => a.startsWith('-') && a !== '--' && !KNOWN_FLAGS.has(a));
 if (unknownFlags.length > 0) {
     console.error(`Unknown option: ${unknownFlags.join(', ')}\nRun \`actual-mcp-server --help\` for usage.`);
     process.exit(1);
@@ -314,13 +316,23 @@ Docs & source: https://github.com/agigante80/actual-mcp-server`);
         // If requested, run the MCP client-side tests now that all variables are ready
         if (useTestMcpClient) {
             logger.info('⚙️  --test-mcp-client specified, starting HTTP server and running client-side MCP tests...');
-            // start server in http mode. Bind all interfaces by default (#239): advertisedUrl
-            // uses the LAN IP (getLocalIp), so the self-test client must be able to reach it.
+            // start server in http mode. Bind all interfaces by default (#239).
             await startHttpServer(mcp, PORT, HTTP_PATH, capabilities, implementedTools, SERVER_DESCRIPTION, serverInstructionsText, toolSchemas, version, bindHost, advertisedUrl);
             // dynamic import to avoid circular at top
             const { testMcpClient } = await import('./tests/testMcpClient.js');
             try {
-                await testMcpClient(advertisedUrl, PORT, HTTP_PATH);
+                // #565: the self-test talks to the address this process bound, not advertisedUrl. The
+                // advertised LAN IP can be answered by another listener on the same port (a Docker
+                // container publishing it is NATed ahead of local sockets), which turned the run into a
+                // 401 from a different server. A wildcard bind is reached on loopback, '::' on '::1' (an
+                // IPv6-only socket refuses IPv4). The scheme is the listener's, not the advertised one
+                // (MCP_BRIDGE_PUBLIC_SCHEME and MCP_BRIDGE_USE_TLS only change what is advertised).
+                // Under native TLS the advertised host is kept: the certificate names it, not 127.0.0.1.
+                const nativeTls = process.env.MCP_ENABLE_HTTPS === 'true';
+                const loopback = bindHost === '0.0.0.0' ? '127.0.0.1' : bindHost === '::' ? '::1' : bindHost;
+                const selfHost = nativeTls ? advertisedHost : loopback;
+                const selfUrl = `${nativeTls ? 'https' : 'http'}://${selfHost.includes(':') ? `[${selfHost}]` : selfHost}:${PORT}${HTTP_PATH}`;
+                await testMcpClient(selfUrl, HTTP_PATH);
                 logger.info('✅ MCP client-side tests passed');
                 process.exit(0);
             }

package/dist/src/lib/actual-adapter/query.js

@@ -48,6 +48,15 @@ function _splitInList(valuesStr) {
 /** A single-quoted literal whose internal quotes are SQL-ESCAPED by doubling.
  *  `'McDonald''s'` matches; `'McDonald's'` (a lone quote) does not. */
 const SQL_ESCAPED_SINGLE_QUOTED = /^'(?:[^']|'')*'$/;
+// ActualQL's value compiler escapes comparison and LIKE strings for SQLite, so SQL's doubled
+// apostrophe must be decoded first. IN uses a separate path that deliberately preserves it.
+function _stripWhereSqlLiteral(s) {
+    const t = s.trim();
+    if (SQL_ESCAPED_SINGLE_QUOTED.test(t)) {
+        return t.slice(1, -1).replace(/''/g, "'");
+    }
+    return _stripWhereQuotes(s);
+}
 function _isSafeInListElement(raw) {
     const t = raw.trim();
     // #433: a single-quoted element may now carry DOUBLED internal quotes. That is
@@ -83,11 +92,11 @@ function _coerceInListValue(s) {
     }
     return _coerceWhereValue(s);
 }
-// Coerce a SQL value literal to a number when it looks numeric, else keep the
-// (unquoted) string. Used for IN lists and comparison operands. Empty stays a
-// string so an empty literal is not silently turned into 0.
+// Coerce a comparison operand (and an IN element with no doubled quote) to a number when it
+// looks numeric, else keep the unquoted string. Empty stays a string so an empty literal is not
+// turned into 0.
 function _coerceWhereValue(s) {
-    const v = _stripWhereQuotes(s);
+    const v = _stripWhereSqlLiteral(s);
     if (v === '')
         return v;
     const n = Number(v);
@@ -158,7 +167,7 @@ export function parseWhereClause(query, whereClause, tableName) {
         const notLikeMatch = trimmedCondition.match(/^([\w.]+)\s+NOT\s+LIKE\s+(.+)$/i);
         if (notLikeMatch) {
             const [, field, valueStr] = notLikeMatch;
-            query = query.filter({ [field]: { $notlike: _stripWhereQuotes(valueStr) } });
+            query = query.filter({ [field]: { $notlike: _stripWhereSqlLiteral(valueStr) } });
             continue;
         }
         // LIKE: pattern match. ActualQL's $like runs through NORMALISE + UNICODE_LIKE,
@@ -167,7 +176,7 @@ export function parseWhereClause(query, whereClause, tableName) {
         const likeMatch = trimmedCondition.match(/^([\w.]+)\s+LIKE\s+(.+)$/i);
         if (likeMatch) {
             const [, field, valueStr] = likeMatch;
-            query = query.filter({ [field]: { $like: _stripWhereQuotes(valueStr) } });
+            query = query.filter({ [field]: { $like: _stripWhereSqlLiteral(valueStr) } });
             continue;
         }
         // IN clause: field IN (value1, value2, ...)
@@ -221,7 +230,25 @@ export function parseWhereClause(query, whereClause, tableName) {
             // operators are left to their normal path, where ActualQL will reject them for a boolean as
             // it does today, rather than us inventing an ordering the column does not have.
             const isBool = _isBooleanField(tableName, field) && (actualOp === '$eq' || actualOp === '$ne');
-            const finalValue = isBool ? _coerceBoolean(field, valueStr) : _coerceWhereValue(valueStr);
+            const isText = tableName !== undefined && getFieldType(tableName, field) === 'string';
+            // #567 review: a quoted number stays a string on a text column. Coercing `notes = '123'` to
+            // the number 123 made upstream throw "Can't convert integer to string".
+            const finalValue = isBool
+                ? _coerceBoolean(field, valueStr)
+                : isText ? _stripWhereSqlLiteral(valueStr) : _coerceWhereValue(valueStr);
+            // #567 review: upstream's val() (aql/compiler.ts) re-escapes a value only when it casts to
+            // type `string`. A value compared against an `id` column is inlined as `'${value}'` with NO
+            // escaping, so a quote in it closes the literal: `account = 'x'||(SELECT ...)||'x'` ran the
+            // subquery, past both validators, and decoding `''` made the doubled form do the same. A
+            // quote is therefore allowed only on a column our schema types as `string` (checked against
+            // upstream's schema: every one of them is `string` there, or does not exist and fails to
+            // compile). Any other or unknown type refuses it, which is fail closed: no id, date, number
+            // or boolean legitimately contains a single quote. LIKE and NOT LIKE always cast to string,
+            // so they need no such check.
+            if (!isText && typeof finalValue === 'string' && finalValue.includes("'")) {
+                throw new Error(`Invalid value for column "${field}": a single quote is only allowed in a value ` +
+                    `compared against a text column (for example payee.name = 'O''Brien').`);
+            }
             if (actualOp === '$eq') {
                 // Simple equality can use the direct field: value shorthand.
                 query = query.filter({ [field]: finalValue });
@@ -252,8 +279,9 @@ const NAME_CONDITION_TABLES = {
  * `NOT LIKE` are skipped: an unknown name there cannot make the result empty. Each condition is
  * ONE lookup, an IN list included (the ticket allows one extra read per name condition), and the
  * lookup reuses the main query's operator and value, so a `$oneof` element compiles exactly as in
- * the main query (where upstream inlines the doubled-quote form #433 keeps). A numeric-looking
- * literal arrives coerced to a number and is kept as is.
+ * the main query (where upstream inlines the doubled-quote form #433 keeps). The three name
+ * columns are text, so since #567 a numeric-looking `=` value arrives as a string; a number is
+ * still accepted (an IN element can be one) and kept as is.
  */
 export function nameConditionLookups(filterExpressions) {
     const out = [];

package/dist/src/lib/query-validator.js

@@ -175,7 +175,12 @@ function extractWhereFields(sql) {
     // comparison operator, but also before IN / LIKE / IS / BETWEEN (with their NOT forms). Before
     // this, `bogus_col IN ('a')`, `bogus_col LIKE '%a%'` and `bogus_col IS NULL` extracted no field
     // and so skipped the allowlist check entirely, while `bogus_col = 'a'` was correctly rejected.
-    const fieldMatches = whereClause.matchAll(/(\w+)\.(\w+)|(?:^|\s)(\w+)\s*[=<>!]|(?:^|\s)(\w+)\s+(?:NOT\s+)?(?:IN|LIKE|BETWEEN)\b|(?:^|\s)(\w+)\s+IS\b/gi);
+    // #566: the IN / LIKE / BETWEEN alternative must not capture the keyword NOT as a field. After
+    // `(\w+)\.(\w+)` consumes a joined name such as `payee.name`, the scan resumes at ` NOT LIKE`,
+    // and without the `(?!NOT\s)` lookahead that alternative read `NOT` as a column and rejected a
+    // valid query with `Field "NOT" does not exist`. The lookahead is exact on purpose: it skips only
+    // the word NOT followed by whitespace, so every real column name is still extracted and checked.
+    const fieldMatches = whereClause.matchAll(/(\w+)\.(\w+)|(?:^|\s)(\w+)\s*[=<>!]|(?:^|\s)(?!NOT\s)(\w+)\s+(?:NOT\s+)?(?:IN|LIKE|BETWEEN)\b|(?:^|\s)(\w+)\s+IS\b/gi);
     for (const match of fieldMatches) {
         if (match[1] && match[2]) {
             // table.field

package/dist/src/tests/testMcpClient.js

@@ -1,9 +1,9 @@
-export async function testMcpClient(advertisedUrl, _port, httpPath) {
+export async function testMcpClient(serverUrl, httpPath) {
     // Try builtin fetch or fallback to node-fetch if necessary
     const globalFetch = globalThis.fetch;
     const fetchAny = globalFetch ?? (await import('node-fetch')).default;
     const fetchFn = fetchAny;
-    const base = new URL(advertisedUrl);
+    const base = new URL(serverUrl);
     // quick probe endpoint (#286: the server-info probe moved off the reserved
     // /.well-known/oauth-protected-resource OAuth path to the non-reserved /mcp-info,
     // now a bare object; the `result ?? raw` unwrap below tolerates both shapes).
@@ -104,8 +104,12 @@ export async function testMcpClient(advertisedUrl, _port, httpPath) {
         headers: listHeaders,
         body: JSON.stringify(listPayload),
     });
-    if (!listRes.ok)
-        throw new Error(`tools/list failed: ${listRes.status}`);
+    if (!listRes.ok) {
+        // #565: a 404 here is usually the session's Actual connection failing (bad credentials or no
+        // reachable server); the body names the cause (#438), so carry it rather than a bare status.
+        const body = await listRes.json().catch(() => undefined);
+        throw new Error(`tools/list failed: ${listRes.status}${body === undefined ? '' : ` ${JSON.stringify(body).slice(0, 300)}`}`);
+    }
     const listJsonRaw = await listRes.json();
     const listJsonObj = listJsonRaw && typeof listJsonRaw === 'object' ? listJsonRaw : undefined;
     if (!listJsonObj || !('result' in listJsonObj))

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "actual-mcp-server",
   "displayName": "Actual MCP Server",
-  "version": "0.22.44",
+  "version": "0.22.46",
   "engines": {
     "node": ">=22.0.0",
     "npm": ">=10.0.0"