@plitzi/sdk-mcp 0.37.2 → 0.37.3

package/dist/modules/mcp/helpers/uris.d.ts

@@ -3,9 +3,9 @@ export declare const guideUri = "plitzi://guide";
 export declare const typesUri = "plitzi://types";
 export declare const cssPropertiesUri = "plitzi://css-properties";
 export declare const primerUri: (env: Env) => string;
+export declare const changesUri: (env: Env) => string;
 export declare const pagesUri: (env: Env) => string;
 export declare const pageUri: (env: Env, ref: string) => string;
-export declare const pageStylesUri: (env: Env, ref: string) => string;
 /** The shared layout shells. One of them is read as a page is — `pages/{ref}` resolves either root. */
 export declare const layoutsUri: (env: Env) => string;
 export declare const elementUri: (env: Env, ref: string) => string;
@@ -23,6 +23,8 @@ export declare const actionUri: (env: Env, ref: string) => string;
 /** The step vocabulary. Under the actions root because that is where an author looks for it, and resolved before
  *  the `{ref}` shape so an action can never be named `tasks`. */
 export declare const actionTasksUri: (env: Env) => string;
+export declare const functionsUri: (env: Env) => string;
+export declare const functionFileUri: (env: Env, path: string) => string;
 export declare const foldersUri: (env: Env) => string;
 export declare const folderUri: (env: Env, ref: string) => string;
 export declare const defsUri: (env: Env) => string;

package/dist/modules/mcp/helpers/uris.js

@@ -3,6 +3,7 @@ var guideUri = "plitzi://guide";
 var typesUri = "plitzi://types";
 var cssPropertiesUri = "plitzi://css-properties";
 var primerUri = (env) => `plitzi://primer/${env}`;
+var changesUri = (env) => `plitzi://changes/${env}`;
 var pagesUri = (env) => `plitzi://schema/${env}/pages`;
 var pageUri = (env, ref) => `plitzi://schema/${env}/pages/${ref}`;
 /** The shared layout shells. One of them is read as a page is — `pages/{ref}` resolves either root. */
@@ -22,6 +23,8 @@ var actionUri = (env, ref) => `plitzi://actions/${env}/${ref}`;
 /** The step vocabulary. Under the actions root because that is where an author looks for it, and resolved before
 *  the `{ref}` shape so an action can never be named `tasks`. */
 var actionTasksUri = (env) => `plitzi://actions/${env}/tasks`;
+var functionsUri = (env) => `plitzi://functions/${env}`;
+var functionFileUri = (env, path) => `plitzi://functions/${env}/${path}`;
 var foldersUri = (env) => `plitzi://folders/${env}`;
 var folderUri = (env, ref) => `plitzi://folders/${env}/${ref}`;
 var defsUri = (env) => `plitzi://definitions/${env}`;
@@ -56,4 +59,4 @@ var itemTemplates = (env) => [
 *  family and extracts its ref in one step, without repeating the prefix string for both the startsWith and slice. */
 var afterPrefix = (uri, prefix) => uri.startsWith(prefix) ? uri.slice(prefix.length) : void 0;
 //#endregion
-export { actionTasksUri, actionUri, actionsUri, afterPrefix, aliasedRoots, connectorPresetsUri, connectorUri, connectorsUri, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, fontUri, fontsUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, layoutsUri, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };
+export { actionTasksUri, actionUri, actionsUri, afterPrefix, aliasedRoots, changesUri, connectorPresetsUri, connectorUri, connectorsUri, cssPropertiesUri, dataSourcesUri, defUri, defsUri, elementUri, folderUri, foldersUri, fontUri, fontsUri, functionFileUri, functionsUri, globalUri, globalsUri, guideUri, idUri, idsUri, interactionsUri, itemTemplates, layoutsUri, pageUri, pagesUri, primerUri, schemaVarsUri, settingsUri, styleVarUri, styleVarsUri, typesUri };

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

@@ -5,10 +5,12 @@ export { computeVersion, buildAgentGuide } from './helpers';
 export { createHttpPreviewClient } from './previewClient';
 export { createLocalScreenshotClient, resolveLocalBrowser } from './localScreenshotClient';
 export { createHttpScreenshotClient } from './screenshotClient';
+export { outlineOfSnapshot, outlineOfTree, unnamedControls } from './accessibilityOutline';
 export type { McpRequestOptions } from './handler';
 export type { HttpPreviewClientConfig } from './previewClient';
 export type { LocalScreenshotClientConfig } from './localScreenshotClient';
 export type { HttpScreenshotClientConfig } from './screenshotClient';
+export type { AccessibilityNode, UnnamedControl } from './accessibilityOutline';
 export type { McpServerContext } from './server';
 export type { ApplyInput, WriteResponse, Persisters, SearchInput, ReadInput, ReadResponse, ValidateInput, Operation, ToolDef, ToolContext } from './tools';
 export type { Space } from './helpers';

package/dist/modules/mcp/localScreenshotClient.d.ts

@@ -1,3 +1,4 @@
+import { AccessibilityNode } from './accessibilityOutline';
 import { ScreenshotClient, ScreenshotInput } from './types';
 /**
  * A capture that needs no service to be running.
@@ -37,6 +38,16 @@ type Page = {
     }[]) => Promise<void>;
     evaluate: <T>(fn: () => T) => Promise<T>;
     screenshot: (options: Record<string, unknown>) => Promise<Buffer | Uint8Array>;
+    /** Playwright's: the page's accessibility tree, already written as an outline. */
+    locator?: (selector: string) => {
+        ariaSnapshot: () => Promise<string>;
+    };
+    /** Puppeteer's: the same tree, as nodes. */
+    accessibility?: {
+        snapshot: (options?: {
+            interestingOnly?: boolean;
+        }) => Promise<AccessibilityNode | null>;
+    };
 };
 type Browser = {
     newPage: () => Promise<Page>;

package/dist/modules/mcp/localScreenshotClient.js

@@ -1,3 +1,4 @@
+import { outlineOfSnapshot, outlineOfTree } from "./accessibilityOutline.js";
 import { PREVIEW_TOKEN_PARAM } from "@plitzi/sdk-server/kernel";
 //#region src/modules/mcp/localScreenshotClient.ts
 /**
@@ -38,6 +39,11 @@ var resolveLocalBrowser = async () => await importDriver("playwright") ?? await
 var setViewport = async (page, size) => {
 	await (page.setViewportSize ? page.setViewportSize(size) : page.setViewport?.(size));
 };
+/** The tree a screen reader walks, from whichever driver this is; `undefined` from one that offers neither. */
+var readOutline = async (page) => {
+	if (page.locator) return outlineOfSnapshot(await page.locator("body").ariaSnapshot());
+	if (page.accessibility) return outlineOfTree(await page.accessibility.snapshot({ interestingOnly: false }));
+};
 /** Before the navigation: a space on the `system` theme paints from `prefers-color-scheme` from its first frame. */
 var emulateColorScheme = async (page, colorScheme) => {
 	await (page.emulateMedia ? page.emulateMedia({ colorScheme }) : page.emulateMediaFeatures?.([{
@@ -55,7 +61,7 @@ var emulateColorScheme = async (page, colorScheme) => {
 var createLocalScreenshotClient = async ({ renderBaseUrl, ignoreHttpsErrors = true }) => {
 	const driver = await resolveLocalBrowser();
 	if (!driver) return;
-	return { async capture({ pagePath, token, viewports, fullPage = true, colorScheme }) {
+	return { async capture({ pagePath, token, viewports, fullPage = true, colorScheme, views = ["image"] }) {
 		const url = new URL(pagePath, renderBaseUrl);
 		if (token) url.searchParams.set(PREVIEW_TOKEN_PARAM, token);
 		/**
@@ -72,6 +78,7 @@ var createLocalScreenshotClient = async ({ renderBaseUrl, ignoreHttpsErrors = tr
 				...ignoreHttpsErrors ? { ignoreHTTPSErrors: true } : {}
 			});
 			const images = [];
+			const accessibility = [];
 			for (const viewport of viewports) {
 				const page = await browser.newPage();
 				await setViewport(page, viewport);
@@ -90,19 +97,27 @@ var createLocalScreenshotClient = async ({ renderBaseUrl, ignoreHttpsErrors = tr
 						height
 					});
 				}
-				const shot = await page.screenshot({
-					type: "png",
-					fullPage
-				});
-				images.push({
+				if (views.includes("image")) {
+					const shot = await page.screenshot({
+						type: "png",
+						fullPage
+					});
+					images.push({
+						label: viewport.label,
+						mimeType: "image/png",
+						data: Buffer.from(shot).toString("base64")
+					});
+				}
+				const outline = views.includes("accessibility") ? await readOutline(page) : void 0;
+				if (outline !== void 0) accessibility.push({
 					label: viewport.label,
-					mimeType: "image/png",
-					data: Buffer.from(shot).toString("base64")
+					outline
 				});
 			}
 			return {
 				ok: true,
-				images
+				images,
+				...views.includes("accessibility") ? { accessibility } : {}
 			};
 		} catch (err) {
 			return {

package/dist/modules/mcp/proxy/guard.d.ts

@@ -1,3 +1,9 @@
+/**
+ * Whether an ADDRESS is never the public internet. The ranges are sdk-server's, the same rule its `http.request` task
+ * and connector engine follow: this module used to keep its own copy, and the copy judged `::ffff:7f00:1` — the form a
+ * URL parser writes `[::ffff:127.0.0.1]` in — as public. Anything that is not an address is refused here; a NAME is
+ * judged by what it resolves to, in `isPublicHost`.
+ */
 export declare const isPrivateAddress: (address: string) => boolean;
 /** Does this hostname resolve somewhere on the public internet? The endpoint fetches URLs an agent authored, so
  *  without this it would be a way to read whatever the pod itself can reach — the cluster's services, the cloud

package/dist/modules/mcp/proxy/guard.js

@@ -1,18 +1,14 @@
+import { isBlockedHost } from "@plitzi/sdk-server/kernel";
 import { lookup } from "node:dns/promises";
 import { isIP } from "node:net";
 //#region src/modules/mcp/proxy/guard.ts
-var isPrivateIpv4 = (address) => {
-	const parts = address.split(".").map(Number);
-	if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) return true;
-	const [a = 0, b = 0] = parts;
-	return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 0 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
-};
-var isPrivateIpv6 = (address) => {
-	const normalized = address.toLowerCase().split("%")[0] ?? "";
-	if (normalized.startsWith("::ffff:") && normalized.includes(".")) return isPrivateIpv4(normalized.slice(7));
-	return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
-};
-var isPrivateAddress = (address) => isIP(address) === 6 ? isPrivateIpv6(address) : isPrivateIpv4(address);
+/**
+* Whether an ADDRESS is never the public internet. The ranges are sdk-server's, the same rule its `http.request` task
+* and connector engine follow: this module used to keep its own copy, and the copy judged `::ffff:7f00:1` — the form a
+* URL parser writes `[::ffff:127.0.0.1]` in — as public. Anything that is not an address is refused here; a NAME is
+* judged by what it resolves to, in `isPublicHost`.
+*/
+var isPrivateAddress = (address) => isIP(address) === 0 || isBlockedHost(address);
 var PRIVATE_SUFFIXES = [
 	".local",
 	".internal",

package/dist/modules/mcp/resources/functions.d.ts

@@ -0,0 +1,8 @@
+import { Space } from '../helpers';
+import { Env, ResourceEnvelope } from '../types';
+/**
+ * The space's own functions: the listing says what they declare and which files they are, so an agent knows where to
+ * look before it reads one; a file reads whole. Server-side code — never a browser payload — and it holds no secret: a
+ * request NAMES a credential, the platform writes it in.
+ */
+export declare const readFunctionsResource: (space: Space, env: Env, uri: string) => ResourceEnvelope<unknown> | null | undefined;

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

@@ -0,0 +1,35 @@
+import { afterPrefix, functionFileUri, functionsUri } from "../helpers/uris.js";
+import { envelope } from "./envelope.js";
+//#region src/modules/mcp/resources/functions.ts
+/**
+* The space's own functions: the listing says what they declare and which files they are, so an agent knows where to
+* look before it reads one; a file reads whole. Server-side code — never a browser payload — and it holds no secret: a
+* request NAMES a credential, the platform writes it in.
+*/
+var readFunctionsResource = (space, env, uri) => {
+	if (uri === functionsUri(env)) {
+		if (!space.functions) return envelope({
+			available: false,
+			reason: "This deployment runs no space functions"
+		});
+		const { files, version, manifest } = space.functions;
+		return envelope({
+			available: true,
+			version,
+			files: Object.entries(files).map(([path, content]) => ({
+				path,
+				bytes: content.length
+			})),
+			declares: manifest
+		});
+	}
+	const path = afterPrefix(uri, functionFileUri(env, ""));
+	if (path === void 0) return;
+	const content = space.functions && Object.hasOwn(space.functions.files, path) ? space.functions.files[path] : void 0;
+	return content === void 0 ? null : envelope({
+		path,
+		content
+	});
+};
+//#endregion
+export { readFunctionsResource };

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

@@ -1,10 +1,11 @@
 import { McpLog, Space } from '../helpers';
 import { Env } from '../types';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSRChangePage, SSRChangeQuery } from '@plitzi/sdk-shared';
 /** 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.
  *
  *  `hasSpace` is false when the connection reaches no space (a guest / widgets-only grant): the space-dependent
  *  families are then not registered at all, so the catalog the agent browses holds only what it can actually
  *  open — no listing that answers every read with the same refusal. */
-export declare const registerResources: (server: McpServer, getSpace: () => Promise<Space>, env: Env, log: McpLog, hasSpace: boolean) => void;
+export declare const registerResources: (server: McpServer, getSpace: () => Promise<Space>, env: Env, log: McpLog, hasSpace: boolean, readChanges?: (query: SSRChangeQuery) => Promise<SSRChangePage>) => void;

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

@@ -1,4 +1,5 @@
 import { cssProperties, cssShorthands } from "../catalogs/index.js";
+import { changesUri } from "../helpers/uris.js";
 import { guideText } from "../helpers/guide.js";
 import { envelope, jsonContents } from "./envelope.js";
 import { resourceErrorMessage } from "./canonical.js";
@@ -6,13 +7,15 @@ import { registerRenderResources } from "./renderGuide.js";
 import { readResource } from "./router.js";
 import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/resources/register.ts
+/** A page an agent can read in one go: each change carries whole elements before and after. */
+var CHANGES_PAGE = 20;
 /** 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.
 *
 *  `hasSpace` is false when the connection reaches no space (a guest / widgets-only grant): the space-dependent
 *  families are then not registered at all, so the catalog the agent browses holds only what it can actually
 *  open — no listing that answers every read with the same refusal. */
-var registerResources = (server, getSpace, env, log, hasSpace) => {
+var registerResources = (server, getSpace, env, log, hasSpace, readChanges) => {
 	const emit = async (uri) => {
 		const start = performance.now();
 		try {
@@ -52,7 +55,7 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 		[
 			"Primer",
 			`plitzi://primer/${env}`,
-			"Read this FIRST. Cold-start bundle in one call: guide, types, css-properties and SUMMARIES of pages, definitions and variables — summaries only, never full page/element trees, so it stays small even on a large space. Open a page or element on demand afterwards."
+			"Read this FIRST. Cold-start bundle in one call: the guide’s quickstart, types, css-properties and SUMMARIES of pages, definitions and variables — summaries only, never full page/element trees, so it stays small even on a large space. Open a page or element on demand afterwards."
 		],
 		[
 			"Element types",
@@ -94,6 +97,11 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 			`plitzi://style-variables/${env}`,
 			"Design tokens by category"
 		],
+		[
+			"Fonts",
+			`plitzi://fonts/${env}`,
+			"The font families the space loads, with their source and fallback"
+		],
 		[
 			"Schema variables",
 			`plitzi://schema-variables/${env}`,
@@ -134,6 +142,11 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 			`plitzi://actions/${env}`,
 			"Server actions this space runs: what starts each one, who may run it, and the input/output contract a caller is held to — what a runServerAction step points at"
 		],
+		[
+			"Functions",
+			`plitzi://functions/${env}`,
+			"The space’s own server code: which files it is, and the tasks, routes and hosts it declares — its tasks are steps like any server task"
+		],
 		[
 			"Style definitions (schema alias)",
 			`plitzi://schema/${env}/definitions`,
@@ -150,6 +163,30 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 			"Alias of plitzi://schema-variables/{env}"
 		]
 	];
+	if (readChanges) {
+		const emitChanges = async (uri, query) => {
+			const start = performance.now();
+			try {
+				const page = await readChanges(query);
+				log.resourceRead(uri, performance.now() - start);
+				return jsonContents(uri, { data: page });
+			} catch (error) {
+				log.resourceRead(uri, performance.now() - start, error);
+				throw error;
+			}
+		};
+		server.registerResource("Change history", changesUri(env), {
+			description: "Read-only: the latest changes to this space, newest first — who made each (a person, an agent, the autofix), from where, and every element, class or token it touched, whole, before and after",
+			mimeType: "application/json"
+		}, () => emitChanges(changesUri(env), { limit: CHANGES_PAGE }));
+		server.registerResource("Change history of one entity", new ResourceTemplate(`${changesUri(env)}/{id}`, { list: void 0 }), {
+			description: "Read-only: the changes that touched one element, class, token or font, newest first",
+			mimeType: "application/json"
+		}, (uri, { id }) => emitChanges(uri.href, {
+			entityId: decodeURIComponent(String(id)),
+			limit: CHANGES_PAGE
+		}));
+	}
 	for (const [name, uri, description] of fixed) server.registerResource(name, uri, {
 		description,
 		mimeType: "application/json"
@@ -185,6 +222,11 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 			`plitzi://actions/${env}/{ref}`,
 			"One action document in full: its access rule, triggers, declared credentials and connectors, and every step"
 		],
+		[
+			"Function file",
+			`plitzi://functions/${env}/{+path}`,
+			"One file of the space’s functions, whole"
+		],
 		[
 			"Style definition",
 			`plitzi://definitions/${env}/{ref}`,
@@ -205,6 +247,11 @@ var registerResources = (server, getSpace, env, log, hasSpace) => {
 			`plitzi://style-variables/${env}/{category}`,
 			"Design tokens for one category"
 		],
+		[
+			"Font",
+			`plitzi://fonts/${env}/{family}`,
+			"One font family the space loads: its source, fallback and files"
+		],
 		[
 			"Style definition (schema alias)",
 			`plitzi://schema/${env}/definitions/{ref}`,

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

@@ -381,7 +381,8 @@ The widget runs the live SDK, so beyond static layout it can fetch data and resp
 \`ref\`, just like styling. (Full reference: **plitzi://guide** — sections Data bindings and Interactions.)
 
 ### Fetch data — a provider + a binding
-An \`apiContainer\` fetches at runtime and exposes the result as the source **\`apiContainer_<id>.data\`**, visible
+An \`apiContainer\` fetches at runtime and exposes the result as the source **\`apiContainer_<id>.data\`** (the
+parsed body; \`.status\` is the HTTP status, beside \`.isLoading\`, \`.isEmpty\` and \`.hasError\`), visible
 to its **DESCENDANTS only** — the bound element must live inside the container's subtree. \`upsertBinding\` then
 connects that source to a descendant's field. With no \`subType\` (its default) the provider renders **no element of
 its own** — its children lay out in its parent, and a class on it styles nothing; give it \`"subType": "div"\` when the
@@ -431,7 +432,7 @@ An element starts hidden with \`initialState: { "visibility": false }\` on the e
 \`true\` counts as false, so a panel that has never been set flips **open** on the first click.
 
 Expand/collapse is therefore **ONE step on ONE trigger** — never two \`setState\` branches under opposite \`when\`
-conditions, which read the state as it was when the flow STARTED and so are always one click behind:
+conditions: every step reads the state as it is when it runs, so the second sees what the first wrote and flips it back:
 
 \`\`\`json
 { "operations": [

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

@@ -4,6 +4,7 @@ import { readActionResource } from "./actions.js";
 import { canonicalUri } from "./canonical.js";
 import { readConnectorResource } from "./connectors.js";
 import { readCoreResource } from "./core.js";
+import { readFunctionsResource } from "./functions.js";
 import { readPrimerResource } from "./primer.js";
 import { readRenderResource } from "./renderGuide.js";
 import { readSchemaResource } from "./schema.js";
@@ -16,7 +17,8 @@ var resolvers = [
 	readSchemaResource,
 	readStyleResource,
 	readConnectorResource,
-	readActionResource
+	readActionResource,
+	readFunctionsResource
 ];
 /** Resolve a resource URI to its versioned envelope, or null if unknown / not found. */
 var readResource = (space, env, rawUri) => {

package/dist/modules/mcp/screenshotClient.js

@@ -1,3 +1,4 @@
+import { outlineOfTree } from "./accessibilityOutline.js";
 import { PREVIEW_TOKEN_PARAM } from "@plitzi/sdk-server/kernel";
 //#region src/modules/mcp/screenshotClient.ts
 var composeUrl = (base, pagePath, token) => {
@@ -23,7 +24,7 @@ var readRefusal = async (res) => {
 /** Default `ScreenshotClient`: composes the navigable preview URL (renderBaseUrl + pagePath + `?__pt=token`) and
 *  POSTs it to the browser service. Any network/HTTP failure surfaces as `ok:false` so the tool can fall back to
 *  the HTML preview instead of hard-failing. */
-var createHttpScreenshotClient = ({ serviceUrl, renderBaseUrl, fetchImpl = fetch }) => ({ async capture({ pagePath, token, viewports, fullPage, colorScheme }) {
+var createHttpScreenshotClient = ({ serviceUrl, renderBaseUrl, fetchImpl = fetch }) => ({ async capture({ pagePath, token, viewports, fullPage, colorScheme, views = ["image"] }) {
 	const url = composeUrl(renderBaseUrl, pagePath, token);
 	let res;
 	try {
@@ -34,7 +35,8 @@ var createHttpScreenshotClient = ({ serviceUrl, renderBaseUrl, fetchImpl = fetch
 				url,
 				viewports,
 				fullPage,
-				colorScheme
+				colorScheme,
+				views
 			})
 		});
 	} catch (err) {
@@ -58,14 +60,20 @@ var createHttpScreenshotClient = ({ serviceUrl, renderBaseUrl, fetchImpl = fetch
 		};
 	}
 	const body = await res.json();
-	if (!body.images || body.images.length === 0) return {
+	const images = body.images ?? [];
+	if (views.includes("image") && images.length === 0) return {
 		ok: false,
 		error: "SCREENSHOT_EMPTY",
 		message: "Browser service returned no images."
 	};
+	const accessibility = body.accessibility?.map(({ label, tree }) => ({
+		label,
+		outline: outlineOfTree(tree)
+	}));
 	return {
 		ok: true,
-		images: body.images
+		images,
+		...accessibility ? { accessibility } : {}
 	};
 } });
 //#endregion

package/dist/modules/mcp/server.js

@@ -6,6 +6,7 @@ import { proxyForTool } from "./proxy/config.js";
 import { registerResources } from "./resources/register.js";
 import { tools } from "./tools/index.js";
 import { isCallToolResult } from "../ai/toolkit.js";
+import { randomUUID } from "node:crypto";
 import { registerAppTool } from "@modelcontextprotocol/ext-apps/server";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 //#region src/modules/mcp/server.ts
@@ -30,13 +31,14 @@ var createMcpServer = async ({ adapters, getGrant, preview, screenshot, logger,
 	};
 	const loadSpace = async () => {
 		const id = requireSpaceId();
-		const [schema, style, catalog, connectors, actions, actionTasks] = await Promise.all([
+		const [schema, style, catalog, connectors, actions, actionTasks, functions] = await Promise.all([
 			adapters.getSchema?.(id, MCP_ENV),
 			adapters.getStyle?.(id, MCP_ENV),
 			adapters.getComponentCatalog?.(id, MCP_ENV).catch(() => void 0),
 			adapters.getConnectors?.(id).catch(() => void 0),
 			adapters.getActions?.(id).catch(() => void 0),
-			adapters.getActionTasks?.(id).catch(() => void 0)
+			adapters.getActionTasks?.(id).catch(() => void 0),
+			adapters.getFunctions?.(id).catch(() => void 0)
 		]);
 		if (!schema || !style) throw new Error(emptySpaceMessage);
 		return {
@@ -45,25 +47,32 @@ var createMcpServer = async ({ adapters, getGrant, preview, screenshot, logger,
 			catalog,
 			connectors: connectors ?? [],
 			actions: actions ?? [],
-			actionTasks
+			actionTasks,
+			...functions ? { functions } : {}
 		};
 	};
-	const { saveSchema, saveStyle, saveConnector, deleteConnector, saveAction, deleteAction } = adapters;
+	const { saveSchema, saveStyle, saveConnector, deleteConnector, saveAction, deleteAction, saveFunctions, tryFunction } = adapters;
+	const write = {
+		userId: grant?.userId,
+		batch: randomUUID()
+	};
 	const persisters = {
-		schema: saveSchema ? (schema) => saveSchema(requireWritableSpaceId(), MCP_ENV, schema) : void 0,
-		style: saveStyle ? (style) => saveStyle(requireWritableSpaceId(), MCP_ENV, style) : void 0,
+		schema: saveSchema ? (schema) => saveSchema(requireWritableSpaceId(), MCP_ENV, schema, write) : void 0,
+		style: saveStyle ? (style) => saveStyle(requireWritableSpaceId(), MCP_ENV, style, write) : void 0,
 		saveConnector: saveConnector ? (entry) => saveConnector(requireWritableSpaceId(), entry) : void 0,
 		deleteConnector: deleteConnector ? (id) => deleteConnector(requireWritableSpaceId(), id) : void 0,
 		saveAction: saveAction ? (entry) => saveAction(requireWritableSpaceId(), entry) : void 0,
-		deleteAction: deleteAction ? (id) => deleteAction(requireWritableSpaceId(), id) : void 0
+		deleteAction: deleteAction ? (id) => deleteAction(requireWritableSpaceId(), id) : void 0,
+		saveFunctions: saveFunctions ? (files, base) => saveFunctions(requireWritableSpaceId(), files, base, write) : void 0
 	};
 	let spacePromise;
 	const getSpace = () => spacePromise ??= loadSpace();
 	const server = new McpServer({
 		name: "plitzi-mcp",
-		version: "0.37.2"
+		version: "0.37.3"
 	}, { instructions: hasSpace ? serverInstructions : widgetsOnlyInstructions });
-	registerResources(server, getSpace, MCP_ENV, log, hasSpace);
+	const { getChanges } = adapters;
+	registerResources(server, getSpace, MCP_ENV, log, hasSpace, getChanges ? (query) => getChanges(requireSpaceId(), MCP_ENV, query) : void 0);
 	registerApps(server, {
 		streaming: renderStreaming,
 		proxyEndpoint: proxy?.endpoint
@@ -75,7 +84,8 @@ var createMcpServer = async ({ adapters, getGrant, preview, screenshot, logger,
 		spaceId: requireSpaceId(),
 		preview,
 		screenshot,
-		proxy: proxyForTool(proxy, tool)
+		proxy: proxyForTool(proxy, tool),
+		...tryFunction ? { tryFunction: (task, params) => tryFunction(requireWritableSpaceId(), task, params, write) } : {}
 	});
 	const spacelessContext = (tool) => ({
 		space: emptySpace(),

package/dist/modules/mcp/tests/guide.test.d.ts

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

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

@@ -5,6 +5,7 @@ import { upsertAction } from "../operations/actions/upsertAction.js";
 import { deleteConnector } from "../operations/connectors/deleteConnector.js";
 import { patchConnector } from "../operations/connectors/patchConnector.js";
 import { upsertConnector } from "../operations/connectors/upsertConnector.js";
+import { deleteFunctionFile, upsertFunctionFile } from "../operations/functions/index.js";
 import { deleteBinding } from "../operations/schema/bindings/deleteBinding.js";
 import { patchBinding } from "../operations/schema/bindings/patchBinding.js";
 import { upsertBinding } from "../operations/schema/bindings/upsertBinding.js";
@@ -81,6 +82,8 @@ var executeOp = (space, env, op) => {
 		case "upsertAction": return upsertAction(space, env, op);
 		case "patchAction": return patchAction(space, env, op);
 		case "deleteAction": return deleteAction(space, env, op);
+		case "upsertFunctionFile": return upsertFunctionFile(space, env, op);
+		case "deleteFunctionFile": return deleteFunctionFile(space, env, op);
 		default: return fail("type", `Unknown operation "${op.type}"`, "See the Operation union");
 	}
 };
@@ -99,7 +102,8 @@ var applyOperations = (space, env, ops) => {
 		changedConnectors: [],
 		deletedConnectors: [],
 		changedActions: [],
-		deletedActions: []
+		deletedActions: [],
+		changedFunctions: false
 	};
 	const stale = /* @__PURE__ */ new Set();
 	const elements = /* @__PURE__ */ new Set();
@@ -136,6 +140,10 @@ var applyOperations = (space, env, ops) => {
 				savedActions.delete(op.ref);
 				droppedActions.add(op.ref);
 				break;
+			case "upsertFunctionFile":
+			case "deleteFunctionFile":
+				outcome.changedFunctions = true;
+				break;
 			default: if (isStyleOp(op.type)) outcome.changedStyle = true;
 			else outcome.changedSchema = true;
 		}

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

@@ -191,6 +191,11 @@ export declare const applyShape: {
             params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             enabled: z.ZodOptional<z.ZodBoolean>;
             when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+            whileRunning: z.ZodOptional<z.ZodEnum<{
+                skip: "skip";
+                parallel: "parallel";
+                queue: "queue";
+            }>>;
             elementId: z.ZodOptional<z.ZodString>;
             preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>>;
@@ -204,6 +209,11 @@ export declare const applyShape: {
         params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         enabled: z.ZodOptional<z.ZodBoolean>;
         when: z.ZodOptional<z.ZodType<import('@plitzi/sdk-shared').RuleGroup, unknown, z.core.$ZodTypeInternals<import('@plitzi/sdk-shared').RuleGroup, unknown>>>;
+        whileRunning: z.ZodOptional<z.ZodEnum<{
+            skip: "skip";
+            parallel: "parallel";
+            queue: "queue";
+        }>>;
         elementId: z.ZodOptional<z.ZodString>;
         preview: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>, z.ZodObject<{
@@ -220,6 +230,8 @@ export declare const applyShape: {
             localStorage: "localStorage";
             sessionStorage: "sessionStorage";
         }>>;
+        transientState: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        paintedState: z.ZodOptional<z.ZodArray<z.ZodString>>;
         userProvider: z.ZodOptional<z.ZodString>;
         tokenStorage: z.ZodOptional<z.ZodEnum<{
             "": "";
@@ -242,6 +254,21 @@ export declare const applyShape: {
             strict: "strict";
         }>>;
         sessionRevalidateSeconds: z.ZodOptional<z.ZodNumber>;
+        channels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNullable<z.ZodObject<{
+            access: z.ZodObject<{
+                mode: z.ZodEnum<{
+                    public: "public";
+                    session: "session";
+                    role: "role";
+                }>;
+                permissions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+            publish: z.ZodOptional<z.ZodEnum<{
+                server: "server";
+                clients: "clients";
+            }>>;
+            presence: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>>;
     }, z.core.$strip>, z.ZodObject<{
         desktop: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
         tablet: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
@@ -994,6 +1021,13 @@ export declare const applyShape: {
     }, z.core.$strip>, z.ZodObject<{
         type: z.ZodLiteral<"deleteAction">;
         ref: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"upsertFunctionFile">;
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"deleteFunctionFile">;
+        path: z.ZodString;
     }, z.core.$strip>], "type">>;
 };
 export declare const apply: (input: ApplyInput, space: Space, persisters?: Persisters) => Promise<WriteResponse>;