@plitzi/sdk-server 0.32.9 → 0.32.11

package/dist/modules/mcp/resources/register.js

@@ -4,7 +4,7 @@ import { resourceErrorMessage } from "./canonical.js";
 import { envelope, jsonContents } from "./envelope.js";
 import { readResource } from "./router.js";
 import { registerRenderResources } from "./renderGuide.js";
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/resources/register.ts
 /** Register every resource on the MCP server: fixed listings plus templated per-item reads. The space is
 *  loaded lazily via getSpace, so listing resources never touches the store — only reading one does. */
@@ -21,19 +21,25 @@ var registerResources = (server, getSpace, env, log) => {
 			throw error;
 		}
 	};
+	const emitStatic = (uri, read) => {
+		const start = performance.now();
+		const result = read();
+		log.resourceRead(uri, performance.now() - start);
+		return result;
+	};
 	server.registerResource("Guide", "plitzi://guide", {
 		description: "How to read and write this space with mcp-ai",
 		mimeType: "text/markdown"
-	}, () => ({ contents: [{
+	}, () => emitStatic("plitzi://guide", () => ({ contents: [{
 		uri: "plitzi://guide",
 		mimeType: "text/markdown",
 		text: guideText
-	}] }));
+	}] })));
 	server.registerResource("CSS properties", "plitzi://css-properties", {
 		description: "Valid kebab-case CSS property keys",
 		mimeType: "application/json"
-	}, () => jsonContents("plitzi://css-properties", envelope(cssProperties)));
-	registerRenderResources(server);
+	}, () => emitStatic("plitzi://css-properties", () => jsonContents("plitzi://css-properties", envelope(cssProperties))));
+	registerRenderResources(server, log);
 	const fixed = [
 		[
 			"Primer",

package/dist/modules/mcp/resources/renderGuide.js

@@ -168,19 +168,29 @@ connects that source to a descendant's field.
 The tool returns \`rendered: false\` with \`errors: [{ path, message, hint }]\`. Read the hint, fix that one op, and
 retry — you never lose the rest of the batch.
 `;
-var registerRenderResources = (server) => {
+var registerRenderResources = (server, log) => {
 	server.registerResource("Render guide", RENDER_GUIDE_URI, {
 		description: "How to author a plitzi_render widget: operations, element types, styling, examples.",
 		mimeType: "text/markdown"
-	}, () => ({ contents: [{
-		uri: RENDER_GUIDE_URI,
-		mimeType: "text/markdown",
-		text: renderGuideText
-	}] }));
+	}, () => {
+		const start = performance.now();
+		const contents = { contents: [{
+			uri: RENDER_GUIDE_URI,
+			mimeType: "text/markdown",
+			text: renderGuideText
+		}] };
+		log.resourceRead(RENDER_GUIDE_URI, performance.now() - start);
+		return contents;
+	});
 	server.registerResource("Render element types", RENDER_TYPES_URI, {
 		description: "Built-in element types a plitzi_render widget can use, with descriptions.",
 		mimeType: "application/json"
-	}, () => jsonContents(RENDER_TYPES_URI, envelope(renderTypes())));
+	}, () => {
+		const start = performance.now();
+		const contents = jsonContents(RENDER_TYPES_URI, envelope(renderTypes()));
+		log.resourceRead(RENDER_TYPES_URI, performance.now() - start);
+		return contents;
+	});
 };
 //#endregion
 export { RENDER_GUIDE_URI, RENDER_TYPES_URI, registerRenderResources };

package/dist/modules/mcp/server.js

@@ -1,18 +1,19 @@
+import { registerApps } from "./apps/index.js";
 import { emptySpace, emptySpaceMessage, unauthorizedSpaceMessage } from "./helpers/space.js";
 import { serverInstructions } from "./helpers/guide.js";
 import { createMcpLog } from "./helpers/log.js";
 import { registerResources } from "./resources/register.js";
-import { registerRenderApp } from "./resources/renderApp.js";
 import { tools } from "./tools/index.js";
 import { isCallToolResult } from "../ai/toolkit.js";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
+import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/server.ts
 var MCP_ENV = "main";
 var asText = (data) => ({ content: [{
 	type: "text",
 	text: JSON.stringify(data)
 }] });
-var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, renderApp }) => {
+var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger }) => {
 	const log = createMcpLog(logger);
 	let spaceIdPromise;
 	const requireSpaceId = () => spaceIdPromise ??= getSpaceId().then((id) => {
@@ -42,10 +43,10 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.32.9"
+		version: "0.32.11"
 	}, { instructions: serverInstructions });
 	registerResources(server, getSpace, MCP_ENV, log);
-	if (renderApp) registerRenderApp(server, renderApp.sdkBase, renderApp.devMode ?? false);
+	registerApps(server);
 	const toolContext = async () => ({
 		space: await getSpace(),
 		env: MCP_ENV,
@@ -63,12 +64,7 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 	});
 	for (const tool of tools) {
 		if (tool.requires === "screenshot" && !screenshot) continue;
-		server.registerTool(tool.name, {
-			title: tool.title,
-			description: tool.description,
-			inputSchema: tool.inputShape,
-			...tool.ui && renderApp ? { _meta: { ui: tool.ui } } : {}
-		}, async (args) => {
+		const run = async (args) => {
 			const start = performance.now();
 			try {
 				const result = await tool.execute(args, tool.spaceless ? spacelessContext() : await toolContext());
@@ -78,7 +74,20 @@ var createMcpServer = ({ adapters, getSpaceId, preview, screenshot, logger, rend
 				log.toolCall(tool.name, args, performance.now() - start, error);
 				throw error;
 			}
-		});
+		};
+		const config = {
+			title: tool.title,
+			description: tool.description,
+			inputSchema: tool.inputShape
+		};
+		if (tool.ui) {
+			registerAppTool(server, tool.name, {
+				...config,
+				_meta: { ui: tool.ui }
+			}, run);
+			continue;
+		}
+		server.registerTool(tool.name, config, run);
 	}
 	return server;
 };

package/dist/modules/mcp/tools/apply/index.js

@@ -6,7 +6,7 @@ import { defineTool } from "../shared/tool.js";
 import { validateOperations } from "../shared/validator/index.js";
 import { auditResources } from "../shared/validator/audit.js";
 import { z } from "zod";
-import { validateSchema } from "@plitzi/sdk-schema";
+import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
 //#region src/modules/mcp/tools/apply/index.ts
 var applyShape = {
 	environment,

package/dist/modules/mcp/tools/render.js

@@ -1,12 +1,12 @@
+import { RENDER_APP_URI } from "../apps/render/index.js";
 import { emptySpace } from "../helpers/space.js";
-import { RENDER_APP_URI } from "../resources/renderApp.js";
 import { operations } from "./operations/index.js";
 import { applyOperations } from "./apply/dispatch.js";
 import { defineTool } from "./shared/tool.js";
 import { validateOperations } from "./shared/validator/index.js";
 import { auditResources } from "./shared/validator/audit.js";
-import { validateSchema } from "@plitzi/sdk-schema";
-import { generateCache } from "@plitzi/sdk-style";
+import { validateSchema } from "@plitzi/sdk-schema/helpers/schemaValidator";
+import { generateCache } from "@plitzi/sdk-style/StyleHelper";
 //#region src/modules/mcp/tools/render.ts
 var HOST_PAGE_REF = "render";
 var seedSpace = () => {

package/dist/modules/ssr/registerExternalPlugins.js

@@ -1,6 +1,6 @@
+import path from "node:path";
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
-import path from "node:path";
 //#region src/modules/ssr/registerExternalPlugins.ts
 var MANIFEST_TTL_MS = 600 * 1e3;
 var manifestCache = /* @__PURE__ */ new Map();

package/dist/modules/ssr/template.js

@@ -1,6 +1,6 @@
 import path from "node:path";
-import fs from "node:fs";
 import { fileURLToPath } from "node:url";
+import fs from "node:fs";
 import ejs from "ejs";
 //#region src/modules/ssr/template.ts
 var __dirname = path.dirname(fileURLToPath(import.meta.url));

package/dist/plugins/compile.js

@@ -1,6 +1,6 @@
-import fs from "node:fs/promises";
 import path from "node:path";
 import esbuild from "esbuild";
+import fs from "node:fs/promises";
 //#region src/plugins/compile.ts
 var EXTERNAL = [
 	"react",

package/dist/plugins/copy.js

@@ -1,5 +1,5 @@
-import fs from "node:fs/promises";
 import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/plugins/copy.ts
 var copyPlugin = async (src, destDir, filename) => {
 	const dest = path.join(destDir, filename);

package/dist/plugins/manager.js

@@ -1,8 +1,9 @@
 import { compilePlugin } from "./compile.js";
 import { copyPlugin } from "./copy.js";
 import { detectAction, isComponentSource } from "./detect.js";
-import fs from "node:fs/promises";
+import { assertPluginSources } from "./validate.js";
 import path from "node:path";
+import fs from "node:fs/promises";
 //#region src/plugins/manager.ts
 var META_FILE = "meta.json";
 var DEFAULT_TTL_MS = 10080 * 60 * 1e3;
@@ -19,6 +20,7 @@ var PluginManager = class {
 	nameIndex = /* @__PURE__ */ new Map();
 	devMode = false;
 	constructor(plugins, cacheDir, ttlMs, devMode = false) {
+		assertPluginSources(plugins);
 		this.plugins = plugins;
 		this.outputDir = path.resolve(process.cwd(), cacheDir ?? DEFAULT_CACHE_DIR);
 		this.ttlMs = ttlMs ?? DEFAULT_TTL_MS;

package/dist/plugins/validate.js

@@ -0,0 +1,23 @@
+import { isComponentSource } from "./detect.js";
+import fs from "node:fs";
+//#region src/plugins/validate.ts
+var isRemote = (js) => js.startsWith("http://") || js.startsWith("https://");
+/** The file a plugin source needs on disk, or null when nothing local is involved — a remote URL (fetched and
+*  cached at request time) or a component handed in directly. */
+var localSourcePath = (source) => {
+	if (isComponentSource(source) || isRemote(source.js)) return null;
+	return source.js;
+};
+/** Fail at boot on a plugin whose entry file is missing. A plugin entry is a plain string path in the server
+*  config, so nothing — not tsc, not eslint — notices when that file is moved or deleted; without this check the
+*  server starts happily and only dies on the first render that needs the plugin, with an esbuild resolve error
+*  far from its cause. */
+var assertPluginSources = (plugins) => {
+	const missing = Object.entries(plugins).map(([name, source]) => ({
+		name,
+		file: localSourcePath(source)
+	})).filter((entry) => entry.file !== null && !fs.existsSync(entry.file)).map((entry) => `  ${entry.name}: ${entry.file ?? ""}`);
+	if (missing.length > 0) throw new Error(`Plugin entry file not found (declared in the server config):\n${missing.join("\n")}`);
+};
+//#endregion
+export { assertPluginSources, localSourcePath };

package/dist/src/core/http/dispatcher.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/core/http/types.d.ts

@@ -10,6 +10,9 @@ export interface BaseContext {
     res: SSRResponseHelpers;
     config: SSRServerConfig;
     port: number;
+    /** Set by the stage that answers when the path alone does not identify the work (the MCP endpoint serves every
+     *  JSON-RPC method on the same URL). The dispatcher folds it into the access log. */
+    operation?: string;
 }
 export interface SSRContext extends BaseContext {
     renderFn: SSRTemplateFn;

package/dist/src/core/requestParser.d.ts

@@ -1,4 +1,7 @@
 import { SSRRequest } from '@plitzi/sdk-shared';
 import { IncomingMessage } from 'node:http';
 export declare const parseRequest: (raw: IncomingMessage) => SSRRequest;
+/** The public origin the request was addressed to (proxy-aware via x-forwarded-proto, port included), or an empty
+ *  string when the request carries no usable authority. */
+export declare const requestOrigin: (req: SSRRequest) => string;
 export declare const readRawBody: (raw: IncomingMessage) => Promise<string>;

package/dist/src/helpers/buildResponseHelpers.d.ts

@@ -1,6 +1,8 @@
 import { SSRResponseHelpers } from '@plitzi/sdk-shared';
 export type RawResponse = {
     headersSent: boolean;
+    /** The status actually written to the wire — the access log reads it once the response is out. */
+    statusCode: number;
     setHeader(name: string, value: string | number | readonly string[]): unknown;
     getHeaders(): Record<string, string | number | readonly string[]>;
     writeHead(statusCode: number, headers?: Record<string, string | number | readonly string[]>): unknown;

package/dist/src/helpers/serverLog.d.ts

@@ -0,0 +1,10 @@
+import { ServerLogEvent, ServerLogger } from '@plitzi/sdk-shared';
+/** One line for any {@link ServerLogEvent}: an HTTP request reads as an access-log line
+ *  (`[SSR] GET /pricing 200 12ms ok`), the MCP events as what happened inside one
+ *  (`[mcp] tools/call plitzi_apply {operations:[3]} 41ms ok`). Events arrive PII-free — the dispatcher strips
+ *  query values and collects no headers, cookies or IPs, and tool args are summarised by shape — so rendering is
+ *  a pure format. */
+export declare const renderLogEvent: (event: ServerLogEvent) => string;
+/** A drop-in `SSRServerConfig.logger` for consumers that just want the log on the console. Consumers with their
+ *  own logging stack should pass their own sink instead and read the structured event. */
+export declare const consoleLogger: ServerLogger;

package/dist/src/index.d.ts

@@ -1,5 +1,6 @@
 export { createServer, createSSRServer, createMCPServer, resolveServices } from './core/createServer';
 export { registerHealthCheck, buildHealthPayload } from './core/health';
+export { consoleLogger, renderLogEvent } from './helpers/serverLog';
 export type { HealthCheckApp, HealthIdentity } from './core/health';
 export { createJsonAdapters } from './adapters/jsonAdapters';
 export { AIEngine, toolResponseOk, toolResponseErr, zodToJsonSchema, getAllowedModes, bindTools, isToolActive, resolveToolHandler, isCallToolResult, toolResponseFromResult } from './modules/ai';
@@ -8,7 +9,7 @@ export { createPreview, createMemoryDraftStore, PREVIEW_TOKEN_PARAM } from './mo
 export { apply, search, read, validate, applyShape, searchShape, readShape, validateShape, operation, tools } from './modules/mcp/tools';
 export type { JsonAdaptersConfig } from './adapters/jsonAdapters';
 export type { ResolvedServices } from './core/createServer';
-export type { McpServerContext, PreviewClient, PreviewRequestBody, PreviewResult, HttpPreviewClientConfig, ScreenshotClient, ScreenshotImage, ScreenshotResult, Viewport, HttpScreenshotClientConfig } from './modules/mcp';
+export type { McpServerContext, McpRequestOptions, PreviewClient, PreviewRequestBody, PreviewResult, HttpPreviewClientConfig, ScreenshotClient, ScreenshotImage, ScreenshotResult, Viewport, HttpScreenshotClientConfig } from './modules/mcp';
 export type { ApplyInput, SearchInput, SearchResponse, SearchHit, ReadInput, ReadResponse, ReadHit, ValidateInput, WriteResponse, WriteElement, Persisters, Operation, ToolDef, ToolContext } from './modules/mcp/tools';
 export type { Space } from './modules/mcp/helpers';
 export type { Env } from './modules/mcp/types';

package/dist/src/mcp.d.ts

@@ -0,0 +1,14 @@
+/** The MCP role's entry point: everything an MCP deployment wires, and nothing else.
+ *
+ *  Import it as `@plitzi/sdk-server/mcp`. The package root is a barrel over every service (SSR, RSC, plugins, the
+ *  AI engine…), so pulling `createMCPServer` from there makes the process load that whole graph — including the
+ *  React element packages its types come from — where this entry loads only the MCP server. */
+export { createMCPServer } from './core/server/mcpServer';
+export { consoleLogger, renderLogEvent } from './helpers/serverLog';
+export { createMcpServer, handleMcp, serveMcp, readMcpBody } from './modules/mcp/handler';
+export { createHttpPreviewClient } from './modules/mcp/previewClient';
+export { createHttpScreenshotClient } from './modules/mcp/screenshotClient';
+export type { McpRequestOptions } from './modules/mcp/handler';
+export type { McpServerContext } from './modules/mcp/server';
+export type { PreviewClient, ScreenshotClient } from './modules/mcp/types';
+export type { HealthIdentity } from './core/health';

package/dist/src/modules/mcp/apps/apps.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/apps/example/index.d.ts

@@ -0,0 +1,8 @@
+import { McpApp } from '../../types';
+/** The reference app: the smallest definition that works, kept as the template a new app is copied from.
+ *
+ *  It is deliberately NOT in the `apps` list — nothing renders it, since no tool points at it — so it costs a
+ *  real deployment nothing while the test suite still builds it, which is what keeps it from rotting. To turn it
+ *  into a real app: add it to `apps` in ../index.ts and give a tool `ui: { resourceUri: EXAMPLE_APP_URI }`. */
+export declare const EXAMPLE_APP_URI = "ui://plitzi/example.html";
+export declare const exampleApp: McpApp;

package/dist/src/modules/mcp/apps/example/view.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/apps/index.d.ts

@@ -0,0 +1,8 @@
+import { McpApp } from '../types';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Every MCP App this server serves. A new one is a folder beside `render/` (its definition + its view) and one
+ *  line here — the tool that opens it points at its `uri` through `ui: { resourceUri }`. Start from `example/`,
+ *  which is that same shape stripped to the minimum. */
+export declare const apps: McpApp[];
+export declare const registerApps: (server: McpServer) => void;
+export { RENDER_APP_URI } from './render';

package/dist/src/modules/mcp/apps/render/index.d.ts

@@ -0,0 +1,3 @@
+import { McpApp } from '../../types';
+export declare const RENDER_APP_URI = "ui://plitzi/render.html";
+export declare const renderApp: McpApp;

package/dist/src/modules/mcp/apps/render/view.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/apps/shared/bundle.d.ts

@@ -0,0 +1 @@
+export declare const bundle: (entry: string) => Promise<string>;

package/dist/src/modules/mcp/apps/shared/index.d.ts

@@ -0,0 +1,2 @@
+export { registerApp } from './registerApp';
+export { require } from './resolve';

package/dist/src/modules/mcp/apps/shared/page.d.ts

@@ -0,0 +1,2 @@
+import { McpApp } from '../../types';
+export declare const page: (app: McpApp) => Promise<string>;

package/dist/src/modules/mcp/apps/shared/registerApp.d.ts

@@ -0,0 +1,5 @@
+import { McpApp } from '../../types';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Serves the app as a self-contained page: no import map, no asset mounts, no cross-origin fetches, so the
+ *  strictest host sandbox runs it and no deployment has to serve anything extra. */
+export declare const registerApp: (server: McpServer, app: McpApp) => void;

package/dist/src/modules/mcp/apps/shared/resolve.d.ts

@@ -0,0 +1 @@
+export declare const require: NodeJS.Require;

package/dist/src/modules/mcp/apps/shared/zodEnglishOnly.d.ts

@@ -0,0 +1,4 @@
+import { Plugin } from 'esbuild';
+/** Drops zod's ~40 translations (194 KB): they are re-exported as a namespace, which no bundler can tree-shake.
+ *  English survives because zod imports `locales/en.js` directly, not through this index. */
+export declare const zodEnglishOnly: Plugin;

package/dist/src/modules/mcp/e2e/connector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/e2e/host.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/modules/mcp/e2e/index.d.ts

@@ -0,0 +1,6 @@
+/** An MCP Apps host in two halves, so the App can be exercised without Claude Desktop or ChatGPT: the CONNECTOR
+ *  (a real MCP client over Streamable HTTP) and the RENDERER (the ui:// page in a DOM, driven by AppBridge). */
+export { readAppPage, startMcpEndpoint } from './mcpEndpoint';
+export { startRenderingHost } from './renderingHost';
+export type { AppPage, McpEndpoint } from './mcpEndpoint';
+export type { RenderingHost } from './renderingHost';

package/dist/src/modules/mcp/e2e/mcpEndpoint.d.ts

@@ -0,0 +1,20 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+/** A live MCP endpoint on loopback — the same handler a deployment serves, transport and all. */
+export interface McpEndpoint {
+    url: string;
+    client: Client;
+    /** Raw fetch, for the probes a connector fires outside the JSON-RPC session. */
+    request: (init?: RequestInit & {
+        path?: string;
+    }) => Promise<Response>;
+    close: () => Promise<void>;
+}
+export interface AppPage {
+    html: string;
+    mimeType?: string;
+    meta?: Record<string, unknown>;
+}
+/** Start the endpoint and connect a real MCP client to it, as a remote connector does. */
+export declare const startMcpEndpoint: () => Promise<McpEndpoint>;
+/** Read a ui:// resource. A page that came back as a blob is a bug a host would meet as a blank frame. */
+export declare const readAppPage: (endpoint: McpEndpoint, uri: string) => Promise<AppPage>;

package/dist/src/modules/mcp/e2e/postMessageChannel.d.ts

@@ -0,0 +1,22 @@
+import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+import { JSDOM } from 'jsdom';
+export interface ParentStub {
+    postMessage: (message: unknown) => void;
+    attach: (deliver: (message: unknown) => void) => void;
+}
+/** Stands in for the window an iframe posts to. It BUFFERS: the page starts parsing the moment the DOM is built,
+ *  so without the queue its `ui/initialize` is dropped and the handshake silently never completes. */
+export declare const parentStub: () => ParentStub;
+/** The host end of that channel, as a transport an AppBridge can connect to. */
+export declare class HostBridgeTransport implements Transport {
+    private readonly window;
+    private readonly parent;
+    onmessage?: (message: JSONRPCMessage) => void;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    constructor(window: JSDOM['window'], parent: ParentStub);
+    start(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/modules/mcp/e2e/renderingHost.d.ts

@@ -0,0 +1,14 @@
+import { AppBridge } from '@modelcontextprotocol/ext-apps/app-bridge';
+import { JSDOM } from 'jsdom';
+import { McpUiHostContext, McpUiToolResultNotification } from '@modelcontextprotocol/ext-apps';
+export interface RenderingHost {
+    bridge: AppBridge;
+    window: JSDOM['window'];
+    /** Deliver a tool result and let the App paint before assertions run. */
+    showResult: (result: McpUiToolResultNotification['params']) => Promise<void>;
+    text: () => string;
+    close: () => void;
+}
+/** Load a ui:// page into a DOM and complete the MCP Apps handshake against it, through the official AppBridge.
+ *  Resolves once the App is connected, so a test can push a tool result straight away. */
+export declare const startRenderingHost: (html: string, hostContext?: McpUiHostContext) => Promise<RenderingHost>;

package/dist/src/modules/mcp/handler.d.ts

@@ -1,12 +1,16 @@
 import { createMcpServer } from './server';
 import { PreviewClient, ScreenshotClient } from './types';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
-import { SSRAdapters, SSRRequest, McpLogger } from '@plitzi/sdk-shared';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSRAdapters, SSRRequest, ServerLogger } from '@plitzi/sdk-shared';
 import { IncomingMessage, ServerResponse } from 'node:http';
+/** Per-request wiring the MCP service does not resolve itself: the renderer clients and the log sink. Everything
+ *  here is optional — the service degrades feature by feature. */
+export type McpRequestOptions = {
+    preview?: PreviewClient;
+    screenshot?: ScreenshotClient;
+    logger?: ServerLogger;
+};
 export declare const readMcpBody: (req: IncomingMessage) => Promise<unknown>;
-export declare const serveMcp: (raw: IncomingMessage, res: ServerResponse, server: McpServer) => Promise<void>;
-export declare const handleMcp: (raw: IncomingMessage, res: ServerResponse, req: SSRRequest, adapters: SSRAdapters, preview?: PreviewClient, screenshot?: ScreenshotClient, logger?: McpLogger, renderApp?: {
-    sdkBase: string;
-    devMode?: boolean;
-}) => Promise<void>;
+export declare const serveMcp: (raw: IncomingMessage, res: ServerResponse, server: McpServer) => Promise<string | undefined>;
+export declare const handleMcp: (raw: IncomingMessage, res: ServerResponse, req: SSRRequest, adapters: SSRAdapters, options?: McpRequestOptions) => Promise<string | undefined>;
 export { createMcpServer };

package/dist/src/modules/mcp/helpers/log.d.ts

@@ -1,8 +1,8 @@
-import { McpLogger } from '@plitzi/sdk-shared';
+import { ServerLogger } from '@plitzi/sdk-shared';
 export interface McpLog {
     toolCall(name: string, args: unknown, ms: number, error?: unknown): void;
     resourceRead(uri: string, ms: number, error?: unknown): void;
 }
-/** Build the request-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
+/** Build the protocol-log sink for one MCP server. Dispatches structured events to the consumer's `logger` when
  *  provided; otherwise renders to the console when MCP_DEBUG=1; otherwise a no-op. */
-export declare const createMcpLog: (logger?: McpLogger) => McpLog;
+export declare const createMcpLog: (logger?: ServerLogger) => McpLog;

package/dist/src/modules/mcp/index.d.ts

@@ -4,6 +4,7 @@ export { apply, validate, search, read, validateOperations, operation, tools } f
 export { computeVersion, buildAgentGuide } from './helpers';
 export { createHttpPreviewClient } from './previewClient';
 export { createHttpScreenshotClient } from './screenshotClient';
+export type { McpRequestOptions } from './handler';
 export type { HttpPreviewClientConfig } from './previewClient';
 export type { HttpScreenshotClientConfig } from './screenshotClient';
 export type { McpServerContext } from './server';

package/dist/src/modules/mcp/resources/register.d.ts

@@ -1,6 +1,6 @@
 import { McpLog, Space } from '../helpers';
 import { Env } from '../types';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 /** Register every resource on the MCP server: fixed listings plus templated per-item reads. The space is
  *  loaded lazily via getSpace, so listing resources never touches the store — only reading one does. */
 export declare const registerResources: (server: McpServer, getSpace: () => Promise<Space>, env: Env, log: McpLog) => void;

package/dist/src/modules/mcp/resources/renderGuide.d.ts

@@ -1,4 +1,5 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { McpLog } from '../helpers';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 export declare const RENDER_GUIDE_URI = "plitzi://render/guide";
 export declare const RENDER_TYPES_URI = "plitzi://render/types";
-export declare const registerRenderResources: (server: McpServer) => void;
+export declare const registerRenderResources: (server: McpServer, log: McpLog) => void;

package/dist/src/modules/mcp/server.d.ts

@@ -1,6 +1,6 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { PreviewClient, ScreenshotClient } from './types';
-import { SSRAdapters, McpLogger } from '@plitzi/sdk-shared';
+import { SSRAdapters, ServerLogger } from '@plitzi/sdk-shared';
 /** The MCP service is stateless: every request resolves its own `spaceId` (from the request JWT) and reads the
  *  space fresh through the adapters — schema and style are two documents, read/written independently. Both the
  *  spaceId and the space itself resolve lazily, so the public surface (handshake, tools-list, resources-list,
@@ -17,14 +17,6 @@ export interface McpServerContext {
     screenshot?: ScreenshotClient;
     /** Structured request-log sink. When set, every tool call and resource read emits an McpLogEvent to it (the
      *  consumer renders them); otherwise logging falls back to the console when MCP_DEBUG=1. */
-    logger?: McpLogger;
-    /** MCP Apps: the interactive render view for plitzi_render. `sdkBase` is this server's absolute origin, which
-     *  serves the Plitzi SDK bundle under /sdk-assets; the iframe imports it and renders the widget client-side.
-     *  `devMode` picks the SDK vendor bundle name (dev vs prod split) to match the served bundle. Absent → the
-     *  ui:// view is not registered (the tool still returns its text summary + offlineData). */
-    renderApp?: {
-        sdkBase: string;
-        devMode?: boolean;
-    };
+    logger?: ServerLogger;
 }
-export declare const createMcpServer: ({ adapters, getSpaceId, preview, screenshot, logger, renderApp }: McpServerContext) => McpServer;
+export declare const createMcpServer: ({ adapters, getSpaceId, preview, screenshot, logger }: McpServerContext) => McpServer;

package/dist/src/modules/mcp/tools/apply/index.d.ts

@@ -179,8 +179,8 @@ export declare const applyShape: {
         userProvider: z.ZodOptional<z.ZodEnum<{
             "": "";
             custom: "custom";
-            basic: "basic";
             auth0: "auth0";
+            basic: "basic";
         }>>;
         auth0Domain: z.ZodOptional<z.ZodString>;
         auth0ClientId: z.ZodOptional<z.ZodString>;
@@ -395,9 +395,9 @@ export declare const applyShape: {
         type: z.ZodLiteral<"upsertStyleVariable">;
         category: z.ZodEnum<{
             color: "color";
-            custom: "custom";
             spacing: "spacing";
             shadow: "shadow";
+            custom: "custom";
         }>;
         name: z.ZodString;
         value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodObject<{
@@ -409,9 +409,9 @@ export declare const applyShape: {
         type: z.ZodLiteral<"deleteStyleVariable">;
         category: z.ZodEnum<{
             color: "color";
-            custom: "custom";
             spacing: "spacing";
             shadow: "shadow";
+            custom: "custom";
         }>;
         name: z.ZodString;
     }, z.core.$strip>], "type">>;