Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import { spawn } from "node:child_process";
import { randomBytes, randomUUID } from "node:crypto";
import { chmodSync, mkdirSync, rmSync } from "node:fs";
import { join } from "node:path";
import { isConnectionUnavailableToAuxiliaryActivity } from "@/lib/exclusiveLeaseIsolation";
import { getProviderConnectionById, updateProviderConnection } from "@/lib/db/providers";
import { validateProviderApiKey } from "@/lib/providers/validation";
import { VNC_CONFIG, getVncProvider } from "./manifest";
import { harvestFromContainer, harvestToCredentials, waitForCdpReady } from "./harvest";
export type VncSessionStatus = "starting" | "running" | "harvesting" | "stopping" | "error";
export interface VncSession {
sessionId: string;
connectionId: string;
providerId: string;
containerName: string;
profileDir: string;
cdpPort: number;
/** Shared secret the CDP bridge (docker/vnc-browser/chromium/cdp-bridge.py) requires (#12571). */
cdpToken: string;
vncPort: number;
url: string;
status: VncSessionStatus;
startedAt: number;
lastViewerAt: number;
lastHarvestAt: number;
error?: string;
}
export interface HarvestSessionResult {
harvested: boolean;
sessionId: string;
connectionId: string;
providerId: string;
updatedFields: string[];
validation: {
valid: boolean;
unsupported: boolean;
error: string | null;
} | null;
}
const LABEL = "com.omniroute.browser-login";
const SESSIONS = new Map<string, VncSession>();
let idleTimer: NodeJS.Timeout | null = null;
let reconciliationPromise: Promise<void> | null = null;
function docker(
args: string[],
opts: { timeoutMs?: number } = {}
): Promise<{ code: number; out: string; err: string }> {
return new Promise((resolve) => {
let settled = false;
let out = "";
let err = "";
const child = spawn(VNC_CONFIG.dockerBin, args, { stdio: ["ignore", "pipe", "pipe"] });
let timer: NodeJS.Timeout | null = null;
const finish = (result: { code: number; out: string; err: string }) => {
if (settled) return;
settled = true;
if (timer) clearTimeout(timer);
resolve(result);
};
timer = setTimeout(() => {
child.kill("SIGKILL");
finish({ code: -1, out, err: `${err} (docker timed out)`.trim() });
}, opts.timeoutMs ?? 60_000);
child.stdout.on("data", (data) => {
out += data.toString();
});
child.stderr.on("data", (data) => {
err += data.toString();
});
child.on("error", (error) => {
finish({ code: -1, out, err: error.message });
});
child.on("close", (code) => {
finish({ code: code ?? -1, out, err });
});
});
}
export function sessionKey(sessionId: string): string {
return `omniroute-browser-login-${sessionId.replace(/[^a-zA-Z0-9]/g, "").slice(0, 20)}`;
}
export function getSession(connectionId: string, sessionId: string): VncSession | undefined {
const session = SESSIONS.get(sessionId);
return session?.connectionId === connectionId ? session : undefined;
}
export function listSessions(connectionId?: string): VncSession[] {
const sessions = [...SESSIONS.values()];
return connectionId ? sessions.filter((session) => session.connectionId === connectionId) : sessions;
}
async function reconcileStaleContainers(): Promise<void> {
if (!reconciliationPromise) {
reconciliationPromise = (async () => {
const listed = await docker(
["ps", "-aq", "--filter", `label=${LABEL}=true`],
{ timeoutMs: 20_000 }
);
if (listed.code !== 0) return;
const ids = listed.out
.split(/\s+/)
.map((value) => value.trim())
.filter(Boolean);
if (ids.length > 0) {
await docker(["rm", "-f", ...ids], { timeoutMs: 30_000 });
}
})();
}
await reconciliationPromise;
}
function findActiveSessionForConnection(connectionId: string): VncSession | undefined {
return [...SESSIONS.values()].find(
(session) =>
session.connectionId === connectionId &&
["starting", "running", "harvesting"].includes(session.status)
);
}
function safePathSegment(value: string): string {
const safe = value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120);
if (!safe || safe === "." || safe === "..") throw new Error("Invalid profile identifier");
return safe;
}
function createProfileDir(connectionId: string, sessionId: string): string {
mkdirSync(VNC_CONFIG.profileDir, { recursive: true, mode: 0o700 });
chmodSync(VNC_CONFIG.profileDir, 0o700);
const profileName = safePathSegment(VNC_CONFIG.persistProfiles ? connectionId : sessionId);
const profileDir = join(VNC_CONFIG.profileDir, profileName);
mkdirSync(profileDir, { recursive: true, mode: 0o700 });
chmodSync(profileDir, 0o700);
return profileDir;
}
let networkEnsured = false;
/**
* Creates the dedicated browser-login bridge network (#12571) if it does not
* already exist. Idempotent: `docker network create` failing because the
* network is already there is not an error.
*/
async function ensureNetwork(): Promise<void> {
if (networkEnsured) return;
const result = await docker(["network", "create", VNC_CONFIG.network], { timeoutMs: 15_000 });
if (result.code !== 0 && !/already exists/i.test(result.err)) {
throw new Error(result.err.trim() || `Could not create Docker network ${VNC_CONFIG.network}`);
}
networkEnsured = true;
}
/**
* Builds the `docker run` argument array for a browser-login container.
* Pulled out as a pure function so the security-relevant shape (dedicated
* network + CDP_BRIDGE_TOKEN, #12571) is directly testable without spawning
* Docker or touching the DB.
*/
export function buildRunArgs(params: {
containerName: string;
sessionId: string;
connectionId: string;
profileDir: string;
chromeCli: string;
cdpToken: string;
}): string[] {
return [
"run",
"-d",
"--name",
params.containerName,
"--restart",
"no",
"--network",
VNC_CONFIG.network,
"--label",
`${LABEL}=true`,
"--label",
`${LABEL}.session-id=${params.sessionId}`,
"--label",
`${LABEL}.connection-id=${params.connectionId}`,
"--shm-size",
"1gb",
"-p",
`127.0.0.1::${VNC_CONFIG.containerVncPort}`,
"-p",
`127.0.0.1::${VNC_CONFIG.containerCdpPort}`,
"-v",
`${params.profileDir}:${VNC_CONFIG.containerProfileDir}`,
"-e",
`CHROME_CLI=${params.chromeCli}`,
"-e",
`CDP_BRIDGE_TOKEN=${params.cdpToken}`,
VNC_CONFIG.image,
];
}
async function publishedPort(containerName: string, containerPort: number): Promise<number> {
const result = await docker(["port", containerName, `${containerPort}/tcp`], {
timeoutMs: 10_000,
});
if (result.code !== 0) {
throw new Error(result.err.trim() || `Could not resolve published port ${containerPort}`);
}
for (const line of result.out.split(/\r?\n/)) {
const match = line.trim().match(/:(\d+)$/);
if (match) return Number(match[1]);
}
throw new Error(`Docker did not publish container port ${containerPort}`);
}
export async function startSession(connectionId: string): Promise<VncSession> {
if (await isConnectionUnavailableToAuxiliaryActivity(connectionId))
throw new Error("Browser login is unavailable for managed lease connections");
await reconcileStaleContainers();
const connection = await getProviderConnectionById(connectionId);
if (!connection) throw new Error("Provider connection not found");
const providerId = typeof connection.provider === "string" ? connection.provider : "";
const provider = getVncProvider(providerId);
if (!provider) {
throw new Error(`Browser login is not supported for provider '${providerId || "unknown"}'`);
}
const existing = findActiveSessionForConnection(connectionId);
if (existing) return existing;
if (SESSIONS.size >= VNC_CONFIG.maxSessions) {
throw new Error(`Maximum ${VNC_CONFIG.maxSessions} concurrent browser-login sessions reached`);
}
const sessionId = randomUUID();
const containerName = sessionKey(sessionId);
const profileDir = createProfileDir(connectionId, sessionId);
const cdpToken = randomBytes(24).toString("hex");
const state: VncSession = {
sessionId,
connectionId,
providerId,
containerName,
profileDir,
cdpPort: 0,
cdpToken,
vncPort: 0,
url: provider.url,
status: "starting",
startedAt: Date.now(),
lastViewerAt: Date.now(),
lastHarvestAt: 0,
};
SESSIONS.set(sessionId, state);
try {
await ensureNetwork();
const chromeCli = `${VNC_CONFIG.chromiumArgs} ${provider.url}`;
const result = await docker(
buildRunArgs({ containerName, sessionId, connectionId, profileDir, chromeCli, cdpToken }),
{ timeoutMs: 120_000 }
);
if (result.code !== 0) {
const message = result.err.trim() || "docker run failed";
const buildHint =
VNC_CONFIG.image === "omniroute-vnc-chromium:local" &&
/pull access denied|unable to find image|not found/i.test(message)
? " Build it with: docker build -t omniroute-vnc-chromium:local docker/vnc-browser/chromium"
: "";
throw new Error(`${message}${buildHint}`);
}
state.vncPort = await publishedPort(containerName, VNC_CONFIG.containerVncPort);
state.cdpPort = await publishedPort(containerName, VNC_CONFIG.containerCdpPort);
await waitForCdpReady(state.cdpPort, VNC_CONFIG.browserReadyTimeoutMs, state.cdpToken);
state.status = "running";
scheduleIdleSweep();
return state;
} catch (error) {
state.status = "error";
state.error = error instanceof Error ? error.message : String(error);
SESSIONS.delete(sessionId);
await docker(["rm", "-f", containerName], { timeoutMs: 20_000 });
cleanupProfile(state);
throw new Error(`Failed to start browser login for connection ${connectionId}: ${state.error}`);
}
}
export function markViewerActive(connectionId: string, sessionId: string): void {
const session = getSession(connectionId, sessionId);
if (session) session.lastViewerAt = Date.now();
}
export async function harvestSession(
connectionId: string,
sessionId: string
): Promise<HarvestSessionResult> {
if (await isConnectionUnavailableToAuxiliaryActivity(connectionId))
throw new Error("Browser login is unavailable for managed lease connections");
const session = getSession(connectionId, sessionId);
if (!session) throw new Error("Browser-login session not found");
if (session.status !== "running") {
throw new Error(`Browser-login session is not running (${session.status})`);
}
const provider = getVncProvider(session.providerId);
if (!provider) throw new Error("Provider is no longer supported for browser login");
session.status = "harvesting";
try {
const harvest = await harvestFromContainer(
session.cdpPort,
provider,
VNC_CONFIG.harvestTimeoutMs,
session.cdpToken
);
session.lastHarvestAt = Date.now();
if (!harvest.hasCredential) {
return {
harvested: false,
sessionId,
connectionId,
providerId: session.providerId,
updatedFields: [],
validation: null,
};
}
const connection = await getProviderConnectionById(connectionId);
if (!connection) throw new Error("Provider connection no longer exists");
if (connection.provider !== session.providerId) {
throw new Error("Provider connection changed while browser login was active");
}
const { providerSpecificData, apiKey } = harvestToCredentials(harvest, provider);
const existingData =
connection.providerSpecificData &&
typeof connection.providerSpecificData === "object" &&
!Array.isArray(connection.providerSpecificData)
? connection.providerSpecificData
: {};
const mergedData = { ...existingData, ...providerSpecificData };
await updateProviderConnection(connectionId, {
providerSpecificData: mergedData,
...(apiKey ? { apiKey } : {}),
});
const validationKey =
apiKey ||
(typeof mergedData.cookie === "string" ? mergedData.cookie : null) ||
(typeof connection.apiKey === "string" ? connection.apiKey : "");
const validationResult = await validateProviderApiKey({
provider: session.providerId,
apiKey: validationKey,
providerSpecificData: mergedData,
});
return {
harvested: true,
sessionId,
connectionId,
providerId: session.providerId,
updatedFields: [
...Object.keys(providerSpecificData).map((key) => `providerSpecificData.${key}`),
...(apiKey ? ["apiKey"] : []),
],
validation: {
valid: !!validationResult.valid,
unsupported: !!validationResult.unsupported,
error:
typeof validationResult.error === "string" && validationResult.error.trim()
? validationResult.error
: null,
},
};
} finally {
if (session.status === "harvesting") session.status = "running";
}
}
export async function stopSession(connectionId: string, sessionId: string): Promise<void> {
const session = getSession(connectionId, sessionId);
if (!session || session.status === "stopping") return;
session.status = "stopping";
SESSIONS.delete(sessionId);
try {
const result = await docker(["rm", "-f", session.containerName], { timeoutMs: 20_000 });
if (result.code !== 0 && !/no such container/i.test(result.err)) {
throw new Error(result.err.trim() || "Failed to remove browser container");
}
} finally {
cleanupProfile(session);
}
}
export async function stopAllSessions(): Promise<void> {
const sessions = [...SESSIONS.values()];
await Promise.all(
sessions.map((session) => stopSession(session.connectionId, session.sessionId).catch(() => {}))
);
if (idleTimer) clearInterval(idleTimer);
idleTimer = null;
}
function cleanupProfile(session: VncSession): void {
if (VNC_CONFIG.persistProfiles) return;
try {
rmSync(session.profileDir, { recursive: true, force: true });
} catch {
// Best-effort cleanup; the directory remains mode 0700 if removal fails.
}
}
function scheduleIdleSweep(): void {
if (idleTimer) return;
idleTimer = setInterval(async () => {
const now = Date.now();
for (const session of [...SESSIONS.values()]) {
if (session.status !== "running") continue;
const idleFor = now - Math.max(session.lastViewerAt, session.lastHarvestAt);
const overMax =
VNC_CONFIG.maxSessionMs > 0 && now - session.startedAt >= VNC_CONFIG.maxSessionMs;
if (idleFor >= VNC_CONFIG.idleTimeoutMs || overMax) {
await stopSession(session.connectionId, session.sessionId).catch(() => {});
}
}
}, 30_000);
idleTimer.unref?.();
}