devframe 0.1.18 → 0.1.20

package/dist/utils/streaming-channel.mjs

@@ -0,0 +1,255 @@
+import { createEventEmitter } from "./events.mjs";
+import { nanoid } from "./nanoid.mjs";
+//#region src/utils/streaming-channel.ts
+const DEFAULT_HIGH_WATER_MARK = 256;
+var StreamClosedError = class extends Error {
+	name = "StreamClosedError";
+};
+/**
+* Build a server-side stream sink. RPC-agnostic — the RPC host wires
+* `events.on('chunk' | 'end')` to broadcast, and reads `buffer` to replay
+* for late or reconnecting subscribers.
+*/
+function createStreamSink(options = {}) {
+	const id = options.id ?? nanoid();
+	const replayWindow = Math.max(0, options.replayWindow ?? 0);
+	const events = createEventEmitter();
+	const controller = new AbortController();
+	const buffer = [];
+	let closed = false;
+	let lastSeq = 0;
+	function write(chunk) {
+		if (closed) throw new StreamClosedError(`Cannot write to a closed stream "${id}"`);
+		lastSeq += 1;
+		if (replayWindow > 0) {
+			buffer.push({
+				seq: lastSeq,
+				chunk
+			});
+			if (buffer.length > replayWindow) buffer.splice(0, buffer.length - replayWindow);
+		}
+		events.emit("chunk", lastSeq, chunk);
+	}
+	function error(reason) {
+		if (closed) return;
+		closed = true;
+		const payload = toErrorPayload(reason);
+		controller.abort(reason);
+		events.emit("end", payload);
+	}
+	function close() {
+		if (closed) return;
+		closed = true;
+		if (!controller.signal.aborted) controller.abort("stream closed");
+		events.emit("end", void 0);
+	}
+	function abort(reason) {
+		if (closed) return;
+		if (!controller.signal.aborted) controller.abort(reason ?? "aborted");
+	}
+	const writable = new WritableStream({
+		write(chunk) {
+			write(chunk);
+		},
+		close() {
+			close();
+		},
+		abort(reason) {
+			error(reason);
+		}
+	});
+	return {
+		id,
+		signal: controller.signal,
+		get closed() {
+			return closed;
+		},
+		get lastSeq() {
+			return lastSeq;
+		},
+		write,
+		error,
+		close,
+		abort,
+		writable,
+		events,
+		buffer
+	};
+}
+/**
+* Build a client-side stream reader. RPC-agnostic — the RPC host calls
+* `_push(seq, chunk)` on each incoming chunk and `_end(error?)` on the
+* terminal frame. Consumers iterate with `for await` or pipe `readable`.
+*/
+function createStreamReader(options = {}) {
+	const id = options.id ?? nanoid();
+	const highWaterMark = Math.max(1, options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK);
+	const queue = [];
+	let lastSeenSeq = 0;
+	let done = false;
+	let cancelled = false;
+	let endError;
+	let pending;
+	let pullController;
+	let readableInstance;
+	function drainNext() {
+		if (!pending) return;
+		if (queue.length > 0) {
+			const value = queue.shift();
+			const r = pending;
+			pending = void 0;
+			r.resolve({
+				value,
+				done: false
+			});
+			return;
+		}
+		if (done) {
+			const r = pending;
+			pending = void 0;
+			if (endError) {
+				const err = new Error(endError.message);
+				err.name = endError.name;
+				r.reject(err);
+			} else r.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+	}
+	function feedReadable() {
+		if (!pullController) return;
+		while (queue.length > 0) {
+			const v = queue.shift();
+			try {
+				pullController.enqueue(v);
+			} catch {
+				break;
+			}
+		}
+		if (done && pullController) {
+			try {
+				if (endError) {
+					const err = new Error(endError.message);
+					err.name = endError.name;
+					pullController.error(err);
+				} else pullController.close();
+			} catch {}
+			pullController = void 0;
+		}
+	}
+	function push(seq, chunk) {
+		if (done || cancelled) return;
+		if (seq <= lastSeenSeq) return;
+		lastSeenSeq = seq;
+		queue.push(chunk);
+		if (queue.length > highWaterMark) {
+			const overflow = queue.length - highWaterMark;
+			queue.splice(0, overflow);
+			options.onOverflow?.(overflow);
+		}
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function end(error) {
+		if (done) return;
+		done = true;
+		endError = error;
+		drainNext();
+		if (readableInstance) feedReadable();
+	}
+	function cancel() {
+		if (cancelled || done) return;
+		cancelled = true;
+		options.onCancel?.();
+		end(void 0);
+	}
+	function getReadable() {
+		if (readableInstance) return readableInstance;
+		readableInstance = new ReadableStream({
+			start(controller) {
+				pullController = controller;
+				feedReadable();
+			},
+			cancel() {
+				cancel();
+			}
+		});
+		return readableInstance;
+	}
+	return {
+		id,
+		get cancelled() {
+			return cancelled;
+		},
+		get done() {
+			return done;
+		},
+		get lastSeenSeq() {
+			return lastSeenSeq;
+		},
+		get readable() {
+			return getReadable();
+		},
+		cancel,
+		_push: push,
+		_end: end,
+		[Symbol.asyncIterator]() {
+			return {
+				next() {
+					if (queue.length > 0) return Promise.resolve({
+						value: queue.shift(),
+						done: false
+					});
+					if (done) {
+						if (endError) {
+							const err = new Error(endError.message);
+							err.name = endError.name;
+							return Promise.reject(err);
+						}
+						return Promise.resolve({
+							value: void 0,
+							done: true
+						});
+					}
+					return new Promise((resolve, reject) => {
+						pending = {
+							resolve,
+							reject
+						};
+					});
+				},
+				return() {
+					cancel();
+					return Promise.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+			};
+		}
+	};
+}
+function toErrorPayload(reason) {
+	if (reason instanceof Error) return {
+		name: reason.name || "Error",
+		message: reason.message
+	};
+	if (typeof reason === "string") return {
+		name: "Error",
+		message: reason
+	};
+	try {
+		return {
+			name: "Error",
+			message: JSON.stringify(reason)
+		};
+	} catch {
+		return {
+			name: "Error",
+			message: String(reason)
+		};
+	}
+}
+//#endregion
+export { createStreamReader, createStreamSink };

package/dist/{ws-client-CDGmViwt.d.mts → ws-client-DQySVfF_.d.mts}

@@ -1,4 +1,4 @@
-import { g as RpcFunctionDefinitionAny } from "./types-BkyzI9r4.mjs";
+import { g as RpcFunctionDefinitionAny } from "./types-ag029cAe.mjs";
 import { ChannelOptions } from "birpc";
 
 //#region src/rpc/transports/ws-client.d.ts

package/dist/{ws-server-Cu8tmZcF.d.mts → ws-server-VQqESKAs.d.mts}

@@ -1,4 +1,4 @@
-import { g as RpcFunctionDefinitionAny } from "./types-BkyzI9r4.mjs";
+import { g as RpcFunctionDefinitionAny } from "./types-ag029cAe.mjs";
 import { BirpcGroup, ChannelOptions } from "birpc";
 import { ServerOptions } from "node:https";
 import { WebSocket, WebSocketServer } from "ws";
@@ -11,6 +11,18 @@ interface DevToolsNodeRpcSessionMeta {
   clientAuthToken?: string;
   isTrusted?: boolean;
   subscribedStates: Set<string>;
+  /**
+   * Streams this session has subscribed to via
+   * `rpc.streaming.subscribe(channel, id)`. Tracked here for O(1) cleanup
+   * on disconnect; the wire format is `${channel}\x1F${id}`.
+   */
+  subscribedStreams?: Set<string>;
+  /**
+   * Inbound streams this session is currently uploading to (via
+   * `rpc.streaming.upload(channel, id)`). Tracked for cleanup on
+   * disconnect; same wire format as `subscribedStreams`.
+   */
+  uploadingStreams?: Set<string>;
 }
 interface WsRpcTransportOptions {
   /** Attach to an existing WebSocketServer. When provided, `port`, `host`, and `https` are ignored. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "devframe",
   "type": "module",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Framework for building generic DevTools",
   "author": "Anthony Fu <anthonyfu117@hotmail.com>",
   "license": "MIT",
@@ -22,14 +22,13 @@
     ".": "./dist/index.mjs",
     "./adapters/build": "./dist/adapters/build.mjs",
     "./adapters/cli": "./dist/adapters/cli.mjs",
+    "./adapters/dev": "./dist/adapters/dev.mjs",
     "./adapters/embedded": "./dist/adapters/embedded.mjs",
     "./adapters/kit": "./dist/adapters/kit.mjs",
     "./adapters/mcp": "./dist/adapters/mcp.mjs",
     "./adapters/vite": "./dist/adapters/vite.mjs",
     "./client": "./dist/client/index.mjs",
     "./constants": "./dist/constants.mjs",
-    "./helpers/nuxt": "./dist/helpers/nuxt/index.mjs",
-    "./helpers/nuxt/runtime/plugin.client": "./dist/helpers/nuxt/runtime/plugin.client.mjs",
     "./node": "./dist/node/index.mjs",
     "./recipes/open-helpers": "./dist/recipes/open-helpers.mjs",
     "./rpc": "./dist/rpc/index.mjs",
@@ -44,46 +43,41 @@
     "./utils/promise": "./dist/utils/promise.mjs",
     "./utils/shared-state": "./dist/utils/shared-state.mjs",
     "./utils/state": "./dist/utils/state.mjs",
+    "./utils/streaming-channel": "./dist/utils/streaming-channel.mjs",
     "./utils/when": "./dist/utils/when.mjs",
     "./package.json": "./package.json"
   },
   "types": "./dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "peerDependencies": {
-    "@modelcontextprotocol/sdk": "^1.0.0",
-    "@nuxt/kit": "^3.0.0 || ^4.0.0",
-    "launch-editor": "^2.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0"
   },
   "peerDependenciesMeta": {
     "@modelcontextprotocol/sdk": {
       "optional": true
-    },
-    "@nuxt/kit": {
-      "optional": true
-    },
-    "launch-editor": {
-      "optional": true
     }
   },
   "dependencies": {
-    "@valibot/to-json-schema": "^1.6.0",
+    "@valibot/to-json-schema": "^1.7.0",
     "ansis": "^4.2.0",
     "birpc": "^4.0.0",
     "cac": "^7.0.0",
     "h3": "^1.15.11",
+    "immer": "^11.1.7",
+    "launch-editor": "^2.13.2",
     "logs-sdk": "^0.0.6",
     "ohash": "^2.0.11",
     "pathe": "^2.0.3",
     "sirv": "^3.0.2",
     "structured-clone-es": "^2.0.0",
-    "valibot": "^1.3.1",
+    "valibot": "^1.4.0",
     "ws": "^8.20.0"
   },
   "devDependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@nuxt/kit": "^4.4.4",
     "launch-editor": "^2.13.2",
     "tsdown": "^0.21.10",
     "whenexpr": "^0.1.2"
@@ -96,7 +90,6 @@
     "define-lazy-prop": "3.0.0",
     "get-port-please": "3.2.0",
     "human-id": "4.1.3",
-    "immer": "11.1.4",
     "is-docker": "3.0.0",
     "is-in-ssh": "1.0.0",
     "is-inside-container": "1.0.0",

package/skills/devframe/README.md

@@ -0,0 +1,13 @@
+# devframe skill
+
+An agent skill that teaches Claude Code how to build a full-featured
+devtool with devframe.
+
+## Opt-in
+
+Until devframe publishes an installable skill, link this directory from
+your Claude Code skills path. Example for the CLI:
+
+```sh
+ln -s "$PWD/devframe/skills/devframe" "$HOME/.claude/skills/devframe"
+```