Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import path from 'node:path';
import { compare, hash } from 'bcryptjs';
import { Worker } from 'node:worker_threads';
import { availableParallelism } from 'node:os';
import { logger } from '@librechat/data-schemas';
import type { HashJob, HashReply } from './hash-worker';
type HashRequest =
| { op: 'hash'; plain: string; rounds: number }
| { op: 'compare'; plain: string; hash: string };
interface Pending {
resolve: (value: string | boolean) => void;
reject: (error: Error) => void;
}
interface HashWorker {
worker: Worker;
pending: Map<number, Pending>;
/** Whether this worker ever answered; one that dies first means workers cannot start here. */
answered: boolean;
}
class HashWorkerStoppedError extends Error {
constructor() {
super('Password hashing worker stopped');
}
}
/** The main-thread path: slower under load, but sign-in keeps working without workers. */
function runInProcess(request: HashRequest): Promise<string | boolean> {
return request.op === 'hash'
? hash(request.plain, request.rounds)
: compare(request.plain, request.hash);
}
export interface HashPool {
hash: (plain: string, rounds: number) => Promise<string>;
compare: (plain: string, hash: string) => Promise<boolean>;
close: () => Promise<void>;
}
/**
* Runs bcrypt on a small pool of worker threads. bcryptjs is pure JavaScript, so hashing on the
* main thread (sync, or its chunked async API) stalls every other request for the whole hash.
* Workers start on demand and hold the process open only while they have work. A job whose
* worker dies is redone on the main thread, and a worker that dies before answering anything
* moves every later job there too, with one warning.
*/
export function createHashPool(
workerPath: string,
size: number = Math.max(1, Math.min(4, availableParallelism() - 1)),
): HashPool {
const workers: HashWorker[] = [];
let nextId = 0;
let unavailable = false;
let warned = false;
const spawn = (): HashWorker => {
const worker = new Worker(workerPath, { execArgv: [] });
worker.unref();
const entry: HashWorker = { worker, pending: new Map(), answered: false };
const fail = (): void => {
const index = workers.indexOf(entry);
if (index !== -1) workers.splice(index, 1);
if (!entry.answered) unavailable = true;
for (const { reject } of entry.pending.values()) {
reject(new HashWorkerStoppedError());
}
entry.pending.clear();
};
worker.on('message', (reply: HashReply) => {
const pending = entry.pending.get(reply.id);
if (!pending) return;
entry.answered = true;
entry.pending.delete(reply.id);
if (entry.pending.size === 0) worker.unref();
if (reply.ok) pending.resolve(reply.value);
else pending.reject(new Error('Password hashing failed'));
});
worker.on('error', fail);
worker.on('exit', fail);
workers.push(entry);
return entry;
};
const pick = (): HashWorker => {
let least: HashWorker | undefined;
for (const entry of workers) {
if (!least || entry.pending.size < least.pending.size) least = entry;
}
if (!least || (least.pending.size > 0 && workers.length < size)) return spawn();
return least;
};
const runOnWorker = (request: HashRequest): Promise<string | boolean> =>
new Promise((resolve, reject) => {
let entry: HashWorker;
try {
entry = pick();
} catch {
unavailable = true;
reject(new HashWorkerStoppedError());
return;
}
const id = nextId++;
entry.pending.set(id, { resolve, reject });
if (entry.pending.size === 1) entry.worker.ref();
entry.worker.postMessage({ id, ...request } satisfies HashJob);
});
const run = async (request: HashRequest): Promise<string | boolean> => {
if (!unavailable) {
try {
return await runOnWorker(request);
} catch (error) {
if (!(error instanceof HashWorkerStoppedError)) throw error;
}
}
if (!warned) {
warned = true;
logger.warn(
'[passwordHashing] A hashing worker stopped; hashing on the main thread, which slows other requests while it runs',
);
}
return runInProcess(request);
};
return {
hash: async (plain, rounds) => (await run({ op: 'hash', plain, rounds })) as string,
compare: async (plain, hash) => (await run({ op: 'compare', plain, hash })) as boolean,
close: async () => {
await Promise.all(workers.map((entry) => entry.worker.terminate()));
},
};
}
let pool: HashPool | undefined;
let configuredSize: number | undefined;
/** Applies `librechat.yaml` `passwordHashing` at startup, before the pool first starts. */
export function configureHashPool(config?: { maxWorkers?: number }): void {
configuredSize = config?.maxWorkers;
}
function getHashPool(): HashPool {
pool ??= createHashPool(
path.join(path.dirname(require.resolve('@librechat/api')), 'auth/hash-worker.cjs'),
configuredSize,
);
return pool;
}
/** bcrypt hash of `plain` at cost `rounds`, computed off the event loop. */
export function hashSecret(plain: string, rounds = 10): Promise<string> {
return getHashPool().hash(plain, rounds);
}
/** Whether `plain` matches the bcrypt `hash`, checked off the event loop. */
export function compareSecret(plain: string, hash: string): Promise<boolean> {
return getHashPool().compare(plain, hash);
}