babelgate 0.0.0 → 1.1.0

package/dist/app.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.app = void 0;
+const express_1 = __importDefault(require("express"));
+const request_logger_1 = require("./middleware/request-logger");
+const resolve_source_1 = require("./middleware/resolve-source");
+const error_handler_1 = require("./middleware/error-handler");
+const require_api_key_1 = require("./middleware/require-api-key");
+const proxy_1 = require("./routes/proxy");
+const app = (0, express_1.default)();
+exports.app = app;
+// 1. Request logger - logs every incoming request
+app.use(request_logger_1.requestLogger);
+// 1a. Source resolver - records res.locals.sourceApi on provider paths so
+// the error handler renders errors (auth, body-parser, upstream) in the
+// client's own dialect.
+app.use((0, resolve_source_1.resolveSource)());
+// 2. Body parser - parses application/json. LLM payloads (base64
+// images, long context) routinely exceed the 100kb default.
+app.use(express_1.default.json({ limit: process.env.MAX_BODY_SIZE || "10mb" }));
+// 3. Routes
+app.get("/health", (_req, res) => {
+    res.status(200).json({ status: "ok" });
+});
+// 3a. Client auth — active only when PROXY_API_KEY is set.
+// /health above stays open for probes.
+app.use((0, require_api_key_1.requireApiKey)(process.env.PROXY_API_KEY || undefined));
+// 3b. Proxy routes - transforms and forwards LLM API requests
+app.use(proxy_1.proxyRouter);
+// 4. 404 handler - catch unmatched routes
+app.use((_req, res) => {
+    res
+        .status(404)
+        .json({ error: { message: "Not Found", code: "NOT_FOUND", status: 404 } });
+});
+// 5. Error handler - must be last
+app.use(error_handler_1.errorHandler);

package/dist/cli.js

@@ -0,0 +1,203 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCliArgs = parseCliArgs;
+exports.presetEnv = presetEnv;
+exports.overriddenKeys = overriddenKeys;
+exports.clientInstructions = clientInstructions;
+exports.main = main;
+const node_util_1 = require("node:util");
+const env_config_1 = require("./config/env-config");
+const index_1 = require("./index");
+const PRESETS = ["claude-code", "openai-apps"];
+const PROVIDERS = ["openai", "gemini", "ollama", "anthropic"];
+/**
+ * Parses CLI arguments. Unknown flags and invalid values throw an error
+ * naming the flag; upstream keys only ever come from the environment.
+ */
+function parseCliArgs(argv) {
+    const { values } = (0, node_util_1.parseArgs)({
+        args: argv,
+        strict: true,
+        options: {
+            preset: { type: "string" },
+            target: { type: "string" },
+            model: { type: "string" },
+            "base-url": { type: "string" },
+            port: { type: "string" },
+            help: { type: "boolean" },
+        },
+    });
+    const args = {};
+    if (values.preset !== undefined) {
+        if (!PRESETS.includes(values.preset)) {
+            throw new Error(`--preset must be one of: ${PRESETS.join(", ")}`);
+        }
+        args.preset = values.preset;
+    }
+    if (values.target !== undefined) {
+        if (!PROVIDERS.includes(values.target)) {
+            throw new Error(`--target must be one of: ${PROVIDERS.join(", ")}`);
+        }
+        args.target = values.target;
+    }
+    if (values.model !== undefined)
+        args.model = values.model;
+    if (values["base-url"] !== undefined)
+        args.baseUrl = values["base-url"];
+    if (values.port !== undefined) {
+        const port = Number(values.port);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+            throw new Error("--port must be an integer between 1 and 65535");
+        }
+        args.port = port;
+    }
+    if (values.help)
+        args.help = true;
+    return args;
+}
+/**
+ * The provider the proxy will target: `--target` when given, else a valid
+ * TARGET_API already in the env. Used wherever a preset/flag value depends
+ * on which target is effective.
+ */
+function effectiveTarget(args, env) {
+    if (args.target !== undefined)
+        return args.target;
+    return PROVIDERS.includes(env.TARGET_API)
+        ? env.TARGET_API
+        : undefined;
+}
+/**
+ * Every env value the flags/preset would set, before "user env wins" is
+ * applied. `env` is still consulted to resolve the effective target for
+ * --base-url and the ollama timeout.
+ */
+function wantedEnv(args, env) {
+    const wanted = {};
+    if (args.preset === "claude-code") {
+        wanted.SOURCE_API = "anthropic";
+    }
+    else if (args.preset === "openai-apps") {
+        wanted.SOURCE_API = "openai";
+    }
+    if (args.target !== undefined) {
+        wanted.TARGET_API = args.target;
+    }
+    if (args.preset === "claude-code") {
+        if (args.model !== undefined) {
+            wanted.MODEL_MAP = `claude-*=${args.model}`;
+        }
+        wanted.TARGET_CONTEXT_WINDOW = "32768";
+        if (effectiveTarget(args, env) === "ollama") {
+            wanted.UPSTREAM_TIMEOUT_MS = "600000";
+        }
+    }
+    if (args.baseUrl !== undefined) {
+        const target = effectiveTarget(args, env);
+        if (target === undefined) {
+            throw new Error("--base-url requires --target or TARGET_API in the environment");
+        }
+        wanted[`${target.toUpperCase()}_API_BASE_URL`] = args.baseUrl;
+    }
+    if (args.port !== undefined) {
+        wanted.PORT = String(args.port);
+    }
+    return wanted;
+}
+/**
+ * Environment values implied by the flags. Keys the user's own env already
+ * sets (a non-empty value) are not returned — user env always wins and
+ * presets are only ever env values, never changes to config defaults.
+ */
+function presetEnv(args, env) {
+    return Object.fromEntries(Object.entries(wantedEnv(args, env)).filter(([key]) => !env[key]));
+}
+/**
+ * Names of the preset/flag env keys that lost to values already set in
+ * `env` — everything the flags/preset wanted that presetEnv(args, env)
+ * dropped. Names only, never values.
+ */
+function overriddenKeys(args, env) {
+    const applied = presetEnv(args, env);
+    return Object.keys(wantedEnv(args, env)).filter((key) => !(key in applied));
+}
+/**
+ * The `export …` lines the user pastes into their shell to point the client
+ * app at this proxy. PROXY_API_KEY is the proxy's own client-facing key, not
+ * an upstream key.
+ */
+function clientInstructions(args, port, proxyApiKey) {
+    const token = proxyApiKey ?? "babelgate";
+    if (args.preset === "claude-code") {
+        return [
+            `export ANTHROPIC_BASE_URL=http://localhost:${port}`,
+            `export ANTHROPIC_AUTH_TOKEN=${token}`,
+        ];
+    }
+    if (args.preset === "openai-apps") {
+        return [
+            `export OPENAI_BASE_URL=http://localhost:${port}/v1`,
+            `export OPENAI_API_KEY=${token}`,
+        ];
+    }
+    return [];
+}
+function usageLines() {
+    return [
+        "Usage: babelgate [--preset <claude-code|openai-apps>] [--target <provider>]",
+        "                 [--model <name>] [--base-url <url>] [--port <n>] [--help]",
+        "",
+        "Upstream API keys come only from the environment",
+        "(OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, OLLAMA_API_KEY).",
+    ];
+}
+/** The preset whose export lines match a resolved source API. */
+function presetForSource(sourceApi) {
+    if (sourceApi === "anthropic")
+        return "claude-code";
+    if (sourceApi === "openai")
+        return "openai-apps";
+    return undefined;
+}
+async function main(argv) {
+    try {
+        const args = parseCliArgs(argv);
+        if (args.help) {
+            for (const line of usageLines())
+                console.log(line);
+            return;
+        }
+        const envValues = presetEnv(args, process.env);
+        const overridden = overriddenKeys(args, process.env);
+        for (const [key, value] of Object.entries(envValues)) {
+            process.env[key] = value;
+        }
+        if (overridden.length > 0) {
+            console.error(`babelgate: your environment overrides ${overridden.join(", ")} ` +
+                "(flags and presets never replace values you set)");
+        }
+        if (args.preset === "claude-code" &&
+            args.model === undefined &&
+            !process.env.MODEL_MAP) {
+            console.error("babelgate: no --model given; claude-* model names are forwarded " +
+                "to the target unchanged");
+        }
+        await (0, index_1.startServer)();
+        const config = (0, env_config_1.getConfig)();
+        if (args.preset !== undefined) {
+            // The export lines must match the server that actually started: the
+            // user's env may have overridden the preset's SOURCE_API.
+            for (const line of clientInstructions({ ...args, preset: presetForSource(config.sourceApi) }, config.port, config.proxyApiKey)) {
+                console.log(line);
+            }
+        }
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        process.exitCode = 1;
+    }
+}
+if (require.main === module) {
+    void main(process.argv.slice(2));
+}

package/dist/config/env-config.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.getConfig = getConfig;
+exports.resetConfig = resetConfig;
+const dotenv_1 = __importDefault(require("dotenv"));
+const model_map_1 = require("../utils/model-map");
+const errors_1 = require("../utils/errors");
+dotenv_1.default.config();
+const VALID_PROVIDERS = ["openai", "gemini", "ollama", "anthropic"];
+function isValidProvider(value) {
+    return VALID_PROVIDERS.includes(value.toLowerCase());
+}
+function normalizeProvider(value) {
+    return value.toLowerCase();
+}
+/**
+ * Loads configuration from environment variables
+ */
+function loadConfig() {
+    if (!process.env.SOURCE_API || !process.env.TARGET_API) {
+        throw new Error("SOURCE_API and TARGET_API environment variables are required");
+    }
+    const sourceApi = process.env.SOURCE_API;
+    const targetApi = process.env.TARGET_API;
+    if (!isValidProvider(sourceApi)) {
+        throw new Error(`SOURCE_API must be one of: ${VALID_PROVIDERS.join(", ")}`);
+    }
+    if (!isValidProvider(targetApi)) {
+        throw new Error(`TARGET_API must be one of: ${VALID_PROVIDERS.join(", ")}`);
+    }
+    const normalizedTarget = normalizeProvider(targetApi);
+    // Get API key based on target
+    const apiKeyEnvVars = {
+        openai: "OPENAI_API_KEY",
+        gemini: "GEMINI_API_KEY",
+        ollama: "OLLAMA_API_KEY",
+        anthropic: "ANTHROPIC_API_KEY",
+    };
+    const targetApiKey = process.env[apiKeyEnvVars[normalizedTarget]];
+    // Ollama doesn't require an API key
+    if (!targetApiKey && normalizedTarget !== "ollama") {
+        throw new Error(`${apiKeyEnvVars[normalizedTarget]} environment variable is required for target API ${targetApi}`);
+    }
+    // Upstream base URL follows the {PROVIDER}_API_BASE_URL convention
+    const baseUrlEnvVar = `${normalizedTarget.toUpperCase()}_API_BASE_URL`;
+    const targetBaseUrl = process.env[baseUrlEnvVar];
+    if (!targetBaseUrl) {
+        throw new Error(`${baseUrlEnvVar} environment variable is required for target API ${targetApi}`);
+    }
+    return {
+        sourceApi: normalizeProvider(sourceApi),
+        targetApi: normalizedTarget,
+        port: process.env.PORT ? parseInt(process.env.PORT, 10) : 3000,
+        targetApiKey,
+        targetBaseUrl: targetBaseUrl.replace(/\/$/, ""),
+        upstreamTimeoutMs: process.env.UPSTREAM_TIMEOUT_MS
+            ? parseInt(process.env.UPSTREAM_TIMEOUT_MS, 10)
+            : 30_000,
+        upstreamRetries: process.env.UPSTREAM_RETRIES
+            ? parseInt(process.env.UPSTREAM_RETRIES, 10)
+            : 1,
+        upstreamStreamIdleMs: process.env.UPSTREAM_STREAM_IDLE_MS
+            ? parseInt(process.env.UPSTREAM_STREAM_IDLE_MS, 10)
+            : 300_000,
+        proxyApiKey: process.env.PROXY_API_KEY || undefined,
+        modelMap: (0, model_map_1.parseModelMap)(process.env.MODEL_MAP),
+        targetContextWindow: parseTargetContextWindow(),
+    };
+}
+function parseTargetContextWindow() {
+    const raw = process.env.TARGET_CONTEXT_WINDOW;
+    if (raw === undefined || raw === "")
+        return undefined;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new errors_1.ConfigurationError("TARGET_CONTEXT_WINDOW must be a positive integer");
+    }
+    return value;
+}
+/**
+ * Get the current configuration (lazy-loaded)
+ */
+let _config = null;
+function getConfig() {
+    if (!_config) {
+        _config = loadConfig();
+    }
+    return _config;
+}
+/**
+ * Reset config (for testing)
+ */
+function resetConfig() {
+    _config = null;
+}

package/dist/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const app_1 = require("./app");
+const env_config_1 = require("./config/env-config");
+const logger_1 = require("./utils/logger");
+/**
+ * Starts the proxy and resolves once it is listening. Importing this module
+ * has no side effects — the server only starts when startServer() is called
+ * (or when index.js is run directly, for `npm start` / `npm run dev`).
+ */
+function startServer() {
+    const config = (0, env_config_1.getConfig)();
+    const port = config.port;
+    return new Promise((resolve, reject) => {
+        // No callback to app.listen: Express 5 registers a passed callback on
+        // both "listening" and "error", which would resolve on a failed bind.
+        const server = app_1.app.listen(port);
+        // Graceful shutdown — drain in-flight requests instead of killing them
+        // mid-generation. server.close() stops accepting new connections and
+        // resolves once active requests finish; the timer is the escape hatch.
+        function shutdown(signal) {
+            logger_1.logger.info({ signal }, "Shutting down");
+            server.close(() => {
+                logger_1.logger.info("All connections drained");
+                process.exit(0);
+            });
+            setTimeout(() => {
+                logger_1.logger.warn("Forcing exit — connections did not drain in time");
+                process.exit(1);
+            }, 10_000).unref();
+        }
+        server.once("listening", () => {
+            logger_1.logger.info({
+                port,
+                sourceApi: config.sourceApi,
+                targetApi: config.targetApi,
+                targetBaseUrl: config.targetBaseUrl,
+                targetApiKey: config.targetApiKey ? "****" : "Not configured",
+            }, "Server started");
+            process.on("SIGTERM", () => shutdown("SIGTERM"));
+            process.on("SIGINT", () => shutdown("SIGINT"));
+            resolve(server);
+        });
+        server.once("error", reject);
+    });
+}
+if (require.main === module) {
+    try {
+        (0, env_config_1.getConfig)();
+    }
+    catch (err) {
+        logger_1.logger.fatal({ err }, "Invalid configuration — check required env vars");
+        process.exit(1);
+    }
+    startServer().catch((err) => {
+        logger_1.logger.fatal({ err }, "Failed to start server");
+        process.exit(1);
+    });
+}

package/dist/middleware/error-handler.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const logger_1 = require("../utils/logger");
+const errors_1 = require("../utils/errors");
+const transformers_1 = require("../transformers");
+const canonical_error_1 = require("../utils/canonical-error");
+/**
+ * The provider's own error classification (type/code) and message,
+ * extracted from an upstream body of whatever shape. Read-only and
+ * generic — no provider-specific branches.
+ */
+function summarizeUpstreamBody(body) {
+    if (!body || typeof body !== "object")
+        return {};
+    const err = body.error;
+    // Ollama-style: { error: "<message>" }
+    if (typeof err === "string")
+        return { message: err };
+    if (!err || typeof err !== "object")
+        return {};
+    const e = err;
+    return {
+        ...(typeof e.type === "string" && { type: e.type }),
+        ...(typeof e.code === "string"
+            ? { code: e.code }
+            : typeof e.status === "string"
+                ? { code: e.status }
+                : {}),
+        ...(typeof e.message === "string" && { message: e.message }),
+    };
+}
+/**
+ * Any error → CanonicalError for dialect rendering (spec §3.3):
+ * ProxyError subclasses map via toCanonical(); body-parser errors map by
+ * their `type`; anything else is `internal` with a generic message in
+ * production.
+ */
+function toCanonical(err, isProduction) {
+    if (err instanceof errors_1.ProxyError)
+        return err.toCanonical();
+    const type = err?.type;
+    if (type === "entity.too.large") {
+        const limit = err.limit;
+        return (0, canonical_error_1.makeCanonicalError)("request_too_large", `Request body too large (limit: ${limit})`);
+    }
+    if (type === "entity.parse.failed") {
+        return (0, canonical_error_1.makeCanonicalError)("invalid_request", "Malformed JSON body");
+    }
+    return (0, canonical_error_1.makeCanonicalError)("internal", isProduction || !(err instanceof Error)
+        ? "Internal Server Error"
+        : err.message);
+}
+/**
+ * §3.3 log policy: an upstream failure is logged at warn with the status,
+ * the provider's own type/code and at most the first 200 characters of
+ * the message — and no message at all for auth failures. The raw
+ * upstream body and any body preview are never logged: both can echo
+ * keys or completion text.
+ */
+function logUpstreamError(err, requestId) {
+    const summary = summarizeUpstreamBody(err.upstreamBody);
+    // An "upstream" client kind on a sub-500 status only arises from the
+    // credentials rule — i.e. the upstream rejected the proxy's key, even
+    // when it didn't use 401/403 (Gemini's 400 + API_KEY_INVALID).
+    const authFailure = err.upstreamStatus === 401 ||
+        err.upstreamStatus === 403 ||
+        (err.clientError?.kind === "upstream" &&
+            err.upstreamStatus !== undefined &&
+            err.upstreamStatus < 500);
+    logger_1.logger.warn({
+        requestId,
+        statusCode: err.statusCode,
+        upstreamStatus: err.upstreamStatus,
+        upstreamType: summary.type,
+        upstreamCode: summary.code,
+        ...(!authFailure && summary.message
+            ? { upstreamMessage: summary.message.slice(0, 200) }
+            : {}),
+    }, "Upstream error");
+}
+const errorHandler = (err, req, res, _next) => {
+    const isProduction = process.env.NODE_ENV === "production";
+    const requestId = req.id;
+    const sourceApi = res.locals.sourceApi;
+    if (err instanceof errors_1.UpstreamError) {
+        logUpstreamError(err, requestId);
+    }
+    else if (err instanceof errors_1.ProxyError) {
+        logger_1.logger.error({
+            requestId,
+            code: err.code,
+            statusCode: err.statusCode,
+            context: err.context,
+            stack: err.stack,
+        }, err.message);
+    }
+    else {
+        // Not err wholesale: body-parser errors carry the raw request body
+        // (prompt text) on `err.body`, and their message echoes a fragment
+        // of it — so entity.* errors log only their type.
+        const errType = err?.type;
+        logger_1.logger.error({
+            requestId,
+            errType,
+            message: typeof errType === "string" && errType.startsWith("entity.")
+                ? `body-parser error: ${errType}`
+                : err instanceof Error
+                    ? err.message
+                    : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        }, "Unhandled error");
+    }
+    // On a provider route every error — including auth and body-parser
+    // errors — renders in the client's own dialect.
+    if (sourceApi) {
+        const canonical = toCanonical(err, isProduction);
+        if (canonical.retryAfterSeconds !== undefined) {
+            res.set("Retry-After", String(canonical.retryAfterSeconds));
+        }
+        const body = transformers_1.adapters[sourceApi].fromCanonicalError(canonical);
+        // Owner decision: the non-JSON-2xx body preview stays in
+        // non-production `details` (it can aid debugging) but is never
+        // logged — it can be completion text.
+        const bodyPreview = !isProduction && err instanceof errors_1.UpstreamError
+            ? err.context?.bodyPreview
+            : undefined;
+        res.status(canonical.status).json(bodyPreview !== undefined
+            ? { ...body, details: { bodyPreview } }
+            : body);
+        return;
+    }
+    // Outside provider routes: today's generic shape.
+    if (err && err.type === "entity.too.large") {
+        res.status(413).json({
+            error: {
+                message: `Request body too large (limit: ${err.limit})`,
+                code: "PAYLOAD_TOO_LARGE",
+                status: 413,
+            },
+        });
+        return;
+    }
+    if (err instanceof errors_1.ProxyError) {
+        res.status(err.statusCode).json(err.toJSON());
+        return;
+    }
+    const response = {
+        error: {
+            message: isProduction ? "Internal Server Error" : err.message,
+            code: "INTERNAL_ERROR",
+            status: 500,
+            ...(!isProduction && { details: { stack: err.stack } }),
+        },
+    };
+    res.status(500).json(response);
+};
+exports.errorHandler = errorHandler;

package/dist/middleware/request-logger.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogger = void 0;
+exports.createRequestLogger = createRequestLogger;
+const pino_http_1 = __importDefault(require("pino-http"));
+const crypto_1 = require("crypto");
+const logger_1 = require("../utils/logger");
+// Header names that can carry a client credential; their values never
+// reach a log line (Node lowercases inbound header names).
+const CREDENTIAL_HEADERS = new Set([
+    'authorization',
+    'proxy-authorization',
+    'x-api-key',
+    'x-goog-api-key',
+    'cookie',
+]);
+// A Gemini-style `?key=` credential can sit anywhere in the query string;
+// every other parameter is logged as it is.
+function redactUrl(url) {
+    return url?.replace(/([?&]key=)[^&]*/g, '$1[REDACTED]');
+}
+// pino-http feeds the standard-serialized req through this before each
+// line is written — the last chance to strip credentials.
+function serializeReq(req) {
+    const headers = { ...req.headers };
+    for (const name of Object.keys(headers)) {
+        if (CREDENTIAL_HEADERS.has(name.toLowerCase())) {
+            headers[name] = '[REDACTED]';
+        }
+    }
+    req.headers = headers;
+    req.url = redactUrl(req.url);
+    // Express parses the query onto req.query, so `key` would survive the
+    // url redaction above; blank the parsed value too.
+    if (req.query && typeof req.query === 'object' && 'key' in req.query) {
+        req.query = { ...req.query, key: '[REDACTED]' };
+    }
+    return req;
+}
+function createRequestLogger(log) {
+    return (0, pino_http_1.default)({
+        logger: log,
+        genReqId: (req) => req.headers['x-request-id'] || (0, crypto_1.randomUUID)(),
+        customLogLevel: (_req, res, err) => {
+            if (err || res.statusCode >= 500)
+                return 'error';
+            if (res.statusCode >= 400)
+                return 'warn';
+            return 'info';
+        },
+        serializers: { req: serializeReq },
+        customSuccessMessage: (req, res) => {
+            return `${req.method} ${redactUrl(req.url)} ${res.statusCode}`;
+        },
+        customErrorMessage: (req, res) => {
+            return `${req.method} ${redactUrl(req.url)} ${res.statusCode}`;
+        },
+        customProps: (req) => ({
+            requestId: req.id,
+        }),
+    });
+}
+exports.requestLogger = createRequestLogger(logger_1.logger);