@agenthippo-ai/agenthippo 0.2.3-dataplane → 1.110.9

package/out/test/auth-broker-hardening.test.js

@@ -0,0 +1,227 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *
+ *  The broker mints tokens. These tests pin the three things that stopped it from minting them for
+ *  whoever asked: a bind that is not every interface, a proof that the identity header came from
+ *  the trusted proxy, and a redirect_uri allow-list that admits only our own clients.
+ *--------------------------------------------------------------------------------------------*/
+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 });
+require("mocha");
+const assert = __importStar(require("assert"));
+const server_1 = require("../auth-broker/server");
+const config_1 = require("../auth-broker/config");
+const types_1 = require("../auth/types");
+const pkce_1 = require("../auth-broker/pkce");
+function prodConfig(over = {}) {
+    return {
+        port: 0,
+        publicBaseUrl: 'https://auth.example.com',
+        jwtSecret: 'a-real-secret-not-the-default',
+        accessTokenTtlSec: 3600,
+        refreshTokenTtlSec: 86400,
+        allowedEmailDomains: ['example.com'],
+        devMode: false,
+        rateLimitPerMin: 0,
+        logPii: false,
+        cookieName: 'ah_token',
+        cookieDomain: '.example.com',
+        idpBaseUrl: '',
+        proxySecret: 'proxy-shared-secret',
+        trustProxyHeadersUnverified: false,
+        teamConfigured: true,
+        team: {
+            id: 'team_test',
+            name: 'Test Team',
+            storeRepo: 'acme/agent-store',
+            storeIndexUrl: 'https://acme.github.io/agent-store',
+            githubOrg: 'acme',
+            gatewayUrl: 'https://gateway.example.com/v1',
+        },
+        ...over,
+    };
+}
+suite('auth-broker bind address', () => {
+    test('defaults to loopback, not every interface', () => {
+        const decision = (0, config_1.resolveAuthBrokerBind)({});
+        assert.strictEqual(decision.address, config_1.DEFAULT_AUTH_BIND);
+        assert.strictEqual(decision.address, '127.0.0.1');
+        assert.strictEqual(decision.isPublic, false);
+    });
+    test('an explicit loopback bind needs no extra flag', () => {
+        const decision = (0, config_1.resolveAuthBrokerBind)({ AGENTHIPPO_AUTH_BIND: '::1' });
+        assert.strictEqual(decision.isPublic, false);
+    });
+    test('a public bind is REFUSED unless separately opted into', () => {
+        assert.throws(() => (0, config_1.resolveAuthBrokerBind)({ AGENTHIPPO_AUTH_BIND: '0.0.0.0' }), /Refusing to bind/);
+        assert.throws(() => (0, config_1.resolveAuthBrokerBind)({ AGENTHIPPO_AUTH_BIND: '10.0.0.5' }), /AGENTHIPPO_AUTH_ALLOW_PUBLIC_BIND/);
+    });
+    test('the opt-in works and reports that the bind is public', () => {
+        const decision = (0, config_1.resolveAuthBrokerBind)({
+            AGENTHIPPO_AUTH_BIND: '0.0.0.0',
+            AGENTHIPPO_AUTH_ALLOW_PUBLIC_BIND: '1',
+        });
+        assert.strictEqual(decision.address, '0.0.0.0');
+        assert.strictEqual(decision.isPublic, true);
+    });
+});
+suite('auth-broker trusted-proxy proof', () => {
+    test('a matching secret passes', () => {
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({ [config_1.AUTH_PROXY_SECRET_HEADER]: 'shhh' }, 'shhh'), true);
+    });
+    test('a missing, empty, or wrong secret fails', () => {
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({}, 'shhh'), false);
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({ [config_1.AUTH_PROXY_SECRET_HEADER]: '' }, 'shhh'), false);
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({ [config_1.AUTH_PROXY_SECRET_HEADER]: 'nope' }, 'shhh'), false);
+    });
+    test('an unconfigured expected secret can never be satisfied', () => {
+        // Fail closed: "no secret configured" must not mean "any secret matches".
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({ [config_1.AUTH_PROXY_SECRET_HEADER]: 'anything' }, ''), false);
+    });
+    test('a length mismatch does not throw (it would leak the secret length)', () => {
+        assert.strictEqual((0, server_1.hasTrustedProxyProof)({ [config_1.AUTH_PROXY_SECRET_HEADER]: 'x' }, 'a-much-longer-secret'), false);
+    });
+});
+suite('auth-broker boot gate', () => {
+    test('refuses to boot in production without a proxy secret', () => {
+        assert.throws(() => (0, server_1.createAuthBrokerServer)(prodConfig({ proxySecret: '' })), /AGENTHIPPO_AUTH_PROXY_SECRET must be set/);
+    });
+    test('the explicit unverified opt-in allows boot', () => {
+        const broker = (0, server_1.createAuthBrokerServer)(prodConfig({ proxySecret: '', trustProxyHeadersUnverified: true }));
+        assert.ok(broker.server);
+    });
+    test('the pre-existing default-secret gates are untouched', () => {
+        assert.throws(() => (0, server_1.createAuthBrokerServer)(prodConfig({ jwtSecret: config_1.DEFAULT_JWT_SECRET })), /AGENTHIPPO_AUTH_JWT_SECRET must be set/);
+    });
+    test('dev mode is still gated on the explicit flag, not NODE_ENV', () => {
+        const asTest = (0, config_1.loadAuthBrokerConfig)({ NODE_ENV: 'test' });
+        assert.strictEqual(asTest.devMode, false);
+        const explicit = (0, config_1.loadAuthBrokerConfig)({ AGENTHIPPO_AUTH_DEV: '1' });
+        assert.strictEqual(explicit.devMode, true);
+    });
+});
+suite('auth-broker forged X-Auth-Request-Email', () => {
+    async function listen(config) {
+        const broker = (0, server_1.createAuthBrokerServer)(config);
+        await new Promise((resolve) => broker.server.listen(0, '127.0.0.1', resolve));
+        const address = broker.server.address();
+        if (!address || typeof address === 'string') {
+            throw new Error('bad listen address');
+        }
+        return { baseUrl: `http://127.0.0.1:${address.port}`, close: () => broker.close() };
+    }
+    function authorizeUrl(baseUrl) {
+        const challenge = (0, pkce_1.codeChallengeFromVerifier)((0, pkce_1.generateCodeVerifier)());
+        return `${baseUrl}/oauth/authorize?client_id=${types_1.AUTH_CLIENT_ID}`
+            + `&redirect_uri=${encodeURIComponent('http://127.0.0.1:54123/callback')}`
+            + `&code_challenge=${challenge}&code_challenge_method=S256&state=x`;
+    }
+    test('an unproven email header gets 401, not an authorization code', async () => {
+        const server = await listen(prodConfig());
+        try {
+            const res = await fetch(authorizeUrl(server.baseUrl), {
+                redirect: 'manual',
+                headers: { 'X-Auth-Request-Email': 'ceo@example.com' },
+            });
+            assert.strictEqual(res.status, 401);
+            assert.strictEqual(res.headers.get('location'), null, 'no auth code was handed out');
+            const body = await res.json();
+            assert.ok(body.error_description?.includes(config_1.AUTH_PROXY_SECRET_HEADER));
+        }
+        finally {
+            await server.close();
+        }
+    });
+    test('the same request WITH the proxy proof succeeds', async () => {
+        const server = await listen(prodConfig());
+        try {
+            const res = await fetch(authorizeUrl(server.baseUrl), {
+                redirect: 'manual',
+                headers: {
+                    'X-Auth-Request-Email': 'user@example.com',
+                    [config_1.AUTH_PROXY_SECRET_HEADER]: 'proxy-shared-secret',
+                },
+            });
+            assert.strictEqual(res.status, 302);
+            const location = res.headers.get('location') || '';
+            assert.ok(new URL(location).searchParams.get('code'), 'a code is issued to the proven proxy');
+        }
+        finally {
+            await server.close();
+        }
+    });
+    test('/oauth/browser-login is gated the same way', async () => {
+        const server = await listen(prodConfig());
+        try {
+            const res = await fetch(`${server.baseUrl}/oauth/browser-login`, {
+                redirect: 'manual',
+                headers: { 'X-Auth-Request-Email': 'ceo@example.com' },
+            });
+            assert.strictEqual(res.status, 401);
+            assert.strictEqual(res.headers.get('set-cookie'), null, 'no session cookie was minted');
+        }
+        finally {
+            await server.close();
+        }
+    });
+});
+suite('auth-broker redirect_uri allow-list', () => {
+    test('accepts the shapes real clients send', () => {
+        assert.ok((0, server_1.isAllowedRedirectUri)('http://127.0.0.1:54123/callback'));
+        assert.ok((0, server_1.isAllowedRedirectUri)('http://localhost:61999/callback'));
+        assert.ok((0, server_1.isAllowedRedirectUri)('vscode://agenthippo.agenthippo/auth/callback'));
+    });
+    test('rejects an attacker-controlled destination', () => {
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('https://attacker.example/collect'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://attacker.example/callback'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1.attacker.example:8080/callback'));
+    });
+    test('rejects a permitted shape carrying a rider', () => {
+        // A query or fragment makes the destination different from the one bound to the code.
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1:54123/callback?next=https://attacker.example'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1:54123/callback#x'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://user:pass@127.0.0.1:54123/callback'));
+    });
+    test('rejects a privileged or absent loopback port', () => {
+        // The loopback server binds an OS-assigned ephemeral port; port 80 or 22 is not it.
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1/callback'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1:22/callback'));
+    });
+    test('rejects a wrong path and a malformed URI', () => {
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('http://127.0.0.1:54123/other'));
+        assert.ok(!(0, server_1.isAllowedRedirectUri)('not a uri'));
+    });
+});

package/out/test/auth-broker.test.js

@@ -56,14 +56,16 @@ function testConfig(port) {
         cookieName: 'ah_token',
         cookieDomain: '.agenthippo.ai',
         idpBaseUrl: 'http://127.0.0.1:0',
+        proxySecret: '',
+        trustProxyHeadersUnverified: false,
+        teamConfigured: true,
         team: {
             id: 'team_test',
             name: 'Test Team',
             storeRepo: 'acme/agent-store',
             storeIndexUrl: 'https://acme.github.io/agent-store',
             githubOrg: 'acme',
-            litellmBaseUrl: 'http://127.0.0.1:4000',
-            litellmApiKey: 'ahk_test_key',
+            gatewayUrl: 'http://127.0.0.1:3456/v1',
         },
     };
 }
@@ -120,7 +122,9 @@ suite('AuthBroker', () => {
             assert.strictEqual(bootstrapRes.status, 200);
             const bootstrap = await bootstrapRes.json();
             assert.strictEqual(bootstrap.store.repo, 'acme/agent-store');
-            assert.strictEqual(bootstrap.routing.litellmBaseUrl, 'http://127.0.0.1:4000');
+            assert.strictEqual(bootstrap.routing.inferenceGatewayUrl, 'http://127.0.0.1:3456/v1');
+            // The bootstrap carries no routing credential — the account JWT is the credential.
+            assert.strictEqual(bootstrap.routing.litellmApiKey, undefined);
             assert.strictEqual(bootstrap.team.id, 'team_test');
             const refreshRes = await postForm(`${baseUrl}/oauth/token`, {
                 grant_type: 'refresh_token',
@@ -163,7 +167,7 @@ suite('AuthBroker', () => {
             await broker.close();
         }
     });
-    test('bootstrap refresh re-issues routing credentials', async () => {
+    test('bootstrap refresh endpoint is gone — routing carries no credential to re-issue', async () => {
         const broker = (0, server_js_1.createAuthBrokerServer)(testConfig(0));
         await new Promise((resolve) => broker.server.listen(0, '127.0.0.1', resolve));
         const address = broker.server.address();
@@ -198,11 +202,57 @@ suite('AuthBroker', () => {
                 method: 'POST',
                 headers: { Authorization: `Bearer ${tokens.access_token}` },
             });
-            assert.strictEqual(refreshRes.status, 200);
-            const body = await refreshRes.json();
-            assert.strictEqual(body.routing.litellmApiKey, 'ahk_test_key');
-            // Static team key — the broker must not fabricate an expiry it can't enforce.
-            assert.strictEqual(body.routing.litellmApiKeyExpiresAt, undefined);
+            assert.strictEqual(refreshRes.status, 404);
+        }
+        finally {
+            await broker.close();
+        }
+    });
+    test('solo deployment omits team in bootstrap and team_id in JWT', async () => {
+        const broker = (0, server_js_1.createAuthBrokerServer)({
+            ...testConfig(0),
+            teamConfigured: false,
+        });
+        await new Promise((resolve) => broker.server.listen(0, '127.0.0.1', resolve));
+        const address = broker.server.address();
+        if (!address || typeof address === 'string') {
+            throw new Error('bad listen address');
+        }
+        const baseUrl = `http://127.0.0.1:${address.port}`;
+        try {
+            const verifier = (0, pkce_js_1.generateCodeVerifier)();
+            const challenge = (0, pkce_js_1.codeChallengeFromVerifier)(verifier);
+            const redirectUri = 'agenthippo://auth/callback';
+            const devRes = await fetch(`${baseUrl}/oauth/dev/login`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    email: 'solo@agenthippo.ai',
+                    client_id: types_js_1.AUTH_CLIENT_ID,
+                    redirect_uri: redirectUri,
+                    code_challenge: challenge,
+                }),
+            });
+            const devJson = await devRes.json();
+            const tokenRes = await postForm(`${baseUrl}/oauth/token`, {
+                grant_type: 'authorization_code',
+                client_id: types_js_1.AUTH_CLIENT_ID,
+                code: devJson.code,
+                redirect_uri: redirectUri,
+                code_verifier: verifier,
+            });
+            assert.strictEqual(tokenRes.status, 200);
+            const tokens = await tokenRes.json();
+            const payload = (0, jwt_js_1.verifyJwt)(tokens.access_token, 'test-jwt-secret');
+            assert.ok(payload);
+            assert.strictEqual(payload.team_id, undefined);
+            const bootstrapRes = await fetch(`${baseUrl}/api/ide/bootstrap`, {
+                headers: { Authorization: `Bearer ${tokens.access_token}` },
+            });
+            assert.strictEqual(bootstrapRes.status, 200);
+            const bootstrap = await bootstrapRes.json();
+            assert.strictEqual(bootstrap.team, undefined);
+            assert.deepStrictEqual(bootstrap.policy.teamManagedSettings, []);
         }
         finally {
             await broker.close();

package/out/test/branding.test.js

@@ -143,6 +143,19 @@ suite('brandify', () => {
     });
 });
 // =============================================================================
+// toSettingsDisplayKey Tests
+// =============================================================================
+suite('toSettingsDisplayKey', () => {
+    test('maps agentide.* keys to agenthippoai.* for user-facing copy', () => {
+        assert.strictEqual((0, branding_1.toSettingsDisplayKey)('agentide.anywhere.installSource'), 'agenthippoai.anywhere.installSource');
+        assert.strictEqual((0, branding_1.toSettingsDisplayKey)('agentide.cli.path'), 'agenthippoai.cli.path');
+        assert.strictEqual((0, branding_1.toSettingsDisplayKey)('agentide.providers.custom.acme.baseUrl'), 'agenthippoai.providers.custom.acme.baseUrl');
+    });
+    test('leaves non-agentide keys unchanged', () => {
+        assert.strictEqual((0, branding_1.toSettingsDisplayKey)('editor.fontSize'), 'editor.fontSize');
+    });
+});
+// =============================================================================
 // copyDirRecursiveWithTransform Tests
 // =============================================================================
 suite('copyDirRecursiveWithTransform', () => {