@withone/mcp 1.3.0 → 1.3.1

package/build/client.js

@@ -9,6 +9,62 @@
 import axios from 'axios';
 import FormData from 'form-data';
 import { fetchPaginatedData, replacePathVariables } from './helpers.js';
+/** Header names that only the server may set on an outgoing request. */
+const RESERVED_HEADER_PREFIX = 'x-one-';
+/**
+ * Drops any caller-supplied header that One itself controls (`x-one-secret`,
+ * `x-one-connection-key`, `x-one-action-id`, ...). Comparison is
+ * case-insensitive because HTTP header names are.
+ */
+export function stripReservedHeaders(headers) {
+    if (!headers)
+        return {};
+    return Object.fromEntries(Object.entries(headers)
+        .filter(([name]) => !name.toLowerCase().startsWith(RESERVED_HEADER_PREFIX))
+        .map(([name, value]) => [name, String(value)]));
+}
+/**
+ * Bounds an upstream error body before it is logged: small payloads pass
+ * through, larger ones are truncated to a string, and an unserializable value
+ * is replaced with a placeholder. Keeps a huge or odd error response from
+ * bloating a single log line.
+ */
+function summarizeErrorData(data) {
+    if (data === undefined || data === null)
+        return undefined;
+    let serialized;
+    try {
+        serialized = typeof data === 'string' ? data : JSON.stringify(data);
+    }
+    catch {
+        return '[unserializable response body]';
+    }
+    const MAX = 1000;
+    return serialized.length <= MAX ? data : `${serialized.slice(0, MAX)}… (${serialized.length} chars, truncated)`;
+}
+/**
+ * A log-safe summary of a failed request. Axios errors carry the full request
+ * config, including the `x-one-secret` header, so they must never be logged
+ * whole. Only the status, the upstream message, the route (query stripped), and
+ * a bounded copy of the response body are kept.
+ */
+export function describeError(error) {
+    if (axios.isAxiosError(error)) {
+        const url = error.config?.url;
+        return {
+            status: error.response?.status,
+            statusText: error.response?.statusText,
+            method: error.config?.method?.toUpperCase(),
+            url: typeof url === 'string' ? url.split('?')[0] : undefined,
+            message: error.message,
+            data: summarizeErrorData(error.response?.data),
+        };
+    }
+    if (error instanceof Error) {
+        return { name: error.name, message: error.message };
+    }
+    return { error: String(error) };
+}
 /**
  * Client for interacting with the One API
  */
@@ -62,11 +118,11 @@ export class OneClient {
         ]);
         const [connectionsResult, connectorsResult] = results;
         if (connectionsResult.status === 'rejected') {
-            console.error("Failed to fetch connections:", connectionsResult.reason);
+            console.error("Failed to fetch connections:", describeError(connectionsResult.reason));
             this.connections = [];
         }
         if (connectorsResult.status === 'rejected') {
-            console.error("Failed to fetch connectors:", connectorsResult.reason);
+            console.error("Failed to fetch connectors:", describeError(connectorsResult.reason));
             this.connectors = [];
         }
         this.isInitialized = true;
@@ -105,7 +161,7 @@ export class OneClient {
             this.connections = await fetchPaginatedData(url, headers, Object.keys(additionalParams).length > 0 ? additionalParams : undefined);
         }
         catch (error) {
-            console.error("Failed to fetch connections:", error);
+            console.error("Failed to fetch connections:", describeError(error));
             this.connections = [];
             throw error;
         }
@@ -120,7 +176,7 @@ export class OneClient {
             this.connectors = await fetchPaginatedData(url, headers);
         }
         catch (error) {
-            console.error("Failed to fetch connection definitions:", error);
+            console.error("Failed to fetch connection definitions:", describeError(error));
             this.connectors = [];
             throw error;
         }
@@ -162,7 +218,7 @@ export class OneClient {
             return response.data || [];
         }
         catch (error) {
-            console.error("Error searching available actions:", error);
+            console.error("Error searching available actions:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to search available actions: ${error.response?.status} ${error.response?.statusText}`);
             }
@@ -204,7 +260,7 @@ export class OneClient {
             return actions[0];
         }
         catch (error) {
-            console.error("Error fetching action details:", error);
+            console.error("Error fetching action details:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to fetch action details: ${error.response?.status} ${error.response?.statusText}`);
             }
@@ -232,7 +288,7 @@ export class OneClient {
             };
         }
         catch (error) {
-            console.error("Error fetching action knowledge:", error);
+            console.error("Error fetching action knowledge:", describeError(error));
             throw error;
         }
     }
@@ -267,7 +323,7 @@ export class OneClient {
                 };
             }
             catch (error) {
-                console.error(`Failed to resolve allowed action ${actionId}:`, error);
+                console.error(`Failed to resolve allowed action ${actionId}:`, describeError(error));
                 return null;
             }
         }));
@@ -286,12 +342,21 @@ export class OneClient {
         const action = preloadedAction ?? await this.getActionDetails(actionId);
         const method = action.method;
         const contentType = isFormData ? 'multipart/form-data' : isFormUrlEncoded ? 'application/x-www-form-urlencoded' : 'application/json';
+        // Caller-supplied headers are merged first and may adjust things like
+        // Content-Type, but they can never override One's own routing and auth
+        // headers. Those are applied last, after the connection and action
+        // allowlist checks in index.ts have already passed, so an `x-one-*`
+        // header in `headers` cannot redirect the call to another connection,
+        // action, or secret.
+        // Drop One's default Content-Type (any casing) so the caller's choice,
+        // merged in below, is not clobbered when the auth headers are applied last.
+        const authHeaders = Object.fromEntries(Object.entries(this.generateHeaders()).filter(([name]) => name.toLowerCase() !== 'content-type'));
         const requestHeaders = {
-            ...this.generateHeaders(),
+            'Content-Type': contentType,
+            ...stripReservedHeaders(headers),
+            ...authHeaders,
             'x-one-connection-key': connectionKey,
             'x-one-action-id': action._id,
-            'Content-Type': contentType,
-            ...headers
         };
         const finalActionPath = pathVariables
             ? replacePathVariables(action.path, pathVariables)
@@ -368,7 +433,7 @@ export class OneClient {
             };
         }
         catch (error) {
-            console.error("Error executing passthrough request:", error);
+            console.error("Error executing passthrough request:", describeError(error));
             if (axios.isAxiosError(error)) {
                 throw new Error(`Failed to execute passthrough request: ${error.response?.status} ${error.response?.statusText}`);
             }

package/build/client.test.js

@@ -0,0 +1,101 @@
+import { describe, it, before, after, beforeEach } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { OneClient, stripReservedHeaders, describeError } from './client.js';
+// A passthrough call must never let the caller override One's own routing/auth
+// headers (the scoping bypass), and a failed call must never log the secret.
+const SECRET = 'sk_test_REALSECRET_abc123';
+const ACTION = { _id: 'conn_mod_def::ALLOWED_ACTION', method: 'GET', path: '/v1/things', tags: [] };
+const exec = (extra) => ({
+    platform: 'test',
+    actionId: 'conn_mod_def::ALLOWED_ACTION',
+    connectionKey: 'live::allowed::default::aaaa',
+    ...extra,
+});
+describe("executePassthroughRequest keeps One's headers authoritative", () => {
+    let server;
+    let base = '';
+    let received = [];
+    let failBody = null;
+    before(async () => {
+        server = http.createServer((req, res) => {
+            received.push({ headers: req.headers });
+            if (failBody !== null) {
+                res.writeHead(422, { 'Content-Type': 'application/json' });
+                res.end(failBody);
+                return;
+            }
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: true }));
+        });
+        await new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve()));
+        base = `http://127.0.0.1:${server.address().port}`;
+    });
+    after(() => {
+        server.close();
+    });
+    beforeEach(() => {
+        received = [];
+        failBody = null;
+    });
+    it('a caller cannot override the x-one-* routing/auth headers', async () => {
+        const client = new OneClient(SECRET, base);
+        await client.executePassthroughRequest(exec({
+            headers: {
+                'x-one-connection-key': 'live::EXCLUDED::default::zzzz',
+                'X-One-Secret': 'sk_live_stolen',
+                'X-ONE-ACTION-ID': 'conn_mod_def::OTHER',
+                'x-custom-trace': 't-1',
+            },
+        }), ACTION);
+        const h = received[0].headers;
+        assert.equal(h['x-one-connection-key'], 'live::allowed::default::aaaa');
+        assert.equal(h['x-one-secret'], SECRET);
+        assert.equal(h['x-one-action-id'], 'conn_mod_def::ALLOWED_ACTION');
+        assert.equal(h['x-custom-trace'], 't-1', 'a non-reserved custom header still passes through');
+        assert.equal(h['content-type'], 'application/json', 'the default content type is kept');
+    });
+    it('a caller may still set Content-Type, in any casing', async () => {
+        const client = new OneClient(SECRET, base);
+        await client.executePassthroughRequest(exec({ headers: { 'content-type': 'text/plain' } }), ACTION);
+        assert.equal(received[0].headers['content-type'], 'text/plain');
+    });
+    it('a failed call throws with the status, never logs the secret, and bounds the body', async () => {
+        failBody = JSON.stringify({ error: 'upstream said no', padding: 'x'.repeat(2000) });
+        const client = new OneClient(SECRET, base);
+        const logged = [];
+        const original = console.error;
+        console.error = (...args) => {
+            logged.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+        };
+        let message = '';
+        try {
+            await client.executePassthroughRequest(exec({}), ACTION);
+        }
+        catch (error) {
+            message = error.message;
+        }
+        finally {
+            console.error = original;
+        }
+        const log = logged.join('\n');
+        assert.ok(!log.includes(SECRET), 'the secret never reaches the log');
+        assert.ok(log.includes('422') && log.includes('upstream said no'), 'the log still says what failed');
+        assert.ok(log.includes('truncated'), 'a huge upstream body is bounded');
+        assert.ok(message.includes('422'), 'the thrown tool error carries the status');
+    });
+});
+describe('stripReservedHeaders', () => {
+    it('drops x-one-* case-insensitively and stringifies values', () => {
+        assert.deepEqual(stripReservedHeaders({ 'X-One-Secret': 'a', 'x-one-action-id': 'b', Accept: 'x' }), { Accept: 'x' });
+        assert.deepEqual(stripReservedHeaders({ n: 5 }), { n: '5' });
+        assert.deepEqual(stripReservedHeaders(undefined), {});
+    });
+});
+describe('describeError', () => {
+    it('summarizes a plain error to its name and message', () => {
+        const described = describeError(new Error('boom'));
+        assert.equal(described.name, 'Error');
+        assert.equal(described.message, 'boom');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/mcp",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "A Model Context Protocol Server for One",
   "type": "module",
   "bin": {