devframe 0.1.20 → 0.1.21

package/dist/context-internal-Dx_NoSv1.mjs

@@ -0,0 +1,199 @@
+import { t as import_dist } from "./human-id-BLoGo_e5.mjs";
+import { n as logger } from "./diagnostics-DxPnRoXO.mjs";
+import { createSharedState } from "./utils/shared-state.mjs";
+import fs from "node:fs";
+import { dirname, join } from "pathe";
+//#region src/node/auth-revoke.ts
+/**
+* Flip `isTrusted` to false on any live WS clients connected with `token`
+* and broadcast the `auth:revoked` event so they can react.
+*
+* Shared between persisted-auth revocation and remote-dock token revocation.
+*/
+async function revokeActiveConnectionsForToken(context, token) {
+	const rpcHost = context.rpc;
+	if (!rpcHost?._rpcGroup) return;
+	const affectedSessionIds = /* @__PURE__ */ new Set();
+	for (const client of rpcHost._rpcGroup.clients) if (client.$meta.clientAuthToken === token) {
+		affectedSessionIds.add(client.$meta.id);
+		client.$meta.isTrusted = false;
+		client.$meta.clientAuthToken = void 0;
+	}
+	if (affectedSessionIds.size === 0) return;
+	await rpcHost.broadcast({
+		method: "devframe:auth:revoked",
+		args: [],
+		filter: (client) => affectedSessionIds.has(client.$meta.id)
+	});
+}
+/**
+* Revoke an auth token: remove from storage and notify all connected clients
+* using this token that they are no longer trusted.
+*/
+async function revokeAuthToken(context, storage, token) {
+	storage.mutate((state) => {
+		delete state.trusted[token];
+	});
+	await revokeActiveConnectionsForToken(context, token);
+}
+//#endregion
+//#region ../../../node_modules/.pnpm/perfect-debounce@2.1.0/node_modules/perfect-debounce/dist/index.mjs
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+//#endregion
+//#region src/node/storage.ts
+function createStorage(options) {
+	const { mergeInitialValue = (initialValue, savedValue) => ({
+		...initialValue,
+		...savedValue
+	}), debounce: debounceTime = 100 } = options;
+	let initialValue = options.initialValue;
+	if (fs.existsSync(options.filepath)) try {
+		const savedValue = JSON.parse(fs.readFileSync(options.filepath, "utf-8"));
+		initialValue = mergeInitialValue ? mergeInitialValue(options.initialValue, savedValue) : savedValue;
+	} catch (error) {
+		logger.DF0012({ filepath: options.filepath }, { cause: error }).log();
+		initialValue = options.initialValue;
+	}
+	const state = createSharedState({
+		initialValue,
+		enablePatches: false
+	});
+	state.on("updated", debounce((newState) => {
+		fs.mkdirSync(dirname(options.filepath), { recursive: true });
+		fs.writeFileSync(options.filepath, `${JSON.stringify(newState, null, 2)}\n`);
+	}, debounceTime));
+	return state;
+}
+//#endregion
+//#region src/node/context-internal.ts
+const internalContextMap = /* @__PURE__ */ new WeakMap();
+function getInternalContext(context) {
+	if (!internalContextMap.has(context)) {
+		const storage = createStorage({
+			filepath: join(context.host.getStorageDir("global"), "auth.json"),
+			initialValue: { trusted: {} }
+		});
+		const remoteTokens = /* @__PURE__ */ new Map();
+		function revokeRemoteToken(token) {
+			if (!remoteTokens.delete(token)) return;
+			revokeActiveConnectionsForToken(context, token);
+		}
+		const internalContext = {
+			storage: { auth: storage },
+			revokeAuthToken: (token) => revokeAuthToken(context, storage, token),
+			remoteTokens,
+			allocateRemoteToken(dockId, origin, originLock) {
+				const token = (0, import_dist.humanId)({
+					separator: "-",
+					capitalize: false
+				});
+				remoteTokens.set(token, {
+					dockId,
+					origin,
+					originLock
+				});
+				return token;
+			},
+			revokeRemoteToken,
+			revokeRemoteTokensForDock(dockId) {
+				const tokensToRevoke = [];
+				for (const [token, record] of remoteTokens) if (record.dockId === dockId) tokensToRevoke.push(token);
+				for (const token of tokensToRevoke) revokeRemoteToken(token);
+			},
+			isRemoteTokenTrusted(token, requestOrigin) {
+				const record = remoteTokens.get(token);
+				if (!record) return false;
+				if (!record.originLock) return true;
+				return !!requestOrigin && record.origin === requestOrigin;
+			}
+		};
+		internalContextMap.set(context, internalContext);
+	}
+	return internalContextMap.get(context);
+}
+//#endregion
+export { revokeAuthToken as a, revokeActiveConnectionsForToken as i, internalContextMap as n, createStorage as r, getInternalContext as t };

package/dist/context-internal-saIAfNVw.d.mts

@@ -0,0 +1,51 @@
+import { P as SharedState, d as DevToolsNodeContext } from "./devtool-CNvLs2_Y.mjs";
+
+//#region src/node/context-internal.d.ts
+interface InternalAnonymousAuthStorage {
+  trusted: Record<string, {
+    authToken: string;
+    ua: string;
+    origin: string;
+    timestamp: number;
+  } | undefined>;
+}
+interface RemoteTokenRecord {
+  dockId: string;
+  /** Dock URL origin — matched against WS handshake `Origin` header when `originLock` is on. */
+  origin: string;
+  originLock: boolean;
+}
+interface DevToolsInternalContext {
+  storage: {
+    auth: SharedState<InternalAnonymousAuthStorage>;
+  };
+  /**
+   * Revoke an auth token: remove from storage and notify all connected clients
+   * using this token that they are no longer trusted.
+   */
+  revokeAuthToken: (token: string) => Promise<void>;
+  /**
+   * Session-only tokens issued to remote-UI iframe docks. Not persisted —
+   * regenerated on every dev-server restart.
+   */
+  remoteTokens: Map<string, RemoteTokenRecord>;
+  allocateRemoteToken: (dockId: string, origin: string, originLock: boolean) => string;
+  revokeRemoteToken: (token: string) => void;
+  revokeRemoteTokensForDock: (dockId: string) => void;
+  /**
+   * Returns true if `token` is a valid remote token and, when `originLock` is
+   * on, `requestOrigin` matches the recorded dock origin.
+   */
+  isRemoteTokenTrusted: (token: string, requestOrigin?: string) => boolean;
+  /**
+   * Populated by `createWsServer` once the WS port is bound. Consumed by the
+   * docks host when enriching remote iframe URLs with a connection descriptor.
+   */
+  wsEndpoint?: {
+    /** Full `ws://` or `wss://` URL with host and port. */url: string;
+  };
+}
+declare const internalContextMap: WeakMap<DevToolsNodeContext, DevToolsInternalContext>;
+declare function getInternalContext(context: DevToolsNodeContext): DevToolsInternalContext;
+//#endregion
+export { internalContextMap as a, getInternalContext as i, InternalAnonymousAuthStorage as n, RemoteTokenRecord as r, DevToolsInternalContext as t };

package/dist/{dev-B8i_CBlQ.mjs → dev-CdAy400a.mjs}

@@ -1,11 +1,11 @@
-import { t as createHostContext } from "./context-BfvbAyGk.mjs";
+import { t as createHostContext } from "./context-BJ4r2SmR.mjs";
+import { t as createH3DevToolsHost } from "./host-h3-9jeHcltx.mjs";
+import { t as startHttpAndWs } from "./server-CBsxXIH5.mjs";
 import { DEVTOOLS_CONNECTION_META_FILENAME } from "./constants.mjs";
-import { t as createH3DevToolsHost } from "./host-h3-BMvrFzIJ.mjs";
-import { t as startHttpAndWs } from "./server-qRRM8t3v.mjs";
-import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-S-Ujqz_L.mjs";
+import { n as resolveBasePath, t as normalizeBasePath } from "./_shared-iZy45oG3.mjs";
 import { resolve } from "pathe";
-import process$1 from "node:process";
 import { networkInterfaces } from "node:os";
+import process$1 from "node:process";
 import { createApp, eventHandler, fromNodeMiddleware } from "h3";
 import { createServer } from "node:net";
 import sirv from "sirv";
@@ -312,7 +312,7 @@ async function maybeOpenBrowser(def, flags, origin, override) {
 	if (resolved === void 0 || resolved === false) return;
 	const target = typeof resolved === "string" ? resolveOpenTarget(origin, resolved) : origin;
 	try {
-		const { default: open } = await import("./open-BtOOEldu.mjs");
+		const { default: open } = await import("./open-Dede_w9r.mjs");
 		await open(target);
 	} catch {}
 }