@rivet-dev/agentos-browser 0.2.4 → 0.2.5-rc.2

package/dist/openai-proxy.js

@@ -0,0 +1,115 @@
+// The in-sandbox OpenAI proxy logic (AGENTOS-WEB-ASYNC-AGENTS.md §6). pi (and any
+// OpenAI/Anthropic HTTP client) talks to its `baseUrl` over plain loopback HTTP; a
+// guest proxy listening on that port forwards the request body to on-device inference
+// through the kernel-brokered `host.inference` syscall and returns the reply as an
+// HTTP response. pi needs ZERO changes beyond the baseUrl.
+//
+// This module is the PURE framing + forwarding logic, free of any socket/syscall
+// dependency (those are injected), so it is unit-testable in Node and reusable by both
+// the test proxy agent and the eventual standalone proxy guest. The proxy does not
+// transform the chat body — it is HTTP framing around the inference call: the request
+// body IS the chat-completion JSON the chrome-llm adapter consumes, and that adapter's
+// reply IS the HTTP response body.
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+/** Build a minimal HTTP/1.1 request (the client/pi side). */
+export function buildHttpRequest(method, path, body, host = "127.0.0.1") {
+    const bodyBytes = encoder.encode(body);
+    const head = `${method} ${path} HTTP/1.1\r\n` +
+        `Host: ${host}\r\n` +
+        `Content-Type: application/json\r\n` +
+        `Content-Length: ${bodyBytes.byteLength}\r\n` +
+        `Connection: close\r\n\r\n`;
+    return concat(encoder.encode(head), bodyBytes);
+}
+/** Build a minimal HTTP/1.1 response (the proxy side). */
+export function buildHttpResponse(status, body) {
+    const bodyBytes = encoder.encode(body);
+    const reason = status === 200 ? "OK" : status === 400 ? "Bad Request" : "Error";
+    const head = `HTTP/1.1 ${status} ${reason}\r\n` +
+        `Content-Type: application/json\r\n` +
+        `Content-Length: ${bodyBytes.byteLength}\r\n` +
+        `Connection: close\r\n\r\n`;
+    return concat(encoder.encode(head), bodyBytes);
+}
+/** Index of the end of the header block (after the CRLFCRLF), or -1 if not yet present. */
+function headerEnd(bytes) {
+    for (let i = 3; i < bytes.length; i += 1) {
+        if (bytes[i - 3] === 13 && bytes[i - 2] === 10 && bytes[i - 1] === 13 && bytes[i] === 10) {
+            return i + 1;
+        }
+    }
+    return -1;
+}
+function parseHeaders(headerText) {
+    const lines = headerText.split("\r\n").filter((l) => l.length > 0);
+    const startLine = lines.shift() ?? "";
+    const headers = new Map();
+    for (const line of lines) {
+        const colon = line.indexOf(":");
+        if (colon > 0)
+            headers.set(line.slice(0, colon).trim().toLowerCase(), line.slice(colon + 1).trim());
+    }
+    return { startLine, headers };
+}
+function contentLength(headers) {
+    const raw = headers.get("content-length");
+    const n = raw ? Number.parseInt(raw, 10) : 0;
+    return Number.isFinite(n) && n >= 0 ? n : 0;
+}
+/** Read a full HTTP message (headers + Content-Length body) by pulling chunks from
+ * `readChunk` until complete. `readChunk()` returns the next bytes (possibly empty if
+ * not ready yet) or null on EOF. Returns the assembled bytes + the body offset. */
+function readFullMessage(initial, readChunk) {
+    let buf = initial;
+    for (let guard = 0; guard < 100_000; guard += 1) {
+        const bodyStart = headerEnd(buf);
+        if (bodyStart >= 0) {
+            const { headers } = parseHeaders(decoder.decode(buf.subarray(0, bodyStart)));
+            const need = bodyStart + contentLength(headers);
+            if (buf.byteLength >= need)
+                return { bytes: buf.subarray(0, need), bodyStart };
+        }
+        const chunk = readChunk();
+        if (chunk === null)
+            return bodyStart >= 0 ? { bytes: buf, bodyStart } : null;
+        if (chunk.byteLength > 0)
+            buf = concat(buf, chunk);
+    }
+    return null;
+}
+/** Parse a complete HTTP request, reading more via `readChunk` until the body is in. */
+export function readHttpRequest(initial, readChunk) {
+    const message = readFullMessage(initial, readChunk);
+    if (!message)
+        return null;
+    const { startLine, headers } = parseHeaders(decoder.decode(message.bytes.subarray(0, message.bodyStart)));
+    const [method = "", path = ""] = startLine.split(" ");
+    return { method, path, headers, body: decoder.decode(message.bytes.subarray(message.bodyStart)) };
+}
+/** Parse a complete HTTP response (the client/pi side). */
+export function readHttpResponse(initial, readChunk) {
+    const message = readFullMessage(initial, readChunk);
+    if (!message)
+        return null;
+    const { startLine, headers } = parseHeaders(decoder.decode(message.bytes.subarray(0, message.bodyStart)));
+    const status = Number.parseInt(startLine.split(" ")[1] ?? "0", 10) || 0;
+    return { status, headers, body: decoder.decode(message.bytes.subarray(message.bodyStart)) };
+}
+/** The proxy core: turn one parsed HTTP request into an HTTP response by forwarding
+ * the body to `infer` (the host.inference call). Only POSTs to a chat/completions or
+ * /v1/messages path are forwarded; anything else is a 404-shaped error. */
+export async function handleProxyRequest(request, infer) {
+    const isChat = request.method === "POST" && /\/(chat\/completions|messages|completions)$/.test(request.path);
+    if (!isChat) {
+        return buildHttpResponse(404, JSON.stringify({ error: { type: "not_found", message: `no handler for ${request.method} ${request.path}` } }));
+    }
+    const reply = await infer(request.body);
+    return buildHttpResponse(200, reply);
+}
+function concat(a, b) {
+    const out = new Uint8Array(a.byteLength + b.byteLength);
+    out.set(a, 0);
+    out.set(b, a.byteLength);
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rivet-dev/agentos-browser",
-	"version": "0.2.4",
+	"version": "0.2.5-rc.2",
 	"type": "module",
 	"license": "Apache-2.0",
 	"main": "./dist/index.js",
@@ -14,56 +14,34 @@
 			"types": "./dist/index.d.ts",
 			"import": "./dist/index.js",
 			"default": "./dist/index.js"
-		},
-		"./internal/driver": {
-			"types": "./dist/driver.d.ts",
-			"import": "./dist/driver.js",
-			"default": "./dist/driver.js"
-		},
-		"./internal/runtime-driver": {
-			"types": "./dist/runtime-driver.d.ts",
-			"import": "./dist/runtime-driver.js",
-			"default": "./dist/runtime-driver.js"
-		},
-		"./internal/worker": {
-			"types": "./dist/worker.d.ts",
-			"import": "./dist/worker.js",
-			"default": "./dist/worker.js"
-		},
-		"./internal/worker-protocol": {
-			"types": "./dist/worker-protocol.d.ts",
-			"import": "./dist/worker-protocol.js",
-			"default": "./dist/worker-protocol.js"
-		},
-		"./internal/permission-validation": {
-			"types": "./dist/permission-validation.d.ts",
-			"import": "./dist/permission-validation.js",
-			"default": "./dist/permission-validation.js"
-		},
-		"./internal/os-filesystem": {
-			"types": "./dist/os-filesystem.d.ts",
-			"import": "./dist/os-filesystem.js",
-			"default": "./dist/os-filesystem.js"
-		},
-		"./internal/worker-adapter": {
-			"types": "./dist/worker-adapter.d.ts",
-			"import": "./dist/worker-adapter.js",
-			"default": "./dist/worker-adapter.js"
 		}
 	},
 	"scripts": {
-		"check-types": "tsc --noEmit",
-		"build": "tsc",
-		"test:browser": "node ./scripts/run-browser-tests.mjs",
-		"test": "pnpm build && vitest run tests/runtime-driver && pnpm run test:browser"
+		"check-types": "pnpm check:converged-gates && tsc --noEmit",
+		"check:converged-gates": "node ./scripts/check-converged-gates.mjs",
+		"dev": "vite",
+		"build": "tsc && pnpm build:dist-wasm",
+		"build:dist-wasm": "node ./scripts/build-dist-wasm.mjs",
+		"build:sidecar-wasm": "node ./scripts/build-sidecar-wasm.mjs",
+		"build:wasm-test-assets": "node ./scripts/build-wasm-test-assets.mjs",
+		"verify:real-language-model": "node ./scripts/verify-real-language-model.mjs",
+		"verify:real-pi-tui": "node ./scripts/verify-real-pi-tui.mjs",
+		"verify:real-pi-model": "node ./scripts/verify-real-pi-model.mjs",
+		"test:browser-wasm": "playwright test --config=playwright.wasm.config.ts",
+		"test": "pnpm check:converged-gates && pnpm build && vitest run tests/runtime-driver && pnpm run test:browser-wasm"
 	},
 	"dependencies": {
+		"@secure-exec/browser": "0.3.4-rc.1",
+		"@secure-exec/core": "0.3.4-rc.1",
 		"sucrase": "^3.35.0"
 	},
 	"devDependencies": {
 		"@playwright/test": "^1.54.2",
 		"@types/node": "^22.10.2",
+		"@xterm/addon-fit": "0.10.0",
+		"@xterm/xterm": "5.5.0",
 		"typescript": "^5.7.2",
+		"vite": "^6.4.3",
 		"vitest": "^2.1.8"
 	}
 }

package/dist/driver.d.ts

@@ -1,114 +0,0 @@
-import type { NetworkAdapter, Permissions, SystemDriver, VirtualFileSystem } from "./runtime.js";
-import { createCommandExecutorStub, createFsStub, createNetworkStub } from "./runtime.js";
-export interface BrowserRuntimeSystemOptions {
-    filesystem: "opfs" | "memory";
-    networkEnabled: boolean;
-}
-export declare function releaseOpfsNamespace(namespace: string): Promise<void>;
-export declare function listOpfsNamespaces(): Promise<string[]>;
-/**
- * VFS backed by the Origin Private File System (OPFS) API. Falls back to
- * InMemoryFileSystem when OPFS is unavailable. Rename is not supported
- * (throws ENOSYS) since OPFS doesn't provide atomic rename.
- */
-export declare class OpfsFileSystem implements VirtualFileSystem {
-    private rootPromise;
-    readonly namespace: string;
-    /**
-     * @param namespace Unique per-runtime/tenant OPFS namespace. Defaults to a
-     * freshly generated id so co-resident runtimes never share storage (F-015).
-     * Pass a stable id to persist a runtime's data across instances.
-     */
-    constructor(namespace?: string);
-    private getDirHandle;
-    private getFileHandle;
-    readFile(path: string): Promise<Uint8Array>;
-    readTextFile(path: string): Promise<string>;
-    readDir(path: string): Promise<string[]>;
-    readDirWithTypes(path: string): Promise<Array<{
-        name: string;
-        isDirectory: boolean;
-    }>>;
-    writeFile(path: string, content: string | Uint8Array): Promise<void>;
-    createDir(path: string): Promise<void>;
-    mkdir(path: string, _options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    exists(path: string): Promise<boolean>;
-    stat(path: string): Promise<{
-        mode: number;
-        size: number;
-        blocks: number;
-        dev: number;
-        rdev: number;
-        isDirectory: boolean;
-        isSymbolicLink: boolean;
-        atimeMs: number;
-        mtimeMs: number;
-        ctimeMs: number;
-        birthtimeMs: number;
-        ino: number;
-        nlink: number;
-        uid: number;
-        gid: number;
-    }>;
-    removeFile(path: string): Promise<void>;
-    removeDir(path: string): Promise<void>;
-    rename(_oldPath: string, _newPath: string): Promise<void>;
-    symlink(_target: string, _linkPath: string): Promise<void>;
-    readlink(_path: string): Promise<string>;
-    lstat(path: string): Promise<{
-        mode: number;
-        size: number;
-        blocks: number;
-        dev: number;
-        rdev: number;
-        isDirectory: boolean;
-        isSymbolicLink: boolean;
-        atimeMs: number;
-        mtimeMs: number;
-        ctimeMs: number;
-        birthtimeMs: number;
-        ino: number;
-        nlink: number;
-        uid: number;
-        gid: number;
-    }>;
-    link(_oldPath: string, _newPath: string): Promise<void>;
-    chmod(_path: string, _mode: number): Promise<void>;
-    chown(_path: string, _uid: number, _gid: number): Promise<void>;
-    utimes(_path: string, _atime: number, _mtime: number): Promise<void>;
-    truncate(path: string, length: number): Promise<void>;
-    realpath(path: string): Promise<string>;
-    pread(path: string, offset: number, length: number): Promise<Uint8Array>;
-    pwrite(path: string, offset: number, data: Uint8Array): Promise<void>;
-}
-export interface BrowserDriverOptions {
-    filesystem?: "opfs" | "memory";
-    permissions?: Permissions;
-    useDefaultNetwork?: boolean;
-    /**
-     * Per-runtime/tenant OPFS namespace. Defaults to a freshly generated id so
-     * co-resident runtimes never share storage (F-015). Pass a stable id to
-     * persist a runtime's data across driver instances. Generated default
-     * namespaces are not garbage-collected automatically; long-lived embedders
-     * should either pass a stable namespace or call `releaseOpfsNamespace`.
-     */
-    opfsNamespace?: string;
-}
-/**
- * Create an OPFS-backed filesystem, falling back to in-memory if OPFS is
- * unavailable. Each instance is namespaced under a unique per-runtime
- * subdirectory (F-015); pass `namespace` to use a stable, persistent namespace.
- */
-export declare function createOpfsFileSystem(namespace?: string): Promise<VirtualFileSystem>;
-export interface BrowserNetworkAdapterOptions {
-    fetch?: typeof fetch;
-}
-/** Network adapter that delegates to the browser's native `fetch`. DNS and http2 are unsupported. */
-export declare function createBrowserNetworkAdapter(options?: BrowserNetworkAdapterOptions): NetworkAdapter;
-/** Recover runtime-driver options from a browser SystemDriver instance. */
-export declare function getBrowserSystemDriverOptions(systemDriver: SystemDriver): BrowserRuntimeSystemOptions;
-/** Assemble a browser-side SystemDriver with permission-wrapped adapters. */
-export declare function createBrowserDriver(options?: BrowserDriverOptions): Promise<SystemDriver>;
-export { createCommandExecutorStub, createFsStub, createNetworkStub };