@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
159 lines (146 loc) • 9.31 kB
text/typescript
import { createHash, randomBytes } from "node:crypto";
import { closeSync, constants, fstatSync, lstatSync, openSync, readSync, writeFileSync } from "node:fs";
import { join } from "node:path";
import { getConfigDir } from "../config/paths";
import { withConfigMutationLockSync } from "../config/mutation-lock";
import { atomicWriteFileNoFollowStreamed } from "../config/atomic-write";
import type { OcxConfig } from "../types";
import { dashboardProxyOrigin, isLoopbackHostname, isTrustedHubManagementRequest, managementRequestOrigin } from "./auth-cors";
import { mintSession, type GuiSessionRecord, type GuiSessionState } from "./gui-session";
export const REMEMBERED_GUI_TTL_MS = 30 * 86400_000;
const RECORD_LIMIT = 128;
const STORE_LIMIT = 128 * 1024;
type State = GuiSessionState & { token: string };
interface DeviceRecord {
digest: string;
credential: string;
proof: string;
serverOrigin: string;
userAgent: string;
expiresAt: number;
}
const hash = (value: string) => createHash("sha256").update(value).digest("hex");
const storePath = () => join(getConfigDir(), "dashboard-sessions.json");
function directOrigin(req: Request, config: OcxConfig): string | null {
const origin = managementRequestOrigin(req, config);
if (!origin) return null;
const url = new URL(origin);
// The process-marked hub management listener sits behind a local TLS terminator, so its
// request URL is http: while the canonical public origin is https:. The configured standalone
// dashboard proxy (#8338) is the same shape, proven by its peer address. Nothing else forwarded
// is trusted.
if (new URL(req.url).origin !== origin && !isTrustedHubManagementRequest(req)
&& dashboardProxyOrigin(req, config) !== origin) return null;
if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopbackHostname(url.hostname))) return null;
const browser = req.headers.get("Origin");
if (browser !== null && browser !== origin) return null;
const site = req.headers.get("Sec-Fetch-Site");
return site && site !== "same-origin" && site !== "none" ? null : origin;
}
function cookieName(origin: string): string {
return (origin.startsWith("https:") ? "__Host-" : "") + "ocx_dashboard_" + hash(origin).slice(0, 16);
}
function deviceDigest(req: Request, origin: string): string | null {
const name = cookieName(origin);
const matches = (req.headers.get("Cookie") ?? "").split(";").map(part => part.trim()).filter(part => part.startsWith(name + "="));
if (matches.length !== 1) return null;
const token = matches[0]!.slice(name.length + 1);
return /^ocx_device_[A-Za-z0-9_-]{43}$/.test(token) ? hash(token) : null;
}
function cookie(origin: string, token: string, maxAge: number): string {
return cookieName(origin) + "=" + token + "; Path=/; HttpOnly; SameSite=Strict; Max-Age=" + maxAge
+ (origin.startsWith("https:") ? "; Secure" : "");
}
function readRecords(): DeviceRecord[] {
const path = storePath();
let fd: number;
try { fd = openSync(path, constants.O_RDONLY | (process.platform === "win32" ? 0 : constants.O_NOFOLLOW | constants.O_NONBLOCK)); }
catch (error) { if ((error as NodeJS.ErrnoException).code === "ENOENT") return []; throw error; }
try {
const stat = fstatSync(fd, { bigint: true });
const entry = lstatSync(path, { bigint: true });
if (!stat.isFile() || stat.nlink !== 1n || stat.size > STORE_LIMIT || entry.isSymbolicLink()
|| stat.dev !== entry.dev || stat.ino !== entry.ino) throw new Error("unsafe dashboard session store");
// Size the read from the stat we validated: a store that grows mid-read overflows
// the +1 sentinel byte and is rejected instead of silently truncated at a fixed limit.
const bytes = Buffer.alloc(Number(stat.size) + 1);
let length = 0;
while (length < bytes.length) { const count = readSync(fd, bytes, length, bytes.length - length, null); if (!count) break; length += count; }
if (length > stat.size) throw new Error("dashboard session store changed during read");
const value: unknown = JSON.parse(bytes.subarray(0, length).toString("utf8"));
if (!Array.isArray(value) || value.length > RECORD_LIMIT) throw new Error("invalid dashboard session store");
for (const row of value) {
if (!row || typeof row !== "object" || Object.keys(row).length !== 6
|| ![row.digest, row.credential, row.proof, row.userAgent].every(v => typeof v === "string" && /^[a-f0-9]{64}$/.test(v))
|| typeof row.serverOrigin !== "string" || row.serverOrigin.length > 2048
|| !Number.isSafeInteger(row.expiresAt) || row.expiresAt <= 0) throw new Error("invalid dashboard session record");
const url = new URL(row.serverOrigin);
if (url.origin !== row.serverOrigin || !["http:", "https:"].includes(url.protocol)) throw new Error("invalid dashboard session origin");
}
return value as DeviceRecord[];
} finally { closeSync(fd); }
}
function matches(row: DeviceRecord, req: Request, origin: string, state: State, now: number, ignoreUserAgent = false): boolean {
return row.serverOrigin === origin && row.credential === hash(state.token)
&& (ignoreUserAgent || row.userAgent === hash(req.headers.get("User-Agent") ?? "")) && row.expiresAt > now;
}
function mintDeviceSession(row: DeviceRecord, state: State, now: number) {
const session = mintSession(row.serverOrigin, row.serverOrigin, "remembered-admin", state, now);
const record = state.sessions.get(session.token)!;
record.persistentDigest = row.digest;
record.persistentExpiresAt = row.expiresAt;
session.expiresAt = Math.min(session.expiresAt, row.expiresAt);
return session;
}
export function rememberGuiDevice(req: Request, config: OcxConfig, state: State, now = Date.now()) {
const origin = directOrigin(req, config);
if (req.method !== "POST" || !origin || req.headers.get("Origin") !== origin || req.body !== null) return null;
return withConfigMutationLockSync(() => {
const previous = deviceDigest(req, origin);
const rows = readRecords().filter(row => row.expiresAt > now && row.credential === hash(state.token));
// Re-sign-in replaces only this device, never another server or browser's record.
const retained = rows.filter(row => !(row.digest === previous && matches(row, req, origin, state, now)));
if (retained.length >= RECORD_LIMIT) throw new Error("dashboard device limit reached");
const token = "ocx_device_" + randomBytes(32).toString("base64url");
const proof = "ocx_proof_" + randomBytes(32).toString("base64url");
const row: DeviceRecord = { digest: hash(token), credential: hash(state.token), proof: hash(proof), serverOrigin: origin,
userAgent: hash(req.headers.get("User-Agent") ?? ""), expiresAt: now + REMEMBERED_GUI_TTL_MS };
atomicWriteFileNoFollowStreamed(storePath(), fd => writeFileSync(fd, JSON.stringify([...retained, row])));
return { session: mintDeviceSession(row, state, now), device: { proof }, cookie: cookie(origin, token, REMEMBERED_GUI_TTL_MS / 1000) };
});
}
export function resumeGuiDevice(req: Request, config: OcxConfig, state: State, now = Date.now()) {
const origin = directOrigin(req, config);
if (req.method !== "GET" || !origin) return null;
const digest = deviceDigest(req, origin);
const proof = req.headers.get("X-OpenCodex-Device-Proof");
if (!digest || !proof || !/^ocx_proof_[A-Za-z0-9_-]{43}$/.test(proof)) return null;
try {
const row = readRecords().find(row => row.digest === digest && row.proof === hash(proof) && matches(row, req, origin, state, now));
return row ? mintDeviceSession(row, state, now) : null;
} catch { return null; }
}
export function rememberedGuiSessionIsCurrent(req: Request, config: OcxConfig, state: State, session: GuiSessionRecord, purpose: "access" | "logout" = "access"): boolean {
if (!session.persistentDigest) return true;
const origin = directOrigin(req, config);
if (!origin || deviceDigest(req, origin) !== session.persistentDigest) return false;
// Admission alone may tolerate browser updates for revocation; currentness and resume stay bound.
const revoking = purpose === "logout" && req.method === "POST" && new URL(req.url).pathname === "/api/session/logout";
try { return readRecords().some(row => row.digest === session.persistentDigest && matches(row, req, origin, state, Date.now(), revoking)); }
catch { return false; }
}
export function forgetGuiDevice(req: Request, config: OcxConfig, state: State): string | null {
const origin = directOrigin(req, config);
if (!origin || req.method !== "POST") return null;
const digest = deviceDigest(req, origin);
if (digest) withConfigMutationLockSync(() => {
const rows = readRecords();
// User-Agent and expiry protect resumption, not deletion: a browser update between
// Remember and Forget must still remove the record Forget was reached through.
const found = rows.find(row => row.digest === digest && row.serverOrigin === origin
&& row.credential === hash(state.token));
if (found) atomicWriteFileNoFollowStreamed(storePath(), fd => writeFileSync(fd, JSON.stringify(rows.filter(row => row !== found))));
for (const [token, session] of state.sessions) if (session.persistentDigest === digest) state.sessions.delete(token);
});
return cookie(origin, "", 0);
}