@undefineds.co/xpod 0.4.14 → 0.4.15

package/dist/api/ai-gateway/pod/OwnerPodAccess.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OwnerPodAccess = exports.POD_INTERFACE_KEY_REJECTED = exports.POD_INTERFACE_KEY_MISSING = void 0;
+exports.podAccessError = podAccessError;
+exports.isPodAccessFailure = isPodAccessFailure;
+const solid_client_authn_core_1 = require("@inrupt/solid-client-authn-core");
+const global_logger_factory_1 = require("global-logger-factory");
+const AuthContext_1 = require("../../auth/AuthContext");
+const CallerPodAccess_1 = require("../auth/CallerPodAccess");
+const TokenEndpointRoute_1 = require("../../auth/TokenEndpointRoute");
+const HostedPodRoute_1 = require("./HostedPodRoute");
+/** No usable Pod credential is on file for this owner; the user has to grant one. */
+exports.POD_INTERFACE_KEY_MISSING = 'pod_interface_key_missing';
+/** The owner's stored credential was refused by the Pod; it has to be granted again. */
+exports.POD_INTERFACE_KEY_REJECTED = 'pod_interface_key_rejected';
+const TOKEN_EXPIRY_SKEW_MS = 30_000;
+const DEFAULT_TOKEN_LIFETIME_SECONDS = 300;
+const MAX_CACHED_TOKENS = 128;
+/**
+ * Reaches a Pod as its owner over the standard Solid interface.
+ *
+ * Three credentials can prove the owner, and all three are the owner's own interface key:
+ * the caller's key, when the caller presented one; the caller's reusable token, when it holds
+ * one; and the key the owner granted this deployment for work no caller is attached to.
+ *
+ * What never happens is asking the Solid server to trust the caller's network position. Every
+ * request carries a credential for the owner and addresses the Pod's own URLs, so the Pod's own
+ * authorization decides - exactly as it does for the browser.
+ */
+class OwnerPodAccess {
+    constructor(options) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.podFetches = new Map();
+        this.keys = options.keys;
+        this.fetchImpl = options.fetch ?? fetch;
+        this.now = options.now ?? Date.now;
+        this.tokenRoute = (0, TokenEndpointRoute_1.resolveTokenEndpointRoute)(options.tokenEndpoint, options.publicBaseUrl);
+        this.route = options.route;
+    }
+    /** Grant, or rotate, the owner's Pod interface key. */
+    async saveKey(owner, credential) {
+        await this.keys.saveKey(owner, credential);
+        this.podFetches.clear();
+    }
+    async forgetKey(owner) {
+        await this.keys.forgetKey(owner);
+        this.podFetches.clear();
+    }
+    async hasKey(owner) {
+        return await this.keys.hasKey(owner);
+    }
+    async getPodFetch(owner, context = {}) {
+        const auth = context.auth;
+        if (auth?.type === 'solid' && auth.webId !== owner) {
+            // A caller authenticated as somebody else never borrows this owner's credential.
+            return undefined;
+        }
+        if ((0, AuthContext_1.hasSolidClientCredentialsAuthority)(auth)) {
+            // The caller's own interface key. Its exchanged token may be DPoP-bound to a proof that
+            // was never kept, so the key is exchanged again with a key this process controls.
+            return await this.credentialFetch(owner, { clientId: auth.clientId, clientSecret: auth.clientSecret });
+        }
+        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth, this.fetchImpl, this.route);
+        if (callerFetch) {
+            return callerFetch;
+        }
+        return await this.storedKeyFetch(owner);
+    }
+    async storedKeyFetch(owner) {
+        const credential = await this.keys.read(owner);
+        return credential ? await this.credentialFetch(owner, credential) : undefined;
+    }
+    async credentialFetch(owner, credential) {
+        const cacheKey = `${owner}\u0000${credential.clientId}`;
+        const cached = this.podFetches.get(cacheKey);
+        if (cached && cached.expiresAt > this.now() + TOKEN_EXPIRY_SKEW_MS) {
+            return cached.fetch;
+        }
+        this.podFetches.delete(cacheKey);
+        const exchanged = await this.exchange(owner, credential);
+        this.podFetches.set(cacheKey, exchanged);
+        pruneOldest(this.podFetches, MAX_CACHED_TOKENS);
+        return exchanged.fetch;
+    }
+    async exchange(owner, credential) {
+        const dpopKey = await (0, solid_client_authn_core_1.generateDpopKeyPair)();
+        const response = await this.fetchImpl(this.tokenRoute.url, {
+            method: 'POST',
+            headers: {
+                accept: 'application/json',
+                'content-type': 'application/x-www-form-urlencoded',
+                authorization: `Basic ${Buffer.from(`${credential.clientId}:${credential.clientSecret}`, 'utf8').toString('base64')}`,
+                DPoP: await (0, solid_client_authn_core_1.createDpopHeader)(this.tokenRoute.proofUrl, 'POST', dpopKey),
+                ...this.tokenRoute.headers,
+            },
+            body: new URLSearchParams({ grant_type: 'client_credentials', scope: 'webid' }),
+        });
+        const body = await response.text().catch(() => '');
+        if (!response.ok) {
+            this.logger.warn(`Pod interface key refused for ${owner}: ${response.status} ${body.slice(0, 200)}`);
+            throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:${response.status}`);
+        }
+        const token = parseTokenResponse(body);
+        if (!token) {
+            this.logger.warn(`Pod interface key exchange returned no access token for ${owner}`);
+            throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:invalid_response`);
+        }
+        const transport = await (0, HostedPodRoute_1.createHostedPodRouteTransport)(this.fetchImpl, this.route);
+        const authenticated = (0, solid_client_authn_core_1.buildAuthenticatedFetch)(token.accessToken, {
+            ...(token.dpopBound ? { dpopKey } : {}),
+            fetch: transport,
+        });
+        return {
+            fetch: this.invalidateOnUnauthorized(`${owner}\u0000${credential.clientId}`, authenticated),
+            expiresAt: this.now() + token.expiresInSeconds * 1000,
+        };
+    }
+    invalidateOnUnauthorized(cacheKey, podFetch) {
+        return async (input, init) => {
+            const response = await podFetch(input, init);
+            if (response.status === 401) {
+                // The token stopped being accepted; the next request exchanges the key again.
+                this.podFetches.delete(cacheKey);
+            }
+            return response;
+        };
+    }
+}
+exports.OwnerPodAccess = OwnerPodAccess;
+/**
+ * Reason an owner's Pod is out of reach, as a stable code the caller and the UI can act on.
+ *
+ * A same-owner caller is the ordinary case: Xpod knows who the user is, but holds nothing it can
+ * present to the Pod on the user's behalf. A browser session explains why its own credential was
+ * not enough - its proof is bound to the URL it was made for - while a bearer session simply has
+ * no Pod credential at all. Either way the fix is the same: grant the interface key.
+ */
+function podAccessError(owner, auth) {
+    if (!auth || auth.type !== 'solid') {
+        return CallerPodAccess_1.CALLER_POD_ACCESS_UNAVAILABLE;
+    }
+    if (auth.webId !== owner) {
+        return CallerPodAccess_1.CALLER_OWNER_MISMATCH;
+    }
+    if (auth.tokenType === 'DPoP' || typeof auth.dpopProof === 'string') {
+        return CallerPodAccess_1.CALLER_DPOP_REPLAY_UNSUPPORTED;
+    }
+    return exports.POD_INTERFACE_KEY_MISSING;
+}
+/**
+ * Whether a failure means Xpod had no usable way into the owner's Pod.
+ *
+ * The stable wire code for this is `service_access_missing`, which callers already report; the
+ * codes below are the reason behind it, kept distinct so the UI can ask for the right fix.
+ */
+function isPodAccessFailure(message) {
+    return message === 'service_access_missing'
+        || message.startsWith(exports.POD_INTERFACE_KEY_MISSING)
+        || message.startsWith(exports.POD_INTERFACE_KEY_REJECTED)
+        || message.startsWith(CallerPodAccess_1.CALLER_DPOP_REPLAY_UNSUPPORTED)
+        || message.startsWith(CallerPodAccess_1.CALLER_OWNER_MISMATCH)
+        || message.startsWith(CallerPodAccess_1.CALLER_POD_ACCESS_UNAVAILABLE);
+}
+function pruneOldest(cache, limit) {
+    while (cache.size > limit) {
+        const oldest = cache.keys().next();
+        if (oldest.done)
+            return;
+        cache.delete(oldest.value);
+    }
+}
+function parseTokenResponse(body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof parsed.access_token !== 'string' || !parsed.access_token) {
+        return undefined;
+    }
+    const expiresIn = typeof parsed.expires_in === 'number' && parsed.expires_in > 0
+        ? parsed.expires_in
+        : DEFAULT_TOKEN_LIFETIME_SECONDS;
+    return {
+        accessToken: parsed.access_token,
+        dpopBound: String(parsed.token_type ?? 'DPoP').toUpperCase() !== 'BEARER',
+        expiresInSeconds: expiresIn,
+    };
+}
+//# sourceMappingURL=OwnerPodAccess.js.map

package/dist/api/ai-gateway/pod/PodInterfaceKeyStore.d.ts

@@ -0,0 +1,52 @@
+import type { CredentialVault } from '../credentials/CredentialVault';
+import type { PodInterfaceKeyRepositoryPort } from '../../../identity/drizzle/PodInterfaceKeyRepository';
+/** The owner's own Pod interface credential: the same kind of key a browser holds. */
+export interface PodInterfaceCredential {
+    clientId: string;
+    clientSecret: string;
+}
+/**
+ * Grants, or withdraws, the interface key server-side components use for an owner.
+ *
+ * The browser is where a Pod credential is created, so it is also where the decision to let
+ * Xpod use it is made; this is the API that decision arrives through.
+ */
+export interface PodInterfaceKeyGrant {
+    saveKey(owner: string, credential: PodInterfaceCredential): Promise<void>;
+    forgetKey(owner: string): Promise<void>;
+    hasKey(owner: string): Promise<boolean>;
+}
+/** Reads back the interface key an owner granted. */
+export interface PodInterfaceKeySource {
+    read(owner: string): Promise<PodInterfaceCredential | undefined>;
+}
+/** Everything a component needs to hold and use an owner's interface key. */
+export interface PodInterfaceKeyAccess extends PodInterfaceKeySource, PodInterfaceKeyGrant {
+}
+export declare const POD_INTERFACE_KEY_CORRUPT_PREFIX = "pod_interface_key_corrupt";
+export interface PodInterfaceKeyStoreOptions {
+    repository: PodInterfaceKeyRepositoryPort;
+    vault: CredentialVault;
+    /** Vault identity the secret is sealed under. */
+    credentialIri?: string;
+}
+/**
+ * Keeps the owner's Pod interface key for server-side use.
+ *
+ * The key is what opens the Pod, so it is sealed with the credential vault rather than kept in
+ * the Pod. Storing it here is what lets a background component reach the Pod through the
+ * standard interface as the owner, instead of asking the Solid server to trust its position.
+ */
+export declare class PodInterfaceKeyStore implements PodInterfaceKeyAccess {
+    private readonly logger;
+    private readonly repository;
+    private readonly vault;
+    private readonly credentialIri;
+    constructor(options: PodInterfaceKeyStoreOptions);
+    /** Store, or rotate, the owner's interface key. */
+    saveKey(ownerWebId: string, credential: PodInterfaceCredential): Promise<void>;
+    forgetKey(ownerWebId: string): Promise<void>;
+    hasKey(ownerWebId: string): Promise<boolean>;
+    read(ownerWebId: string): Promise<PodInterfaceCredential | undefined>;
+    private open;
+}

package/dist/api/ai-gateway/pod/PodInterfaceKeyStore.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PodInterfaceKeyStore = exports.POD_INTERFACE_KEY_CORRUPT_PREFIX = void 0;
+const global_logger_factory_1 = require("global-logger-factory");
+exports.POD_INTERFACE_KEY_CORRUPT_PREFIX = 'pod_interface_key_corrupt';
+const CREDENTIAL_IRI = 'urn:xpod:pod-interface-key';
+const CREDENTIAL_PROVIDER = 'solid';
+/**
+ * Keeps the owner's Pod interface key for server-side use.
+ *
+ * The key is what opens the Pod, so it is sealed with the credential vault rather than kept in
+ * the Pod. Storing it here is what lets a background component reach the Pod through the
+ * standard interface as the owner, instead of asking the Solid server to trust its position.
+ */
+class PodInterfaceKeyStore {
+    constructor(options) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.repository = options.repository;
+        this.vault = options.vault;
+        this.credentialIri = options.credentialIri ?? CREDENTIAL_IRI;
+    }
+    /** Store, or rotate, the owner's interface key. */
+    async saveKey(ownerWebId, credential) {
+        const sealed = await this.vault.seal({ webId: ownerWebId }, this.credentialIri, CREDENTIAL_PROVIDER, { clientSecret: credential.clientSecret });
+        await this.repository.write({
+            ownerWebId,
+            clientId: credential.clientId,
+            sealedSecret: JSON.stringify(sealed),
+        });
+        this.logger.debug(`Stored Pod interface key for ${ownerWebId}`);
+    }
+    async forgetKey(ownerWebId) {
+        await this.repository.remove(ownerWebId);
+    }
+    async hasKey(ownerWebId) {
+        return await this.repository.read(ownerWebId) !== undefined;
+    }
+    async read(ownerWebId) {
+        const record = await this.repository.read(ownerWebId);
+        return record ? await this.open(record) : undefined;
+    }
+    async open(record) {
+        const sealed = parseSealedSecret(record.sealedSecret, record.ownerWebId);
+        const opened = await this.vault.open({ webId: record.ownerWebId }, this.credentialIri, CREDENTIAL_PROVIDER, sealed);
+        const clientSecret = opened.clientSecret;
+        if (typeof clientSecret !== 'string' || !clientSecret) {
+            throw new Error(`${exports.POD_INTERFACE_KEY_CORRUPT_PREFIX}:${record.ownerWebId}`);
+        }
+        return { clientId: record.clientId, clientSecret };
+    }
+}
+exports.PodInterfaceKeyStore = PodInterfaceKeyStore;
+function parseSealedSecret(value, ownerWebId) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        throw new Error(`${exports.POD_INTERFACE_KEY_CORRUPT_PREFIX}:${ownerWebId}`);
+    }
+}
+//# sourceMappingURL=PodInterfaceKeyStore.js.map

package/dist/api/ai-gateway/quota/ProviderQuotaAdapter.d.ts

@@ -1,7 +1,7 @@
 import { quotaSnapshotResource, type QuotaSnapshotRow } from '@undefineds.co/models';
 import type { AuthContext } from '../../auth/AuthContext';
+import { type PodAccessFetchProvider } from '../pod/OwnerPodAccess';
 import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
-import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
 import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
 import type { ConnectCredentialRecord, PodCredentialRepository } from '../connect';
 import type { CredentialVault, ProviderSecret } from '../credentials/CredentialVault';
@@ -180,7 +180,7 @@ type QuotaSnapshotDb = {
     };
 };
 export interface PodQuotaSnapshotRepositoryOptions {
-    internalPodAccess?: InternalPodAccessTokenProvider;
+    podAccess?: PodAccessFetchProvider;
     podBaseUrlResolver?: PodBaseUrlResolver;
     dbFactory?: (input: {
         owner: string;
@@ -191,7 +191,7 @@ export interface PodQuotaSnapshotRepositoryOptions {
 }
 export declare class PodQuotaSnapshotRepository implements QuotaSnapshotRepository {
     private readonly dbFactory;
-    private readonly internalPodAccess?;
+    private readonly podAccess?;
     private readonly podBaseUrlResolver?;
     constructor(options?: PodQuotaSnapshotRepositoryOptions);
     findFresh(input: {

package/dist/api/ai-gateway/quota/ProviderQuotaAdapter.js

@@ -10,7 +10,7 @@ exports.decimalAmount = decimalAmount;
 exports.normalizeProvider = normalizeProvider;
 const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
-const CallerPodAccess_1 = require("../auth/CallerPodAccess");
+const OwnerPodAccess_1 = require("../pod/OwnerPodAccess");
 const PodBaseUrlResolver_1 = require("../pod/PodBaseUrlResolver");
 const QuotaCapabilityRegistry_1 = require("./QuotaCapabilityRegistry");
 class ProviderQuotaService {
@@ -337,7 +337,7 @@ function quotaOfferingMatches(candidateOfferingId, inputOfferingId) {
 }
 class PodQuotaSnapshotRepository {
     constructor(options = {}) {
-        this.internalPodAccess = options.internalPodAccess;
+        this.podAccess = options.podAccess;
         this.podBaseUrlResolver = options.podBaseUrlResolver;
         this.dbFactory = options.dbFactory ?? createDefaultQuotaSnapshotDb;
     }
@@ -405,37 +405,12 @@ class PodQuotaSnapshotRepository {
         return db;
     }
     async resolveTrustedFetch(owner, auth, podBaseUrl) {
-        if (auth?.type === 'solid' && auth.webId !== owner) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        if (auth?.type === 'solid'
-            && auth.webId === owner
-            && auth.viaApiKey === true
-            && typeof auth.clientId === 'string'
-            && typeof auth.clientSecret === 'string') {
-            const hostedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
-            if (hostedFetch) {
-                return this.wrapPodFetch(hostedFetch);
-            }
-        }
-        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth);
-        if (callerFetch) {
-            return this.wrapPodFetch(callerFetch);
-        }
-        if (auth?.type === 'solid'
-            && auth.webId === owner
-            && (auth.tokenType === 'DPoP' || typeof auth.dpopProof === 'string')) {
-            const hostedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
-            if (hostedFetch) {
-                return this.wrapPodFetch(hostedFetch);
-            }
-        }
-        if (!(0, CallerPodAccess_1.isInternalPodAccessAllowed)(auth)) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        const trustedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
+        const trustedFetch = await this.podAccess?.getPodFetch(owner, {
+            ...(auth ? { auth } : {}),
+            podBaseUrl,
+        });
         if (!trustedFetch) {
-            throw new Error('AI Connection service identity is not configured');
+            throw new Error((0, OwnerPodAccess_1.podAccessError)(owner, auth));
         }
         return this.wrapPodFetch(trustedFetch);
     }

package/dist/api/auth/ClientCredentialsAuthenticator.js

@@ -4,6 +4,7 @@ exports.ClientCredentialsAuthenticator = void 0;
 const node_crypto_1 = require("node:crypto");
 const solid_client_authn_core_1 = require("@inrupt/solid-client-authn-core");
 const global_logger_factory_1 = require("global-logger-factory");
+const TokenEndpointRoute_1 = require("./TokenEndpointRoute");
 const TokenIdentity_1 = require("./TokenIdentity");
 /**
  * Authenticator for CSS client credentials wrapped in sk-xxx transport format.
@@ -20,9 +21,10 @@ class ClientCredentialsAuthenticator {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.tokenCache = options.tokenCache;
-        this.tokenEndpoint = options.tokenEndpoint;
-        this.tokenEndpointHeaders = tokenEndpointRoutingHeaders(options.tokenEndpoint, options.publicBaseUrl);
-        this.tokenEndpointProofUrl = tokenEndpointProofUrl(options.tokenEndpoint, options.publicBaseUrl, this.tokenEndpointHeaders);
+        const route = (0, TokenEndpointRoute_1.resolveTokenEndpointRoute)(options.tokenEndpoint, options.publicBaseUrl);
+        this.tokenEndpoint = route.url;
+        this.tokenEndpointHeaders = route.headers;
+        this.tokenEndpointProofUrl = route.proofUrl;
     }
     canAuthenticate(request) {
         const auth = request.headers.authorization;
@@ -175,29 +177,4 @@ class ClientCredentialsAuthenticator {
     }
 }
 exports.ClientCredentialsAuthenticator = ClientCredentialsAuthenticator;
-function tokenEndpointRoutingHeaders(tokenEndpoint, publicBaseUrl) {
-    if (!publicBaseUrl)
-        return {};
-    try {
-        const internal = new URL(tokenEndpoint);
-        const canonical = new URL(publicBaseUrl);
-        if (internal.origin === canonical.origin || !isLoopbackHostname(internal.hostname))
-            return {};
-        return {
-            'X-Forwarded-Host': canonical.host,
-            'X-Forwarded-Proto': canonical.protocol.slice(0, -1),
-        };
-    }
-    catch {
-        return {};
-    }
-}
-function tokenEndpointProofUrl(tokenEndpoint, publicBaseUrl, routingHeaders) {
-    if (!publicBaseUrl || Object.keys(routingHeaders).length === 0)
-        return tokenEndpoint;
-    return new URL('/.oidc/token', publicBaseUrl).toString();
-}
-function isLoopbackHostname(hostname) {
-    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]';
-}
 //# sourceMappingURL=ClientCredentialsAuthenticator.js.map

package/dist/api/auth/TokenEndpointRoute.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Where an OIDC token request is sent, versus the URL its DPoP proof must be made for.
+ *
+ * Xpod reaches the Solid interface over a loopback alias while the canonical URL never changes
+ * (`docs/multi-channel-access.md`). An internal loopback token endpoint therefore needs two
+ * things at once: the request goes to the alias, and the receiver is told which canonical origin
+ * it is really serving, so the proof verifies against the canonical URL.
+ */
+export interface TokenEndpointRoute {
+    /** Request target: where the token request is actually sent. */
+    url: string;
+    /** URL the DPoP proof is bound to (`htu`). */
+    proofUrl: string;
+    /** Headers that make the receiver serve the canonical origin for this request. */
+    headers: Record<string, string>;
+}
+export declare function resolveTokenEndpointRoute(tokenEndpoint: string, publicBaseUrl?: string): TokenEndpointRoute;
+export declare function isLoopbackHostname(hostname: string): boolean;

package/dist/api/auth/TokenEndpointRoute.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTokenEndpointRoute = resolveTokenEndpointRoute;
+exports.isLoopbackHostname = isLoopbackHostname;
+function resolveTokenEndpointRoute(tokenEndpoint, publicBaseUrl) {
+    const headers = canonicalRoutingHeaders(tokenEndpoint, publicBaseUrl);
+    if (!publicBaseUrl || Object.keys(headers).length === 0) {
+        return { url: tokenEndpoint, proofUrl: tokenEndpoint, headers };
+    }
+    return {
+        url: tokenEndpoint,
+        proofUrl: new URL('/.oidc/token', publicBaseUrl).toString(),
+        headers,
+    };
+}
+function isLoopbackHostname(hostname) {
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]';
+}
+function canonicalRoutingHeaders(tokenEndpoint, publicBaseUrl) {
+    if (!publicBaseUrl)
+        return {};
+    try {
+        const internal = new URL(tokenEndpoint);
+        const canonical = new URL(publicBaseUrl);
+        if (internal.origin === canonical.origin || !isLoopbackHostname(internal.hostname))
+            return {};
+        return {
+            'X-Forwarded-Host': canonical.host,
+            'X-Forwarded-Proto': canonical.protocol.slice(0, -1),
+        };
+    }
+    catch {
+        return {};
+    }
+}
+//# sourceMappingURL=TokenEndpointRoute.js.map

package/dist/api/chatkit/pod-store.d.ts

@@ -3,12 +3,14 @@ import type { ThreadMetadata, ThreadRef, ThreadItem, Attachment, Page, StoreItem
 import { type RunListOptions, type RunRecordData, type RunStepRecordData, type RunStore } from '../runs/store';
 import { type TaskListOptions, type TaskRecordData, type TaskStore } from '../tasks/store';
 import { type TaskAuthBindingRepository } from '../tasks/TaskAuthBinding';
+import { type PodAccessFetchProvider } from '../ai-gateway/pod/OwnerPodAccess';
 import { type AiCredentialSecretDecoder } from '../../ai/service/AiCredentialSecret';
 import { CredentialStatus } from '../../credential/schema/types';
 import { type ServerGroupReconcilerService } from '../reconciler';
 import { type ReaderAiConfig } from '../../document/ReaderAiConfig';
 export interface PodChatKitStoreOptions {
-    tokenEndpoint: string;
+    /** Reaches a Pod as its owner over the Pod's standard interface. */
+    podAccess?: PodAccessFetchProvider;
     serverGroupReconcilerService?: ServerGroupReconcilerService;
     /**
      * Reads a Pod credential secret (AI Connections envelope, `plaintext-v1`
@@ -30,7 +32,7 @@ export interface PodChatKitStoreOptions {
  */
 export declare class PodChatKitStore implements ChatKitStore<StoreContext>, RunStore<StoreContext>, TaskStore<StoreContext>, TaskAuthBindingRepository<StoreContext> {
     private readonly logger;
-    private readonly tokenEndpoint;
+    private readonly podAccess?;
     private readonly serverGroupReconcilerService?;
     private readonly credentialSecretDecoder;
     private readonly deployment?;
@@ -47,8 +49,6 @@ export declare class PodChatKitStore implements ChatKitStore<StoreContext>, RunS
      * 获取认证后的 drizzle 实例 (缓存到 context 中)
      */
     private getDb;
-    private getClientCredentialsAccessToken;
-    private createAccessTokenFetch;
     /**
      * 从 context 获取 webId
      */