devframe 0.6.0-beta.3 → 0.6.0

package/dist/adapters/build.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DgvncQy2.mjs";
+import { r as DevframeDefinition } from "../devframe-BtVHhmwM.mjs";
 
 //#region src/adapters/build.d.ts
 interface CreateBuildOptions {

package/dist/adapters/cli.d.mts

@@ -1,4 +1,4 @@
-import { Ct as CliFlagsSchema, Et as parseCliFlags, Tt as defineCliFlags, r as DevframeDefinition, wt as InferCliFlags } from "../devframe-DgvncQy2.mjs";
+import { Dt as parseCliFlags, Et as defineCliFlags, Tt as InferCliFlags, r as DevframeDefinition, wt as CliFlagsSchema } from "../devframe-BtVHhmwM.mjs";
 import { CAC } from "cac";
 import { H3 } from "h3";
 

package/dist/adapters/cli.mjs

@@ -1,6 +1,6 @@
 import { n as colors } from "../diagnostics-reporter-CsIG85Q5.mjs";
 import { createBuild } from "./build.mjs";
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-DSxKFn-v.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-zC5542OV.mjs";
 import process from "node:process";
 import cac from "cac";
 import { safeParse } from "valibot";
@@ -82,7 +82,7 @@ function createCli(d, options = {}) {
 	const defaultPort = options.defaultPort ?? d.cli?.port ?? 9999;
 	const defaultHost = d.cli?.host ?? "localhost";
 	const cli = cac(d.cli?.command ?? d.id);
-	const devCommand = cli.command("[...args]", "Start a local dev server").option("--port <port>", "Port to listen on").option("--host <host>", "Host to bind to", { default: defaultHost }).option("--open", "Open the browser on start").option("--no-open", "Do not open the browser");
+	const devCommand = cli.command("[...args]", "Start a local dev server").option("--port <port>", "Port to listen on").option("--host <host>", "Host to bind to", { default: defaultHost }).option("--open", "Open the browser on start").option("--no-open", "Do not open the browser").option("--mcp", "Expose an MCP server over HTTP at /__mcp (use --no-mcp to disable) [experimental]");
 	if (d.cli?.flags) for (const [key, schema] of Object.entries(d.cli.flags)) {
 		const optionName = flagKeyToOption(key);
 		const description = schema.description ?? "";
@@ -92,13 +92,16 @@ function createCli(d, options = {}) {
 	devCommand.action(async (_args, rawFlags) => {
 		const flags = resolveTypedFlags(d, rawFlags);
 		const host = flags.host ?? defaultHost;
+		const port = flags.port ?? await resolveDevServerPort(d, {
+			host,
+			defaultPort
+		});
+		const mcp = flags.mcp;
 		await createDevServer(d, {
 			host,
-			port: flags.port ?? await resolveDevServerPort(d, {
-				host,
-				defaultPort
-			}),
+			port,
 			flags,
+			mcp,
 			onReady: options.onReady
 		});
 	});

package/dist/adapters/dev.d.mts

@@ -1,5 +1,5 @@
-import { l as DevframeWsOptions, r as DevframeDefinition } from "../devframe-DgvncQy2.mjs";
-import { n as StartedServer } from "../server-DXPq8q0K.mjs";
+import { l as DevframeWsOptions, r as DevframeDefinition, u as McpRouteOptions } from "../devframe-BtVHhmwM.mjs";
+import { n as StartedServer } from "../server-Cfr1NrGQ.mjs";
 import { H3 } from "h3";
 
 //#region src/adapters/dev.d.ts
@@ -51,6 +51,13 @@ interface CreateDevServerOptions {
    * sources; a string opens that relative path.
    */
   openBrowser?: boolean | string;
+  /**
+   * Expose a route-based MCP server on the dev server (Streamable-HTTP).
+   * Overrides `def.cli?.mcp`; `undefined` falls through to it. `false`
+   * disables the route regardless of the definition default. See
+   * {@link McpRouteOptions}.
+   */
+  mcp?: boolean | McpRouteOptions;
   /**
    * Called once the WS server is bound. Devframe stays headless
    * otherwise — wire this if you want a startup banner.

package/dist/adapters/dev.mjs

@@ -1,2 +1,2 @@
-import { n as resolveDevServerPort, t as createDevServer } from "../dev-DSxKFn-v.mjs";
+import { n as resolveDevServerPort, t as createDevServer } from "../dev-zC5542OV.mjs";
 export { createDevServer, resolveDevServerPort };

package/dist/adapters/embedded.d.mts

@@ -1,4 +1,4 @@
-import { m as DevframeNodeContext, r as DevframeDefinition } from "../devframe-DgvncQy2.mjs";
+import { h as DevframeNodeContext, r as DevframeDefinition } from "../devframe-BtVHhmwM.mjs";
 
 //#region src/adapters/embedded.d.ts
 interface CreateEmbeddedOptions {

package/dist/adapters/mcp.d.mts

@@ -1,4 +1,4 @@
-import { r as DevframeDefinition } from "../devframe-DgvncQy2.mjs";
+import { r as DevframeDefinition } from "../devframe-BtVHhmwM.mjs";
 //#region src/adapters/mcp/build-server.d.ts
 interface CreateMcpServerOptions {
   /**

package/dist/adapters/mcp.mjs

@@ -1,338 +1,2 @@
-import { a as diagnostics } from "../storage-yrUZaiib.mjs";
-import { n as createHostContext } from "../host-h3-Dsf-Tgwx.mjs";
-import { join } from "pathe";
-import process from "node:process";
-import { homedir } from "node:os";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { CallToolRequestSchema, ListResourcesRequestSchema, ListToolsRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { toJsonSchema } from "@valibot/to-json-schema";
-//#region src/adapters/mcp/stringify.ts
-/**
-* JSON-coercing serializer for MCP text payloads.
-*
-* MCP carries tool results and resource reads as plain text over a
-* JSON-RPC transport, so we cannot use the `s:`-prefixed structured-clone
-* format the WS RPC transport falls back to for non-JSON values. Instead,
-* we coerce common non-JSON types into JSON-friendly forms so the LLM
-* client sees something useful instead of `[object Object]`.
-*
-* Coercions:
-*   - `BigInt` → `"123n"`
-*   - `Date` → ISO string (via the native `toJSON`)
-*   - `Map` → `{ __type: 'Map', entries: [[k, v], …] }`
-*   - `Set` → `{ __type: 'Set', entries: [v, …] }`
-*   - `Error` → `{ name, message, stack, cause? }` (cause recurses)
-*   - `Function` → `"[Function: name]"`
-*   - `Symbol` → `value.toString()`
-*   - cycles → `"[Circular]"`
-*/
-function stringifyForMcp(value) {
-	if (value === void 0) return "undefined";
-	if (typeof value === "string") return value;
-	const seen = /* @__PURE__ */ new WeakSet();
-	return JSON.stringify(value, (_key, val) => {
-		if (typeof val === "bigint") return `${val}n`;
-		if (val instanceof Error) {
-			const out = {
-				name: val.name,
-				message: val.message,
-				stack: val.stack
-			};
-			if (val.cause !== void 0) out.cause = val.cause;
-			return out;
-		}
-		if (val instanceof Map) return {
-			__type: "Map",
-			entries: [...val.entries()]
-		};
-		if (val instanceof Set) return {
-			__type: "Set",
-			entries: [...val]
-		};
-		if (typeof val === "function") return `[Function: ${val.name || "anonymous"}]`;
-		if (typeof val === "symbol") return val.toString();
-		if (val !== null && typeof val === "object") {
-			if (seen.has(val)) return "[Circular]";
-			seen.add(val);
-		}
-		return val;
-	}, 2);
-}
-/**
-* Format a thrown value for an MCP `isError` text payload. Surfaces the
-* `Error.name`/`message`, and one level of `cause.message` so context
-* isn't dropped silently.
-*/
-function formatMcpError(error) {
-	if (!(error instanceof Error)) return String(error);
-	const cause = error.cause;
-	const causeText = cause instanceof Error ? ` (cause: ${cause.message})` : cause !== void 0 ? ` (cause: ${String(cause)})` : "";
-	return `${error.name}: ${error.message}${causeText}`;
-}
-//#endregion
-//#region src/adapters/mcp/to-json-schema.ts
-const FALLBACK_OBJECT_SCHEMA = Object.freeze({
-	type: "object",
-	additionalProperties: true
-});
-/**
-* Convert a valibot return schema to JSON Schema.
-* @internal
-*/
-function valibotReturnToJsonSchema(schema) {
-	if (!schema) return void 0;
-	try {
-		return toJsonSchema(schema);
-	} catch {
-		return FALLBACK_OBJECT_SCHEMA;
-	}
-}
-/**
-* Convert positional RPC args schemas to a single MCP-friendly object
-* schema. When the RPC declares `args: [v.object(...)]`, unwrap the
-* single-object schema directly (nicer agent UX than `{ arg0: {...} }`).
-*
-* Returns `undefined` when there are no args (the MCP SDK treats this
-* as `{ type: 'object', properties: {} }`).
-* @internal
-*/
-function valibotArgsToJsonSchema(args) {
-	if (!args || args.length === 0) return {
-		schema: {
-			type: "object",
-			properties: {}
-		},
-		unwrapped: false
-	};
-	if (args.length === 1) {
-		const inner = safeToJsonSchema(args[0]);
-		if (isObjectJsonSchema(inner)) return {
-			schema: inner,
-			unwrapped: true
-		};
-	}
-	const properties = {};
-	const required = [];
-	for (let i = 0; i < args.length; i++) {
-		const key = `arg${i}`;
-		properties[key] = safeToJsonSchema(args[i]);
-		required.push(key);
-	}
-	return {
-		schema: {
-			type: "object",
-			properties,
-			required,
-			additionalProperties: false
-		},
-		unwrapped: false
-	};
-}
-function safeToJsonSchema(schema) {
-	try {
-		return toJsonSchema(schema);
-	} catch {
-		return FALLBACK_OBJECT_SCHEMA;
-	}
-}
-function isObjectJsonSchema(value) {
-	return !!value && typeof value === "object" && value.type === "object";
-}
-//#endregion
-//#region src/adapters/mcp/build-server.ts
-/**
-* Wire an MCP {@link Server} to a devframe context. Returns the server
-* plus a disposal function for the subscriptions it sets up. The
-* transport is the caller's responsibility — `createMcpServer` connects
-* stdio; tests can connect an {@link InMemoryTransport} instead.
-*
-* @internal
-*/
-function buildMcpServerFromContext(ctx, options) {
-	const server = new Server({
-		name: options.serverName,
-		version: options.serverVersion
-	}, { capabilities: {
-		tools: { listChanged: true },
-		resources: { listChanged: true }
-	} });
-	registerToolHandlers(server, ctx);
-	registerResourceHandlers(server, ctx, options.exposeSharedState);
-	const notify = (method) => {
-		server.notification({ method }).catch(() => {});
-	};
-	const offManifest = ctx.agent.events.on("agent:manifest:changed", () => {
-		notify("notifications/tools/list_changed");
-		notify("notifications/resources/list_changed");
-	});
-	const offKeyAdded = ctx.rpc.sharedState.onKeyAdded(() => {
-		notify("notifications/resources/list_changed");
-	});
-	return {
-		server,
-		dispose: () => {
-			offManifest();
-			offKeyAdded();
-		}
-	};
-}
-/**
-* Build an MCP server over the agent surface of a devframe definition.
-* Currently supports `stdio` transport only.
-*
-* @experimental The agent-native surface is experimental and may change
-* without a major version bump until it stabilizes.
-*/
-async function createMcpServer(definition, options = {}) {
-	const transport = options.transport ?? "stdio";
-	if (transport !== "stdio") throw diagnostics.DF0017({
-		transport,
-		reason: "Only stdio transport is supported in this release."
-	});
-	const ctx = await createHostContext({
-		cwd: process.cwd(),
-		mode: "dev",
-		host: {
-			mountStatic: () => {},
-			resolveOrigin: () => "mcp://devframe",
-			getStorageDir: (scope) => scope === "workspace" ? join(process.cwd(), `node_modules/.${definition.id}/devframe`) : join(homedir(), `.${definition.id}/devframe`)
-		}
-	});
-	await definition.setup(ctx);
-	const { server, dispose } = buildMcpServerFromContext(ctx, {
-		serverName: options.serverName ?? `${definition.id} (devframe)`,
-		serverVersion: options.serverVersion ?? definition.version ?? "0.0.0",
-		exposeSharedState: options.exposeSharedState ?? true
-	});
-	const { startStdioTransport } = await import("../transports-BmDVn4SF.mjs");
-	let stop;
-	try {
-		stop = await startStdioTransport(server);
-	} catch (error) {
-		const reason = error instanceof Error ? error.message : String(error);
-		throw diagnostics.DF0017({
-			transport,
-			reason,
-			cause: error
-		});
-	}
-	options.onReady?.({ transport: "stdio" });
-	return { async stop() {
-		dispose();
-		await stop();
-	} };
-}
-function registerToolHandlers(server, ctx) {
-	server.setRequestHandler(ListToolsRequestSchema, async () => {
-		return { tools: ctx.agent.list().tools.map((tool) => projectTool(tool, ctx)) };
-	});
-	server.setRequestHandler(CallToolRequestSchema, async (request) => {
-		const { name, arguments: args } = request.params;
-		try {
-			return { content: [{
-				type: "text",
-				text: stringifyForMcp(await ctx.agent.invoke(name, args ?? {}))
-			}] };
-		} catch (error) {
-			return {
-				isError: true,
-				content: [{
-					type: "text",
-					text: `Error invoking "${name}": ${formatMcpError(error)}`
-				}]
-			};
-		}
-	});
-}
-function registerResourceHandlers(server, ctx, exposeSharedState) {
-	server.setRequestHandler(ListResourcesRequestSchema, async () => {
-		const resources = ctx.agent.list().resources.map((resource) => ({
-			uri: resource.uri,
-			name: resource.name,
-			description: resource.description,
-			mimeType: resource.mimeType
-		}));
-		if (exposeSharedState !== false) {
-			const filter = typeof exposeSharedState === "function" ? exposeSharedState : () => true;
-			for (const key of ctx.rpc.sharedState.keys()) {
-				if (!filter(key)) continue;
-				resources.push({
-					uri: `devframe://state/${encodeURIComponent(key)}`,
-					name: key,
-					description: `Shared state: ${key}`,
-					mimeType: "application/json"
-				});
-			}
-		}
-		return { resources };
-	});
-	server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-		const { uri } = request.params;
-		const parsed = parseResourceUri(uri);
-		if (parsed.kind === "resource") {
-			const content = await ctx.agent.read(parsed.id);
-			return { contents: [{
-				uri,
-				mimeType: content.mimeType ?? "application/json",
-				text: content.text ?? stringifyForMcp(content.json)
-			}] };
-		}
-		if (parsed.kind === "state") return { contents: [{
-			uri,
-			mimeType: "application/json",
-			text: stringifyForMcp((await ctx.rpc.sharedState.get(parsed.key)).value())
-		}] };
-		throw new Error(`[devframe/mcp] unknown resource URI "${uri}"`);
-	});
-}
-function projectTool(tool, ctx) {
-	const inputSchema = tool.inputSchema ?? computeInputSchema(tool, ctx);
-	const outputSchema = tool.outputSchema ?? computeOutputSchema(tool, ctx);
-	return {
-		name: tool.id,
-		title: tool.title,
-		description: tool.description,
-		inputSchema,
-		...outputSchema ? { outputSchema } : {},
-		annotations: {
-			title: tool.title,
-			readOnlyHint: tool.safety === "read",
-			destructiveHint: tool.safety === "destructive"
-		}
-	};
-}
-function computeInputSchema(tool, ctx) {
-	if (tool.kind !== "rpc" || !tool.rpcName) return {
-		type: "object",
-		properties: {}
-	};
-	const def = ctx.rpc.definitions.get(tool.rpcName);
-	if (!def) return {
-		type: "object",
-		properties: {}
-	};
-	const args = def.args;
-	return valibotArgsToJsonSchema(args).schema;
-}
-function computeOutputSchema(tool, ctx) {
-	if (tool.kind !== "rpc" || !tool.rpcName) return void 0;
-	const def = ctx.rpc.definitions.get(tool.rpcName);
-	if (!def) return void 0;
-	return valibotReturnToJsonSchema(def.returns);
-}
-function parseResourceUri(uri) {
-	const match = uri.match(/^devframe:\/\/(resource|state)\/(.+)$/);
-	if (!match) return { kind: "unknown" };
-	const [, kind, rest] = match;
-	const decoded = decodeURIComponent(rest);
-	if (kind === "resource") return {
-		kind: "resource",
-		id: decoded
-	};
-	return {
-		kind: "state",
-		key: decoded
-	};
-}
-//#endregion
+import { n as createMcpServer } from "../build-server-0jWgMrz-.mjs";
 export { createMcpServer };