devframe 0.7.16 → 0.8.0

package/dist/utils/agent-tool-name.d.mts

@@ -0,0 +1,27 @@
+//#region src/utils/agent-tool-name.d.ts
+/**
+ * Derive the wire-safe agent tool name for an internal tool id.
+ *
+ * Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+ * built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
+ * command ids for command-derived tools. MCP clients constrain tool names
+ * to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
+ * name automatically: every run of characters outside `[a-zA-Z0-9_-]`
+ * becomes a single `_`, truncated to 128 characters. Internal ids never
+ * change — resolution back to the id happens at the boundary.
+ *
+ * ```
+ * devframe:state:read          → devframe_state_read
+ * devframes:plugin:git:status  → devframes_plugin_git_status
+ * ```
+ *
+ * A plain string transform with no node dependency, so browser-side UIs
+ * that display a tool's id (e.g. the inspect plugin's agent view) can
+ * import it too and show the name a client actually calls.
+ *
+ * @experimental The agent-native surface is experimental and may change
+ * without a major version bump until it stabilizes.
+ */
+declare function toAgentToolName(id: string): string;
+//#endregion
+export { toAgentToolName };

package/dist/utils/agent-tool-name.mjs

@@ -0,0 +1,34 @@
+//#region src/utils/agent-tool-name.ts
+/**
+* Maximum tool-name length several MCP clients enforce (the Anthropic API
+* pattern is `^[a-zA-Z0-9_-]{1,128}$`).
+*/
+const MAX_TOOL_NAME_LENGTH = 128;
+/**
+* Derive the wire-safe agent tool name for an internal tool id.
+*
+* Devframe tool ids are colon-namespaced — `devframe:<area>:<fn>` for
+* built-ins, `devframes:plugin:<slug>:<fn>` for plugin RPCs, and hub
+* command ids for command-derived tools. MCP clients constrain tool names
+* to `^[a-zA-Z0-9_-]{1,128}$`, so the agent/MCP boundary derives the wire
+* name automatically: every run of characters outside `[a-zA-Z0-9_-]`
+* becomes a single `_`, truncated to 128 characters. Internal ids never
+* change — resolution back to the id happens at the boundary.
+*
+* ```
+* devframe:state:read          → devframe_state_read
+* devframes:plugin:git:status  → devframes_plugin_git_status
+* ```
+*
+* A plain string transform with no node dependency, so browser-side UIs
+* that display a tool's id (e.g. the inspect plugin's agent view) can
+* import it too and show the name a client actually calls.
+*
+* @experimental The agent-native surface is experimental and may change
+* without a major version bump until it stabilizes.
+*/
+function toAgentToolName(id) {
+	return id.replace(/[^\w-]+/g, "_").slice(0, MAX_TOOL_NAME_LENGTH);
+}
+//#endregion
+export { toAgentToolName };

package/dist/utils/events.d.mts

@@ -1,4 +1,4 @@
-import { jt as EventsMap, kt as EventEmitter } from "../devframe-Ckhf3kFw.mjs";
+import { Nt as EventsMap, jt as EventEmitter } from "../devframe-Dsjn_Xtq.mjs";
 //#region src/utils/events.d.ts
 /**
  * Create event emitter.

package/dist/utils/shared-state.d.mts

@@ -1,2 +1,2 @@
-import { _t as SharedStateOptions, dt as ImmutableArray, ft as ImmutableMap, gt as SharedStateEvents, ht as SharedState, mt as ImmutableSet, pt as ImmutableObject, ut as Immutable, vt as SharedStatePatch, yt as createSharedState } from "../devframe-Ckhf3kFw.mjs";
+import { _t as SharedStateOptions, dt as ImmutableArray, ft as ImmutableMap, gt as SharedStateEvents, ht as SharedState, mt as ImmutableSet, pt as ImmutableObject, ut as Immutable, vt as SharedStatePatch, yt as createSharedState } from "../devframe-Dsjn_Xtq.mjs";
 export { Immutable, ImmutableArray, ImmutableMap, ImmutableObject, ImmutableSet, SharedState, SharedStateEvents, SharedStateOptions, SharedStatePatch, createSharedState };

package/dist/utils/simple-schema.d.mts

@@ -0,0 +1,2 @@
+import { a as literal, c as number, d as picklist, f as record, g as voidType, h as union, i as describe, l as object, m as string, n as array, o as nullType, p as s, r as boolean, s as nullable, t as SimpleSchema, u as optional } from "../simple-schema-BDzLeJDk.mjs";
+export { SimpleSchema, array, boolean, describe, literal, nullType, nullable, number, object, optional, picklist, record, s, string, union, voidType };

package/dist/utils/simple-schema.mjs

@@ -0,0 +1,154 @@
+//#region src/utils/simple-schema.ts
+function ok(value) {
+	return { value };
+}
+function fail(message, path) {
+	return { issues: [path ? {
+		message,
+		path
+	} : { message }] };
+}
+function make(type, validate, extra) {
+	return {
+		type,
+		...extra,
+		"~standard": {
+			version: 1,
+			vendor: "devframe",
+			validate
+		}
+	};
+}
+/** Run a Standard Schema synchronously, rejecting async validators. */
+function runSync(schema, value) {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise) throw new TypeError("[devframe/utils/simple-schema] async validators are not supported inside object()/optional()/nullable()");
+	return result;
+}
+/** Any string. */
+function string() {
+	return make("string", (v) => typeof v === "string" ? ok(v) : fail("Expected a string"));
+}
+/** A finite number (rejects `NaN`). */
+function number() {
+	return make("number", (v) => typeof v === "number" && !Number.isNaN(v) ? ok(v) : fail("Expected a number"));
+}
+/** A boolean. */
+function boolean() {
+	return make("boolean", (v) => typeof v === "boolean" ? ok(v) : fail("Expected a boolean"));
+}
+/** `undefined` — mirrors valibot's `void`. */
+function voidType() {
+	return make("void", (v) => v === void 0 ? ok(void 0) : fail("Expected undefined"));
+}
+/** `null`. */
+function nullType() {
+	return make("null", (v) => v === null ? ok(null) : fail("Expected null"));
+}
+/** One of a fixed set of literal values. */
+function picklist(values) {
+	const set = new Set(values);
+	return make("picklist", (v) => set.has(v) ? ok(v) : fail(`Expected one of: ${values.join(", ")}`), { values });
+}
+/** A single literal value (string / number / boolean). */
+function literal(value) {
+	return make("literal", (v) => v === value ? ok(v) : fail(`Expected ${JSON.stringify(value)}`), { value });
+}
+/** A value matching any one of the given schemas. */
+function union(options) {
+	return make("union", (v) => {
+		const issues = [];
+		for (const option of options) {
+			const result = runSync(option, v);
+			if (!result.issues) return ok(v);
+			issues.push(...result.issues);
+		}
+		return { issues };
+	}, { options });
+}
+/** A record with string keys whose values each satisfy the value schema. */
+function record(_key, value) {
+	return make("record", (v) => {
+		if (typeof v !== "object" || v === null || Array.isArray(v)) return fail("Expected an object");
+		const obj = v;
+		const issues = [];
+		for (const key of Object.keys(obj)) {
+			const result = runSync(value, obj[key]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [key, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** An array whose every element satisfies the item schema. */
+function array(item) {
+	return make("array", (v) => {
+		if (!Array.isArray(v)) return fail("Expected an array");
+		const issues = [];
+		for (let i = 0; i < v.length; i++) {
+			const result = runSync(item, v[i]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [i, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** An object whose known keys each satisfy their schema (extra keys are kept). */
+function object(shape) {
+	const entries = Object.entries(shape);
+	return make("object", (v) => {
+		if (typeof v !== "object" || v === null || Array.isArray(v)) return fail("Expected an object");
+		const obj = v;
+		const issues = [];
+		for (const [key, schema] of entries) {
+			const result = runSync(schema, obj[key]);
+			if (result.issues) for (const issue of result.issues) issues.push({
+				message: issue.message,
+				path: [key, ...issue.path ?? []]
+			});
+		}
+		return issues.length ? { issues } : ok(v);
+	});
+}
+/** Allow `undefined` in addition to the inner schema. */
+function optional(inner) {
+	return make("optional", (v) => v === void 0 ? ok(void 0) : runSync(inner, v), { wrapped: inner });
+}
+/** Allow `null` in addition to the inner schema. */
+function nullable(inner) {
+	return make("nullable", (v) => v === null ? ok(null) : runSync(inner, v), { wrapped: inner });
+}
+/** Attach a human-readable description (used for CLI option help). */
+function describe(schema, description) {
+	return {
+		...schema,
+		description
+	};
+}
+/**
+* Grouped access to every builder — `s.string()`, `s.object({ ... })`,
+* `s.void()`, etc. Handy for a valibot-like `import { s } from
+* 'devframe/utils/simple-schema'` call site.
+*/
+const s = {
+	string,
+	number,
+	boolean,
+	void: voidType,
+	null: nullType,
+	literal,
+	picklist,
+	union,
+	record,
+	array,
+	object,
+	optional,
+	nullable,
+	describe
+};
+//#endregion
+export { array, boolean, describe, literal, nullType, nullable, number, object, optional, picklist, record, s, string, union, voidType };

package/dist/utils/streaming-channel.d.mts

@@ -1,2 +1,2 @@
-import { at as StreamReader, ct as createStreamReader, it as StreamErrorPayload, lt as createStreamSink, nt as CreateStreamReaderOptions, ot as StreamSink, rt as CreateStreamSinkOptions, st as StreamSinkEvents, tt as BufferedChunk } from "../devframe-Ckhf3kFw.mjs";
+import { at as StreamReader, ct as createStreamReader, it as StreamErrorPayload, lt as createStreamSink, nt as CreateStreamReaderOptions, ot as StreamSink, rt as CreateStreamSinkOptions, st as StreamSinkEvents, tt as BufferedChunk } from "../devframe-Dsjn_Xtq.mjs";
 export { BufferedChunk, CreateStreamReaderOptions, CreateStreamSinkOptions, StreamErrorPayload, StreamReader, StreamSink, StreamSinkEvents, createStreamReader, createStreamSink };

package/dist/{ws-client-DSXiI2h7.d.mts → ws-client-B6Tnr0ic.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CrzNxXKq.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
 import { ChannelOptions } from "birpc";
 //#region src/rpc/transports/ws-client.d.ts
 interface WsRpcChannelOptions {

package/dist/{ws-server-9-wn7MNQ.d.mts → ws-server-D_Vjtums.d.mts}

@@ -1,4 +1,4 @@
-import { v as RpcFunctionDefinitionAny } from "./types-CrzNxXKq.mjs";
+import { v as RpcFunctionDefinitionAny } from "./types-CnJSgRVa.mjs";
 import { Peer } from "crossws";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { NodeAdapter } from "crossws/adapters/node";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.7.16",
+  "version": "0.8.0",
   "description": "Framework for building generic devframes",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -42,6 +42,7 @@
     "./rpc/transports/ws-client": "./dist/rpc/transports/ws-client.mjs",
     "./rpc/transports/ws-server": "./dist/rpc/transports/ws-server.mjs",
     "./types": "./dist/types/index.mjs",
+    "./utils/agent-tool-name": "./dist/utils/agent-tool-name.mjs",
     "./utils/colors": "./dist/utils/colors.mjs",
     "./utils/crypto-token": "./dist/utils/crypto-token.mjs",
     "./utils/events": "./dist/utils/events.mjs",
@@ -50,6 +51,7 @@
     "./utils/nanoid": "./dist/utils/nanoid.mjs",
     "./utils/open": "./dist/utils/open.mjs",
     "./utils/promise": "./dist/utils/promise.mjs",
+    "./utils/simple-schema": "./dist/utils/simple-schema.mjs",
     "./utils/scope": "./dist/utils/scope.mjs",
     "./utils/serve-static": "./dist/utils/serve-static.mjs",
     "./utils/shared-state": "./dist/utils/shared-state.mjs",
@@ -59,16 +61,24 @@
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.mts",
+  "bin": {
+    "devframe": "./bin/devframe.mjs"
+  },
   "files": [
+    "bin",
     "dist",
     "skills"
   ],
   "peerDependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "cac": "^7.0.0"
   },
   "peerDependenciesMeta": {
-    "@modelcontextprotocol/sdk": {
+    "@modelcontextprotocol/client": {
+      "optional": true
+    },
+    "@modelcontextprotocol/server": {
       "optional": true
     },
     "cac": {
@@ -76,7 +86,7 @@
     }
   },
   "dependencies": {
-    "@valibot/to-json-schema": "^1.7.1",
+    "@standard-schema/spec": "^1.1.0",
     "birpc": "^4.0.0",
     "crossws": "^0.4.10",
     "destr": "^2.0.5",
@@ -84,11 +94,11 @@
     "mrmime": "^2.0.1",
     "nostics": "^1.2.0",
     "pathe": "^2.0.3",
-    "ufo": "^1.6.4",
-    "valibot": "^1.4.2"
+    "ufo": "^1.6.4"
   },
   "devDependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
     "cac": "^7.0.0",
     "get-port-please": "^3.2.0",
     "immer": "^11.1.15",
@@ -103,6 +113,7 @@
     "tinyglobby": "^0.2.17",
     "tsdown": "^0.22.14",
     "ua-parser-modern": "^0.1.1",
+    "valibot": "^1.4.2",
     "whenexpr": "^0.1.2",
     "ws": "^8.21.1"
   },

package/skills/devframe/SKILL.md

@@ -485,7 +485,7 @@ import { createMcpServer } from 'devframe/adapters/mcp'
 await createMcpServer(devframe, { transport: 'stdio' })
 ```
 
-`@modelcontextprotocol/sdk` is a peer dependency. The CLI adapter also exposes `my-devframe mcp` — route host logs to stderr (stdout is the MCP transport). Safety classifications (`'read' | 'action' | 'destructive'`) drive MCP hint annotations that agent clients use to prompt for confirmation.
+`@modelcontextprotocol/server` is a peer dependency. The CLI adapter also exposes `my-devframe mcp` — route host logs to stderr (stdout is the MCP transport). Safety classifications (`'read' | 'action' | 'destructive'`) drive MCP hint annotations that agent clients use to prompt for confirmation.
 
 ## Author SPA
 

package/dist/http-_pPbryTQ.mjs

@@ -1,114 +0,0 @@
-import { isAllowedOrigin } from "./rpc/transports/ws-server.mjs";
-import { t as buildMcpServerFromContext } from "./build-server-C7vTKjiQ.mjs";
-import { randomUUID } from "node:crypto";
-import { defineHandler } from "h3";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
-import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
-//#region src/adapters/mcp/http.ts
-/**
-* Mount an MCP Streamable-HTTP endpoint on an h3 app at `path`.
-*
-* Each MCP session gets its own {@link WebStandardStreamableHTTPServerTransport}
-* and MCP server (built from the shared, live `ctx` via
-* `buildMcpServerFromContext`), correlated by the `Mcp-Session-Id` header:
-* an `initialize` POST spins up a session; later requests route to it; a
-* `DELETE` (or client disconnect) tears it down.
-*
-* The transport is web-standard — its `handleRequest` takes the h3 event's
-* web `Request` and returns a web `Response` (an SSE `ReadableStream` body
-* for the server→client stream). We copy that response onto `event.res` and
-* return its body rather than returning the `Response` object directly, so a
-* legitimate MCP 404 (unknown session) isn't swallowed by h3's
-* "Response-with-404 falls through to the next handler" rule (which would
-* otherwise hand the request to the SPA static catch-all).
-*
-* @experimental
-*/
-function mountMcpHttp(app, ctx, path, options) {
-	const sessions = /* @__PURE__ */ new Map();
-	const allowedOrigins = options.allowedOrigins;
-	function drop(sessionId) {
-		const session = sessions.get(sessionId);
-		if (!session) return;
-		sessions.delete(sessionId);
-		session.dispose();
-	}
-	async function createSession() {
-		let session;
-		const transport = new WebStandardStreamableHTTPServerTransport({
-			sessionIdGenerator: () => randomUUID(),
-			onsessioninitialized: (id) => {
-				sessions.set(id, session);
-			},
-			onsessionclosed: (id) => {
-				drop(id);
-			}
-		});
-		const { server, dispose } = buildMcpServerFromContext(ctx, {
-			serverName: options.serverName,
-			serverVersion: options.serverVersion,
-			exposeSharedState: options.exposeSharedState
-		});
-		session = {
-			transport,
-			dispose: async () => {
-				dispose();
-				await server.close();
-			}
-		};
-		transport.onclose = () => {
-			if (transport.sessionId) drop(transport.sessionId);
-		};
-		await server.connect(transport);
-		return session;
-	}
-	app.use(path, defineHandler(async (event) => {
-		const req = event.req;
-		const origin = req.headers.get("origin") ?? void 0;
-		if (allowedOrigins !== false && !isAllowedOrigin(origin, allowedOrigins ?? [])) {
-			event.res.status = 403;
-			return "Forbidden: origin not allowed";
-		}
-		const sessionId = req.headers.get("mcp-session-id") ?? void 0;
-		let session = sessionId ? sessions.get(sessionId) : void 0;
-		if (!session && req.method === "POST") {
-			let body;
-			try {
-				body = await req.json();
-			} catch {
-				body = void 0;
-			}
-			if (!sessionId && isInitializeRequest(body)) session = await createSession();
-			else {
-				event.res.status = sessionId ? 404 : 400;
-				return sessionId ? "Not Found: unknown MCP session" : "Bad Request: no valid session ID and not an initialize request";
-			}
-			return respond(event, await session.transport.handleRequest(req, { parsedBody: body }));
-		}
-		if (!session) {
-			event.res.status = sessionId ? 404 : 400;
-			return sessionId ? "Not Found: unknown MCP session" : "Bad Request: missing MCP session ID";
-		}
-		return respond(event, await session.transport.handleRequest(req));
-	}));
-	return { dispose: async () => {
-		const live = [...sessions.values()];
-		sessions.clear();
-		await Promise.all(live.map((session) => session.dispose()));
-	} };
-}
-/**
-* Copy a web `Response` from the MCP transport onto the h3 event's response
-* and return its body. Returning the body (a `ReadableStream` or `null`)
-* rather than the `Response` object avoids h3's 404-fall-through behavior.
-*/
-function respond(event, response) {
-	event.res.status = response.status;
-	event.res.statusText = response.statusText;
-	response.headers.forEach((value, key) => {
-		event.res.headers.set(key, value);
-	});
-	return response.body ?? "";
-}
-//#endregion
-export { mountMcpHttp };