@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/analytics/sessionEvents.js

@@ -1,323 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *  Licensed under the MIT License. See LICENSE.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-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.ObservableStreamEmitter = exports.SessionEventWriter = void 0;
-exports.getSessionEventWriterStats = getSessionEventWriterStats;
-exports.resetSessionEventWriterStatsForTest = resetSessionEventWriterStatsForTest;
-exports.wrapEmitterWithObservability = wrapEmitterWithObservability;
-/**
- * Session Event Writer & Observable Stream Emitter
- *
- * Layer 2 of the analytics design (see PLAN/analytics-design.md):
- * Captures agent-level events (tool calls, file edits, turn boundaries)
- * that happen between LLM calls and are invisible to LiteLLM OTEL.
- *
- * Events are written to ~/.agent-hippo/analytics/sessions/<session_id>.jsonl
- * and queryable by DuckDB alongside OTEL traces.
- *
- * PRIVACY: user identifiers are salted hashes and tool I/O is a sha256 + length, unless an
- * operator opts in — see ./identity.ts. These records are shipped wholesale to the evidence
- * server, so whatever lands in this file leaves the machine.
- */
-const path = __importStar(require("path"));
-const fs_1 = require("fs");
-const branding_1 = require("../branding");
-const os = __importStar(require("os"));
-const identity_1 = require("./identity");
-/** Process-wide counters, aggregated across every writer instance. */
-const globalStats = {
-    written: 0,
-    failed: 0,
-};
-/**
- * Process-wide evidence-write health, for /health-style output.
- *
- * `failed > 0` means at least one consequential act produced no record (R-1 completeness).
- */
-function getSessionEventWriterStats() {
-    return { written: globalStats.written, failed: globalStats.failed, lastError: globalStats.lastError };
-}
-/** Reset the process-wide counters. Tests only. */
-function resetSessionEventWriterStatsForTest() {
-    globalStats.written = 0;
-    globalStats.failed = 0;
-    globalStats.lastError = undefined;
-}
-/**
- * Set when evidence is REQUIRED: a failed write then rejects rather than returning, so the turn
- * fails instead of proceeding unrecorded. Off by default — an IDE user should not lose a turn
- * because a disk was full — but a regulated deployment wants the opposite trade.
- */
-const EVIDENCE_REQUIRED_ENV = 'AGENTHIPPO_EVIDENCE_REQUIRED';
-function evidenceRequired(env = process.env) {
-    const v = (env[EVIDENCE_REQUIRED_ENV] ?? '').trim().toLowerCase();
-    return v === '1' || v === 'true' || v === 'yes' || v === 'on';
-}
-class SessionEventWriter {
-    baseDir;
-    ensuredDirs = new Set();
-    written = 0;
-    failed = 0;
-    lastError;
-    sanitizeSessionId(sessionId) {
-        const trimmed = sessionId.trim();
-        if (!trimmed) {
-            return `session-${Date.now()}`;
-        }
-        // Prevent path traversal or separator injection in filenames.
-        return trimmed.replace(/[\\/]/g, '_').replace(/\.\./g, '_');
-    }
-    constructor(baseDir) {
-        this.baseDir = baseDir ?? path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME, 'analytics', 'sessions');
-    }
-    /**
-     * Append a session event to the session's JSONL file.
-     *
-     * A failed write is a HOLE IN THE RECORD, not a nuisance: the act still happened, and nothing
-     * downstream can tell the difference between "no tool ran" and "the tool event never landed".
-     * So every failure is logged at error level and counted into /health-visible state. With
-     * AGENTHIPPO_EVIDENCE_REQUIRED set it also rejects, so the caller fails the turn rather than
-     * completing it unrecorded.
-     *
-     * This used to swallow every error in an empty catch block — silence on every failure.
-     */
-    async append(sessionId, requestId, eventType, payload) {
-        try {
-            const safeSessionId = this.sanitizeSessionId(sessionId);
-            // Ensure directory exists (cached per session to avoid repeated stat)
-            if (!this.ensuredDirs.has(safeSessionId)) {
-                await fs_1.promises.mkdir(this.baseDir, { recursive: true });
-                this.ensuredDirs.add(safeSessionId);
-            }
-            const event = {
-                session_id: sessionId,
-                request_id: requestId,
-                timestamp: Date.now(),
-                event_type: eventType,
-                payload,
-            };
-            const filePath = path.join(this.baseDir, `${safeSessionId}.jsonl`);
-            const line = JSON.stringify(event) + '\n';
-            await fs_1.promises.appendFile(filePath, line);
-            this.written++;
-            globalStats.written++;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            this.failed++;
-            globalStats.failed++;
-            const record = { at: Date.now(), message, eventType };
-            this.lastError = record;
-            globalStats.lastError = record;
-            console.error(`[evidence] LOST session event ${eventType} (session=${sessionId} request=${requestId}): ` +
-                `${message} — ${globalStats.failed} evidence write(s) lost since start`);
-            if (evidenceRequired()) {
-                throw new Error(`evidence write failed for ${eventType}: ${message}`);
-            }
-        }
-    }
-    /** Per-writer evidence-write health. See {@link getSessionEventWriterStats} for the process view. */
-    getStats() {
-        return { written: this.written, failed: this.failed, lastError: this.lastError };
-    }
-    /**
-     * Get the sessions directory path (for DuckDB queries).
-     */
-    getSessionsDir() {
-        return this.baseDir;
-    }
-}
-exports.SessionEventWriter = SessionEventWriter;
-// -----------------------------------------------------------------------------
-// Observable Stream Emitter (Decorator)
-// -----------------------------------------------------------------------------
-/**
- * Wraps an existing StreamEmitter to capture tool events as session events.
- * This is the bridge between engine-level streaming (what the UI sees) and
- * analytics-level event logging (what DuckDB queries).
- *
- * The decorator pattern means zero changes to engine code - just wrap the
- * emitter before passing it to engine.stream().
- */
-class ObservableStreamEmitter {
-    inner;
-    writer;
-    sessionId;
-    requestId;
-    stamp;
-    missingCallIdCounter = 0;
-    pendingSyntheticCallIds = new Map();
-    /**
-     * Salted pseudonym of the acting user — the warrant, in the form the evidence index wants
-     * (PLAN/compliance.md §2 "salted identity hashes"). Raw only under
-     * AGENTHIPPO_EVIDENCE_RAW_IDS=1. Derived in the constructor; the raw id is never a field.
-     */
-    actorId;
-    constructor(inner, writer, sessionId, requestId, 
-    /**
-     * Acting user for the warrant audit trail on tool events. Captured once at
-     * wrap time (still inside the request's credential scope) and stored on this
-     * per-turn emitter — never re-read from ambient AsyncLocalStorage at emit
-     * time. Custom-engine persistent workers deliver tool events on a detached
-     * parent IPC callback whose ALS can stick to the spawn request; constructor
-     * capture keeps attribution correct for every engine. Undefined outside a
-     * serve credential scope (IDE-local / CLI without runWithCredential).
-     *
-     * NOT a field: it is hashed into `actorId` in the constructor and the raw value is then
-     * unreachable from any emit path.
-     */
-    userId, 
-    /**
-     * Provenance stamp merged into turn_start (policy_version, pack_digest, engine_version,
-     * tier) — which rules and which artifacts governed this turn, recorded at the moment of
-     * the act rather than reconstructed later (PLAN/compliance.md §3.1).
-     */
-    stamp) {
-        this.inner = inner;
-        this.writer = writer;
-        this.sessionId = sessionId;
-        this.requestId = requestId;
-        this.stamp = stamp;
-        // Hash once at construction: the raw id is never stored on this object, so no later edit
-        // to an emit path can leak it by reaching for `this.userId`.
-        this.actorId = (0, identity_1.hashIdentity)(userId);
-    }
-    makeCallIdKey(toolName) {
-        return `${this.sessionId}:${this.requestId}:${toolName}`;
-    }
-    enqueueSyntheticCallId(toolName) {
-        const key = this.makeCallIdKey(toolName);
-        const id = `synthetic-${toolName}-${++this.missingCallIdCounter}`;
-        const queue = this.pendingSyntheticCallIds.get(key) ?? [];
-        queue.push(id);
-        this.pendingSyntheticCallIds.set(key, queue);
-        return id;
-    }
-    dequeueSyntheticCallId(toolName) {
-        const key = this.makeCallIdKey(toolName);
-        const queue = this.pendingSyntheticCallIds.get(key);
-        if (!queue || queue.length === 0) {
-            return undefined;
-        }
-        const id = queue.shift();
-        if (queue.length === 0) {
-            this.pendingSyntheticCallIds.delete(key);
-        }
-        else {
-            this.pendingSyntheticCallIds.set(key, queue);
-        }
-        return id;
-    }
-    async thinking(delta) {
-        return this.inner.thinking(delta);
-    }
-    async text(delta) {
-        return this.inner.text(delta);
-    }
-    async toolStart(toolName, input, toolCallId, metadata) {
-        const loggedCallId = toolCallId?.trim()
-            ? toolCallId
-            : this.enqueueSyntheticCallId(toolName);
-        await this.writer.append(this.sessionId, this.requestId, 'tool_start', {
-            toolName,
-            callId: loggedCallId,
-            // Tool arguments are content — paths, queries, credentials people paste into prompts.
-            // Digest by default (input_sha256 + input_length); `inputPreview` returns only under
-            // AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE=1.
-            ...(0, identity_1.describeContent)('input', input),
-            // The warrant: who this tool call ran as (captured at wrap; see constructor).
-            userId: this.actorId,
-        });
-        return this.inner.toolStart(toolName, input, toolCallId, metadata);
-    }
-    async toolEnd(toolName, toolCallId, result, isError, metadata) {
-        const loggedCallId = toolCallId?.trim()
-            ? toolCallId
-            : this.dequeueSyntheticCallId(toolName) ?? '';
-        await this.writer.append(this.sessionId, this.requestId, 'tool_end', {
-            toolName,
-            callId: loggedCallId,
-            isError: isError ?? false,
-            // Tool output is content — file contents, command output, customer data. Digest by
-            // default; `resultPreview` returns only under AGENTHIPPO_EVIDENCE_CONTENT_CAPTURE=1.
-            ...(0, identity_1.describeContent)('result', result),
-            userId: this.actorId,
-        });
-        return this.inner.toolEnd(toolName, toolCallId, result, isError, metadata);
-    }
-    async progress(message) {
-        return this.inner.progress(message);
-    }
-    async question(payload) {
-        return this.inner.question(payload);
-    }
-    async error(message) {
-        await this.writer.append(this.sessionId, this.requestId, 'error', {
-            message,
-            userId: this.actorId,
-        });
-        return this.inner.error(message);
-    }
-    async done() {
-        return this.inner.done();
-    }
-    /**
-     * Emit a turn_start event. Call at the beginning of stream().
-     */
-    async emitTurnStart() {
-        await this.writer.append(this.sessionId, this.requestId, 'turn_start', { userId: this.actorId, ...this.stamp });
-    }
-    /**
-     * Emit a turn_end event. Call at the end of stream().
-     */
-    async emitTurnEnd(success) {
-        await this.writer.append(this.sessionId, this.requestId, 'turn_end', {
-            success,
-            userId: this.actorId,
-        });
-    }
-}
-exports.ObservableStreamEmitter = ObservableStreamEmitter;
-/**
- * Create an ObservableStreamEmitter that wraps the given emitter.
- * Returns both the wrapped emitter and emit helpers for turn boundaries.
- */
-function wrapEmitterWithObservability(inner, writer, sessionId, requestId, userId, stamp) {
-    return new ObservableStreamEmitter(inner, writer, sessionId, requestId, userId, stamp);
-}

package/out/auth/callbackUriParse.js

@@ -1,59 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseAuthCallback = parseAuthCallback;
-exports.parseAuthCallbackFromText = parseAuthCallbackFromText;
-exports.isAuthCallbackParts = isAuthCallbackParts;
-exports.parseAuthCallbackFromLoopbackUrl = parseAuthCallbackFromLoopbackUrl;
-const types_js_1 = require("./types.js");
-function parseAuthCallback(uri, expectedState) {
-    if (uri.authority !== types_js_1.AUTH_EXTENSION_AUTHORITY || uri.path !== types_js_1.AUTH_CALLBACK_PATH) {
-        return undefined;
-    }
-    const params = new URLSearchParams(uri.query);
-    const code = params.get('code');
-    const state = params.get('state');
-    if (!code || state !== expectedState) {
-        return undefined;
-    }
-    return code;
-}
-/** Accept pasted redirect URL when the OS does not hand off to the IDE automatically. */
-function parseAuthCallbackFromText(text, expectedState) {
-    const trimmed = text.trim();
-    if (!trimmed) {
-        return undefined;
-    }
-    try {
-        const url = new URL(trimmed);
-        return parseAuthCallback({ authority: url.host, path: url.pathname, query: url.search.replace(/^\?/, '') }, expectedState);
-    }
-    catch {
-        return undefined;
-    }
-}
-function isAuthCallbackParts(authority, path) {
-    return authority === types_js_1.AUTH_EXTENSION_AUTHORITY && path === types_js_1.AUTH_CALLBACK_PATH;
-}
-function parseAuthCallbackFromLoopbackUrl(text, expectedState) {
-    try {
-        const url = new URL(text.trim());
-        if (url.hostname !== '127.0.0.1' && url.hostname !== 'localhost') {
-            return undefined;
-        }
-        if (url.pathname !== '/callback') {
-            return undefined;
-        }
-        const code = url.searchParams.get('code');
-        const state = url.searchParams.get('state');
-        if (!code || state !== expectedState) {
-            return undefined;
-        }
-        return code;
-    }
-    catch {
-        return undefined;
-    }
-}

package/out/auth/types.js

@@ -1,12 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AUTH_CALLBACK_PATH = exports.AUTH_EXTENSION_AUTHORITY = exports.AUTH_SCOPES = exports.AUTH_CLIENT_ID = exports.AUTH_PROVIDER_ID = void 0;
-exports.AUTH_PROVIDER_ID = 'agenthippo';
-exports.AUTH_CLIENT_ID = 'agenthippo-ide';
-exports.AUTH_SCOPES = ['openid', 'profile', 'email', 'agenthippo:ide'];
-/** Extension id authority for URI callback routing (must match package publisher.name). */
-exports.AUTH_EXTENSION_AUTHORITY = 'agenthippo.agenthippo';
-exports.AUTH_CALLBACK_PATH = '/auth/callback';

package/out/auth-broker/config.js

@@ -1,112 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AUTH_BIND = exports.AUTH_PROXY_SECRET_HEADER = exports.DEFAULT_JWT_SECRET = void 0;
-exports.resolveAuthBrokerBind = resolveAuthBrokerBind;
-exports.loadAuthBrokerConfig = loadAuthBrokerConfig;
-exports.emailDomainAllowed = emailDomainAllowed;
-function parseDomains(raw) {
-    if (!raw?.trim()) {
-        return [];
-    }
-    return raw.split(',').map((d) => d.trim().toLowerCase()).filter(Boolean);
-}
-/** Well-known default secret used in dev/test. Never acceptable in production. */
-exports.DEFAULT_JWT_SECRET = 'dev-agenthippo-auth-secret-change-me';
-/**
- * Header the trusted proxy sets to prove it is the trusted proxy.
- *
- * `X-Auth-Request-Email` is set by oauth2-proxy AFTER a real Google login, but nothing about the
- * header itself proves it came from oauth2-proxy — anything that can reach the broker's port can
- * send it. The proxy therefore also sets this header from a secret only it and the broker know.
- */
-exports.AUTH_PROXY_SECRET_HEADER = 'x-agenthippo-proxy-secret';
-/**
- * Where the broker listens. 127.0.0.1 by default: this port mints tokens, and every intended caller
- * (the Caddy/oauth2-proxy sidecar) is same-host. Binding a routable interface is an explicit,
- * separately-flagged decision — see `resolveAuthBrokerBind`.
- */
-exports.DEFAULT_AUTH_BIND = '127.0.0.1';
-const LOOPBACK_BINDS = new Set(['127.0.0.1', 'localhost', '::1', '[::1]']);
-/**
- * Resolve (and gate) the bind address.
- *
- * The old default was `0.0.0.0`, which put a token-minting endpoint on every interface: reach
- * :9780 directly, forge `X-Auth-Request-Email`, get an auth code for any address, and exchange it
- * at the ungated `/oauth/token`. Loopback is now the default, and a public bind must be asked for
- * TWICE — the address plus `AGENTHIPPO_AUTH_ALLOW_PUBLIC_BIND=1` — so it can never happen by
- * inheriting a stray env var from a base image.
- */
-function resolveAuthBrokerBind(env = process.env) {
-    const requested = env.AGENTHIPPO_AUTH_BIND?.trim() || exports.DEFAULT_AUTH_BIND;
-    const isPublic = !LOOPBACK_BINDS.has(requested.toLowerCase());
-    if (!isPublic) {
-        return { address: requested, isPublic: false };
-    }
-    if (env.AGENTHIPPO_AUTH_ALLOW_PUBLIC_BIND !== '1') {
-        throw new Error(`Refusing to bind the auth broker to "${requested}". This port issues authorization codes ` +
-            `and access tokens, and a directly reachable broker can be asked to mint a token for an ` +
-            `arbitrary email by forging X-Auth-Request-Email.\n` +
-            `  - Same-host proxy (recommended): bind 127.0.0.1 and run Caddy/oauth2-proxy alongside it.\n` +
-            `  - SEPARATE CONTAINER for the proxy (the compose/Cloud Run layout, where Caddy dials\n` +
-            `    "auth-broker:9780"): the broker must listen on the container's network interface, so set\n` +
-            `    BOTH  AGENTHIPPO_AUTH_BIND=${requested}  AND  AGENTHIPPO_AUTH_ALLOW_PUBLIC_BIND=1,\n` +
-            `    and make sure the port is not published outside the private network.\n` +
-            `In either case set AGENTHIPPO_AUTH_PROXY_SECRET (and have the proxy send it) so a forged ` +
-            `X-Auth-Request-Email is rejected — that is what actually stops the token-minting attack.`);
-    }
-    return { address: requested, isPublic: true };
-}
-function loadAuthBrokerConfig(env = process.env) {
-    const jwtSecret = env.AGENTHIPPO_AUTH_JWT_SECRET?.trim() || exports.DEFAULT_JWT_SECRET;
-    const publicBaseUrl = (env.AGENTHIPPO_AUTH_PUBLIC_URL?.trim() || `http://127.0.0.1:${env.AGENTHIPPO_AUTH_PORT?.trim() || '9780'}`).replace(/\/+$/, '');
-    const storeRepo = env.AGENTHIPPO_TEAM_STORE_REPO?.trim() || 'agenthippoai/agenthippo-store';
-    const storeOwner = storeRepo.split('/')[0] || 'agenthippoai';
-    const storeName = storeRepo.split('/')[1] || 'agenthippo-store';
-    return {
-        port: Number(env.AGENTHIPPO_AUTH_PORT || 9780),
-        publicBaseUrl,
-        jwtSecret,
-        accessTokenTtlSec: Number(env.AGENTHIPPO_AUTH_ACCESS_TTL_SEC || 3600),
-        refreshTokenTtlSec: Number(env.AGENTHIPPO_AUTH_REFRESH_TTL_SEC || 30 * 24 * 3600),
-        allowedEmailDomains: parseDomains(env.AGENTHIPPO_AUTH_ALLOWED_DOMAINS),
-        // Deliberately not gated on NODE_ENV=test: that value is too easy to inherit by accident
-        // (test runners, base images, wrapper scripts) and this flag unlocks an unauthenticated
-        // login bypass (/oauth/dev/login, login_hint auto-auth) — require the explicit opt-in.
-        devMode: env.AGENTHIPPO_AUTH_DEV === '1',
-        rateLimitPerMin: env.AGENTHIPPO_AUTH_RATE_LIMIT !== undefined ? Number(env.AGENTHIPPO_AUTH_RATE_LIMIT) : 60,
-        logPii: env.AGENTHIPPO_AUTH_LOG_PII === '1',
-        cookieName: env.AGENTHIPPO_AUTH_COOKIE_NAME?.trim() || 'ah_token',
-        cookieDomain: env.AGENTHIPPO_AUTH_COOKIE_DOMAIN?.trim() || '',
-        idpBaseUrl: (env.AGENTHIPPO_AUTH_IDP_URL?.trim() || '').replace(/\/+$/, ''),
-        proxySecret: env.AGENTHIPPO_AUTH_PROXY_SECRET?.trim() || '',
-        trustProxyHeadersUnverified: env.AGENTHIPPO_AUTH_TRUST_PROXY_UNVERIFIED === '1',
-        dataDir: env.AGENTHIPPO_AUTH_DATA_DIR?.trim() || undefined,
-        teamConfigured: Boolean(env.AGENTHIPPO_TEAM_ID?.trim()),
-        team: {
-            id: env.AGENTHIPPO_TEAM_ID?.trim() || 'team_default',
-            name: env.AGENTHIPPO_TEAM_NAME?.trim() || 'Default Team',
-            storeRepo,
-            storeIndexUrl: env.AGENTHIPPO_TEAM_STORE_INDEX_URL?.trim() || `https://${storeOwner}.github.io/${storeName}`,
-            githubOrg: env.AGENTHIPPO_TEAM_GITHUB_ORG?.trim() || storeOwner,
-            gatewayUrl: env.AGENTHIPPO_TEAM_GATEWAY_URL?.trim() || 'https://gateway.agenthippo.ai/v1',
-        },
-    };
-}
-/**
- * Check whether an email is permitted to sign in.
- *
- * When `allowedDomains` is empty (AGENTHIPPO_AUTH_ALLOWED_DOMAINS not set) this
- * returns `true` for every domain — any upstream-SSO-authenticated user can
- * receive a token. Set the env var to restrict sign-in to specific domains in
- * team deployments (e.g. "example.com,partner.com").
- */
-function emailDomainAllowed(email, allowedDomains) {
-    if (allowedDomains.length === 0) {
-        return true;
-    }
-    const domain = email.split('@')[1]?.toLowerCase();
-    return !!domain && allowedDomains.includes(domain);
-}

package/out/auth-broker/jwt.js

@@ -1,105 +0,0 @@
-"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.signJwt = signJwt;
-exports.verifyJwt = verifyJwt;
-exports.extractBearerToken = extractBearerToken;
-exports.looksLikeJwt = looksLikeJwt;
-const crypto = __importStar(require("crypto"));
-function base64url(input) {
-    const buf = typeof input === 'string' ? Buffer.from(input, 'utf8') : input;
-    return buf.toString('base64url');
-}
-function signJwt(payload, secret, expiresInSec) {
-    const header = { alg: 'HS256', typ: 'JWT' };
-    const now = Math.floor(Date.now() / 1000);
-    const body = {
-        ...payload,
-        iat: now,
-        exp: now + expiresInSec,
-    };
-    const encodedHeader = base64url(JSON.stringify(header));
-    const encodedPayload = base64url(JSON.stringify(body));
-    const signature = crypto
-        .createHmac('sha256', secret)
-        .update(`${encodedHeader}.${encodedPayload}`)
-        .digest('base64url');
-    return `${encodedHeader}.${encodedPayload}.${signature}`;
-}
-function verifyJwt(token, secret) {
-    const parts = token.split('.');
-    if (parts.length !== 3) {
-        return undefined;
-    }
-    const [encodedHeader, encodedPayload, signature] = parts;
-    const expected = crypto
-        .createHmac('sha256', secret)
-        .update(`${encodedHeader}.${encodedPayload}`)
-        .digest('base64url');
-    if (signature.length !== expected.length) {
-        return undefined;
-    }
-    let diff = 0;
-    for (let i = 0; i < signature.length; i++) {
-        diff |= signature.charCodeAt(i) ^ expected.charCodeAt(i);
-    }
-    if (diff !== 0) {
-        return undefined;
-    }
-    try {
-        const payload = JSON.parse(Buffer.from(encodedPayload, 'base64url').toString('utf8'));
-        const now = Math.floor(Date.now() / 1000);
-        if (typeof payload.exp === 'number' && payload.exp < now) {
-            return undefined;
-        }
-        return payload;
-    }
-    catch {
-        return undefined;
-    }
-}
-function extractBearerToken(authorization) {
-    if (!authorization?.trim()) {
-        return undefined;
-    }
-    const match = /^Bearer\s+(.+)$/i.exec(authorization.trim());
-    return match?.[1]?.trim() || undefined;
-}
-function looksLikeJwt(token) {
-    return token.split('.').length === 3;
-}

package/out/auth-broker/pkce.js

@@ -1,59 +0,0 @@
-"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.generateCodeVerifier = generateCodeVerifier;
-exports.codeChallengeFromVerifier = codeChallengeFromVerifier;
-exports.verifyPkceChallenge = verifyPkceChallenge;
-const crypto = __importStar(require("crypto"));
-const CODE_VERIFIER_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~';
-function generateCodeVerifier(length = 64) {
-    const bytes = crypto.randomBytes(length);
-    let result = '';
-    for (let i = 0; i < length; i++) {
-        result += CODE_VERIFIER_CHARS[bytes[i] % CODE_VERIFIER_CHARS.length];
-    }
-    return result;
-}
-function codeChallengeFromVerifier(verifier) {
-    return crypto.createHash('sha256').update(verifier).digest('base64url');
-}
-function verifyPkceChallenge(verifier, challenge) {
-    const expected = Buffer.from(codeChallengeFromVerifier(verifier));
-    const actual = Buffer.from(challenge);
-    return expected.length === actual.length && crypto.timingSafeEqual(expected, actual);
-}