@ekrooh/bare 0.1.0

package/dist/static-file-server-CxeI_mQr.d.mts

@@ -0,0 +1,74 @@
+import "bare-http1";
+//#region core/server/static-file-server.d.ts
+type WebSocketLike = {
+  on(event: 'data', listener: (chunk: unknown) => void): unknown;
+  on(event: 'close', listener: () => void): unknown;
+  on(event: 'error', listener: (err: Error) => void): unknown;
+  write(data: unknown): boolean;
+  destroy(): void;
+};
+/** Minimal shape of the HTTP request object handed to WS upgrade handlers. */
+type LoopbackRequest = {
+  url?: string;
+  method?: string;
+  headers: Record<string, string | number>;
+};
+type LoopbackConnectionHandler = (socket: WebSocketLike, request: LoopbackRequest) => void;
+interface LoopbackServerOptions {
+  /** Bind address. Defaults to `127.0.0.1`. */
+  host?: string;
+  /** Port to bind; `0` picks an ephemeral port (on-device). */
+  port?: number;
+  /** Require the per-session token/cookie on every request and WS upgrade.
+   * The dev backend turns this off (the browser cannot know the token). */
+  auth?: boolean;
+  /** Fixed session token (dev/tests); otherwise a random 32-byte token is
+   * generated on first bind. */
+  token?: string;
+  /** Idle timeout (ms) after which an authenticated WebSocket connection is
+   * dropped. Defaults to 60s. */
+  wsIdleTimeoutMs?: number;
+}
+interface LoopbackServer {
+  /** Resolves to the server origin (`http://127.0.0.1:<port>`), binding on
+   * first use. */
+  origin(): Promise<string>;
+  /** Resolves to a URL for `path` (`<origin><path>`). The per-session cookie
+   * authorizes media loads; no token is embedded in the URL anymore. */
+  url(path: string): Promise<string>;
+  /** The per-session token (generated on first bind). */
+  token(): string;
+  /** Resolves to the bound origin, port and token — written to the handoff
+   * file for the host to read before loading the page. */
+  credentials(): Promise<{
+    origin: string;
+    port: number;
+    token: string;
+  }>;
+  /** Serves `filePath` at `http://<origin><path>` (exact match). */
+  mount(path: string, filePath: string): void;
+  unmount(path: string): void;
+  /** Serves every file under `dirPath` below `prefix` (longest-prefix match),
+   * with an SPA fallback to `dirPath/index.html` for unknown GET paths. */
+  mountDir(prefix: string, dirPath: string): void;
+  /** Registers a handler for authenticated, handshaken WebSocket connections
+   * (the protocol socket). */
+  onConnection(handler: LoopbackConnectionHandler): void;
+  /** Stops accepting connections and closes the server. */
+  close(cb?: (err?: Error | null) => void): void;
+}
+/**
+ * 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.
+ */
+declare function createLoopbackServer(options?: LoopbackServerOptions): LoopbackServer;
+//#endregion
+export { createLoopbackServer as n, LoopbackServer as t };

package/dist/transports.d.mts

@@ -0,0 +1,38 @@
+import { V as MessageHeader, X as WireMessage, tt as MessageTypeValue } from "./index-DjulYFJL.mjs";
+//#region web/websocket-client.d.ts
+declare global {
+  interface Window {
+    /** Per-session bridge state injected by the embedding shell on-device.
+     * `token` is exchanged for a session cookie via `POST /login`, which then
+     * rides every same-origin request — including the WebSocket upgrade.
+     * Browser dev has none (the dev backend runs without auth). */
+    __ekrooh?: {
+      token?: string;
+      [key: string]: unknown;
+    };
+    /** Set by the embedding shell on-device. */
+    BareShell?: boolean;
+  }
+}
+interface CreateWebSocketTransportOptions {
+  /** WebSocket URL. Defaults to the page's same-origin (`ws://location.host`).
+   * Browser dev passes `VITE_BARE_WS_URL` explicitly. */
+  url?: string;
+  /** Whether to bootstrap the session cookie via `POST /login` when a token
+   * is present. Defaults to `true`. */
+  login?: boolean;
+  /** Reconnect attempts after an unexpected close (boot-window). Default 5. */
+  maxRetries?: number;
+  /** Initial reconnect backoff in ms, doubling to a 2s cap. Default 250. */
+  backoffMs?: number;
+}
+interface MessageTransport {
+  send(type: MessageTypeValue, header: MessageHeader, payload?: Uint8Array | ArrayBuffer | string | null): void;
+  subscribe(handler: (message: WireMessage) => void): () => void;
+}
+declare function createWebSocketTransport(urlOrOptions?: string | CreateWebSocketTransportOptions): MessageTransport;
+//#endregion
+//#region web/transports/mock.d.ts
+declare function createMockTransport(): MessageTransport;
+//#endregion
+export { type MessageTransport, createMockTransport, createWebSocketTransport };

package/dist/transports.mjs

@@ -0,0 +1,384 @@
+import { ErrorCode, MessageProtocol, MessageType } from "./index.mjs";
+import { Actor, RealClock, event, state } from "@mantaq/core";
+//#region web/connection-machine.ts
+const idleState = state("idle")();
+const openingState = state("opening")();
+const connectedState = state("connected")();
+const backoffState = state("backoff")();
+const gaveUpState = state("gaveUp")().final();
+const loginOk = event("LOGIN_OK")();
+const loginFail = event("LOGIN_FAIL")();
+const socketOpen = event("SOCKET_OPEN")();
+const socketClose = event("SOCKET_CLOSE")();
+const retryTimer = event("RETRY_TIMER")();
+/** Append the session token to the URL as a `?token=...` query param, keeping
+* any query the URL already carries. */
+function withToken(url, token) {
+	const parsed = new URL(url);
+	parsed.searchParams.set("token", token);
+	return parsed.toString();
+}
+function createConnectionMachine(options) {
+	const context = {
+		url: options.url,
+		baseUrl: options.url,
+		token: options.token,
+		maxRetries: options.maxRetries,
+		initialBackoffMs: options.initialBackoffMs,
+		maxBackoffMs: options.maxBackoffMs,
+		retries: 0,
+		tokenTried: false
+	};
+	const actor = new Actor({
+		inputs: [
+			loginOk,
+			loginFail,
+			socketOpen,
+			socketClose
+		],
+		internal: [retryTimer],
+		outputs: [],
+		states: [
+			idleState,
+			openingState,
+			connectedState,
+			backoffState,
+			gaveUpState
+		],
+		initial: idleState,
+		clock: options.clock ?? new RealClock(),
+		context,
+		setup: (m) => {
+			m.effect(backoffState, ({ signal, context, clock, emit }) => {
+				const s = context.get();
+				const delay = Math.min(s.initialBackoffMs * 2 ** (s.retries - 1), s.maxBackoffMs);
+				clock.setTimeout(delay, () => {
+					if (signal.aborted) return;
+					emit({ type: "RETRY_TIMER" });
+				});
+			});
+			m.on(idleState, loginOk, () => ({ state: openingState }));
+			m.on(idleState, loginFail, (_event, opts) => {
+				const s = opts.context.get();
+				const tokenUrl = s.token && s.token.length > 0 ? withToken(s.baseUrl, s.token) : s.url;
+				opts.context.set({
+					...s,
+					url: tokenUrl,
+					tokenTried: true
+				});
+				return { state: openingState };
+			});
+			m.on(openingState, socketOpen, (_event, opts) => {
+				const s = opts.context.get();
+				opts.context.set({
+					...s,
+					retries: 0
+				});
+				return { state: connectedState };
+			});
+			m.on(openingState, socketClose, (_event, opts) => {
+				const s = opts.context.get();
+				if (!s.tokenTried && typeof s.token === "string" && s.token.length > 0) {
+					opts.context.set({
+						...s,
+						url: withToken(s.baseUrl, s.token),
+						tokenTried: true
+					});
+					return { state: openingState };
+				}
+				if (s.retries >= s.maxRetries) return { state: gaveUpState };
+				opts.context.set({
+					...s,
+					retries: s.retries + 1
+				});
+				return { state: backoffState };
+			});
+			m.on(connectedState, socketClose, (_event, opts) => {
+				const s = opts.context.get();
+				if (s.retries >= s.maxRetries) return { state: gaveUpState };
+				opts.context.set({
+					...s,
+					retries: s.retries + 1
+				});
+				return { state: backoffState };
+			});
+			m.on(backoffState, retryTimer, () => ({ state: openingState }));
+			m.on(backoffState, socketClose, () => ({}));
+		}
+	});
+	const name = (snapshot) => snapshot.path[0];
+	return {
+		url: () => actor.context.url,
+		state: () => name(actor.snapshot()),
+		isConnected: () => name(actor.snapshot()) === "connected",
+		isGaveUp: () => name(actor.snapshot()) === "gaveUp",
+		sendLoginOk: () => actor.send(loginOk.create()),
+		sendLoginFail: () => actor.send(loginFail.create()),
+		sendOpen: () => actor.send(socketOpen.create()),
+		sendClose: () => actor.send(socketClose.create()),
+		onChange(fn) {
+			return actor.on("change", (snapshot) => fn(name(snapshot)));
+		}
+	};
+}
+//#endregion
+//#region web/websocket-client.ts
+const protocol = new MessageProtocol();
+const WS_DISCONNECTED_MESSAGE = "WebSocket disconnected before request could be sent";
+const DEFAULT_RETRIES = 5;
+const DEFAULT_BACKOFF_MS = 250;
+const MAX_BACKOFF_MS = 2e3;
+const LOGIN_TIMEOUT_MS = 2e3;
+/** Same-origin default: on-device the page is served by the loopback server,
+* so `ws://<location.host>` is the protocol socket with no mixed content and
+* no custom scheme. */
+function defaultWsUrl() {
+	if (typeof window !== "undefined" && window.location?.host) return `ws://${window.location.host}`;
+	return "ws://localhost:8080";
+}
+/**
+* `websocket.send` needs a `BufferSource` backed by a plain `ArrayBuffer`;
+* the codec may produce a view into a pooled Buffer, so slice a standalone
+* copy of just the frame.
+*/
+function toArrayBuffer(bytes) {
+	return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+function createWebSocketTransport(urlOrOptions = {}) {
+	const options = typeof urlOrOptions === "string" ? { url: urlOrOptions } : urlOrOptions;
+	const url = options.url ?? defaultWsUrl();
+	const maxRetries = options.maxRetries ?? DEFAULT_RETRIES;
+	const initialBackoff = options.backoffMs ?? DEFAULT_BACKOFF_MS;
+	const token = typeof window !== "undefined" ? window.__ekrooh?.token : void 0;
+	const shouldLogin = options.login !== false && typeof token === "string" && token.length > 0;
+	const listeners = /* @__PURE__ */ new Set();
+	const queued = [];
+	let socket = null;
+	const machine = createConnectionMachine({
+		url,
+		token: typeof token === "string" ? token : void 0,
+		maxRetries,
+		initialBackoffMs: initialBackoff,
+		maxBackoffMs: MAX_BACKOFF_MS
+	});
+	const emitTransportError = (header, message) => {
+		if (header.type !== "INVOKE_REQUEST") return;
+		for (const listener of listeners) listener({
+			type: MessageType.ENVELOPE,
+			header: {
+				type: "INVOKE_RESPONSE",
+				pluginId: header.pluginId,
+				event: header.event,
+				requestId: header.requestId,
+				error: {
+					code: ErrorCode.TRANSPORT_ERROR,
+					message
+				}
+			},
+			payload: /* @__PURE__ */ new Uint8Array(0)
+		});
+	};
+	const failQueuedMessages = (message) => {
+		for (const queuedMessage of queued) emitTransportError(queuedMessage.header, message);
+		queued.length = 0;
+	};
+	const flushQueued = () => {
+		for (const queuedMessage of queued) socket?.send(toArrayBuffer(queuedMessage.bytes));
+		queued.length = 0;
+	};
+	/** Opens a WebSocket for the machine's current URL and wires it to the
+	* machine's lifecycle events. */
+	function openSocket() {
+		socket = new WebSocket(machine.url());
+		socket.binaryType = "arraybuffer";
+		socket.onopen = () => {
+			machine.sendOpen();
+			flushQueued();
+		};
+		socket.onmessage = (event) => {
+			if ((event.data?.byteLength ?? 0) === 0) return;
+			try {
+				const message = protocol.decode(event.data);
+				for (const listener of listeners) listener(message);
+			} catch (err) {
+				console.error("Failed to parse WS message:", err);
+			}
+		};
+		socket.onclose = () => {
+			machine.sendClose();
+		};
+		socket.onerror = () => {};
+	}
+	machine.onChange((state) => {
+		if (state === "opening") openSocket();
+		else if (state === "gaveUp") failQueuedMessages(WS_DISCONNECTED_MESSAGE);
+	});
+	async function bootstrap() {
+		if (shouldLogin) {
+			const loginTimeout = new Promise((resolve) => {
+				setTimeout(() => resolve("timeout"), LOGIN_TIMEOUT_MS);
+			});
+			try {
+				if (await Promise.race([fetch("/login", {
+					method: "POST",
+					body: token
+				}).then((response) => response.ok ? "ok" : "rejected"), loginTimeout]) === "ok") machine.sendLoginOk();
+				else machine.sendLoginFail();
+			} catch {
+				machine.sendLoginFail();
+			}
+		} else machine.sendLoginOk();
+	}
+	bootstrap();
+	return {
+		send(type, header, payload) {
+			const encoded = protocol.encode(type, header, payload);
+			if (machine.isConnected() && socket && socket.readyState === WebSocket.OPEN) {
+				socket.send(toArrayBuffer(encoded));
+				return;
+			}
+			if (machine.isGaveUp()) {
+				emitTransportError(header, WS_DISCONNECTED_MESSAGE);
+				return;
+			}
+			queued.push({
+				bytes: encoded,
+				header
+			});
+		},
+		subscribe(handler) {
+			listeners.add(handler);
+			return () => {
+				listeners.delete(handler);
+			};
+		}
+	};
+}
+//#endregion
+//#region web/transports/mock-handlers.ts
+function createHealthInvokeHandlers() {
+	return {
+		"health.ping": (args) => ({
+			message: String(args?.message ?? "pong"),
+			ts: Date.now()
+		}),
+		"health.payloadEcho": (args, payload) => {
+			const payloadSize = typeof payload === "string" ? new TextEncoder().encode(payload).byteLength : payload instanceof ArrayBuffer ? payload.byteLength : payload?.byteLength ?? 0;
+			return {
+				label: String(args?.label ?? "payload"),
+				payloadSize
+			};
+		},
+		"health.roundtrip": () => ({
+			pong: true,
+			ts: Date.now()
+		})
+	};
+}
+//#endregion
+//#region web/transports/mock.ts
+const MOCK_MEDIA_DATA_URI = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAbUlEQVR4nO3O7UkCABiAQcd5hjXSyCKLPrCiklRswHOM/rw3wS0s4yquYxXruInb2MRd3MdDbOMxnuI5XuI13mIX7/ERn/EV3/ET+/iNQxzjFOf4y2ICE5jABCYwgQlMYAITmMAEJjCBCfx34ALvwBam5OydHgAAAABJRU5ErkJggg==";
+const permissionOf = (args) => typeof args?.permission === "string" ? args.permission : "storage";
+const mockInvokeHandlers = {
+	...createHealthInvokeHandlers(),
+	"discovery.list": () => ({
+		schemaVersion: 1,
+		capabilities: [
+			{
+				pluginId: "core.health",
+				capabilities: [],
+				events: [
+					"health.ping",
+					"health.payloadEcho",
+					"health.roundtrip"
+				],
+				runtimes: ["bare"]
+			},
+			{
+				pluginId: "core.discovery",
+				capabilities: ["discovery"],
+				events: ["discovery.list"],
+				runtimes: ["bare"]
+			},
+			{
+				pluginId: "core.permissions",
+				capabilities: ["permissions"],
+				events: ["permissions.request", "permissions.status"],
+				runtimes: []
+			},
+			{
+				pluginId: "vendor.media",
+				capabilities: ["media"],
+				events: ["media.pick", "media.capture"],
+				runtimes: ["bare"]
+			}
+		]
+	}),
+	"permissions.request": (args) => ({
+		permission: permissionOf(args),
+		status: "granted"
+	}),
+	"permissions.status": (args) => ({
+		permission: permissionOf(args),
+		status: "granted"
+	}),
+	"media.pick": () => ({
+		url: MOCK_MEDIA_DATA_URI,
+		path: ""
+	}),
+	"media.capture": () => ({
+		url: MOCK_MEDIA_DATA_URI,
+		path: ""
+	})
+};
+function createMockTransport() {
+	const listeners = /* @__PURE__ */ new Set();
+	const invokeHandlers = mockInvokeHandlers;
+	const emit = (message) => {
+		queueMicrotask(() => {
+			for (const listener of listeners) listener(message);
+		});
+	};
+	return {
+		send(type, header, payload) {
+			if (type !== MessageType.ENVELOPE || header.type !== "INVOKE_REQUEST") return;
+			const handler = invokeHandlers[header.event];
+			if (!handler) {
+				emit({
+					type: MessageType.ENVELOPE,
+					header: {
+						type: "INVOKE_RESPONSE",
+						pluginId: header.pluginId,
+						event: header.event,
+						requestId: header.requestId,
+						error: {
+							code: ErrorCode.UNSUPPORTED_EVENT,
+							message: `Unsupported mock event: ${header.event}`
+						}
+					},
+					payload: /* @__PURE__ */ new Uint8Array(0)
+				});
+				return;
+			}
+			emit({
+				type: MessageType.ENVELOPE,
+				header: {
+					type: "INVOKE_RESPONSE",
+					pluginId: header.pluginId,
+					event: header.event,
+					requestId: header.requestId,
+					result: handler(header.args, payload)
+				},
+				payload: /* @__PURE__ */ new Uint8Array(0)
+			});
+		},
+		subscribe(handler) {
+			listeners.add(handler);
+			return () => {
+				listeners.delete(handler);
+			};
+		}
+	};
+}
+//#endregion
+export { createMockTransport, createWebSocketTransport };

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@ekrooh/bare",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "One soul, many platforms — the boring bootstrap for cross-platform apps on the Bare runtime: wire protocol, plugin kernel, RPC messenger, transports, and native host bridges.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AndersCan/ekrooh.git"
+  },
+  "workspaces": [
+    "examples/*",
+    "e2e"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./core": "./dist/index.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./plugins": "./dist/plugins.mjs",
+    "./plugins/health/events": "./dist/plugins-health-events.mjs",
+    "./plugins/discovery/events": "./dist/plugins-discovery-events.mjs",
+    "./plugins/permissions/events": "./dist/plugins-permissions-events.mjs",
+    "./plugins/media/events": "./dist/plugins-media-events.mjs",
+    "./transports": "./dist/transports.mjs",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "check": "vp check",
+    "lint": "vp fmt . --fix",
+    "typecheck": "tsc --noEmit",
+    "test": "vp test && npm run test:e2e:web && npm run test:e2e:harness",
+    "test:unit": "vp test",
+    "test:e2e:web": "node scripts/playwright-local-browsers.mjs test",
+    "dev": "concurrently \"vp -C examples/web dev\" \"npm run dev:bare\"",
+    "predev": "npm run build:pkg",
+    "dev:bare": "node scripts/dev-bare.mjs",
+    "dev:mock": "VITE_TRANSPORT_MODE=mock vp -C examples/web dev",
+    "predev:mock": "npm run build:pkg",
+    "dev:ws": "vp -C examples/web dev",
+    "predev:ws": "npm run build:pkg",
+    "dev:e2e": "vp -C examples/web dev --host 127.0.0.1 --port 4173 --strictPort",
+    "predev:e2e": "npm run build:pkg",
+    "build": "npm run build:android-assets",
+    "build:pkg": "vp pack",
+    "prepack": "npm run build:pkg",
+    "prepublishOnly": "npm run build:pkg",
+    "build:web": "npm run build:pkg && vp -C examples/web build",
+    "build:core": "npm run build:bare:app",
+    "build:android-assets": "npm run build:core && npm run build:web",
+    "build:ios": "node scripts/build-ios-app.mjs",
+    "test:ios": "node scripts/test-ios.mjs",
+    "build:bare": "npm run build:core",
+    "build:bare:app": "esbuild core/main.core.ts --bundle --packages=external --platform=node --format=esm --outfile=core/main.core.gen.js",
+    "build:harness": "esbuild core/harness.core.ts --bundle --packages=external --platform=node --format=esm --outfile=core/harness.core.gen.js",
+    "harness:e2e": "npm run build:harness && npm run build:web && node scripts/harness-e2e.mjs",
+    "test:e2e:harness": "node scripts/playwright-local-browsers.mjs test --config playwright.harness.config.ts",
+    "playwright:install": "node scripts/playwright-local-browsers.mjs install chromium",
+    "smoke:loopback": "esbuild scripts/smoke-loopback.mjs --bundle --packages=external --platform=node --format=esm --outfile=scripts/smoke-loopback.gen.mjs && bare scripts/smoke-loopback.gen.mjs",
+    "smoke:p2p": "npm run build:p2p-verify && rm -rf .p2p-smoke && mkdir .p2p-smoke && bare core/p2p-verify.core.gen.js .p2p-smoke",
+    "build:p2p-verify": "esbuild core/p2p-verify.core.ts --bundle --packages=external --platform=node --format=esm --outfile=core/p2p-verify.core.gen.js",
+    "prebuilds": "node scripts/fetch-prebuilds.mjs",
+    "prepare": "vp config"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "@vitest/coverage-v8": "^4.1.10",
+    "bare": "^1.28.0",
+    "bare-link": "^3.3.0",
+    "bare-pack": "^2.2.1",
+    "bare-runtime": "^1.28.0",
+    "concurrently": "^10.0.4",
+    "corestore": "^7.12.0",
+    "esbuild": "^0.28.0",
+    "hyperdrive": "^13.3.3",
+    "hyperswarm": "^4.17.0",
+    "typescript": "^7.0.2",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.8",
+    "vite-plus": "0.2.8"
+  },
+  "dependencies": {
+    "@mantaq/core": "^0.2.0",
+    "@mantaq/sugar": "^0.2.0",
+    "bare-crypto": "^1.15.3",
+    "bare-encoding": "^1.0.3",
+    "bare-env": "^3.0.0",
+    "bare-fs": "^4.8.0",
+    "bare-http1": "^4.5.7",
+    "bare-path": "^3.1.1",
+    "bare-tcp": "^2.2.7",
+    "bare-ws": "^3.0.0",
+    "fs-native-extensions": "1.5.0",
+    "quickbit-native": "2.4.8",
+    "rabin-native": "2.0.0",
+    "rocksdb-native": "3.17.4",
+    "simdle-native": "1.3.9",
+    "sodium-native": "5.1.0",
+    "udx-native": "1.21.0"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "npm",
+      "version": "12.0.2",
+      "onFail": "warn"
+    }
+  },
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.8"
+  }
+}