@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
124 lines (111 loc) • 4.49 kB
text/typescript
import http2 from "node:http2";
import { registerOptionalShutdownHook } from "../../lib/optional-shutdown-hooks";
const DEFAULT_MAX_SESSIONS = 8;
const SESSION_CLOSE_TIMEOUT_MS = 2_000;
interface PoolEntry {
readonly session: http2.ClientHttp2Session;
readonly streams: Set<http2.ClientHttp2Stream>;
usable: boolean;
}
/**
* HTTP/2 connection pool for Cursor Connect DISCOVERY calls (GetUsableModels).
* Sessions are keyed by origin (scheme+host+port) and reused to avoid fresh
* TCP+TLS per call. The Run path deliberately dials its own session: Run
* streams are long-lived bidi whose lifecycle/EOF semantics are owned by
* live-transport (see devlog 260822_senpi_cursor_transfer/190 — Run-path
* pooling is a separate, deliberate unit if ever taken).
*/
export class CursorH2SessionPool {
private readonly entries = new Map<string, PoolEntry>();
private closed = false;
constructor(private readonly maxSessions = DEFAULT_MAX_SESSIONS) {}
/**
* Lazily registered on first use so a process that never talks to Cursor registers
* nothing (optional-subsystem doctrine). The seam is synchronous and best-effort;
* shutdown() is fire-and-forget there because lifecycle's drainAndShutdown runs
* under its own absolute deadline.
*/
private armShutdownHook: (() => void) | undefined = () => {
this.armShutdownHook = undefined;
registerOptionalShutdownHook("cursor-h2-pool", () => { void this.shutdown(); });
};
request(
url: string,
headers: http2.OutgoingHttpHeaders,
): http2.ClientHttp2Stream {
if (this.closed) throw new Error("Cursor H2 session pool is closed");
this.armShutdownHook?.();
const origin = new URL(url).origin;
const entry = this.usableEntry(origin) ?? this.createEntry(origin);
try {
const stream = entry.session.request(headers);
entry.streams.add(stream);
stream.once("close", () => { entry.streams.delete(stream); });
return stream;
} catch (error) {
this.drain(entry, true);
throw error;
}
}
async shutdown(): Promise<void> {
if (this.closed) return;
this.closed = true;
const pending: Promise<void>[] = [];
for (const entry of [...this.entries.values()]) {
for (const stream of [...entry.streams]) stream.destroy();
entry.session.close();
if (entry.session.destroyed) continue;
pending.push(new Promise<void>(resolve => {
const timer = setTimeout(resolve, SESSION_CLOSE_TIMEOUT_MS);
timer.unref?.();
entry.session.once("close", () => { clearTimeout(timer); resolve(); });
}));
}
this.entries.clear();
await Promise.all(pending);
}
get size(): number { return this.entries.size; }
private usableEntry(origin: string): PoolEntry | undefined {
const entry = this.entries.get(origin);
if (!entry) return undefined;
if (entry.usable && !entry.session.closed && !entry.session.destroyed) return entry;
this.drain(entry, false);
return undefined;
}
private createEntry(origin: string): PoolEntry {
const session = http2.connect(origin);
const entry: PoolEntry = {
session,
streams: new Set(),
usable: true,
};
this.entries.set(origin, entry);
session.once("goaway", () => { this.drain(entry, true); });
session.on("error", () => { this.drain(entry, false); });
session.once("close", () => {
// Identity check: a stale close event from an old session must not evict
// a healthy replacement entry that was created after drain() removed the old one.
if (this.entries.get(origin) === entry) this.entries.delete(origin);
});
// Enforce bound: evict oldest when over capacity.
while (this.entries.size > this.maxSessions) {
const oldest = this.entries.keys().next().value;
if (!oldest || oldest === origin) break;
const old = this.entries.get(oldest);
if (old) this.drain(old, true);
}
return entry;
}
private drain(entry: PoolEntry, closeSession: boolean): void {
entry.usable = false;
for (const stream of [...entry.streams]) stream.destroy();
entry.streams.clear();
if (closeSession) entry.session.close();
// Remove from map by finding the matching key.
for (const [key, value] of this.entries) {
if (value === entry) { this.entries.delete(key); break; }
}
}
}
/** Shared singleton pool for all Cursor adapter H2 traffic. */
export const cursorH2Pool = new CursorH2SessionPool();