hyperbrane 0.1.2 → 0.2.0

package/dist/agent/session/workerConnection.js

@@ -1,44 +1,39 @@
 import { createJsonRpcPeer } from "./worker/jsonRpc.js";
-import { WorkerMethodNotFoundError, decodeWorkerError, encodeWorkerError, } from "./worker/protocol.js";
-/** A connection speaking JSON-RPC over `transport` (`label` says where to, in errors). */
+import { WORKER_PROTOCOL, WorkerMethodNotFoundError, decodeWorkerError, encodeWorkerError, } from "./worker/protocol.js";
 export function workerConnectionOver(transport, label, onNotification) {
     let peer;
     transport.onText((text) => peer?.receive(text));
     const closed = transport.closed.then(() => peer?.close(new Error(`the worker at ${label} closed the connection`)));
     peer = createJsonRpcPeer((text) => transport.write(text), {
-        // The worker makes no requests of its clients.
         onRequest: async (method) => {
             throw new WorkerMethodNotFoundError(`no method ${method}`);
         },
-        // type-bypass: notifications arrive as JSON; the worker only sends those in WorkerNotifications.
         onNotification: (method, params) => onNotification?.(method, params),
+        protocol: WORKER_PROTOCOL,
         encodeError: encodeWorkerError,
         decodeError: decodeWorkerError,
     });
     const connected = peer;
     return {
-        // type-bypass: the result is the one WorkerRequests pairs with this method.
         request: (method, params) => connected.request(method, params),
         closed,
         close: () => transport.close(),
     };
 }
-/**
- * Connects over the worker's unix socket at `socketPath` in `host` (the dimension's run directory is
- * mounted on the host, wherever that is: this machine, or a server reached over SSH), speaking
- * JSON-RPC.
- */
 export function workerSocketConnector(host, socketPath) {
+    return workerStreamConnector(() => host.connect(socketPath), socketPath);
+}
+export function workerStreamConnector(open, label) {
     return async (onNotification) => {
         const decoder = new TextDecoder();
         const encoder = new TextEncoder();
-        const socket = await host.connect(socketPath);
+        const socket = await open();
         const transport = {
             write: (text) => socket.write(encoder.encode(text)),
             onText: (listener) => socket.onData((data) => listener(decoder.decode(data, { stream: true }))),
             closed: socket.closed,
             close: () => socket.close(),
         };
-        return workerConnectionOver(transport, socketPath, onNotification);
+        return workerConnectionOver(transport, label, onNotification);
     };
 }

package/dist/agent/session/workerGatewayConnection.d.ts

@@ -0,0 +1,18 @@
+import type { SandboxAccess } from "../../sandbox/api.ts";
+import { type ConnectWorker } from "./workerConnection.ts";
+export declare class EndpointUnreachableError extends Error {
+    readonly url: string;
+    name: string;
+    constructor(url: string, cause?: unknown);
+}
+export declare class EndpointCredentialsError extends Error {
+    readonly url: string;
+    name: string;
+    constructor(url: string);
+}
+export declare function workerGatewayConnector(endpoint: SandboxAccess, { dimensionName, agentName, }: {
+    dimensionName: string;
+    agentName: string;
+}, { signal, }?: {
+    signal?: AbortSignal;
+}): ConnectWorker;

package/dist/agent/session/workerGatewayConnection.js

@@ -0,0 +1,86 @@
+import { EventSourceParserStream } from "eventsource-parser/stream";
+import { AgentNotFoundError } from "../api.js";
+import { workerConnectionOver } from "./workerConnection.js";
+const TOKEN_PARAM = "hyb_token";
+export class EndpointUnreachableError extends Error {
+    url;
+    name = "EndpointUnreachableError";
+    constructor(url, cause) {
+        super(`the gateway ${url} didn't answer (a browser reports this as a CORS error): the machine is unreachable, or the gateway isn't running`, { cause });
+        this.url = url;
+    }
+}
+export class EndpointCredentialsError extends Error {
+    url;
+    name = "EndpointCredentialsError";
+    constructor(url) {
+        super(`the gateway ${url} refused the credentials: they expired, or aren't its own; get new ones`);
+        this.url = url;
+    }
+}
+export function workerGatewayConnector(endpoint, { dimensionName, agentName, }, { signal, } = {}) {
+    const { exeDev, token } = endpoint.credentials;
+    const headers = exeDev ? { "x-exedev-authorization": `Bearer ${exeDev.token}` } : {};
+    const url = (path, params = {}) => `${endpoint.url}${path}?${new URLSearchParams({ ...params, [TOKEN_PARAM]: token })}`;
+    const label = `agent ${agentName}'s worker through ${endpoint.url}`;
+    return async (onNotification) => {
+        signal?.throwIfAborted();
+        const aborting = new AbortController();
+        signal?.addEventListener("abort", () => aborting.abort(), { once: true });
+        let response;
+        try {
+            response = await fetch(url("/connect", { dimension: dimensionName, agent: agentName }), { headers, signal: aborting.signal });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            throw new EndpointUnreachableError(endpoint.url, error);
+        }
+        if (response.status === 401)
+            throw new EndpointCredentialsError(endpoint.url);
+        if (response.status === 502)
+            throw new AgentNotFoundError(`${label} can't be reached: ${(await response.text()).trim()}`);
+        if (!response.ok || !response.body)
+            throw new Error(`${label}: the gateway answered ${response.status}: ${(await response.text()).trim()}`);
+        const events = response.body.pipeThrough(new TextDecoderStream()).pipeThrough(new EventSourceParserStream()).getReader();
+        const opened = await events.read();
+        if (opened.done || opened.value.event !== "open")
+            throw new Error(`${label}: the gateway's stream didn't open`);
+        const { connection } = JSON.parse(opened.value.data);
+        const listeners = [];
+        let markClosed;
+        const closed = new Promise((done) => (markClosed = done));
+        void (async () => {
+            try {
+                for (;;) {
+                    const { value, done } = await events.read();
+                    if (done || value.event === "close")
+                        break;
+                    for (const listener of listeners)
+                        listener(`${value.data}\n`);
+                }
+            }
+            catch {
+                return;
+            }
+            finally {
+                markClosed();
+            }
+        })();
+        let writes = Promise.resolve();
+        const transport = {
+            write(text) {
+                if (aborting.signal.aborted)
+                    return;
+                writes = writes.then(() => fetch(url(`/connect/${connection}`), { method: "POST", headers, body: text, signal: aborting.signal }).then((response) => {
+                    if (!response.ok)
+                        aborting.abort();
+                }, () => aborting.abort()));
+            },
+            onText: (listener) => void listeners.push(listener),
+            closed,
+            close: () => aborting.abort(),
+        };
+        return workerConnectionOver(transport, label, onNotification);
+    };
+}

package/dist/agent/vendor-types/manifest.json

@@ -0,0 +1,87 @@
+{
+    "claude": {
+        "docs": "https://code.claude.com/docs/en/agent-sdk/typescript",
+        "sources": [
+            {
+                "source": "npm:@anthropic-ai/claude-agent-sdk@0.3.283",
+                "into": "agent-sdk",
+                "files": 7
+            }
+        ]
+    },
+    "codex": {
+        "docs": "https://developers.openai.com/codex/app-server",
+        "sources": [
+            {
+                "source": "npm:@openai/codex-sdk@0.157.1",
+                "into": "sdk",
+                "files": 1
+            },
+            {
+                "source": "github:openai/codex@rust-v0.157.1/codex-rs/app-server-protocol/schema/typescript",
+                "into": "app-server",
+                "files": 740
+            },
+            {
+                "source": "github:openai/codex@rust-v0.157.1/codex-rs/app-server-protocol/schema/json",
+                "into": "app-server-json",
+                "files": 2
+            }
+        ]
+    },
+    "pi": {
+        "docs": "https://github.com/badlogic/pi-mono/blob/main/packages/coding-agent/docs/rpc.md",
+        "sources": [
+            {
+                "source": "npm:@mariozechner/pi-coding-agent@0.73.1",
+                "into": "coding-agent",
+                "files": 137
+            },
+            {
+                "source": "npm:@mariozechner/pi-agent-core@0.73.1",
+                "into": "agent-core",
+                "files": 5
+            },
+            {
+                "source": "npm:@mariozechner/pi-ai@0.73.1",
+                "into": "ai",
+                "files": 44
+            }
+        ]
+    },
+    "opencode": {
+        "docs": "https://opencode.ai/docs/server",
+        "sources": [
+            {
+                "source": "npm:@opencode-ai/sdk@1.18.32",
+                "into": "sdk",
+                "files": 39
+            },
+            {
+                "source": "github:anomalyco/opencode@v1.18.32/packages/sdk",
+                "into": "",
+                "files": 1
+            }
+        ]
+    },
+    "openclaw": {
+        "docs": "https://docs.openclaw.ai/gateway/protocol",
+        "sources": [
+            {
+                "source": "npm:@openclaw/gateway-protocol@2026.9.6",
+                "into": "gateway-protocol",
+                "files": 17
+            }
+        ]
+    },
+    "hermes": {
+        "docs": "https://hermes-agent.nousresearch.com/docs",
+        "sources": [
+            {
+                "source": "github:NousResearch/hermes-agent@v2026.9.24/apps/shared/src",
+                "into": "gateway",
+                "files": 3
+            }
+        ]
+    }
+}

package/dist/agent/workerBundle.d.ts

@@ -1,19 +1,4 @@
-/**
- * The session worker (agent/session/main.ts and all it imports) as the one script AgentService
- * uploads into a dimension and runs with bun. The backends' own packages aren't part of it: the
- * worker installs them into the dimension and loads them from there.
- */
-export type WorkerBundle = {
-    /** The worker as one script for bun. */
-    source: string;
-    /** Identifies the source: a running worker with another build is replaced. */
-    build: string;
-};
-/**
- * The worker, once per process. Under Bun with the sources at hand (a checkout) it is bundled from
- * them; otherwise (Node, or the built package, which ships no sources) it comes from
- * agent/workerBundle.generated.ts (scripts/bundle-worker.ts).
- */
-export declare function workerBundle(): Promise<WorkerBundle>;
-/** Bundles the worker with Bun.build. */
-export declare function buildWorkerSource(): Promise<string>;
+import { type ScriptBundle } from "../lib/scriptBundle.ts";
+export type WorkerBundle = ScriptBundle;
+export declare const workerEntry: () => string;
+export declare const workerBundle: () => Promise<ScriptBundle>;