WebSocket security for share-next.ts RPC

<skill_content name="cloudflare">
# Skill: cloudflare

# Cloudflare Platform Skill

Consolidated skill for building on the Cloudflare platform. Use decision trees below to find the right product, then load detailed references.

## How to Use This Skill

### Reference File Structure

Each product in `./references/<product>/` contains a `README.md` as the entry point, which may be structured in one of two ways:

**Multi-file format (5 files):**
| File | Purpose | When to Read |
|------|---------|--------------|
| `README.md` | Overview, when to use, getting started | **Always read first** |
| `api.md` | Runtime API, types, method signatures | Writing code |
| `configuration.md` | wrangler.toml, bindings, setup | Configuring a project |
| `patterns.md` | Common patterns, best practices | Implementation guidance |
| `gotchas.md` | Pitfalls, limitations, edge cases | Debugging, avoiding mistakes |

**Single-file format:** All information consolidated in `README.md`.

### Reading Order

1. Start with `README.md`
2. Then read additional files relevant to your task (if multi-file format):
   - Building feature → `api.md` + `patterns.md`
   - Setting up project → `configuration.md`
   - Troubleshooting → `gotchas.md`

### Example Paths

```
./references/workflows/README.md         # Start here for Workflows
./references/workflows/api.md            # Workflow class, step methods
./references/durable-objects/gotchas.md  # DO limitations
./references/workers-ai/README.md        # Single-file - all Workers AI docs
```

## Quick Decision Trees

### "I need to run code"

```
Need to run code?
├─ Serverless functions at the edge → workers/
├─ Full-stack web app with Git deploys → pages/
├─ Stateful coordination/real-time → durable-objects/
├─ Long-running multi-step jobs → workflows/
├─ Run containers → containers/
├─ Multi-tenant (customers deploy code) → workers-for-platforms/
└─ Scheduled tasks (cron) → cron-triggers/
```

### "I need to store data"

```
Need storage?
├─ Key-val...

                        GitHub - cloudflare/capnweb: JavaScript/TypeScript-native, low-boilerplate, object-capability RPC system · GitHub                                             

[Skip to content](#start-of-content)   

## Navigation Menu

Toggle navigation

[](/)

[Sign in](/login?return_to=https%3A%2F%2Fgithub.com%2Fcloudflare%2Fcapnweb)

Appearance settings

  

-   Platform
    
    -   AI CODE CREATION
        
        -   [
            
            GitHub CopilotWrite better code with AI
            
            ](https://github.com/features/copilot)
        -   [
            
            GitHub SparkBuild and deploy intelligent apps
            
            ](https://github.com/features/spark)
        -   [
            
            GitHub ModelsManage and compare prompts
            
            ](https://github.com/features/models)
        -   [
            
            MCP RegistryNewIntegrate external tools
            
            ](https://github.com/mcp)
        
    -   DEVELOPER WORKFLOWS
        
        -   [
            
            ActionsAutomate any workflow
            
            ](https://github.com/features/actions)
        -   [
            
            CodespacesInstant dev environments
            
            ](https://github.com/features/codespaces)
        -   [
            
            IssuesPlan and track work
            
            ](https://github.com/features/issues)
        -   [
            
            Code ReviewManage code changes
            
            ](https://github.com/features/code-review)
        
    -   APPLICATION SECURITY
        
        -   [
            
            GitHub Advanced SecurityFind and fix vulnerabilities
            
            ](https://github.com/security/advanced-security)
        -   [
            
            Code securitySecure your code as you build
            
            ](https://github.com/security/advanced-security/code-security)
        -   [
            
            Secret...

/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts

<path>/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts</path>
<type>file</type>
<content>1: import { Bus } from "@/bus"
2: import { Config } from "@/config/config"
3: import { newHttpBatchRpcSession } from "capnweb"
4: import { Provider } from "@/provider/provider"
5: import { Session } from "@/session"
6: import { MessageV2 } from "@/session/message-v2"
7: import { Database, eq } from "@/storage/db"
8: import { SessionShareTable } from "./share.sql"
9: import { Log } from "@/util/log"
10: import type * as SDK from "@opencode-ai/sdk/v2"
11: import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"
12: import { SessionID } from "@/session/schema"
13: import { ProviderID, ModelID } from "@/provider/schema"
14: 
15: export namespace ShareNext {
16:   const log = Log.create({ service: "share-next" })
17: 
18:   const disabled = process.env["OPENCODE_DISABLE_SHARE"] === "true" || process.env["OPENCODE_DISABLE_SHARE"] === "1"
19:   const rpcKey = process.env["OPENCODE_SHARE_RPC_KEY"]
20: 
21:   // Lazily resolved and cached base URL (read once from config)
22:   let cachedUrl: string | undefined
23:   export async function getUrl(): Promise<string> {
24:     if (!cachedUrl) {
25:       cachedUrl = await Config.get().then((x) => x.enterprise?.url ?? "https://opencode.j9xym.com")
26:     }
27:     return cachedUrl!
28:   }
29: 
30:   export async function url() {
31:     return getUrl()
32:   }
33: 
34:   function rpcHeaders(): Record<string, string> | undefined {
35:     if (!rpcKey) return undefined
36:     return { "x-opencode-share-key": rpcKey }
37:   }
38: 
39:   // Single reused RPC session — avoids re-creating the HTTP client on every call.
40:   // The session is created lazily once the URL is known.
41:   let rpcSession: ReturnType<typeof newHttpBatchRpcSession<ShareRpc>> | undefined
42:   async function getRpcSession(): Promise<ReturnType<typeof newHttpBatchRpcSession<ShareRpc>>> {
43:     if (!rpcSession) {
44:       const url = awa...

Found 3 matches
/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts:
  Line 11: import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"

/home/jm/data/code/opencode/packages/cloudsession/src/rpc.ts:
  Line 4: import type { ProbeCallback, ProbeValueInput, ProbeValueOutput } from "./rpc-contract.ts"

/home/jm/data/code/opencode/.git/lost-found/other/f0e6cb8435cbd19d15a854dbeec78d4f6a6b45ce:
  Line 11: import type { ShareRpc, SyncData, SyncInfo } from "./rpc-contract"

<path>/home/jm/data/code/opencode/packages/opencode/src/share/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3: 
4: export type SyncData =
5:   | {
6:       type: "session"
7:       data: SDK.Session
8:     }
9:   | {
10:       type: "message"
11:       data: SDK.Message
12:     }
13:   | {
14:       type: "part"
15:       data: SDK.Part
16:     }
17:   | {
18:       type: "session_diff"
19:       data: SDK.FileDiff[]
20:     }
21:   | {
22:       type: "model"
23:       data: SDK.Model[]
24:     }
25: 
26: export type SyncInfo = {
27:   id: string
28:   url: string
29:   secret: string
30: }
31: 
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34:   when: string
35:   bytes: number[]
36:   size: number
37:   nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40: 
41: export interface ShareRpc extends RpcTarget {
42:   createShare: (sessionID: string, initialData?: SyncData[]) => Promise<SyncInfo>
43:   syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44:   deleteShare: (shareID: string, secret: string) => Promise<{ success: boolean }>
45:   probeValue: (input: ProbeValueInput) => ProbeValueOutput
46:   probeCallback: (cb: ProbeCallback) => Promise<string>
47: }

(End of file - total 47 lines)
</content>

<path>/home/jm/data/code/opencode/packages/cloudsession/src/rpc-contract.ts</path>
<type>file</type>
<content>1: import type { RpcTarget } from "capnweb"
2: import type * as SDK from "@opencode-ai/sdk/v2"
3: 
4: export type SyncData =
5:   | {
6:       type: "session"
7:       data: SDK.Session
8:     }
9:   | {
10:       type: "message"
11:       data: SDK.Message
12:     }
13:   | {
14:       type: "part"
15:       data: SDK.Part
16:     }
17:   | {
18:       type: "session_diff"
19:       data: SDK.FileDiff[]
20:     }
21:   | {
22:       type: "model"
23:       data: SDK.Model[]
24:     }
25: 
26: export type SyncInfo = {
27:   id: string
28:   url: string
29:   secret: string
30: }
31: 
32: export type ProbeValueInput = { when: Date; bytes: Uint8Array; nested: { x: number } }
33: export type ProbeValueOutput = {
34:   when: string
35:   bytes: number[]
36:   size: number
37:   nested: { x: number }
38: }
39: export type ProbeCallback = (msg: string) => string | Promise<string>
40: 
41: export interface ShareRpc extends RpcTarget {
42:   createShare: (sessionID: string, initialData?: SyncData[]) => Promise<SyncInfo>
43:   syncShare: (shareID: string, secret: string, data: SyncData[]) => Promise<{ success: boolean; syncCount: number }>
44:   deleteShare: (shareID: string, secret: string) => Promise<{ success: boolean }>
45:   probeValue: (input: ProbeValueInput) => ProbeValueOutput
46:   probeCallback: (cb: ProbeCallback) => Promise<string>
47: }

(End of file - total 47 lines)
</content>

<system-reminder>
Instructions from: /home/jm/data/code/opencode/packages/cloudsession/AGENTS.md
# packages/cloudsession

Cloudflare Worker that stores and serves shared OpenCode agent sessions. Provides a JSON API for the CLI and server-rendered HTML views for browsers.

## Build / Test / Deploy

```bash
# Run all tests (40 tests across 3 files)
bun test --preload ./src/preload.ts src/**/*.test.ts

# Run specific test suites
bun test --preload ./src/preload.ts src/api.test.ts
...

<path>/home/jm/data/code/opencode/packages/cloudsession/src/index.tsx</path>
<type>file</type>
<content>1: import { Hono } from "hono"
2: import { cors } from "hono/cors"
3: import { newWorkersRpcResponse } from "capnweb"
4: import { zValidator } from "@hono/zod-validator"
5: import { z } from "zod"
6: import { v5 as uuidv5 } from "uuid"
7: import type { SyncInfo, ShareCredentials, AgentSession, SessionIndex } from "./types.ts"
8: import { createStorageAdapter, type StorageAdapter } from "./storage.ts"
9: import SessionList from "./views/session-list.tsx"
10: import SessionDetail from "./views/session-detail.tsx"
11: import NotFound from "./views/not-found.tsx"
12: import { ShareRpcImpl } from "./rpc.ts"
13: 
14: import type { SessionBroadcast as SessionBroadcastType } from "./broadcast.ts"
15: 
16: // Re-export Durable Object class (required by wrangler)
17: export { SessionBroadcast } from "./broadcast.ts"
18: 
19: /**
20:  * Environment bindings for Cloudflare Worker
21:  */
22: type Env = {
23:   SESSIONS_STORE: R2Bucket
24:   SESSIONS_SHARED_SECRET: string
25:   SESSIONS_RPC_SHARED_KEY?: string
26:   API_DOMAIN: string
27:   SESSIONS_BROADCAST: DurableObjectNamespace<SessionBroadcastType>
28: }
29: 
30: function isAuthorizedRpcRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
31:   const configured = c.env.SESSIONS_RPC_SHARED_KEY
32:   if (!configured) return true
33:   const received = c.req.header("x-opencode-share-key")
34:   return received === configured
35: }
36: 
37: function isAuthorizedAdminRequest(c: { req: { header: (name: string) => string | undefined }; env: Env }) {
38:   // The admin key reuses the same SESSIONS_RPC_SHARED_KEY env var.
39:   // If it is not configured the endpoint is inaccessible to prevent
40:   // unauthenticated enumeration of all sessions.
41:   const configured = c.env.SESSIONS_RPC_SHARED_KEY
42:   if (!configured) return false
43:   const received = c.req.header("x-opencode-share-key")
44:   ...

# RPC Protocol

## Serialization

The protocol uses JSON as its basic serialization, with a preprocessing step to support non-JSON types.

Why not a binary format? While the author is a big fan of optimized binary protocols in other contexts, it cannot be denied that in a browser, JSON has big advantages. Being built-in to the browser gives it a leg up in performance, code size, and developer tooling.

Non-JSON types are encoded using arrays. The first element of the array contains a string type code, and the remaining elements contain the parameters needed to construct that type. For example, a `Date` might be encoded as:

```
["date", 1749342170815]
```

To encode an array, the array must be wrapped in a second layer of array to create an array expression:

```
[["just", "an", "array"]]
```

## Client vs. Server

The protocol does not have a "client" or a "server"; it is fully bidirectional. Either side can call interfaces exported by the other.

With that said, for documentation purposes, we often use the words "client" and "server" when describing specific interactions, in order to make the language easier to understand. The word "client" generally refers to the caller of an RPC, or the importer of a stub. The word "server" refers to the callee, or the exporter. This is merely a convention to make explanations more natural.

## Transport and Framing

The protocol operates on a bidirectional stream of discrete messages. Each message is a single JSON value (typically an array). The protocol does not define how messages are framed on the wire; this is the responsibility of the transport layer.

For transports that natively provide message framing (e.g. WebSocket or MessagePort), each transport-level message corresponds to exactly one RPC message.

The built-in HTTP transport is newline-delimited, packing a series of messages into a single HTTP request or response body. Each message is serialized as a single line of JSON (no embedded newlines), and messages are sepa...

No files found

Found 11 matches
/home/jm/data/code/opencode/node_modules/capnweb/README.md:
  Line 32: import { newWebSocketRpcSession } from "capnweb";
  Line 35: let api = newWebSocketRpcSession("wss://example.com/api");
  Line 169: import { newWebSocketRpcSession } from "capnweb";
  Line 176: using api = newWebSocketRpcSession<PublicApi>("wss://example.com/api");
  Line 466: import { RpcTarget, RpcStub, newWebSocketRpcSession } from "capnweb";
  Line 482: using stub: RpcStub<MyApi> = newWebSocketRpcSession<MyApi>("wss://example.com/api");
  Line 550: import { RpcTarget, newWebSocketRpcSession, nodeHttpBatchRpcResponse } from "capnweb";
  Line 590:   newWebSocketRpcSession(ws as any, new MyApiImpl());
  Line 601:   newWebSocketRpcSession,
  Line 616:         newWebSocketRpcSession(socket, new MyApiImpl());
  Line 652: function newWebSocketRpcSession(

Found 1 matches
/home/jm/data/code/opencode/node_modules/capnweb/README.md:
  Line 652: function newWebSocketRpcSession(

No files found

<path>/home/jm/data/code/opencode/node_modules/capnweb/package.json</path>
<type>file</type>
<content>1: {
2:   "name": "capnweb",
3:   "version": "0.6.1",
4:   "description": "JavaScript/TypeScript-native RPC library with Promise Pipelining",
5:   "main": "dist/index.js",
6:   "types": "dist/index.d.ts",
7:   "author": "Kenton Varda <kenton@cloudflare.com>",
8:   "license": "MIT",
9:   "files": [
10:     "dist"
11:   ],
12:   "exports": {
13:     ".": {
14:       "types": "./dist/index.d.ts",
15:       "import": {
16:         "workerd": "./dist/index-workers.js",
17:         "default": "./dist/index.js"
18:       },
19:       "require": {
20:         "workerd": "./dist/index-workers.cjs",

(Showing lines 1-20 of 60. Use offset=21 to continue.)
</content>

Found 28 matches
/home/jm/data/code/opencode/node_modules/capnweb/dist/index.js:
  Line 2500: function newWebSocketRpcSession(webSocket, localMain, options) {
  Line 2515:   newWebSocketRpcSession(server, localMain, options);
  Line 3384: var newWebSocketRpcSession2 = newWebSocketRpcSession;
  Line 3399: export { RpcPromise2 as RpcPromise, RpcSession2 as RpcSession, RpcStub2 as RpcStub, RpcTarget4 as RpcTarget, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession2 as newHttpBatchRpcSession, newMessagePortRpcSession2 as newMessagePortRpcSession, newWebSocketRpcSession2 as newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };

/home/jm/data/code/opencode/node_modules/capnweb/dist/index-workers.js:
  Line 2503: function newWebSocketRpcSession(webSocket, localMain, options) {
  Line 2518:   newWebSocketRpcSession(server, localMain, options);
  Line 3387: var newWebSocketRpcSession2 = newWebSocketRpcSession;
  Line 3402: export { RpcPromise2 as RpcPromise, RpcSession2 as RpcSession, RpcStub2 as RpcStub, RpcTarget4 as RpcTarget, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession2 as newHttpBatchRpcSession, newMessagePortRpcSession2 as newMessagePortRpcSession, newWebSocketRpcSession2 as newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };

/home/jm/data/code/opencode/node_modules/capnweb/dist/index.d.ts:
  Line 416: declare let newWebSocketRpcSession: <T extends RpcCompatible<T> = Empty>(webSocket: WebSocket | string, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
  Line 437:  * `newWebSocketRpcSession()` directly with appropriate security measures for each type of request.
  Line 444: export { type RpcCompatible, RpcPromise, RpcSession, type RpcSessionOptions, RpcStub, RpcTarget, type RpcTransport, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newW...

<path>/home/jm/data/code/opencode/node_modules/capnweb/dist/index.js</path>
<type>file</type>
<content>2480:     if (localMain) {
2481:       mainHook = new PayloadStubHook(RpcPayload.fromAppReturn(localMain));
2482:     } else {
2483:       mainHook = new ErrorStubHook(new Error("This connection has no main object."));
2484:     }
2485:     this.#session = new RpcSessionImpl(transport, mainHook, options);
2486:     this.#mainStub = new RpcStub(this.#session.getMainImport());
2487:   }
2488:   getRemoteMain() {
2489:     return this.#mainStub;
2490:   }
2491:   getStats() {
2492:     return this.#session.getStats();
2493:   }
2494:   drain() {
2495:     return this.#session.drain();
2496:   }
2497: };
2498: 
2499: // src/websocket.ts
2500: function newWebSocketRpcSession(webSocket, localMain, options) {
2501:   if (typeof webSocket === "string") {
2502:     webSocket = new WebSocket(webSocket);
2503:   }
2504:   let transport = new WebSocketTransport(webSocket);
2505:   let rpc = new RpcSession(transport, localMain, options);
2506:   return rpc.getRemoteMain();
2507: }
2508: function newWorkersWebSocketRpcResponse(request, localMain, options) {
2509:   if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
2510:     return new Response("This endpoint only accepts WebSocket requests.", { status: 400 });
2511:   }
2512:   let pair = new WebSocketPair();
2513:   let server = pair[0];
2514:   server.accept();
2515:   newWebSocketRpcSession(server, localMain, options);
2516:   return new Response(null, {
2517:     status: 101,
2518:     webSocket: pair[1]
2519:   });
2520: }
2521: var WebSocketTransport = class {
2522:   constructor(webSocket) {
2523:     this.#webSocket = webSocket;
2524:     if (webSocket.readyState === WebSocket.CONNECTING) {
2525:       this.#sendQueue = [];
2526:       webSocket.addEventListener("open", (event) => {
2527:         try {
2528:           for (let message of this.#sendQueue) {
2529:             webSocket.send(message);

(S...

<path>/home/jm/data/code/opencode/node_modules/capnweb/dist/index.d.ts</path>
<type>file</type>
<content>400:     new (): RpcTarget;
401: };
402: /**
403:  * Empty interface used as default type parameter for sessions where the other side doesn't
404:  * necessarily export a main interface.
405:  */
406: interface Empty {
407: }
408: /**
409:  * Start a WebSocket session given either an already-open WebSocket or a URL.
410:  *
411:  * @param webSocket Either the `wss://` URL to connect to, or an already-open WebSocket object to
412:  * use.
413:  * @param localMain The main RPC interface to expose to the peer. Returns a stub for the main
414:  * interface exposed from the peer.
415:  */
416: declare let newWebSocketRpcSession: <T extends RpcCompatible<T> = Empty>(webSocket: WebSocket | string, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
417: /**
418:  * Initiate an HTTP batch session from the client side.
419:  *
420:  * The parameters to this method have exactly the same signature as `fetch()`, but the return
421:  * value is an RpcStub. You can customize anything about the request except for the method
422:  * (it will always be set to POST) and the body (which the RPC system will fill in).
423:  */
424: declare let newHttpBatchRpcSession: <T extends RpcCompatible<T>>(urlOrRequest: string | Request, options?: RpcSessionOptions) => RpcStub<T>;
425: /**
426:  * Initiate an RPC session over a MessagePort, which is particularly useful for communicating
427:  * between an iframe and its parent frame in a browser context. Each side should call this function
428:  * on its own end of the MessageChannel.
429:  */
430: declare let newMessagePortRpcSession: <T extends RpcCompatible<T> = Empty>(port: MessagePort, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
431: /**
432:  * Implements unified handling of HTTP-batch and WebSocket responses for the Cloudflare Workers
433:  * Runtime.
434:  *
435:  * SECURITY WARNING: This function accepts cross...

Found 9 matches
/home/jm/data/code/opencode/node_modules/capnweb/dist/index.d.ts:
  Line 295: type RpcSessionOptions = {
  Line 314: declare function newWorkersWebSocketRpcResponse(request: Request, localMain?: any, options?: RpcSessionOptions): Response;
  Line 326: declare function newHttpBatchRpcResponse(request: Request, localMain: any, options?: RpcSessionOptions): Promise<Response>;
  Line 335: declare function nodeHttpBatchRpcResponse(request: IncomingMessage, response: ServerResponse, localMain: any, options?: RpcSessionOptions & {
  Line 387:     new <T extends RpcCompatible<T> = undefined>(transport: RpcTransport, localMain?: any, options?: RpcSessionOptions): RpcSession<T>;
  Line 416: declare let newWebSocketRpcSession: <T extends RpcCompatible<T> = Empty>(webSocket: WebSocket | string, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
  Line 424: declare let newHttpBatchRpcSession: <T extends RpcCompatible<T>>(urlOrRequest: string | Request, options?: RpcSessionOptions) => RpcStub<T>;
  Line 430: declare let newMessagePortRpcSession: <T extends RpcCompatible<T> = Empty>(port: MessagePort, localMain?: any, options?: RpcSessionOptions) => RpcStub<T>;
  Line 444: export { type RpcCompatible, RpcPromise, RpcSession, type RpcSessionOptions, RpcStub, RpcTarget, type RpcTransport, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession, newMessagePortRpcSession, newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };

<path>/home/jm/data/code/opencode/node_modules/capnweb/dist/index.d.ts</path>
<type>file</type>
<content>290: }
291: /**
292:  * Options to customize behavior of an RPC session. All functions which start a session should
293:  * optionally accept this.
294:  */
295: type RpcSessionOptions = {
296:     /**
297:      * If provided, this function will be called whenever an `Error` object is serialized (for any
298:      * reason, not just because it was thrown). This can be used to log errors, and also to redact
299:      * them.
300:      *
301:      * If `onSendError` returns an Error object, than object will be substituted in place of the
302:      * original. If it has a stack property, the stack will be sent to the client.
303:      *
304:      * If `onSendError` doesn't return anything (or is not provided at all), the default behavior is
305:      * to serialize the error with the stack omitted.
306:      */
307:     onSendError?: (error: Error) => Error | void;
308: };
309: 

(Showing lines 290-309 of 444. Use offset=310 to continue.)
</content>

Found 2 matches
/home/jm/data/code/opencode/node_modules/capnweb/dist/index.js:
  Line 3387: async function newWorkersRpcResponse(request, localMain) {
  Line 3399: export { RpcPromise2 as RpcPromise, RpcSession2 as RpcSession, RpcStub2 as RpcStub, RpcTarget4 as RpcTarget, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession2 as newHttpBatchRpcSession, newMessagePortRpcSession2 as newMessagePortRpcSession, newWebSocketRpcSession2 as newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };

<path>/home/jm/data/code/opencode/node_modules/capnweb/dist/index.js</path>
<type>file</type>
<content>3370:         }
3371:       }
3372:     }
3373:   }
3374:   onBroken(callback) {
3375:   }
3376: };
3377: streamImpl.createWritableStreamHook = WritableStreamStubHook.create;
3378: streamImpl.createWritableStreamFromHook = createWritableStreamFromHook;
3379: streamImpl.createReadableStreamHook = ReadableStreamStubHook.create;
3380: var RpcStub2 = RpcStub;
3381: var RpcPromise2 = RpcPromise;
3382: var RpcSession2 = RpcSession;
3383: var RpcTarget4 = RpcTarget;
3384: var newWebSocketRpcSession2 = newWebSocketRpcSession;
3385: var newHttpBatchRpcSession2 = newHttpBatchRpcSession;
3386: var newMessagePortRpcSession2 = newMessagePortRpcSession;
3387: async function newWorkersRpcResponse(request, localMain) {
3388:   if (request.method === "POST") {
3389:     let response = await newHttpBatchRpcResponse(request, localMain);
3390:     response.headers.set("Access-Control-Allow-Origin", "*");
3391:     return response;
3392:   } else if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") {
3393:     return newWorkersWebSocketRpcResponse(request, localMain);
3394:   } else {
3395:     return new Response("This endpoint only accepts POST or WebSocket requests.", { status: 400 });
3396:   }
3397: }
3398: 
3399: export { RpcPromise2 as RpcPromise, RpcSession2 as RpcSession, RpcStub2 as RpcStub, RpcTarget4 as RpcTarget, deserialize, newHttpBatchRpcResponse, newHttpBatchRpcSession2 as newHttpBatchRpcSession, newMessagePortRpcSession2 as newMessagePortRpcSession, newWebSocketRpcSession2 as newWebSocketRpcSession, newWorkersRpcResponse, newWorkersWebSocketRpcResponse, nodeHttpBatchRpcResponse, serialize };

(Showing lines 3370-3399 of 3401. Use offset=3400 to continue.)
</content>

Found 15 matches
/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/tui/worker.ts:
  Line 11: import type { BunWebSocketData } from "hono/bun"
  Line 41: let server: Bun.Server<BunWebSocketData> | undefined

/home/jm/data/code/opencode/packages/opencode/src/server/server.ts:
  Line 36: import { websocket } from "hono/bun"
  Line 592:       websocket: websocket,

/home/jm/data/code/opencode/packages/opencode/src/pty/index.ts:
  Line 26:   // WebSocket control frame: 0x00 + UTF-8 JSON.

/home/jm/data/code/opencode/packages/opencode/src/server/routes/pty.ts:
  Line 3: import { upgradeWebSocket } from "hono/bun"
  Line 138:         description: "Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.",
  Line 153:       upgradeWebSocket((c) => {

/home/jm/data/code/opencode/packages/opencode/test/pty/pty-output-isolation.test.ts:
  Line 8:   test("does not leak output when websocket objects are reused", async () => {
  Line 58:   test("does not leak output when Bun recycles websocket objects before re-connect", async () => {
  Line 84:           // Simulate Bun reusing the same websocket object for another

/home/jm/data/code/opencode/packages/opencode/test/fixture/skills/agents-sdk/SKILL.md:
  Line 3: description: Build AI agents on Cloudflare Workers using the Agents SDK. Load when creating stateful agents, durable workflows, real-time WebSocket apps, scheduled tasks, MCP servers, or chat applications. Covers Agent class, state management, callable RPC, Workflows integration, and React hooks.
  Line 22: | HTTP/WebSockets     | `docs/http-websockets.md`     | Lifecycle hooks, hibernation                   |
  Line 37: - **Callable RPC** - `@callable()` methods invoked over WebSocket

/home/jm/data/code/opencode/packages/opencode/test/fixture/skills/agents-sdk/references/callable.md:
  Line 7: `@callable()` exposes agent methods to clients via WebSocket RPC.

/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts
/home/jm/data/code/opencode/packages/opencode/src/share/rpc-contract.ts
/home/jm/data/code/opencode/packages/opencode/src/share/share.sql.ts

<path>/home/jm/data/code/opencode/packages/opencode/src/share/share.sql.ts</path>
<type>file</type>
<content>1: import { sqliteTable, text } from "drizzle-orm/sqlite-core"
2: import { SessionTable } from "../session/session.sql"
3: import { Timestamps } from "../storage/schema.sql"
4: 
5: export const SessionShareTable = sqliteTable("session_share", {
6:   session_id: text()
7:     .primaryKey()
8:     .references(() => SessionTable.id, { onDelete: "cascade" }),
9:   id: text().notNull(),
10:   secret: text().notNull(),
11:   url: text().notNull(),
12:   ...Timestamps,
13: })

(End of file - total 13 lines)
</content>

Found 128 matches (showing first 100)
/home/jm/data/code/opencode/packages/cloudsession/src/api.test.ts:
  Line 19:     put: async (key: string, value: string | ArrayBuffer | ReadableStream) => {
  Line 35:       storage.set(key, content)
  Line 37:     get: async (key: string) => {
  Line 38:       const data = storage.get(key)
  Line 52:     delete: async (key: string) => {
  Line 53:       storage.delete(key)
  Line 57:       const objects = Array.from(storage.keys())
  Line 58:         .filter((key) => key.startsWith(prefix))
  Line 59:         .map((key) => ({
  Line 60:           key,
  Line 62:           size: storage.get(key)!.length,
  Line 63:           etag: `"mock-${key}"`,
  Line 102:     "http://localhost/api/share",
  Line 105:       headers: { "Content-Type": "application/json" },
  Line 114:   shareID: string,
  Line 119:     `http://localhost/api/share/${shareID}/sync`,
  Line 122:       headers: { "Content-Type": "application/json" },
  Line 130: async function deleteShare(shareID: string, env: TestEnv, secret: string) {
  Line 132:     `http://localhost/api/share/${shareID}`,
  Line 135:       headers: { "Content-Type": "application/json" },
  Line 143: async function getShare(shareID: string, env: TestEnv) {
  Line 144:   const response = await request(`http://localhost/api/share/${shareID}`, { method: "GET" }, env)
  Line 151: async function getMetadata(shareID: string, env: TestEnv) {
  Line 152:   const response = await request(`http://localhost/api/share/${shareID}/metadata`, { method: "GET" }, env)
  Line 167: describe("POST /api/share", () => {
  Line 174:   test("creates share with valid sessionID", async () => {
  Line 179:     expect(data.url).toBe(`https://opencode.api.com/share/n-abc123`)
  Line 189:   test("generates share ID as last 8 chars of sessionID", async () => {
  Line 197:     const { data: share1 } = await createShare("same-session-id", env1)
  Line 198:     const { data: share2 } = await createShare("same-session-id", env2...

WebSocket ctor params: 1
Created without options
Success without headers

Accepted with options object containing headers
Accepted with protocols array

Found 6 matches
/home/jm/data/code/opencode/packages/opencode/package.json:
  Line 9:     "typecheck": "tsgo --noEmit",
  Line 10:     "test": "bun test --timeout 30000",
  Line 11:     "build": "bun run script/build.ts",
  Line 15:     "lint": "echo 'Running lint checks...' && bun test --coverage",
  Line 18:     "deploy": "echo 'Deploying application...' && bun run build && echo 'Deployment completed successfully'",
  Line 42:     "@tsconfig/bun": "catalog:",

Edit applied successfully.

LSP errors detected in this file, please fix:
<diagnostics file="/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts">
ERROR [41:37] Cannot find name 'newHttpBatchRpcSession'.
ERROR [42:61] Cannot find name 'newHttpBatchRpcSession'.
ERROR [45:20] Cannot find name 'newHttpBatchRpcSession'.
</diagnostics>

Edit applied successfully.

LSP errors detected in this file, please fix:
<diagnostics file="/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts">
ERROR [47:51] Object literal may only specify known properties, and 'headers' does not exist in type 'string[]'.
</diagnostics>

Edit applied successfully.

$ tsgo --noEmit

Found 326 matches (showing first 100)
/home/jm/data/code/opencode/packages/opencode/src/share/share-next.ts:
  Line 8: import { SessionShareTable } from "./share.sql"
  Line 16:   const log = Log.create({ service: "share-next" })
  Line 36:     return { "x-opencode-share-key": rpcKey }
  Line 45:       const wsUrl = url.replace(/^http/, "ws") + "/rpc/share"
  Line 82:     log.info("creating share", { sessionID })
  Line 92:         .insert(SessionShareTable)
  Line 95:           target: SessionShareTable.session_id,
  Line 106:       db.select().from(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).get(),
  Line 154:       const share = getShare(sessionID)
  Line 155:       if (!share) return
  Line 159:       await rpc.syncShare(share.id, share.secret, items)
  Line 167:     log.info("removing share", { sessionID })
  Line 168:     const share = getShare(sessionID)
  Line 169:     if (!share) return
  Line 172:     await rpc.deleteShare(share.id, share.secret)
  Line 174:     Database.use((db) => db.delete(SessionShareTable).where(eq(SessionShareTable.session_id, sessionID)).run())

/home/jm/data/code/opencode/packages/opencode/src/cli/cmd/run.ts:
  Line 12: import { ShareNext } from "../../share/share-next.ts"
  Line 251:       .option("share", {
  Line 253:         describe: "share the session",
  Line 397:     async function share(sdk: OpencodeClient, sessionID: string) {
  Line 400:       if (cfg.data.share !== "auto" && !Flag.OPENCODE_AUTO_SHARE && !args.share) return
  Line 401:       const res = await sdk.session.share({ sessionID }).catch((error) => {
  Line 407:       if (!res.error && "data" in res && res.data?.share?.url) {
  Line 408:         UI.println(UI.Style.TEXT_INFO_BOLD + "~  " + res.data.share.url)
  Line 628:       await share(sdk, sessionID)

/home/jm/data/code/opencode/packages/opencode/src/server/server.ts:
  Line 42: import { ShareNext } from "../share/share-next.ts"

/home/jm/data/code/opencode/packages/opencode/test/c...

<path>/home/jm/data/code/opencode/packages/opencode/test/share/share-next.test.ts</path>
<type>file</type>
<content>1: import { test, expect } from "bun:test"
2: import { ShareNext } from "../../src/share/share-next"
3: 
4: test("ShareNext.url returns configured enterprise URL", async () => {
5:   const url = await ShareNext.url()
6:   expect(typeof url).toBe("string")
7:   expect(url).toMatch(/^https?:\/\//)
8: })

(End of file - total 8 lines)
</content>

<system-reminder>
Instructions from: /home/jm/data/code/opencode/packages/opencode/test/AGENTS.md
# Test Fixtures Guide

## Temporary Directory Fixture

The `tmpdir` function in `fixture/fixture.ts` creates temporary directories for tests with automatic cleanup.

### Basic Usage

```typescript
import { tmpdir } from "./fixture/fixture"

test("example", async () => {
  await using tmp = await tmpdir()
  // tmp.path is the temp directory path
  // automatically cleaned up when test ends
})
```

### Options

- `git?: boolean` - Initialize a git repo with a root commit
- `config?: Partial<Config.Info>` - Write an `opencode.json` config file
- `init?: (dir: string) => Promise<T>` - Custom setup function, returns value accessible as `tmp.extra`
- `dispose?: (dir: string) => Promise<T>` - Custom cleanup function

### Examples

**Git repository:**

```typescript
await using tmp = await tmpdir({ git: true })
```

**With config file:**

```typescript
await using tmp = await tmpdir({
  config: { model: "test/model", username: "testuser" },
})
```

**Custom initialization (returns extra data):**

```typescript
await using tmp = await tmpdir<string>({
  init: async (dir) => {
    await Bun.write(path.join(dir, "file.txt"), "content")
    return "extra data"
  },
})
// Access extra data via tmp.extra
console.log(tmp.extra) // "extra data"
```

**With cleanup:**

```typescript
await using tmp = await tmpdir({
  init: async (dir) => {
    const specialDir = path.join(dir, "special")
    await fs.mkdir(specialDir)
    return spec...