@ekrooh/bare 0.1.0

package/dist/runtime.mjs

@@ -0,0 +1,637 @@
+import { MessageProtocol, MessageType, createPluginRegistry, createPluginRouter } from "./index.mjs";
+import { t as createDefaultPlugins } from "./plugins-1KweEBct.mjs";
+import { TextDecoder, TextEncoder } from "bare-encoding";
+import fs from "bare-fs";
+import path from "bare-path";
+import http from "bare-http1";
+import ws from "bare-ws";
+import crypto from "bare-crypto";
+//#region core/lib/get-ipc.ts
+/**
+* Returns the active IPC channel.
+* In BareKit (Android), it uses BareKit.IPC.
+* In Bare (Sidecar), it uses Bare.IPC.
+*/
+function getIPC() {
+	const IPC = typeof BareKit !== "undefined" ? BareKit.IPC : Bare.IPC;
+	if (IPC && typeof IPC.resume === "function") IPC.resume();
+	return IPC;
+}
+//#endregion
+//#region core/messages/host-ipc.ts
+function toUint8Array$2(data) {
+	if (data instanceof Uint8Array) return data;
+	if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) return new Uint8Array(data);
+	return new Uint8Array(data);
+}
+function newCorrelationId() {
+	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function writeEncoded(ipc, bytes) {
+	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.from(bytes));
+	else ipc.write(bytes);
+}
+function createHostIpcBridge(config) {
+	const { ipc, protocol } = config;
+	const pending = /* @__PURE__ */ new Map();
+	function waitFor(requestId, expectedType, timeoutMs) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				pending.delete(requestId);
+				reject(/* @__PURE__ */ new Error(`Host IPC timeout waiting for ${String(expectedType)} (${requestId})`));
+			}, timeoutMs);
+			pending.set(requestId, {
+				timer,
+				resolve: (h) => {
+					clearTimeout(timer);
+					pending.delete(requestId);
+					if (h.type === expectedType) {
+						resolve(h);
+						return;
+					}
+					reject(/* @__PURE__ */ new Error(`Unexpected host response type ${h.type}, expected ${String(expectedType)}`));
+				}
+			});
+		});
+	}
+	return {
+		tryConsumeDownstreamFromHost(raw) {
+			let msg;
+			try {
+				msg = protocol.decode(toUint8Array$2(raw));
+			} catch {
+				return false;
+			}
+			const h = msg.header;
+			if (h.type !== "HOST_CAPABILITIES_RESPONSE" && h.type !== "HOST_INVOKE_RESPONSE") return false;
+			const id = h.requestId;
+			if (!id) return false;
+			const slot = pending.get(id);
+			if (!slot) return false;
+			clearTimeout(slot.timer);
+			pending.delete(id);
+			slot.resolve(h);
+			return true;
+		},
+		async queryCapabilities(timeoutMs = 5e3) {
+			const requestId = newCorrelationId();
+			const promise = waitFor(requestId, "HOST_CAPABILITIES_RESPONSE", timeoutMs);
+			const header = {
+				type: "HOST_CAPABILITIES_QUERY",
+				requestId
+			};
+			writeEncoded(ipc, protocol.encode(MessageType.ENVELOPE, header, null));
+			return (await promise).capabilities ?? [];
+		},
+		async invokeOnHost(header, payload, timeoutMs = 3e5) {
+			const requestId = header.requestId;
+			if (!requestId) return null;
+			const promise = waitFor(requestId, "HOST_INVOKE_RESPONSE", timeoutMs);
+			const hostHeader = {
+				type: "HOST_INVOKE_REQUEST",
+				requestId,
+				pluginId: header.pluginId,
+				event: header.event,
+				args: header.args
+			};
+			writeEncoded(ipc, protocol.encode(MessageType.ENVELOPE, hostHeader, payload));
+			const hostResp = await promise;
+			return {
+				type: "INVOKE_RESPONSE",
+				pluginId: hostResp.pluginId,
+				event: hostResp.event,
+				requestId: hostResp.requestId,
+				result: hostResp.result,
+				error: hostResp.error
+			};
+		}
+	};
+}
+//#endregion
+//#region core/server/static-file-server.ts
+const MIME_BY_EXTENSION = {
+	html: "text/html",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	css: "text/css",
+	json: "application/json",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	png: "image/png",
+	gif: "image/gif",
+	webp: "image/webp",
+	svg: "image/svg+xml",
+	heic: "image/heic",
+	heif: "image/heif",
+	mp4: "video/mp4",
+	mov: "video/quicktime",
+	m4v: "video/x-m4v",
+	woff: "font/woff",
+	woff2: "font/woff2"
+};
+function mimeTypeFor(filePath) {
+	const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+	return MIME_BY_EXTENSION[ext] ?? "application/octet-stream";
+}
+/** Extracts the `token` query param from a raw query string (`a=1&token=x`). */
+function tokenFromQuery(query) {
+	for (const pair of query.split("&")) {
+		const eq = pair.indexOf("=");
+		if (eq === -1) continue;
+		if (pair.slice(0, eq) === "token") return pair.slice(eq + 1);
+	}
+	return null;
+}
+/** Reads the token from the `X-Bare-Token` request header (parser-lowercased).
+* `fetch`-based non-browser clients that cannot carry cookies use this. */
+function tokenFromHeaders(headers) {
+	const value = headers["x-bare-token"];
+	return typeof value === "string" ? value : null;
+}
+/** Reads the `bare_session` value from the `Cookie` request header. */
+function cookieSession(headers) {
+	const cookie = headers["cookie"];
+	if (typeof cookie !== "string") return null;
+	for (const part of cookie.split(";")) {
+		const eq = part.indexOf("=");
+		if (eq === -1) continue;
+		if (part.slice(0, eq).trim() === "bare_session") return part.slice(eq + 1).trim();
+	}
+	return null;
+}
+/** Derives the cookie value from the session token so the token itself is not
+* echoed into a request header a local attacker could read back. */
+function sessionNonce(token) {
+	return crypto.createHash("blake2b-256").update(token).digest("hex");
+}
+/** Parses a `Range: bytes=<start>-<end>` header. Returns `null` when absent or
+* unsatisfiable (caller falls back to a 200 full response). */
+function parseRange(value, size) {
+	if (typeof value !== "string") return null;
+	const match = /^bytes=(\d*)-(\d*)$/.exec(value.trim());
+	if (!match) return null;
+	let start = match[1] === "" ? NaN : parseInt(match[1], 10);
+	let end = match[2] === "" ? NaN : parseInt(match[2], 10);
+	if (Number.isNaN(start) && Number.isNaN(end)) return null;
+	if (Number.isNaN(start)) {
+		start = Math.max(0, size - end);
+		end = size - 1;
+	} else {
+		if (Number.isNaN(end)) end = size - 1;
+		end = Math.min(end, size - 1);
+	}
+	if (start >= size || start > end) return null;
+	return {
+		start,
+		end
+	};
+}
+/** Accumulates an HTTP request body into a UTF-8 string. Node http emits
+* Buffers, bare-http1 emits Uint8Arrays, and a setEncoding'd stream emits
+* strings — `String(uint8array)` would join bytes with commas, so decode
+* explicitly (the `/login` token body must match byte-for-byte). */
+function collectRequestBody(req) {
+	return new Promise((resolve) => {
+		const decoder = new TextDecoder();
+		let body = "";
+		req.on("data", (chunk) => {
+			body += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+		});
+		req.on("end", () => resolve(body + decoder.decode(/* @__PURE__ */ new Uint8Array(0))));
+	});
+}
+/**
+* The single loopback HTTP+WS server for the worklet. One origin serves the
+* web app (`/`), the media files mounted by plugins, and the framed-protocol
+* WebSocket socket the page connects to. On device it binds `127.0.0.1` on an
+* ephemeral port. The bundled web app (directory mounts) is public content — a
+* fresh WebView must load the page before the page can `POST /login`. Mounted
+* session files (media) and the WS upgrade are gated by a per-session token,
+* accepted as a `bare_session` cookie (set via `POST /login`), the
+* `X-Bare-Token` header, or a `?token=` query param — defense in depth for
+* non-browser clients. All responses send `Referrer-Policy: no-referrer` so
+* token-bearing URLs never leak through a Referer header.
+*/
+function createLoopbackServer(options = {}) {
+	const host = options.host ?? "127.0.0.1";
+	const port = options.port ?? 0;
+	const authEnabled = options.auth ?? true;
+	const wsIdleTimeoutMs = options.wsIdleTimeoutMs ?? 6e4;
+	const fileMounts = /* @__PURE__ */ new Map();
+	const dirMounts = /* @__PURE__ */ new Map();
+	const connectionHandlers = [];
+	let token = options.token ?? null;
+	let boundOrigin = "";
+	let originPromise = null;
+	let activeSocket = null;
+	function isAuthorized(headers, query) {
+		if (!authEnabled) return true;
+		if (token === null) return false;
+		if (tokenFromQuery(query) === token) return true;
+		if (tokenFromHeaders(headers) === token) return true;
+		return cookieSession(headers) === sessionNonce(token);
+	}
+	function writeError(res, status, message) {
+		res.writeHead(status, {
+			"Content-Type": "text/plain",
+			"Referrer-Policy": "no-referrer"
+		});
+		res.end(message);
+	}
+	function handleLogin(req, res) {
+		collectRequestBody(req).then((body) => {
+			if (!(!authEnabled || token !== null && body.trim() === token)) {
+				writeError(res, 401, "Unauthorized");
+				return;
+			}
+			const headers = {
+				"Content-Type": "text/plain",
+				"Cache-Control": "no-store",
+				"Referrer-Policy": "no-referrer"
+			};
+			if (authEnabled && token !== null) headers["Set-Cookie"] = `bare_session=${sessionNonce(token)}; HttpOnly; SameSite=Lax; Path=/`;
+			res.writeHead(200, headers);
+			res.end("ok");
+		});
+	}
+	/** Resolves a request path to a file mount, or a directory mount + relative
+	* path. Directory mounts win on longest-prefix match. */
+	function resolveMount(cleanPath) {
+		const fileMount = fileMounts.get(cleanPath);
+		if (fileMount) return {
+			kind: "file",
+			filePath: fileMount
+		};
+		let best = null;
+		let bestPrefix = -1;
+		for (const [prefix, dirPath] of dirMounts) {
+			let rel;
+			if (cleanPath === prefix) rel = "";
+			else if (prefix === "/") rel = cleanPath.replace(/^\/+/, "");
+			else if (cleanPath.startsWith(`${prefix}/`)) rel = cleanPath.slice(prefix.length + 1);
+			else continue;
+			if (prefix.length > bestPrefix) {
+				best = {
+					dirPath,
+					rel
+				};
+				bestPrefix = prefix.length;
+			}
+		}
+		return best ? {
+			kind: "dir",
+			dirPath: best.dirPath,
+			rel: best.rel
+		} : null;
+	}
+	/** Resolves a directory-mount request to a concrete file, applying the SPA
+	* fallback (unknown GET navigation → `index.html`). Subresource requests
+	* (`Accept` without `text/html`) never fall back — a missing asset is a 404. */
+	function resolveDirFile(mount, headers) {
+		const candidate = mount.rel === "" ? mount.dirPath : path.join(mount.dirPath, mount.rel);
+		try {
+			if (fs.statSync(candidate).isFile()) return candidate;
+		} catch {}
+		if (mount.rel === "") return indexHtmlIfPresent(mount.dirPath);
+		const accept = headers["accept"];
+		if (typeof accept !== "string" || !accept.includes("text/html")) return null;
+		return indexHtmlIfPresent(mount.dirPath);
+	}
+	function indexHtmlIfPresent(dirPath) {
+		try {
+			const index = path.join(dirPath, "index.html");
+			if (fs.statSync(index).isFile()) return index;
+		} catch {}
+		return null;
+	}
+	function serveFile(req, res, filePath) {
+		let stat;
+		try {
+			stat = fs.statSync(filePath);
+		} catch {
+			writeError(res, 404, "Not found");
+			return;
+		}
+		if (!stat.isFile()) {
+			writeError(res, 404, "Not found");
+			return;
+		}
+		const range = parseRange(req.headers["range"], stat.size);
+		if (range) {
+			res.writeHead(206, {
+				"Content-Type": mimeTypeFor(filePath),
+				"Content-Range": `bytes ${range.start}-${range.end}/${stat.size}`,
+				"Content-Length": range.end - range.start + 1,
+				"Accept-Ranges": "bytes",
+				"Access-Control-Allow-Origin": "*",
+				"Referrer-Policy": "no-referrer",
+				"Cache-Control": "no-store"
+			});
+			res.flushHeaders();
+			pipeFile(res, filePath, range);
+			return;
+		}
+		res.writeHead(200, {
+			"Content-Type": mimeTypeFor(filePath),
+			"Content-Length": stat.size,
+			"Accept-Ranges": "bytes",
+			"Access-Control-Allow-Origin": "*",
+			"Referrer-Policy": "no-referrer",
+			"Cache-Control": "no-store"
+		});
+		res.flushHeaders();
+		pipeFile(res, filePath);
+	}
+	/** Pipes a file's bytes to the response with an error handler. bare-fs opens
+	* its fd asynchronously, so a file evicted between `statSync` and the open
+	* (e.g. the spool LRU eviction in #8) emits `'error'` with no listeners —
+	* an unhandled error would crash the whole worklet. Headers are flushed
+	* before piping, so a mid-stream error aborts the response rather than
+	* writing a late status. */
+	function pipeFile(res, filePath, range) {
+		const stream = range ? fs.createReadStream(filePath, {
+			start: range.start,
+			end: range.end
+		}) : fs.createReadStream(filePath);
+		stream.on("error", (err) => {
+			if (!res.headersSent) {
+				writeError(res, err.code === "ENOENT" ? 404 : 500, "Failed to read file");
+				return;
+			}
+			res.destroy();
+		});
+		stream.pipe(res);
+	}
+	const server = http.createServer((req, res) => {
+		try {
+			const [rawPath, query = ""] = (req.url ?? "/").split("?");
+			const cleanPath = rawPath.split("#")[0].replace(/\/+$/, "") || "/";
+			const headers = req.headers;
+			if (req.method === "POST" && cleanPath === "/login") {
+				handleLogin(req, res);
+				return;
+			}
+			if (cleanPath.split("/").includes("..")) {
+				writeError(res, 400, "Bad request");
+				return;
+			}
+			const mount = resolveMount(cleanPath);
+			if (!(mount !== null && mount.kind === "dir") && !isAuthorized(headers, query)) {
+				writeError(res, 401, "Unauthorized");
+				return;
+			}
+			const filePath = mount === null ? null : mount.kind === "file" ? mount.filePath : resolveDirFile(mount, headers);
+			if (filePath === null) {
+				writeError(res, 404, "Not found");
+				return;
+			}
+			serveFile(req, res, filePath);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			res.writeHead(500, { "Content-Type": "text/plain" });
+			res.end(message);
+		}
+	});
+	function origin() {
+		if (!originPromise) originPromise = new Promise((resolve, reject) => {
+			token ??= crypto.randomBytes(32).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+			server.on("error", reject);
+			server.listen(port, host, () => {
+				const address = server.address();
+				boundOrigin = `http://${host}:${address.port}`;
+				resolve(boundOrigin);
+			});
+		});
+		return originPromise;
+	}
+	server.on("upgrade", (req, socket, head) => {
+		const headers = req.headers;
+		const [, query = ""] = (req.url ?? "").split("?");
+		const origin = headers["origin"];
+		if (authEnabled && typeof origin === "string" && origin.length > 0 && boundOrigin !== "" && origin !== boundOrigin) {
+			socket.destroy();
+			return;
+		}
+		if (!isAuthorized(headers, query)) {
+			socket.destroy();
+			return;
+		}
+		if (activeSocket) {
+			socket.destroy();
+			return;
+		}
+		ws.Server.handshake(req, socket, head, (err) => {
+			if (err) {
+				socket.destroy(err);
+				return;
+			}
+			const client = new ws.Socket({
+				socket,
+				isServer: true
+			});
+			activeSocket = client;
+			client.on("close", () => {
+				if (activeSocket === client) activeSocket = null;
+			});
+			socket.setTimeout(wsIdleTimeoutMs, () => client.destroy());
+			for (const handler of connectionHandlers) try {
+				handler(client, req);
+			} catch (e) {
+				const message = e instanceof Error ? e.message : String(e);
+				console.error("Error in loopback WS connection handler:", message);
+			}
+		});
+	});
+	async function url(path) {
+		return `${await origin()}${path}`;
+	}
+	return {
+		origin,
+		url,
+		token() {
+			return token ?? "";
+		},
+		async credentials() {
+			const originUrl = await origin();
+			return {
+				origin: originUrl,
+				port: Number(originUrl.slice(originUrl.lastIndexOf(":") + 1)),
+				token
+			};
+		},
+		mount(path, filePath) {
+			fileMounts.set(path, filePath);
+		},
+		unmount(path) {
+			fileMounts.delete(path);
+		},
+		mountDir(prefix, dirPath) {
+			dirMounts.set(prefix, dirPath);
+		},
+		onConnection(handler) {
+			connectionHandlers.push(handler);
+		},
+		close(cb) {
+			if (activeSocket) try {
+				activeSocket.destroy();
+			} catch {}
+			server.close(cb);
+		}
+	};
+}
+//#endregion
+//#region core/server/websocket-server.ts
+function toUint8Array$1(data) {
+	if (data instanceof Uint8Array) return data;
+	if (data instanceof ArrayBuffer) return new Uint8Array(data);
+	throw new Error("Expected Uint8Array or ArrayBuffer from socket data");
+}
+/**
+* Attaches the framed-protocol socket to the unified loopback server. The
+* server owns the WebSocket upgrade (origin check, cookie/token auth, single
+* client, idle timeout); this layer only routes decoded envelopes through the
+* plugin router and writes responses back as raw frames.
+*/
+function attachWebSocketProtocol(server, context) {
+	const { protocol, pluginRouter } = context;
+	server.onConnection((socket, _request) => {
+		socket.on("data", async (raw) => {
+			try {
+				const data = toUint8Array$1(raw);
+				if (data.byteLength === 0) return;
+				const parsed = protocol.decode(data);
+				const header = parsed.header;
+				const pluginResponse = await pluginRouter.route(header, parsed.payload);
+				if (pluginResponse) socket.write(protocol.encode(MessageType.ENVELOPE, pluginResponse, null));
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				console.error("Error handling WebSocket message:", message);
+			}
+		});
+	});
+}
+//#endregion
+//#region core/runtime.ts
+/** Resolves the host-provided worklet configuration from `start(...)`
+* arguments. On-device hosts pass `["<webAssets>", "<storage>", "<cache>"]`,
+* landing at `Bare.argv[0..2]`; the Bare CLI (dev) passes the binary and the
+* script path instead, so a missing/absent config means dev mode (auth off,
+* fixed port, no handoff file). */
+function resolveWorkletConfig() {
+	const argv = typeof Bare !== "undefined" && Array.isArray(Bare.argv) ? Bare.argv : [];
+	const webAssets = argv[0];
+	const storage = argv[1];
+	const cache = argv[2];
+	if (typeof webAssets === "string" && typeof storage === "string") try {
+		const isDir = (p) => fs.statSync(p).isDirectory();
+		if (isDir(webAssets) && isDir(storage)) {
+			const cacheDir = typeof cache === "string" && isDir(cache) ? cache : storage;
+			if (cacheDir !== cache) console.warn("[bare] cache dir missing or not a directory; falling back to the storage dir");
+			return {
+				webAssets,
+				storage,
+				cache: cacheDir
+			};
+		}
+	} catch {}
+	return {};
+}
+function toUint8Array(data) {
+	if (data instanceof Uint8Array) return data;
+	if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) return new Uint8Array(data);
+	return new Uint8Array(data);
+}
+function writeIpc(ipc, bytes) {
+	if (typeof Buffer !== "undefined" && typeof Buffer.from === "function") ipc.write(Buffer.from(bytes));
+	else ipc.write(bytes);
+}
+/**
+* Creates one worklet runtime — a per-instance, stateless factory (no
+* module-scope singletons, no hardcoded port) so the dev/test backend can host
+* N of them and a consumer worklet entry can be just "register plugins +
+* wire p2p". Mirrors the reference wiring in `core/main.core.ts`.
+*/
+function createWorkletRuntime(options = {}) {
+	const deviceMode = options.storage !== void 0;
+	const auth = options.auth ?? deviceMode;
+	const port = options.port ?? (deviceMode ? 0 : 8080);
+	const protocol = new MessageProtocol({
+		encode: (str) => new TextEncoder().encode(str),
+		decode: (bytes) => new TextDecoder().decode(bytes)
+	});
+	let ipc;
+	try {
+		ipc = getIPC();
+	} catch {
+		ipc = void 0;
+	}
+	const hostBridge = ipc ? createHostIpcBridge({
+		ipc,
+		protocol
+	}) : null;
+	const pluginRegistry = createPluginRegistry();
+	const server = createLoopbackServer({
+		host: options.host,
+		port,
+		auth,
+		wsIdleTimeoutMs: options.wsIdleTimeoutMs
+	});
+	for (const plugin of createDefaultPlugins({
+		listBareCapabilities: () => pluginRegistry.listCapabilities(),
+		queryHostCapabilities: () => hostBridge?.queryCapabilities() ?? Promise.resolve([]),
+		staticServer: server,
+		invokeOnHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null)
+	})) pluginRegistry.register(plugin);
+	const pluginRouter = createPluginRouter(pluginRegistry, "bare", { delegateToHost: (header, payload) => hostBridge?.invokeOnHost(header, payload) ?? Promise.resolve(null) });
+	if (ipc) ipc.on("data", async (data) => {
+		try {
+			const raw = toUint8Array(data);
+			if (hostBridge?.tryConsumeDownstreamFromHost(raw)) return;
+			const parsed = protocol.decode(raw);
+			const header = parsed.header;
+			const pluginResponse = await pluginRouter.route(header, parsed.payload);
+			if (pluginResponse) writeIpc(ipc, protocol.encode(MessageType.ENVELOPE, pluginResponse, null));
+		} catch (e) {
+			const message = e instanceof Error ? e.message : String(e);
+			console.error(`Malformed IPC frame dropped: ${message}`);
+		}
+	});
+	async function start() {
+		if (options.storage) try {
+			fs.rmSync(path.join(options.storage, "handoff.json"), { force: true });
+		} catch {}
+		if (options.webAssets) server.mountDir("/", options.webAssets);
+		attachWebSocketProtocol(server, {
+			protocol,
+			pluginRegistry,
+			pluginRouter
+		});
+		const credentials = await server.credentials();
+		if (deviceMode && options.storage) try {
+			fs.writeFileSync(path.join(options.storage, "handoff.json"), JSON.stringify(credentials));
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			console.error(`Failed to write handoff file: ${message}`);
+		}
+		return credentials;
+	}
+	return {
+		protocol,
+		pluginRegistry,
+		pluginRouter,
+		server,
+		hostBridge,
+		config: {
+			webAssets: options.webAssets,
+			storage: options.storage,
+			cache: options.cache,
+			deviceMode
+		},
+		start,
+		close(cb) {
+			server.close(cb);
+		}
+	};
+}
+//#endregion
+export { attachWebSocketProtocol, createLoopbackServer, createWorkletRuntime, getIPC, resolveWorkletConfig };