ofw-mcp 2.20.0 → 2.20.2

package/dist/client.js

@@ -1,4 +1,4 @@
-import { loadDotenvSafely, parseBoolEnv, redactSecrets, withAmbientCancellation } from '@chrischall/mcp-utils';
+import { EdgeBlockedError, detectEdgeBlock, loadDotenvSafely, parseContentDispositionFilename, parseBoolEnv, redactSecrets, withAmbientCancellation, } from '@chrischall/mcp-utils';
 import { TokenManager } from '@chrischall/mcp-utils/session';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
@@ -18,22 +18,6 @@ try {
 catch {
     /* v8 ignore next -- only reached in a non-Node runtime: no .env to load */
 }
-// Parse a Content-Disposition header for a filename. Prefers RFC 6266
-// `filename*=UTF-8''…` (percent-decoded) and falls back to `filename="…"`.
-function parseContentDispositionFilename(cd) {
-    const extMatch = /filename\*=(?:UTF-8'')?([^;]+)/i.exec(cd);
-    if (extMatch) {
-        const raw = extMatch[1].trim().replace(/^"|"$/g, '');
-        try {
-            return decodeURIComponent(raw);
-        }
-        catch {
-            return raw;
-        }
-    }
-    const m = /filename="?([^";]+)"?/i.exec(cd);
-    return m ? m[1] : null;
-}
 // Set OFW_DEBUG_LOG=1 (or true/yes/on) to log every OFW request/response to
 // stderr. Authorization is redacted. Bodies are logged in full — set this
 // only when debugging, never in normal use.
@@ -59,6 +43,48 @@ function getRequestTimeoutMs() {
 // refresh when its refresh token is `undefined`, so a non-empty placeholder
 // keeps the single-flight refresh path live; the refresh callback ignores it.
 const OFW_REFRESH_SENTINEL = 'ofw';
+/**
+ * Throw {@link EdgeBlockedError} when `response` is a CDN/WAF refusal.
+ *
+ * Its HEADERS are always judged (Cloudflare's `cf-mitigated`). Its BODY is
+ * judged for a 401 or 429 before releasing it for a replay. A challenge page
+ * without the header must not spend a login or be reported as a rate limit.
+ * The 401 body is read from a clone (a final 401 still needs its error body);
+ * the 429 body can be consumed directly since it is always released. JSON is
+ * never probed — no refusal page is. Other non-2xx bodies are judged where
+ * the error body is read anyway; a 2xx body is never consumed here.
+ */
+async function throwIfEdgeBlocked(response, method, path) {
+    if (response.ok)
+        return;
+    let edge = detectEdgeBlock({ headers: response.headers, status: response.status });
+    if (edge === null && (response.status === 401 || response.status === 429) && !/json/i.test(response.headers.get('content-type') ?? '')) {
+        let body = '';
+        try {
+            body = await (response.status === 401 ? response.clone() : response).text();
+        }
+        catch {
+            /* unreadable: not shown to be a block */
+        }
+        edge = detectEdgeBlock({ body, headers: response.headers, status: response.status });
+    }
+    if (edge !== null) {
+        await releaseBody(response);
+        throw new EdgeBlockedError(response.status, edge.vendor, { service: 'OurFamilyWizard', method, path });
+    }
+}
+/**
+ * Release a response's connection without reading it. A cancel that fails
+ * changes nothing about the answer, so its failure is swallowed.
+ */
+async function releaseBody(response) {
+    try {
+        await response.body?.cancel();
+    }
+    catch {
+        /* already settled */
+    }
+}
 export class OFWClient {
     // Bearer-token lifecycle is delegated to the shared, race-safe TokenManager
     // (proactive refresh inside the skew window, single-flight refresh so a burst
@@ -111,52 +137,75 @@ export class OFWClient {
         return this.tokenManager;
     }
     async request(method, path, body) {
-        const response = await this.fetchAuthed(method, path, body, 'application/json');
-        const text = await response.text();
-        if (debugLogEnabled()) {
-            console.error(`[ofw-debug] response body: ${text || '<empty>'}`);
-        }
-        return (text ? JSON.parse(text) : null);
+        return this.fetchAuthed(method, path, body, 'application/json', async (response) => {
+            const text = await response.text();
+            if (debugLogEnabled()) {
+                console.error(`[ofw-debug] response body: ${text || '<empty>'}`);
+            }
+            return (text ? JSON.parse(text) : null);
+        });
     }
     /** Like `request`, but returns the raw bytes plus Content-Type/-Disposition metadata. */
     async requestBinary(method, path) {
-        const response = await this.fetchAuthed(method, path, undefined, 'application/octet-stream');
-        return {
+        return this.fetchAuthed(method, path, undefined, 'application/octet-stream', async (response) => ({
             body: Buffer.from(await response.arrayBuffer()),
             contentType: response.headers.get('content-type'),
-            suggestedFileName: parseContentDispositionFilename(response.headers.get('content-disposition') ?? ''),
-        };
+            suggestedFileName: parseContentDispositionFilename(response.headers.get('content-disposition') ?? '') ?? null,
+        }));
     }
     // Authenticated fetch for both JSON and binary callers. Auth (proactive
     // refresh inside the skew window + one 401-replay, guarded against a
     // double-refresh under concurrency) is delegated to the shared TokenManager's
     // `withAuth`. The 429 wait-and-replay and the non-2xx → throw remain here.
-    async fetchAuthed(method, path, body, accept) {
-        // `withAuth` invokes `call` once, and again after a refresh on a 401. The
-        // second invocation is the replay — mark it `(retry)` in the debug log,
-        // preserving the prior bespoke-loop diagnostic.
+    async fetchAuthed(method, path, body, accept, consume) {
         let attempt = 0;
-        let response = await this.getTokenManager().withAuth((token) => this.fetchOnce(method, path, body, accept, token, attempt++ > 0));
+        let result;
+        // Keep all response I/O inside fetchOnce's per-attempt deadline. Returning
+        // the Response still lets TokenManager own its one 401 refresh/replay.
+        const call = async (retry) => {
+            let authAttempt = 0;
+            return this.getTokenManager().withAuth((token) => {
+                const firstAuthAttempt = authAttempt++ === 0;
+                return this.fetchOnce(method, path, body, accept, token, async (response) => {
+                    await throwIfEdgeBlocked(response, method, path);
+                    if (response.status === 401 && firstAuthAttempt) {
+                        await releaseBody(response);
+                        return;
+                    }
+                    if (response.status === 429) {
+                        await releaseBody(response);
+                        return;
+                    }
+                    if (!response.ok) {
+                        const errorBody = await response.text();
+                        const edge = detectEdgeBlock({ body: errorBody, headers: response.headers, status: response.status });
+                        if (edge !== null) {
+                            throw new EdgeBlockedError(response.status, edge.vendor, { service: 'OurFamilyWizard', method, path });
+                        }
+                        const safeBody = redactSecrets(errorBody).replace(/\s+/g, ' ').trim().slice(0, 4000);
+                        throw new Error(`OFW API error: ${response.status} ${response.statusText} for ${method} ${path}` +
+                            (safeBody ? ` — ${safeBody}` : ''));
+                    }
+                    result = await consume(response);
+                }, retry || attempt++ > 0);
+            });
+        };
+        const response = await call(false);
         if (response.status === 429) {
+            // The attempt is released and its timer cleared before the backoff.
             await new Promise((r) => setTimeout(r, 2000));
-            response = await this.getTokenManager().withAuth((token) => this.fetchOnce(method, path, body, accept, token, true));
-            if (response.status === 429)
+            if ((await call(true)).status === 429) {
                 throw new Error('Rate limited by OFW API');
+            }
         }
-        if (!response.ok) {
-            const errorBody = await response.text();
-            const safeBody = redactSecrets(errorBody).replace(/\s+/g, ' ').trim().slice(0, 4000);
-            throw new Error(`OFW API error: ${response.status} ${response.statusText} for ${method} ${path}` +
-                (safeBody ? ` — ${safeBody}` : ''));
-        }
-        return response;
+        return result;
     }
     // A single OFW API fetch with the bearer token supplied by `withAuth`.
     // Carries the per-request timeout (AbortController + setTimeout so vitest
     // fake timers can drive it and we attach a clear error message) and the
-    // OFW_DEBUG_LOG instrumentation. Returns the raw Response — 401/429/non-2xx
-    // handling lives in the callers (`withAuth` and `fetchAuthed`).
-    async fetchOnce(method, path, body, accept, token, isRetry = false) {
+    // OFW_DEBUG_LOG instrumentation. The handler completes body consumption or
+    // release before this attempt returns its Response to `withAuth`.
+    async fetchOnce(method, path, body, accept, token, handleResponse, isRetry = false) {
         const isFormData = body instanceof FormData;
         const headers = {
             ...OFW_PROTOCOL_HEADERS,
@@ -188,22 +237,36 @@ export class OFWClient {
         const ac = new AbortController();
         const timer = setTimeout(() => ac.abort(), timeoutMs);
         const startedAt = Date.now();
-        let response;
+        // Passing our own signal guarantees a signal even without an ambient caller.
+        const signal = withAmbientCancellation(ac.signal);
+        let onAbort;
+        // Race the complete attempt, not just fetch: body.cancel() may not settle
+        // on abort, and edge-probe/release helpers deliberately swallow I/O errors.
+        const aborted = new Promise((_resolve, reject) => {
+            onAbort = () => reject(signal.reason);
+            if (signal.aborted)
+                onAbort();
+            else
+                signal.addEventListener('abort', onAbort, { once: true });
+        });
         try {
-            response = await fetch(url, {
-                method,
-                headers,
-                // THE CALLER'S CANCELLATION, folded in with our timeout (mcp-utils
-                // `cancel`). Until this the only thing that could stop an OFW
-                // request was the timeout below, so a cancelled tool call held it
-                // open for the full budget while the child burned the CPU
-                // mcp-host meters it on. The timeout diagnosis below is unaffected
-                // because it asks `ac.signal`, OUR controller — a caller's abort
-                // falls through to the generic path rather than being reported as
-                // OFW being slow.
-                signal: withAmbientCancellation(ac.signal),
-                ...(body !== undefined ? { body: isFormData ? body : JSON.stringify(body) } : {}),
-            });
+            return await Promise.race([aborted, (async () => {
+                    signal.throwIfAborted();
+                    const response = await fetch(url, {
+                        method,
+                        headers,
+                        // The caller's cancellation and our timeout both cover headers,
+                        // body reads and releases; only our controller diagnoses slowness.
+                        signal,
+                        ...(body !== undefined ? { body: isFormData ? body : JSON.stringify(body) } : {}),
+                    });
+                    if (debugLogEnabled()) {
+                        console.error(`[ofw-debug] ← ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
+                    }
+                    await handleResponse(response);
+                    signal.throwIfAborted();
+                    return response;
+                })()]);
         }
         catch (err) {
             const elapsed = Date.now() - startedAt;
@@ -220,11 +283,8 @@ export class OFWClient {
         }
         finally {
             clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
         }
-        if (debugLogEnabled()) {
-            console.error(`[ofw-debug] ← ${response.status} ${response.statusText} (${Date.now() - startedAt}ms)`);
-        }
-        return response;
     }
 }
 export const client = new OFWClient();

package/dist/index.js

@@ -47,7 +47,7 @@ const tools = selectToolRegistrars({
 });
 await runMcp({
     name: 'ofw',
-    version: '2.20.0', // x-release-please-version
+    version: '2.20.2', // x-release-please-version
     deps: client,
     tools,
     banner: '[ofw-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.',

package/dist/tools/attachments.js

@@ -8,10 +8,10 @@
 // disk injects an inline, filesystem-free implementation.
 // Keeping the interface here means src/tools/messages.ts imports nothing from
 // node:fs.
-import { chmodSync, existsSync, readFileSync, realpathSync, statSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
+import { chmodSync, readFileSync, realpathSync, statSync, mkdirSync, unlinkSync } from 'node:fs';
 import { basename, dirname, extname, isAbsolute, relative, resolve, sep } from 'node:path';
 import { getDefaultAttachmentsDir, getUploadDir } from '../config.js';
-import { fileBlob, expandPath } from '@chrischall/mcp-utils';
+import { assertPathWithinRoots, expandPath, fileBlob, FileWriteRefusedError, sniffMimeBytes, writeFileSafe, } from '@chrischall/mcp-utils';
 /**
  * True when `candidate` is strictly inside `root` (both absolute). Lexical:
  * resolve symlinks first when that matters.
@@ -20,13 +20,6 @@ export function isWithin(root, candidate) {
     const rel = relative(root, candidate);
     return rel !== '' && !rel.startsWith('..') && !isAbsolute(rel);
 }
-/** The deepest ancestor of `path` (itself included) that exists on disk. */
-function deepestExisting(path) {
-    let current = path;
-    while (!existsSync(current))
-        current = dirname(current);
-    return current;
-}
 // Lightweight mime sniff from extension. OFW re-derives mime from the filename
 // server-side anyway, so this is just a polite Content-Type for the Blob.
 const MIME_BY_EXT = {
@@ -81,20 +74,11 @@ export function normalizeMimeType(raw) {
  * onto them), so the actual bytes are the authoritative signal. Returns the
  * bare media type, or null when the bytes aren't a PNG/JPEG/GIF/WEBP.
  */
-const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-const JPEG_MAGIC = Buffer.from([0xff, 0xd8, 0xff]);
 export function sniffImageMime(bytes) {
-    if (bytes.length >= 8 && bytes.subarray(0, 8).equals(PNG_MAGIC))
-        return 'image/png';
-    if (bytes.length >= 3 && bytes.subarray(0, 3).equals(JPEG_MAGIC))
-        return 'image/jpeg';
-    if (bytes.length >= 6 && bytes.toString('ascii', 0, 4) === 'GIF8')
-        return 'image/gif';
-    if (bytes.length >= 12 &&
-        bytes.toString('ascii', 0, 4) === 'RIFF' && bytes.toString('ascii', 8, 12) === 'WEBP') {
-        return 'image/webp';
-    }
-    return null;
+    // mcp-utils' shared magic-byte table, narrowed to what a host renders inline
+    // (it also names PDF, zip, MIDI and HEIC/MP4 — not ImageContent material).
+    const sniffed = sniffMimeBytes(bytes);
+    return sniffed !== undefined && HOST_RENDERABLE_IMAGE_MIMES.has(sniffed) ? sniffed : null;
 }
 /**
  * Resolve the MIME type to report for downloaded bytes, in priority order:
@@ -129,12 +113,18 @@ export class NodeAttachmentIO {
         // against the upload dir instead, and only expand a leading ~.
         const abs = resolve(root, path.startsWith('~') ? expandPath(path) : path);
         const outside = new Error(`Refusing to upload ${abs}: it is outside the upload directory (${root}). Only files placed in that directory can be uploaded — ask the user to copy the file there, or set OFW_UPLOAD_DIR.`);
+        // Lexical check first (a path that merely names somewhere else is refused
+        // even if a symlink there leads back in), then the shared real-path check.
         if (!isWithin(root, abs))
             throw outside;
         const real = realpathSync(abs); // throws if missing
         const realRoot = realpathSync(root);
-        if (!isWithin(realRoot, real))
+        try {
+            assertPathWithinRoots(real, [realRoot]);
+        }
+        catch {
             throw outside;
+        }
         if (relative(realRoot, real).split(sep).some((segment) => segment.startsWith('.'))) {
             throw new Error(`Refusing to upload ${abs}: hidden files and files in hidden directories (dotfiles, credential stores) are never uploaded.`);
         }
@@ -160,7 +150,7 @@ export class NodeAttachmentIO {
             return null;
         }
     }
-    writeDownload(dest, bytes, { root, overwrite }) {
+    async writeDownload(dest, bytes, { root, overwrite }) {
         // The bytes are co-parent-supplied, so where they land is the security
         // boundary. Check the REAL path of the nearest existing ancestor before
         // creating anything, so a symlinked directory inside the root cannot carry
@@ -177,25 +167,35 @@ export class NodeAttachmentIO {
             chmodSync(root, 0o700);
         const realRoot = realpathSync(root);
         const parent = dirname(dest);
-        const anchor = realpathSync(deepestExisting(parent));
-        if (anchor !== realRoot && !isWithin(realRoot, anchor)) {
-            throw new Error(`Refusing to write ${dest}: it resolves outside the attachments directory (${root}).`);
+        const outside = () => new Error(`Refusing to write ${dest}: it resolves outside the attachments directory (${root}).`);
+        // Real path of the nearest existing ancestor (mcp-utils assertPathWithinRoots).
+        try {
+            assertPathWithinRoots(parent, [realRoot]);
+        }
+        catch {
+            throw outside();
         }
         mkdirSync(parent, { recursive: true, mode: 0o700 });
         if (overwrite) {
-            // unlink removes a symlink itself, never its target.
+            // Replace by unlink + exclusive create, NOT an O_TRUNC overwrite: unlink
+            // removes a symlink (or a hard link) itself, never its target, so a link
+            // planted at `dest` can't make "replace" rewrite a file elsewhere.
             try {
                 unlinkSync(dest);
             }
             catch { /* nothing there to replace */ }
         }
         try {
-            // 'wx' fails on ANY existing entry, a symlink (even dangling) included,
-            // so nothing already at `dest` is ever clobbered or followed.
-            writeFileSync(dest, bytes, { flag: 'wx', mode: 0o600 });
+            // writeFileSafe: an O_CREAT|O_EXCL|O_NOFOLLOW open, so ANY existing
+            // entry — a symlink (even dangling) included — is refused, never
+            // clobbered or followed. allowedRoots re-confines the parent at write
+            // time, closing the window since the check above (and the mkdir).
+            await writeFileSafe(dest, bytes, { mode: 0o600, allowedRoots: [realRoot] });
         }
         catch (e) {
-            if (e.code === 'EEXIST') {
+            if (e instanceof FileWriteRefusedError) {
+                if (e.reason === 'outside-roots')
+                    throw outside();
                 throw new Error(`Refusing to overwrite ${dest}: a file already exists there. Pass force:true to replace it, or choose another saveTo.`);
             }
             throw e;

package/dist/tools/calendar.js

@@ -215,7 +215,7 @@ export function registerCalendarTools(server, client) {
         });
     if (allowWrites)
         server.registerTool('ofw_update_event', {
-            description: 'Update an existing OurFamilyWizard calendar event. Fetches the event, applies the given changes, and writes the merged result back (OFW has no partial update). A change to an event the co-parent can see (shared before or after the change) is confirmed first; the confirmation is bound to the event exactly as read, so if it changes on OFW in between (say the co-parent edited it) the update is refused instead of overwriting their edit. ' + CONFIRM_NOTE,
+            description: 'Update an existing OurFamilyWizard calendar event. Fetches the event, applies the given changes, and writes the merged result back (OFW has no partial update). A change to an event the co-parent can see (shared before or after the change) is confirmed first; the confirmation is bound to the event exactly as read, so if it changes on OFW in between (say the co-parent edited it) the update is refused instead of overwriting their edit. If the write fails without a definitive answer, or lands but cannot be re-read to confirm it, the result is EVENT_UNCONFIRMED: the change may already be on OFW, so do NOT retry until ofw_list_events shows whether it landed. ' + CONFIRM_NOTE,
             annotations: { destructiveHint: true },
             inputSchema: z.object({
                 eventId: z.string().describe('Event id — the `id` from ofw_list_events / eventRecurrenceId from ofw_create_event'),
@@ -267,15 +267,37 @@ export function registerCalendarTools(server, client) {
                 if (gate)
                     return gate;
             }
-            await client.request('PUT', `/pub/v3/events/${id}`, payload);
+            try {
+                await requestWrite(client, 'PUT', `/pub/v3/events/${id}`, payload);
+            }
+            catch (e) {
+                if (!(e instanceof UnconfirmedWriteError))
+                    throw e;
+                return unconfirmedWriteResponse(e, {
+                    result: 'EVENT_UNCONFIRMED',
+                    what: `update event ${eventId}`,
+                    checkWith: 'ofw_list_events for this event and date range',
+                });
+            }
             // PUT responses aren't documented — re-fetch the detail as authoritative state.
-            const rawAfter = await client.request('GET', `/pub/v3/events/${id}`);
-            const event = parseLenient(eventDetailSchema, rawAfter, { label: 'ofw-mcp', context: `GET /pub/v3/events/${eventId} (post-update)`, mode: 'strict' });
-            return jsonResponse({ note: 'Event updated; returning re-fetched event state.', event });
+            // Once PUT succeeded, even a definitive rejection of this GET is not a
+            // rejection of the write. Do not present a failed verification as a safe retry.
+            try {
+                const rawAfter = await client.request('GET', `/pub/v3/events/${id}`);
+                const event = parseLenient(eventDetailSchema, rawAfter, { label: 'ofw-mcp', context: `GET /pub/v3/events/${eventId} (post-update)`, mode: 'strict' });
+                return jsonResponse({ note: 'Event updated; returning re-fetched event state.', event });
+            }
+            catch (e) {
+                return unconfirmedWriteResponse(new UnconfirmedWriteError(null, e), {
+                    result: 'EVENT_UNCONFIRMED',
+                    what: `verify the update to event ${eventId}`,
+                    checkWith: 'ofw_list_events for this event and date range',
+                });
+            }
         });
     if (allowWrites)
         server.registerTool('ofw_delete_event', {
-            description: 'Delete an OurFamilyWizard calendar event. Reads the event first; deleting one the co-parent can see is confirmed first, with a preview of exactly which event (title, date, time) is removed, and is refused if the event changed on OFW after that preview. ' + CONFIRM_NOTE,
+            description: 'Delete an OurFamilyWizard calendar event. Reads the event first; deleting one the co-parent can see is confirmed first, with a preview of exactly which event (title, date, time) is removed, and is refused if the event changed on OFW after that preview. If the request fails without a definitive answer the result is EVENT_UNCONFIRMED: the event may already be gone, so do NOT retry until ofw_list_events shows whether it is still there. ' + CONFIRM_NOTE,
             annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
             inputSchema: z.object({
                 eventId: z.string().describe('Event id — the `id` from ofw_list_events / eventRecurrenceId from ofw_create_event'),
@@ -309,7 +331,18 @@ export function registerCalendarTools(server, client) {
                 if (gate)
                     return gate;
             }
-            await client.request('DELETE', `/pub/v3/events/${id}?includeFuture=${includeFuture}`);
+            try {
+                await requestWrite(client, 'DELETE', `/pub/v3/events/${id}?includeFuture=${includeFuture}`);
+            }
+            catch (e) {
+                if (!(e instanceof UnconfirmedWriteError))
+                    throw e;
+                return unconfirmedWriteResponse(e, {
+                    result: 'EVENT_UNCONFIRMED',
+                    what: `delete event ${args.eventId}${includeFuture ? ' and its future occurrences' : ''}`,
+                    checkWith: 'ofw_list_events for this event and date range (including future occurrences if requested)',
+                });
+            }
             return textResponse(`Event ${args.eventId} ("${current.title}") deleted`);
         });
 }

package/dist/tools/messages.js

@@ -1630,7 +1630,7 @@ export function registerMessageTools(server, client, cacheProvider, attachmentIO
             }
         }
         const response = await client.requestBinary('GET', `/pub/v1/myfiles/${fileId}/data`);
-        attachmentIO.writeDownload(dest, response.body, { root, overwrite: args.force === true });
+        await attachmentIO.writeDownload(dest, response.body, { root, overwrite: args.force === true });
         await cache.markAttachmentDownloaded(fileId, dest);
         const fileName = response.suggestedFileName ?? cached.fileName;
         const mimeType = resolveDownloadMime(response.body, response.contentType ?? cached.mimeType, fileName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ofw-mcp",
-  "version": "2.20.0",
+  "version": "2.20.2",
   "license": "MIT",
   "mcpName": "io.github.chrischall/ofw-mcp",
   "description": "OurFamilyWizard MCP server for Claude — developed and maintained by AI (Claude Code)",
@@ -34,14 +34,14 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@chrischall/mcp-utils": "^2.8.0",
+    "@chrischall/mcp-utils": "^2.14.0",
     "@fetchproxy/bootstrap": "^3.4.1",
-    "@modelcontextprotocol/server": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.3.0",
     "dotenv": "^18.0.0",
     "zod": "^4.6.5"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/client": "^2.3.0",
     "@types/node": "^26.0.0",
     "@vitest/coverage-v8": "^5.0.0",
     "esbuild": "^0.28.0",

package/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/chrischall/ofw-mcp",
     "source": "github"
   },
-  "version": "2.20.0",
+  "version": "2.20.2",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "ofw-mcp",
-      "version": "2.20.0",
+      "version": "2.20.2",
       "transport": {
         "type": "stdio"
       },