7.4 billion tokens per month. 34 free LLM providers. 635 free model endpoints. All behind one /v1 endpoint, plus any custom OpenAI-compatible endpoint. Smart routing, automatic failover, encrypted keys. Personal experimentation only.
TypeScript
// A file log for the desktop app (#824).
//
// The embedded server writes operational output to the console — including the
// one-time password-reset code, which POST /api/auth/forgot-password prints and
// nothing else ever shows. A server operator reads it from `docker logs` or the
// terminal; a Finder/Explorer-launched Electron app has no attached stdout, so
// that code was unreadable and the reset flow could never be completed.
//
// So tee console output into <userData>/logs/freeapi.log. Writes are synchronous
// (a code printed a moment before the app quits must already be on disk) and
// every filesystem call is wrapped: logging must never be the reason the app
// fails to start.
import fs from 'node:fs';
import path from 'node:path';
import util from 'node:util';
import { app, shell } from 'electron';
const LOG_NAME = 'freeapi.log';
// Two files, 1 MB each: enough history to cover a reset or a bad boot, small
// enough that nobody's disk notices.
const MAX_LOG_BYTES = 1024 * 1024;
const PREVIOUS_NAME = `${LOG_NAME}.1`;
export function logsDir(): string {
return path.join(app.getPath('userData'), 'logs');
}
export function logFilePath(): string {
return path.join(logsDir(), LOG_NAME);
}
export interface FileSink {
write(line: string): void;
close(): void;
}
// The sink itself, free of electron so it can be exercised in tests: appends to
// <dir>/freeapi.log and rotates it to freeapi.log.1 once it passes maxBytes.
export function createFileSink(dir: string, maxBytes: number = MAX_LOG_BYTES): FileSink {
const current = path.join(dir, LOG_NAME);
const previous = path.join(dir, PREVIOUS_NAME);
let fd: number | null = null;
let size = 0;
function open(): void {
fs.mkdirSync(dir, { recursive: true });
fd = fs.openSync(current, 'a');
size = fs.fstatSync(fd).size;
}
function rotate(): void {
if (fd !== null) {
fs.closeSync(fd);
fd = null;
}
fs.rmSync(previous, { force: true });
fs.renameSync(current, previous);
open();
}
return {
write(line: string): void {
try {
if (fd === null) open();
const buf = Buffer.from(line.endsWith('\n') ? line : `${line}\n`, 'utf8');
// Rotate before the write that would cross the limit, never on an empty
// file — a single line longer than maxBytes must not loop.
if (size > 0 && size + buf.length > maxBytes) rotate();
fs.writeSync(fd as number, buf);
size += buf.length;
} catch {
// A read-only or full disk is not worth crashing over; drop the line.
}
},
close(): void {
try {
if (fd !== null) fs.closeSync(fd);
} catch {
// already gone
}
fd = null;
},
};
}
let installed = false;
// Wrap console.log/info/warn/error so everything the app and the embedded
// server print also lands in the log file. The original console is still
// called, so `npm run dev` output is unchanged.
export function installFileLogger(dir: string = logsDir()): void {
if (installed) return;
installed = true;
let sink: FileSink;
try {
sink = createFileSink(dir);
} catch {
return;
}
for (const level of ['log', 'info', 'warn', 'error'] as const) {
const original = console[level].bind(console);
console[level] = (...args: unknown[]): void => {
original(...args);
try {
sink.write(`${new Date().toISOString()} [${level}] ${util.format(...args)}`);
} catch {
// never let logging break the caller
}
};
}
process.on('exit', () => sink.close());
console.log(`[desktop] writing logs to ${path.join(dir, LOG_NAME)}`);
}
// Tray → "Open Logs Folder". Create the directory first so the reveal works
// even before anything has been written.
export function openLogsFolder(): void {
try {
const dir = logsDir();
fs.mkdirSync(dir, { recursive: true });
void shell.openPath(dir);
} catch (err) {
console.warn('[desktop] could not open the logs folder:', err);
}
}
// Tray → "Open Backups Folder". The server writes dumps to <db dir>/backups
// (server/src/services/backups.ts dataDir()) and main.ts puts the DB at
// <userData>/freeapi.db, so this is where they land — the dashboard's Backups
// panel only ever shows paths relative to that directory, which a desktop
// user has no other way to locate.
export function openBackupsFolder(): void {
try {
const dir = path.join(app.getPath('userData'), 'backups');
fs.mkdirSync(dir, { recursive: true });
void shell.openPath(dir);
} catch (err) {
console.warn('[desktop] could not open the backups folder:', err);
}
}