@moxxy/plugin-mcp 0.26.0

package/dist/timeout.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Bounded connect/discovery timeout shared by every boot-time path that
+ * opens a connection and lists tools. The per-call timeout in `wrap.ts`
+ * (MCP_CALL_TIMEOUT_MS) only guards tool *invocations* — it does nothing
+ * for the connect()+listTools() handshake performed at session boot
+ * (refreshServerCache, eager createMcpPlugin) or on first lazy call. Without
+ * a cap, a single unreachable HTTP/SSE endpoint or a stdio child that spawns
+ * but never answers listTools blocks session boot forever (core awaits
+ * onInit serially), so one stale entry in mcp.json can make moxxy unstartable.
+ *
+ * 30s is generous for a real handshake (npx cold-start, slow proxy auth) but
+ * bounds the worst case to a skipped server rather than a wedged boot.
+ */
+export declare const MCP_CONNECT_TIMEOUT_MS: number;
+/**
+ * Race `work` against a hard timeout. On timeout the returned promise
+ * rejects; `work` itself is not cancellable here (the MCP SDK connect/list
+ * calls take no AbortSignal), so the caller is responsible for closing any
+ * handle that escapes after the reject. The timer is always cleared so it
+ * never keeps the event loop alive.
+ */
+export declare function withTimeout<T>(work: Promise<T>, ms: number, label: string): Promise<T>;
+//# sourceMappingURL=timeout.d.ts.map

package/dist/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,QAAY,CAAC;AAEhD;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,CAAC,CAAC,CAUZ"}

package/dist/timeout.js

@@ -0,0 +1,35 @@
+/**
+ * Bounded connect/discovery timeout shared by every boot-time path that
+ * opens a connection and lists tools. The per-call timeout in `wrap.ts`
+ * (MCP_CALL_TIMEOUT_MS) only guards tool *invocations* — it does nothing
+ * for the connect()+listTools() handshake performed at session boot
+ * (refreshServerCache, eager createMcpPlugin) or on first lazy call. Without
+ * a cap, a single unreachable HTTP/SSE endpoint or a stdio child that spawns
+ * but never answers listTools blocks session boot forever (core awaits
+ * onInit serially), so one stale entry in mcp.json can make moxxy unstartable.
+ *
+ * 30s is generous for a real handshake (npx cold-start, slow proxy auth) but
+ * bounds the worst case to a skipped server rather than a wedged boot.
+ */
+export const MCP_CONNECT_TIMEOUT_MS = 30 * 1000;
+/**
+ * Race `work` against a hard timeout. On timeout the returned promise
+ * rejects; `work` itself is not cancellable here (the MCP SDK connect/list
+ * calls take no AbortSignal), so the caller is responsible for closing any
+ * handle that escapes after the reject. The timer is always cleared so it
+ * never keeps the event loop alive.
+ */
+export async function withTimeout(work, ms, label) {
+    let timer;
+    const timeout = new Promise((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    });
+    try {
+        return await Promise.race([work, timeout]);
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+//# sourceMappingURL=timeout.js.map

package/dist/timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.js","sourceRoot":"","sources":["../src/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,EAAE,GAAG,IAAI,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,IAAgB,EAChB,EAAU,EACV,KAAa;IAEb,IAAI,KAAgD,CAAC;IACrD,MAAM,OAAO,GAAG,IAAI,OAAO,CAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE;QACtD,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,GAAG,KAAK,oBAAoB,EAAE,IAAI,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACtF,CAAC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;IAC7C,CAAC;YAAS,CAAC;QACT,IAAI,KAAK;YAAE,YAAY,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;AACH,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,59 @@
+export interface StdioServerConfig {
+    readonly kind?: 'stdio';
+    readonly name: string;
+    readonly command: string;
+    readonly args?: ReadonlyArray<string>;
+    readonly env?: Record<string, string>;
+    readonly cwd?: string;
+}
+export interface SseServerConfig {
+    readonly kind: 'sse';
+    readonly name: string;
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+}
+export interface StreamableHttpServerConfig {
+    readonly kind: 'http';
+    readonly name: string;
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+}
+export type McpServerConfig = StdioServerConfig | SseServerConfig | StreamableHttpServerConfig;
+export interface McpPluginOptions {
+    readonly servers: ReadonlyArray<McpServerConfig>;
+    readonly clientName?: string;
+    readonly clientVersion?: string;
+    readonly toolNamePrefix?: (serverName: string, toolName: string) => string;
+}
+export interface McpClientLike {
+    listTools(): Promise<{
+        tools: ReadonlyArray<McpToolDescriptor>;
+    }>;
+    callTool(args: {
+        name: string;
+        arguments: unknown;
+    }): Promise<McpCallResult>;
+    close(): Promise<void>;
+}
+export interface McpToolDescriptor {
+    readonly name: string;
+    readonly description?: string;
+    readonly inputSchema: unknown;
+}
+export interface McpCallResult {
+    readonly content?: ReadonlyArray<McpContentBlock>;
+    readonly isError?: boolean;
+}
+export type McpContentBlock = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'image';
+    readonly data: string;
+    readonly mimeType: string;
+} | {
+    readonly type: 'resource';
+    readonly resource: unknown;
+};
+export declare function defaultToolNamePrefix(serverName: string, toolName: string): string;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG,eAAe,GAAG,0BAA0B,CAAC;AAE/F,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IACjD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5E;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAA;KAAE,CAAC,CAAC;IAClE,QAAQ,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IAC7E,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,MAAM,MAAM,eAAe,GACvB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAChD;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAE9D,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAElF"}

package/dist/types.js

@@ -0,0 +1,4 @@
+export function defaultToolNamePrefix(serverName, toolName) {
+    return `mcp__${serverName}__${toolName}`;
+}
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAsDA,MAAM,UAAU,qBAAqB,CAAC,UAAkB,EAAE,QAAgB;IACxE,OAAO,QAAQ,UAAU,KAAK,QAAQ,EAAE,CAAC;AAC3C,CAAC"}

package/dist/wrap.d.ts

@@ -0,0 +1,23 @@
+import { type ToolDef } from '@moxxy/sdk';
+import { type McpClientLike, type McpServerConfig, type McpToolDescriptor } from './types.js';
+export interface WrapOptions {
+    readonly server: McpServerConfig;
+    readonly client: McpClientLike;
+    readonly toolNamePrefix?: (serverName: string, toolName: string) => string;
+}
+export declare function wrapMcpServerTools(opts: WrapOptions): Promise<ToolDef[]>;
+/**
+ * Build ToolDefs from CACHED descriptors without an open client. The
+ * provided `getClient` factory is invoked the first time any tool runs;
+ * the promise is cached so subsequent calls reuse the same connection.
+ * Enables instant TUI boot — connections only happen when the model
+ * actually invokes a tool from a given MCP server.
+ */
+export interface WrapLazyOptions {
+    readonly server: McpServerConfig;
+    readonly descriptors: ReadonlyArray<McpToolDescriptor>;
+    readonly getClient: () => Promise<McpClientLike>;
+    readonly toolNamePrefix?: (serverName: string, toolName: string) => string;
+}
+export declare function wrapMcpServerToolsLazy(opts: WrapLazyOptions): ToolDef[];
+//# sourceMappingURL=wrap.d.ts.map

package/dist/wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap.d.ts","sourceRoot":"","sources":["../src/wrap.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAC;AAgDpB,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5E;AAED,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAS9E;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC;IACjC,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC,iBAAiB,CAAC,CAAC;IACvD,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IACjD,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5E;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,EAAE,CAKvE"}

package/dist/wrap.js

@@ -0,0 +1,193 @@
+import { z } from 'zod';
+import { defineTool } from '@moxxy/sdk';
+import { defaultToolNamePrefix, } from './types.js';
+/**
+ * Hard cap on a single MCP tool call. The MCP SDK's `callTool` doesn't
+ * accept an AbortSignal, so without a timeout a hung server (crashed
+ * stdio child, dead websocket, blocked DB query) would hang the agent's
+ * tool-use loop indefinitely — leaving a permanent pending dot in the UI
+ * with no way to recover without killing moxxy. 5 minutes is enough room
+ * for slow operations (image generation, large queries) but bounded.
+ */
+const MCP_CALL_TIMEOUT_MS = 5 * 60 * 1000;
+/**
+ * Race the MCP call against (1) abort and (2) a hard timeout. Whichever
+ * settles first wins. If the underlying callTool ever does resolve after
+ * we've rejected, its result is silently discarded — the MCP SDK's
+ * cleanup is the SDK's problem.
+ */
+async function runMcpCallWithFallback(callPromise, signal, toolName) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const settle = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            signal.removeEventListener('abort', onAbort);
+            fn();
+        };
+        const onAbort = () => {
+            settle(() => reject(new Error(`aborted MCP tool "${toolName}"`)));
+        };
+        const timer = setTimeout(() => {
+            settle(() => reject(new Error(`MCP tool "${toolName}" timed out after ${MCP_CALL_TIMEOUT_MS}ms`)));
+        }, MCP_CALL_TIMEOUT_MS);
+        signal.addEventListener('abort', onAbort, { once: true });
+        callPromise.then((v) => settle(() => resolve(v)), (err) => settle(() => reject(err instanceof Error ? err : new Error(String(err)))));
+    });
+}
+export async function wrapMcpServerTools(opts) {
+    const prefix = opts.toolNamePrefix ?? defaultToolNamePrefix;
+    const list = await opts.client.listTools();
+    // Eager path: the connection is already open, so the resolver is a trivial
+    // thunk over the live client.
+    const resolveClient = () => Promise.resolve(opts.client);
+    return list.tools.map((descriptor) => wrapOneMcpTool(descriptor, opts.server.name, resolveClient, prefix));
+}
+export function wrapMcpServerToolsLazy(opts) {
+    const prefix = opts.toolNamePrefix ?? defaultToolNamePrefix;
+    return opts.descriptors.map((descriptor) => wrapOneMcpTool(descriptor, opts.server.name, opts.getClient, prefix));
+}
+/**
+ * Single tool builder shared by the eager and lazy paths. They differ only in
+ * how the client is obtained: the eager path passes a thunk over a live client,
+ * the lazy path passes a `getClient` factory that connects on first call (and
+ * caches the connection for subsequent calls). Everything else — name, schema,
+ * permission, abort checks, the timeout/abort race, and result rendering — is
+ * identical, so it lives here once.
+ */
+function wrapOneMcpTool(descriptor, serverName, resolveClient, prefix) {
+    const wrappedName = prefix(serverName, descriptor.name);
+    return defineTool({
+        name: wrappedName,
+        description: descriptor.description ?? `MCP tool ${descriptor.name} on server ${serverName}`,
+        inputSchema: z.record(z.string(), z.unknown()),
+        inputJsonSchema: descriptor.inputSchema ?? { type: 'object' },
+        permission: { action: 'prompt' },
+        handler: async (input, ctx) => {
+            if (ctx.signal.aborted)
+                throw new Error('aborted');
+            // The runtime Zod schema is a permissive record (so OpenAI accepts it),
+            // so whatever the model emits would otherwise reach the server verbatim.
+            // Fail fast with a readable message on an obviously-malformed call
+            // (missing required field / wrong primitive type) instead of forwarding
+            // garbage that may crash or hang the server (hitting the 5-min timeout).
+            const violation = validateAgainstSchema(input, descriptor.inputSchema);
+            if (violation)
+                return `[error] invalid arguments for ${descriptor.name}: ${violation}`;
+            // For the lazy path this pays the network/spawn cost only on first call
+            // (the factory caches its connection); for the eager path it resolves
+            // immediately to the already-open client.
+            const client = await resolveClient();
+            if (ctx.signal.aborted)
+                throw new Error('aborted');
+            const result = await runMcpCallWithFallback(client.callTool({ name: descriptor.name, arguments: input }), ctx.signal, wrappedName);
+            return renderResult(result.content, result.isError);
+        },
+    });
+}
+function renderResult(content, isError) {
+    const parts = [];
+    for (const block of content ?? []) {
+        if (block.type === 'text')
+            parts.push(block.text);
+        // Images still can't be surfaced through this string-returning handler
+        // (rich image passthrough would need the document/image ContentBlock
+        // path); keep the placeholder so the model at least knows one exists.
+        else if (block.type === 'image')
+            parts.push(`[image:${block.mimeType}]`);
+        else if (block.type === 'resource')
+            parts.push(renderResource(block.resource));
+    }
+    const text = parts.join('\n');
+    return isError ? `[error] ${text}` : text;
+}
+/**
+ * Surface an MCP resource block. A text resource (`resource.text`) is the
+ * whole point — passing it through stops the model getting a bare
+ * `[resource]` for content it could actually read. A binary/blob resource
+ * has no text representation here, so we annotate the placeholder with its
+ * uri/mimeType rather than swallow it silently.
+ */
+function renderResource(resource) {
+    if (resource && typeof resource === 'object') {
+        const r = resource;
+        if (typeof r.text === 'string')
+            return r.text;
+        const meta = [
+            typeof r.uri === 'string' ? r.uri : null,
+            typeof r.mimeType === 'string' ? r.mimeType : null,
+        ].filter((v) => v !== null);
+        if (meta.length > 0)
+            return `[resource:${meta.join(' ')}]`;
+    }
+    return `[resource]`;
+}
+/**
+ * Minimal, dependency-free guard for the model's tool input against the
+ * server's declared JSON Schema. We deliberately do NOT pull in a full
+ * JSON-Schema validator (ajv) — this only enforces the two cheap invariants
+ * that catch the common malformed-call cases: (1) every `required` property is
+ * present, and (2) any declared top-level primitive `type` matches. Anything
+ * the server's schema doesn't constrain (nested shapes, formats, enums) is
+ * left to the server, so a usable schema can't reject a structurally-valid
+ * call. Returns a human-readable reason on the first violation, or null.
+ */
+function validateAgainstSchema(input, schema) {
+    if (!schema || typeof schema !== 'object')
+        return null;
+    const s = schema;
+    // Only validate object schemas — the model always emits an object here.
+    if (s.type !== undefined && s.type !== 'object')
+        return null;
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        return 'expected an object';
+    }
+    const obj = input;
+    if (Array.isArray(s.required)) {
+        for (const key of s.required) {
+            if (typeof key === 'string' && !(key in obj)) {
+                return `missing required field "${key}"`;
+            }
+        }
+    }
+    if (s.properties && typeof s.properties === 'object') {
+        const props = s.properties;
+        for (const [key, value] of Object.entries(obj)) {
+            const propSchema = props[key];
+            if (!propSchema || typeof propSchema !== 'object')
+                continue;
+            const expected = propSchema.type;
+            if (typeof expected !== 'string')
+                continue;
+            if (!matchesPrimitiveType(value, expected)) {
+                return `field "${key}" must be of type ${expected}`;
+            }
+        }
+    }
+    return null;
+}
+/** True when `value` satisfies a JSON-Schema primitive `type` keyword. */
+function matchesPrimitiveType(value, type) {
+    switch (type) {
+        case 'string':
+            return typeof value === 'string';
+        case 'number':
+            return typeof value === 'number' && Number.isFinite(value);
+        case 'integer':
+            return typeof value === 'number' && Number.isInteger(value);
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'object':
+            return typeof value === 'object' && value !== null && !Array.isArray(value);
+        case 'array':
+            return Array.isArray(value);
+        case 'null':
+            return value === null;
+        default:
+            // Unknown/unsupported type keyword — don't reject (server decides).
+            return true;
+    }
+}
+//# sourceMappingURL=wrap.js.map

package/dist/wrap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap.js","sourceRoot":"","sources":["../src/wrap.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@moxxy/plugin-mcp",
+  "version": "0.26.0",
+  "description": "MCP (Model Context Protocol) client plugin for moxxy — connect to MCP servers and surface their tools.",
+  "keywords": [
+    "moxxy",
+    "agent",
+    "mcp",
+    "tools",
+    "model-context-protocol"
+  ],
+  "homepage": "https://moxxy.ai",
+  "bugs": {
+    "url": "https://github.com/moxxy-ai/moxxy/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moxxy-ai/moxxy.git",
+    "directory": "packages/plugin-mcp"
+  },
+  "author": "Michal Makowski <michal.makowski97@gmail.com>",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "moxxy": {
+    "plugin": {
+      "entry": "./dist/index.js",
+      "kind": "mcp"
+    }
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.24.0",
+    "@moxxy/sdk": "0.26.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8",
+    "@moxxy/vitest-preset": "0.0.0",
+    "@moxxy/tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "clean": "rm -rf dist .turbo"
+  }
+}

package/src/admin/config-io.test.ts

@@ -0,0 +1,188 @@
+import { promises as fs } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  mcpConfigPath,
+  mutateMcpConfig,
+  readMcpConfig,
+  removeServerFromConfig,
+  setServerDisabled,
+  writeMcpConfig,
+} from './config-io.js';
+import type { McpStoredConfig } from './types.js';
+
+// config-io derives every path from moxxyPath(), which honors $MOXXY_HOME.
+// Point it at a fresh tmp dir per test so we never touch the real ~/.moxxy.
+describe('admin/config-io', () => {
+  let home: string;
+  const original = process.env.MOXXY_HOME;
+
+  beforeEach(async () => {
+    home = await mkdtemp(join(tmpdir(), 'moxxy-mcp-cfg-'));
+    process.env.MOXXY_HOME = home;
+  });
+
+  afterEach(async () => {
+    if (original === undefined) delete process.env.MOXXY_HOME;
+    else process.env.MOXXY_HOME = original;
+    await rm(home, { recursive: true, force: true });
+  });
+
+  it('writeMcpConfig -> readMcpConfig is a faithful atomic round-trip', async () => {
+    const cfg: McpStoredConfig = {
+      servers: [
+        { kind: 'stdio', name: 'fs', command: 'npx', args: ['-y', 'srv'] },
+        {
+          kind: 'http',
+          name: 'remote',
+          url: 'https://example.test/mcp',
+          // Opaque extras must survive the round-trip via .passthrough().
+          cachedTools: [{ name: 'ping', description: 'pong', inputSchema: { type: 'object' } }],
+          disabled: true,
+        } as never,
+      ],
+    };
+    await writeMcpConfig(cfg);
+    const back = await readMcpConfig();
+    expect(back).toEqual(cfg);
+  });
+
+  it('writes a trailing newline and leaves no temp file behind', async () => {
+    await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+    const raw = await fs.readFile(mcpConfigPath(), 'utf8');
+    expect(raw.endsWith('\n')).toBe(true);
+    const entries = await fs.readdir(home);
+    expect(entries.filter((n) => n.includes('.tmp'))).toEqual([]);
+  });
+
+  it('readMcpConfig returns an empty catalog when the file is absent', async () => {
+    expect(await readMcpConfig()).toEqual({ servers: [] });
+  });
+
+  it('discards malformed JSON without throwing and leaves the bad file in place', async () => {
+    await fs.writeFile(mcpConfigPath(), '{ this is not json', 'utf8');
+    expect(await readMcpConfig()).toEqual({ servers: [] });
+    // Bad file preserved for the user to inspect.
+    expect(await fs.readFile(mcpConfigPath(), 'utf8')).toBe('{ this is not json');
+  });
+
+  it('discards a structurally-invalid (Zod-failing) config without throwing', async () => {
+    // A whole row with no usable name is dropped (per-entry), and a top-level
+    // shape error (servers not an array) falls back to empty rather than crash.
+    await fs.writeFile(mcpConfigPath(), JSON.stringify({ servers: [{ name: '' }] }), 'utf8');
+    expect(await readMcpConfig()).toEqual({ servers: [] });
+
+    await fs.writeFile(mcpConfigPath(), JSON.stringify({ servers: 'nope' }), 'utf8');
+    expect(await readMcpConfig()).toEqual({ servers: [] });
+  });
+
+  it('keeps valid servers when one entry is malformed (u85-6: no whole-catalog wipe)', async () => {
+    // One good row + one nameless row. The bad row must drop ALONE — the
+    // valid server has to survive boot/list/enable/remove, not vanish.
+    await fs.writeFile(
+      mcpConfigPath(),
+      JSON.stringify({
+        servers: [
+          { kind: 'stdio', name: 'good', command: 'x' },
+          { kind: 'stdio', name: '', command: 'y' },
+        ],
+      }),
+      'utf8',
+    );
+    const back = await readMcpConfig();
+    expect(back.servers.map((s) => s.name)).toEqual(['good']);
+    expect(back.servers[0]).toMatchObject({ kind: 'stdio', name: 'good', command: 'x' });
+  });
+
+  describe('setServerDisabled', () => {
+    it('toggles the disabled flag and returns the updated entry', async () => {
+      await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+      const disabled = await setServerDisabled('a', true);
+      expect(disabled).toMatchObject({ name: 'a', disabled: true });
+      expect((await readMcpConfig()).servers[0]).toMatchObject({ name: 'a', disabled: true });
+
+      const enabled = await setServerDisabled('a', false);
+      expect(enabled).toMatchObject({ name: 'a', disabled: false });
+      expect((await readMcpConfig()).servers[0]).toMatchObject({ name: 'a', disabled: false });
+    });
+
+    it('leaves sibling entries and per-entry fields untouched', async () => {
+      await writeMcpConfig({
+        servers: [
+          { kind: 'stdio', name: 'a', command: 'x', args: ['--keep'] } as never,
+          { kind: 'http', name: 'b', url: 'https://b.test' },
+        ],
+      });
+      await setServerDisabled('a', true);
+      const cfg = await readMcpConfig();
+      expect(cfg.servers[0]).toMatchObject({ name: 'a', command: 'x', args: ['--keep'], disabled: true });
+      expect(cfg.servers[1]).toEqual({ kind: 'http', name: 'b', url: 'https://b.test' });
+    });
+
+    it('returns null for an unknown server', async () => {
+      await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+      expect(await setServerDisabled('ghost', true)).toBeNull();
+    });
+
+    it('does not rewrite the file when the server is unknown (no-op skip)', async () => {
+      await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+      const before = await fs.stat(mcpConfigPath());
+      await new Promise((r) => setTimeout(r, 10));
+      expect(await setServerDisabled('ghost', true)).toBeNull();
+      const after = await fs.stat(mcpConfigPath());
+      expect(after.mtimeMs).toBe(before.mtimeMs);
+    });
+  });
+
+  describe('removeServerFromConfig', () => {
+    it('drops a server by name and reports the change', async () => {
+      await writeMcpConfig({
+        servers: [
+          { kind: 'stdio', name: 'a', command: 'x' },
+          { kind: 'stdio', name: 'b', command: 'y' },
+        ],
+      });
+      expect(await removeServerFromConfig('a')).toBe(true);
+      expect((await readMcpConfig()).servers.map((s) => s.name)).toEqual(['b']);
+    });
+
+    it('returns false (and changes nothing) for an unknown name', async () => {
+      await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+      expect(await removeServerFromConfig('ghost')).toBe(false);
+      expect((await readMcpConfig()).servers.map((s) => s.name)).toEqual(['a']);
+    });
+  });
+
+  describe('mutateMcpConfig', () => {
+    it('skips the write entirely when the mutator returns the same reference (no-op)', async () => {
+      await writeMcpConfig({ servers: [{ kind: 'stdio', name: 'a', command: 'x' }] });
+      const before = await fs.stat(mcpConfigPath());
+      // Ensure mtime can differ if a write were to happen.
+      await new Promise((r) => setTimeout(r, 10));
+      const result = await mutateMcpConfig((cfg) => ({ next: cfg, result: 'noop' }));
+      expect(result).toBe('noop');
+      const after = await fs.stat(mcpConfigPath());
+      expect(after.mtimeMs).toBe(before.mtimeMs);
+    });
+
+    it('serializes concurrent mutators so neither read+write interleaves', async () => {
+      await writeMcpConfig({ servers: [] });
+      // Fire two adds concurrently. The mutex must serialize the
+      // read-modify-write so both land — a lost update would drop one.
+      await Promise.all([
+        mutateMcpConfig((cfg) => ({
+          next: { servers: [...cfg.servers, { kind: 'stdio', name: 'a', command: 'x' }] },
+          result: undefined,
+        })),
+        mutateMcpConfig((cfg) => ({
+          next: { servers: [...cfg.servers, { kind: 'stdio', name: 'b', command: 'y' }] },
+          result: undefined,
+        })),
+      ]);
+      const names = (await readMcpConfig()).servers.map((s) => s.name).sort();
+      expect(names).toEqual(['a', 'b']);
+    });
+  });
+});