@agenthippo-ai/agenthippo 0.1.0

package/out/auth-broker/server.js

@@ -0,0 +1,539 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthBrokerServer = createAuthBrokerServer;
+exports.startAuthBrokerServer = startAuthBrokerServer;
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const url_1 = require("url");
+const path = __importStar(require("path"));
+const config_js_1 = require("./config.js");
+const store_js_1 = require("./store.js");
+const pkce_js_1 = require("./pkce.js");
+const jwt_js_1 = require("./jwt.js");
+const types_js_1 = require("../auth/types.js");
+const serve_hardening_js_1 = require("../cli/serve-hardening.js");
+function sendJson(res, status, body) {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(body));
+}
+/** Mask the local-part of an email for logs: `n***@example.com` (domain kept for debugging). */
+function maskEmail(value) {
+    const at = value.indexOf('@');
+    if (at <= 0) {
+        return value;
+    }
+    return `${value[0]}***@${value.slice(at + 1)}`;
+}
+/** Auth request bodies (PKCE codes, emails, form fields) are always tiny. */
+const MAX_BODY_BYTES = 64 * 1024;
+async function readBody(req) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of req) {
+        const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+        size += buf.length;
+        if (size > MAX_BODY_BYTES) {
+            const err = new Error('Request body too large');
+            err.status = 413;
+            throw err;
+        }
+        chunks.push(buf);
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+function parseFormBody(raw) {
+    const params = new URLSearchParams(raw);
+    const out = {};
+    for (const [key, value] of params.entries()) {
+        out[key] = value;
+    }
+    return out;
+}
+/** Read a named cookie from the Cookie header. */
+function extractCookieToken(cookieHeader, name) {
+    if (!cookieHeader?.trim()) {
+        return undefined;
+    }
+    for (const part of cookieHeader.split(';')) {
+        const eq = part.indexOf('=');
+        if (eq <= 0) {
+            continue;
+        }
+        const key = part.slice(0, eq).trim();
+        if (key === name) {
+            const val = part.slice(eq + 1).trim();
+            if (val) {
+                return val;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Federated SSO (A′): validate a `return_to` redirect target for the browser-login endpoint.
+ * The target host must live under the configured `cookieDomain` (e.g. `.agenthippo.ai`) so the
+ * shared cookie we're about to set will actually be sent back to it. With no cookie domain
+ * configured (dev), allow same-host / localhost.
+ */
+function safeReturnTo(rawReturnTo, cookieDomain, fallback) {
+    try {
+        const target = new url_1.URL(rawReturnTo);
+        if (cookieDomain) {
+            const parent = cookieDomain.replace(/^\./, '').toLowerCase();
+            if (target.hostname.toLowerCase() === parent || target.hostname.toLowerCase().endsWith('.' + parent)) {
+                return target.toString();
+            }
+        }
+        else if (target.hostname === '127.0.0.1' || target.hostname === 'localhost') {
+            return target.toString();
+        }
+    }
+    catch {
+        // fall through
+    }
+    return fallback;
+}
+function createAuthBrokerServer(config) {
+    const resolved = config ?? (0, config_js_1.loadAuthBrokerConfig)();
+    // Fail-closed: a known-default secret makes JWT forgery trivial.
+    if (!resolved.devMode && resolved.jwtSecret === config_js_1.DEFAULT_JWT_SECRET) {
+        throw new Error('AGENTHIPPO_AUTH_JWT_SECRET must be set to a strong secret in production. ' +
+            'Generate one with: openssl rand -hex 32');
+    }
+    // Warn when no domain restriction is configured: any SSO-authenticated email can sign in.
+    if (!resolved.devMode && resolved.allowedEmailDomains.length === 0) {
+        console.warn('[auth-broker] Warning: AGENTHIPPO_AUTH_ALLOWED_DOMAINS is not set — ' +
+            'any upstream-SSO-authenticated email can receive a token. ' +
+            'Set it to restrict sign-in (e.g. "example.com").');
+    }
+    const persistPath = resolved.dataDir
+        ? path.join(resolved.dataDir, 'auth-store.json')
+        : undefined;
+    const store = new store_js_1.AuthBrokerStore(resolved, persistPath);
+    // Per-client-IP cap on the credential-issuing endpoints (authorize/token/dev-login) so a
+    // direct caller can't brute-force or hammer them. /api/ide/me is deliberately exempt: Caddy
+    // forward_auth calls it on every IDE request and it's already cheap + cached.
+    const authLimiter = new serve_hardening_js_1.RateLimiter(resolved.rateLimitPerMin);
+    /** Structured auth-event audit log; emails masked unless AGENTHIPPO_AUTH_LOG_PII=1. */
+    const audit = (event, fields = {}) => {
+        const parts = Object.entries(fields)
+            .filter(([, v]) => v !== undefined && v !== '')
+            .map(([k, v]) => {
+            const masked = !resolved.logPii && typeof v === 'string' && v.includes('@') ? maskEmail(v) : v;
+            return `${k}=${masked}`;
+        })
+            .join(' ');
+        console.log(`[auth-broker] ${event}${parts ? ' ' + parts : ''}`);
+    };
+    // Short-lived positive cache for /api/ide/me (Caddy forward_auth calls it on every IDE
+    // /v1/* request). Access tokens are short-lived JWTs with no server-side revocation, so
+    // trusting a verified token for a few seconds is safe and avoids a verifyJwt+getUser
+    // round-trip on every chat turn. Keyed by token hash; capped + pruned.
+    const ME_CACHE_TTL_MS = 10_000;
+    const ME_CACHE_MAX = 2048;
+    const meCache = new Map();
+    // Throttle the per-turn /me 401 audit so an expired-token burst doesn't spam the log.
+    const ME_UNAUTHORIZED_LOG_INTERVAL_MS = 5_000;
+    let lastMeUnauthorizedLogMs = 0;
+    function resolveAuthedUser(req) {
+        // Bearer (IDE) first; fall back to the federated `.agenthippo.ai` cookie (browser).
+        const bearer = (0, jwt_js_1.extractBearerToken)(req.headers.authorization)
+            || extractCookieToken(req.headers.cookie, resolved.cookieName);
+        if (!bearer) {
+            return undefined;
+        }
+        const key = crypto.createHash('sha256').update(bearer).digest('hex');
+        const cached = meCache.get(key);
+        if (cached) {
+            if (cached.exp > Date.now()) {
+                return cached.user;
+            }
+            meCache.delete(key);
+        }
+        const payload = (0, jwt_js_1.verifyJwt)(bearer, resolved.jwtSecret);
+        if (!payload?.sub || !payload.email) {
+            return undefined;
+        }
+        let user = store.getUser(String(payload.sub));
+        // Federated trust (A′): a token signed with our shared AGENTHIPPO_AUTH_JWT_SECRET is
+        // authoritative even when the issuing user record lives in the central IdP's store, not
+        // this broker's local store (which is an empty ephemeral volume on distributed edge
+        // services). The IdP vouches for sub/email/name; the HMAC signature is the proof. The
+        // IdP's own broker still hits getUser for its locally-created users, so this fallback is
+        // a no-op there.
+        if (!user) {
+            user = {
+                id: String(payload.sub),
+                email: String(payload.email),
+                displayName: typeof payload.name === 'string' && payload.name ? payload.name : String(payload.email),
+                teamId: typeof payload.team_id === 'string' && payload.team_id ? payload.team_id : resolved.team.id,
+            };
+        }
+        if (payload.exp) {
+            const exp = Math.min(payload.exp * 1000, Date.now() + ME_CACHE_TTL_MS);
+            if (meCache.size >= ME_CACHE_MAX) {
+                const now = Date.now();
+                for (const [k, v] of meCache) {
+                    if (v.exp < now) {
+                        meCache.delete(k);
+                    }
+                }
+                if (meCache.size >= ME_CACHE_MAX) {
+                    meCache.clear();
+                }
+            }
+            meCache.set(key, { user, exp });
+        }
+        return user;
+    }
+    const server = http.createServer(async (req, res) => {
+        try {
+            const host = req.headers.host || `127.0.0.1:${resolved.port}`;
+            const url = new url_1.URL(req.url || '/', `http://${host}`);
+            const pathname = url.pathname;
+            // Gate on the credential-issuing endpoints only (see authLimiter note above).
+            const ip = (0, serve_hardening_js_1.clientIp)(req);
+            const rateLimited = () => {
+                if (authLimiter.tryConsume(ip)) {
+                    return false;
+                }
+                audit('rate_limited', { ip, path: pathname });
+                res.writeHead(429, { 'Content-Type': 'application/json', 'Retry-After': String(authLimiter.retryAfterSeconds(ip)) });
+                res.end(JSON.stringify({ error: 'rate_limited' }));
+                return true;
+            };
+            if (req.method === 'GET' && (pathname === '/health' || pathname === '/api/ide/health')) {
+                sendJson(res, 200, { status: 'ok', service: 'auth-broker' });
+                return;
+            }
+            if (req.method === 'GET' && pathname === '/oauth/authorize') {
+                if (rateLimited()) {
+                    return;
+                }
+                const clientId = url.searchParams.get('client_id') || '';
+                const redirectUri = url.searchParams.get('redirect_uri') || '';
+                const codeChallenge = url.searchParams.get('code_challenge') || '';
+                const state = url.searchParams.get('state') || '';
+                const loginHint = url.searchParams.get('login_hint') || url.searchParams.get('email') || '';
+                if (clientId !== types_js_1.AUTH_CLIENT_ID || !redirectUri || !codeChallenge) {
+                    audit('authorize.invalid_request', { client_id: clientId });
+                    sendJson(res, 400, { error: 'invalid_request' });
+                    return;
+                }
+                // Dev mode with explicit login_hint: auto-authenticate (backward compat for tests).
+                if (resolved.devMode && loginHint) {
+                    const user = store.upsertUser(loginHint);
+                    const code = store.createAuthCode({ userId: user.id, clientId, redirectUri, codeChallenge });
+                    audit('authorize.dev', { user: user.email });
+                    const redirect = new url_1.URL(redirectUri);
+                    redirect.searchParams.set('code', code);
+                    if (state) {
+                        redirect.searchParams.set('state', state);
+                    }
+                    res.writeHead(302, { Location: redirect.toString() });
+                    res.end();
+                    return;
+                }
+                // Caddy forward_auth (via oauth2-proxy) sets X-Auth-Request-Email after the user
+                // logs in with Google. The authorize endpoint is gated behind forward_auth in the
+                // Caddyfile so this header is always present when the request reaches the broker.
+                const userEmail = (req.headers['x-auth-request-email'] || '').trim().toLowerCase();
+                if (!userEmail) {
+                    sendJson(res, 401, { error: 'unauthorized', error_description: 'No authenticated user (missing X-Auth-Request-Email)' });
+                    return;
+                }
+                const user = store.upsertUser(userEmail);
+                const code = store.createAuthCode({ userId: user.id, clientId, redirectUri, codeChallenge });
+                audit('authorize.signin', { user: user.email });
+                const redirect = new url_1.URL(redirectUri);
+                redirect.searchParams.set('code', code);
+                if (state) {
+                    redirect.searchParams.set('state', state);
+                }
+                res.writeHead(302, { Location: redirect.toString() });
+                res.end();
+                return;
+            }
+            if (req.method === 'GET' && pathname === '/oauth/browser-login') {
+                if (rateLimited()) {
+                    return;
+                }
+                // Federated SSO (A′): the central IdP (auth.agenthippo.ai) stamps the shared
+                // `.agenthippo.ai` cookie after Google SSO. Gated behind oauth2-proxy forward_auth
+                // (same as /oauth/authorize) — X-Auth-Request-Email is only set once Google login
+                // completes. Federated agent services never hit this path (they have no oauth2-proxy),
+                // so it 401s there, which is correct.
+                const userEmail = (req.headers['x-auth-request-email'] || '').trim().toLowerCase();
+                if (!userEmail) {
+                    sendJson(res, 401, { error: 'unauthorized', error_description: 'No authenticated user (missing X-Auth-Request-Email)' });
+                    return;
+                }
+                const user = store.upsertUser(userEmail);
+                const tokens = store.issueTokens(user, types_js_1.AUTH_CLIENT_ID, 'openid profile email agenthippo:ide');
+                audit('browser.login', { user: user.email });
+                const secure = resolved.publicBaseUrl.startsWith('https');
+                const cookieParts = [
+                    `${resolved.cookieName}=${tokens.accessToken}`,
+                    'Path=/',
+                    'HttpOnly',
+                    'SameSite=Lax',
+                    ...(secure ? ['Secure'] : []),
+                    ...(resolved.cookieDomain ? [`Domain=${resolved.cookieDomain}`] : []),
+                    `Max-Age=${tokens.expiresIn}`,
+                ];
+                const returnTo = safeReturnTo(url.searchParams.get('return_to') || '', resolved.cookieDomain, resolved.publicBaseUrl || '/');
+                res.writeHead(302, { 'Set-Cookie': cookieParts.join('; '), Location: returnTo });
+                res.end();
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/oauth/dev/login') {
+                if (rateLimited()) {
+                    return;
+                }
+                if (!resolved.devMode) {
+                    sendJson(res, 404, { error: 'not_found' });
+                    return;
+                }
+                const raw = await readBody(req);
+                const body = raw.trim().startsWith('{')
+                    ? JSON.parse(raw)
+                    : parseFormBody(raw);
+                const email = body.email?.trim();
+                const codeChallenge = body.code_challenge?.trim();
+                const redirectUri = body.redirect_uri?.trim();
+                const clientId = body.client_id?.trim() || types_js_1.AUTH_CLIENT_ID;
+                if (!email || !codeChallenge || !redirectUri) {
+                    sendJson(res, 400, { error: 'invalid_request' });
+                    return;
+                }
+                const user = store.upsertUser(email);
+                const code = store.createAuthCode({
+                    userId: user.id,
+                    clientId,
+                    redirectUri,
+                    codeChallenge,
+                });
+                audit('dev.login', { user: user.email });
+                sendJson(res, 200, { code });
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/oauth/token') {
+                if (rateLimited()) {
+                    return;
+                }
+                const raw = await readBody(req);
+                const body = parseFormBody(raw);
+                const grantType = body.grant_type;
+                const clientId = body.client_id || types_js_1.AUTH_CLIENT_ID;
+                const scope = body.scope || 'openid profile email agenthippo:ide';
+                if (grantType === 'authorization_code') {
+                    const code = body.code;
+                    const codeVerifier = body.code_verifier;
+                    const redirectUri = body.redirect_uri;
+                    if (!code || !codeVerifier || !redirectUri) {
+                        sendJson(res, 400, { error: 'invalid_request' });
+                        return;
+                    }
+                    const authCode = store.consumeAuthCode(code);
+                    if (!authCode || authCode.clientId !== clientId || authCode.redirectUri !== redirectUri) {
+                        sendJson(res, 400, { error: 'invalid_grant' });
+                        return;
+                    }
+                    if (!(0, pkce_js_1.verifyPkceChallenge)(codeVerifier, authCode.codeChallenge)) {
+                        sendJson(res, 400, { error: 'invalid_grant', error_description: 'PKCE verification failed' });
+                        return;
+                    }
+                    const user = store.getUser(authCode.userId);
+                    if (!user) {
+                        sendJson(res, 400, { error: 'invalid_grant' });
+                        return;
+                    }
+                    const tokens = store.issueTokens(user, clientId, scope);
+                    audit('token.signin', { user: user.email, client_id: clientId });
+                    sendJson(res, 200, {
+                        access_token: tokens.accessToken,
+                        refresh_token: tokens.refreshToken,
+                        token_type: 'Bearer',
+                        expires_in: tokens.expiresIn,
+                        scope,
+                    });
+                    return;
+                }
+                if (grantType === 'refresh_token') {
+                    const refreshToken = body.refresh_token;
+                    if (!refreshToken) {
+                        sendJson(res, 400, { error: 'invalid_request' });
+                        return;
+                    }
+                    const record = store.consumeRefreshToken(refreshToken);
+                    if (!record || record.clientId !== clientId) {
+                        audit('token.refresh.invalid_grant');
+                        sendJson(res, 400, { error: 'invalid_grant' });
+                        return;
+                    }
+                    const user = store.getUser(record.userId);
+                    if (!user) {
+                        sendJson(res, 400, { error: 'invalid_grant' });
+                        return;
+                    }
+                    const tokens = store.issueTokens(user, clientId, scope);
+                    audit('token.refresh', { user: user.email });
+                    sendJson(res, 200, {
+                        access_token: tokens.accessToken,
+                        refresh_token: tokens.refreshToken,
+                        token_type: 'Bearer',
+                        expires_in: tokens.expiresIn,
+                        scope,
+                    });
+                    return;
+                }
+                sendJson(res, 400, { error: 'unsupported_grant_type' });
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/oauth/introspect') {
+                // RFC 7662: introspect must be protected. Require a valid bearer (any live JWT)
+                // so an anonymous caller can't probe arbitrary tokens for user claims.
+                if (!resolveAuthedUser(req)) {
+                    audit('introspect.unauthorized');
+                    sendJson(res, 401, { error: 'unauthorized' });
+                    return;
+                }
+                const raw = await readBody(req);
+                const body = parseFormBody(raw);
+                const token = body.token;
+                if (!token) {
+                    sendJson(res, 400, { error: 'invalid_request' });
+                    return;
+                }
+                const payload = (0, jwt_js_1.verifyJwt)(token, resolved.jwtSecret);
+                if (!payload?.sub) {
+                    sendJson(res, 200, { active: false });
+                    return;
+                }
+                sendJson(res, 200, {
+                    active: true,
+                    sub: payload.sub,
+                    email: payload.email,
+                    team_id: payload.team_id,
+                    scope: payload.scope,
+                    exp: payload.exp,
+                });
+                return;
+            }
+            const user = resolveAuthedUser(req);
+            if (req.method === 'GET' && pathname === '/api/ide/me') {
+                if (!user) {
+                    // /me is called per IDE turn via Caddy forward_auth; an expired-token burst
+                    // would spam this log, so throttle to one line per few seconds.
+                    const now = Date.now();
+                    if (now - lastMeUnauthorizedLogMs > ME_UNAUTHORIZED_LOG_INTERVAL_MS) {
+                        lastMeUnauthorizedLogMs = now;
+                        audit('me.unauthorized');
+                    }
+                    sendJson(res, 401, { error: 'unauthorized' });
+                    return;
+                }
+                // Set X-Agent-User so Caddy's forward_auth can copy the validated identity
+                // into the upstream request without serve needing its own JWT validation.
+                res.setHeader('X-Agent-User', user.email || user.id);
+                sendJson(res, 200, store.buildMe(user));
+                return;
+            }
+            if (req.method === 'GET' && pathname === '/api/ide/bootstrap') {
+                if (!user) {
+                    sendJson(res, 401, { error: 'unauthorized' });
+                    return;
+                }
+                sendJson(res, 200, store.buildBootstrap(user));
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/api/ide/bootstrap/refresh') {
+                if (!user) {
+                    sendJson(res, 401, { error: 'unauthorized' });
+                    return;
+                }
+                const routing = store.refreshRoutingCredentials();
+                sendJson(res, 200, {
+                    routing: {
+                        litellmBaseUrl: resolved.team.litellmBaseUrl,
+                        ...routing,
+                    },
+                });
+                return;
+            }
+            if (req.method === 'POST' && pathname === '/api/ide/signout') {
+                if (user) {
+                    store.revokeRefreshTokensForUser(user.id);
+                    audit('signout', { user: user.email });
+                }
+                sendJson(res, 200, { ok: true });
+                return;
+            }
+            sendJson(res, 404, { error: 'not_found' });
+        }
+        catch (err) {
+            if (err.status === 413) {
+                sendJson(res, 413, { error: 'request_entity_too_large' });
+                return;
+            }
+            // Log the real error internally; return a generic message so clients don't see
+            // stack fragments / internal paths in the 500 body.
+            console.error('[auth-broker] internal error', err);
+            sendJson(res, 500, { error: 'server_error' });
+        }
+    });
+    return {
+        server,
+        baseUrl: resolved.publicBaseUrl,
+        store,
+        config: resolved,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => (err ? reject(err) : resolve()));
+        }),
+    };
+}
+async function startAuthBrokerServer(config) {
+    const broker = createAuthBrokerServer(config);
+    const bind = process.env.AGENTHIPPO_AUTH_BIND?.trim() || '0.0.0.0';
+    await new Promise((resolve, reject) => {
+        broker.server.listen(broker.config.port, bind, () => resolve());
+        broker.server.once('error', reject);
+    });
+    return broker;
+}