@undefineds.co/xpod 0.4.14 → 0.4.16

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHostedPodRoute = resolveHostedPodRoute;
+exports.createHostedPodRouteTransport = createHostedPodRouteTransport;
+const bootstrap_1 = require("../../../runtime/bootstrap");
+/**
+ * The route that reaches this deployment's hosted Pods from inside the API sidecar.
+ *
+ * The inputs are resolved where they are known - when the runtime builds its services - and not
+ * read from the environment per request: the runtime restores the environment it borrowed once
+ * its services are up, so a lazy lookup would silently find nothing and address the Pod's
+ * canonical URL instead of the route that is actually reachable.
+ */
+function resolveHostedPodRoute(input) {
+    const canonicalBaseUrl = input.canonicalBaseUrl?.trim();
+    const gatewayPort = String(input.gatewayPort ?? '').trim();
+    if (!canonicalBaseUrl || !/^\d+$/u.test(gatewayPort)) {
+        return undefined;
+    }
+    return {
+        canonicalBaseUrl,
+        // The gateway has to be reached on the address it actually bound: `localhost` may be
+        // IPv6-only, and a wildcard bind is not connectable on every platform.
+        localBaseUrl: `${(0, bootstrap_1.localServiceUrl)(input.gatewayHost, Number(gatewayPort))}/`,
+    };
+}
+/**
+ * Wrap a transport so canonical Pod URLs are sent over the gateway route.
+ *
+ * This belongs *under* a DPoP signer, never wrapped around an authenticated fetch: the proof is
+ * made for the canonical URL, and this layer only replaces the wire target, so a DPoP-bound
+ * request stays bound to the URL the caller named.
+ */
+async function createHostedPodRouteTransport(transport, route) {
+    if (!route) {
+        return transport;
+    }
+    const { createSolidLocalRouteFetch } = await importSolidLocalRouteFetch();
+    return createSolidLocalRouteFetch({ fetch: transport, routes: () => [route] });
+}
+async function importSolidLocalRouteFetch() {
+    // The API runtime is CommonJS while solid-sdk is intentionally ESM-only. Keep the package
+    // boundary and load the SDK without TypeScript lowering import() to require().
+    const dynamicImport = new Function('specifier', 'return import(specifier)');
+    return dynamicImport('@undefineds.co/solid-sdk/local-route-fetch');
+}
+//# sourceMappingURL=HostedPodRoute.js.map

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

@@ -0,0 +1,122 @@
+import { type AuthContext } from '../../auth/AuthContext';
+import { type SolidSessionFactory } from '../../auth/SolidSessionFactory';
+import { type HostedPodRoute } from './HostedPodRoute';
+import type { PodInterfaceCredential } from './PodInterfaceKeyStore';
+/** No usable Pod credential is on file for this owner; the user has to grant one. */
+export declare const POD_INTERFACE_KEY_MISSING = "pod_interface_key_missing";
+/** The owner's stored credential was refused by the Pod; it has to be granted again. */
+export declare const POD_INTERFACE_KEY_REJECTED = "pod_interface_key_rejected";
+export interface PodAccessRequestContext {
+    /** The authenticated caller, when the request carries one. */
+    auth?: AuthContext;
+    /** Physical Pod root when the identity WebID is hosted by a separate IdP. */
+    podBaseUrl?: string;
+    /**
+     * Work that runs without a caller takes its credential from the task layer.
+     *
+     * `ownerGrant` asks for the owner's active grant; `credentialRef` names one grant, optionally
+     * frozen at the `version` its binding recorded. Setting this means the request may not borrow
+     * the API's stored key: an unusable grant fails the call so the caller reports why.
+     */
+    taskCredential?: {
+        credentialRef?: string;
+        version?: number;
+        ownerGrant?: true;
+    };
+}
+/** A credential the task layer holds for an owner, with the grant it came from. */
+export interface TaskPodCredential extends PodInterfaceCredential {
+    credentialRef: string;
+    version: number;
+}
+/**
+ * The task layer's credentials, as this component needs them.
+ *
+ * Kept as an interface so Pod access depends on "a grant the task layer vouches for" rather than
+ * on the task layer's storage.
+ */
+export interface TaskCredentialSource {
+    /** The owner's active grant for this deployment, if the owner made one. */
+    activeFor(ownerWebId: string): Promise<TaskPodCredential | undefined>;
+    /** One named grant, checked for its owner and version. */
+    forRef(input: {
+        credentialRef: string;
+        ownerWebId: string;
+        version?: number;
+    }): Promise<TaskPodCredential | undefined>;
+}
+/**
+ * Source of a fetch that reaches an owner's Pod through its standard interface.
+ *
+ * `undefined` means no credential is on file, which is a state the caller reports to the user
+ * rather than papers over.
+ */
+export interface PodAccessFetchProvider {
+    getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
+}
+export interface OwnerPodAccessOptions {
+    /**
+     * Shared Solid session factory. The caller's own credential was already exchanged while
+     * authenticating the request, so reaching the Pod reuses that session and its DPoP key
+     * instead of exchanging the same credential a second time.
+     */
+    sessions: SolidSessionFactory;
+    /**
+     * Task-layer credentials for work that runs without a caller. Absent means such work can only
+     * use the deployment's stored key, which is the pre-migration behaviour.
+     */
+    taskCredentials?: TaskCredentialSource;
+    /** Route this deployment exposes for its own hosted Pods, when one is needed. */
+    route?: HostedPodRoute;
+    fetch?: typeof fetch;
+}
+/**
+ * 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.
+ */
+export declare class OwnerPodAccess implements PodAccessFetchProvider {
+    private readonly logger;
+    private readonly sessions;
+    private readonly taskCredentials?;
+    private readonly fetchImpl;
+    private readonly route?;
+    private transport?;
+    constructor(options: OwnerPodAccessOptions);
+    getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
+    /**
+     * Reach the Pod with a task-layer grant. There is no fallback on purpose: falling back to the
+     * API's stored key would make "this task was authorized" indistinguishable from "somebody
+     * registered once".
+     */
+    private taskCredentialFetch;
+    private credentialFetch;
+    private invalidateOnUnauthorized;
+}
+/**
+ * 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.
+ *
+ * One cause is not covered by that fix: a principal Xpod authenticated for itself (a gateway
+ * access key, or a runtime invocation token) is not a Pod principal, so it reports the missing
+ * key even though the caller's remedy is to present a Pod credential. Splitting that into its
+ * own reason is tracked in `docs/pod-interface-key.md` decision 4.
+ */
+export declare function podAccessError(owner: string, auth?: AuthContext): string;
+/**
+ * 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.
+ */
+export declare function isPodAccessFailure(message: string): boolean;

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

@@ -0,0 +1,142 @@
+"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 SolidSessionFactory_1 = require("../../auth/SolidSessionFactory");
+const CallerPodAccess_1 = require("../auth/CallerPodAccess");
+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';
+/**
+ * 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.sessions = options.sessions;
+        this.taskCredentials = options.taskCredentials;
+        this.fetchImpl = options.fetch ?? fetch;
+        this.route = options.route;
+    }
+    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 (context.taskCredential) {
+            return await this.taskCredentialFetch(owner, context.taskCredential);
+        }
+        if ((0, AuthContext_1.hasSolidClientCredentialsAuthority)(auth)) {
+            // The caller's own interface key, already exchanged while authenticating this request: the
+            // session factory hands back that same token together with the key it is bound to.
+            return await this.credentialFetch(owner, { clientId: auth.clientId, clientSecret: auth.clientSecret });
+        }
+        // Only the caller's own credential opens the Pod. A deployment-held key would make "this
+        // request was authorized" indistinguishable from "somebody registered once".
+        return (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth, this.fetchImpl, this.route);
+    }
+    /**
+     * Reach the Pod with a task-layer grant. There is no fallback on purpose: falling back to the
+     * API's stored key would make "this task was authorized" indistinguishable from "somebody
+     * registered once".
+     */
+    async taskCredentialFetch(owner, request) {
+        if (!this.taskCredentials) {
+            return undefined;
+        }
+        const credential = request.credentialRef
+            ? await this.taskCredentials.forRef({
+                credentialRef: request.credentialRef,
+                ownerWebId: owner,
+                ...(request.version !== undefined ? { version: request.version } : {}),
+            })
+            : await this.taskCredentials.activeFor(owner);
+        if (!credential) {
+            return undefined;
+        }
+        return await this.credentialFetch(owner, credential);
+    }
+    async credentialFetch(owner, credential) {
+        let session;
+        try {
+            session = await this.sessions.session(credential);
+        }
+        catch (error) {
+            const status = error instanceof SolidSessionFactory_1.SolidSessionError ? error.status : undefined;
+            this.logger.warn(`Pod interface key refused for ${owner}: ${String(error)}`);
+            throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:${status ?? 'invalid_response'}`);
+        }
+        const transport = await (this.transport ??= (0, HostedPodRoute_1.createHostedPodRouteTransport)(this.fetchImpl, this.route));
+        const authenticated = (0, solid_client_authn_core_1.buildAuthenticatedFetch)(session.accessToken, {
+            ...(session.dpopKey ? { dpopKey: session.dpopKey } : {}),
+            fetch: transport,
+        });
+        return this.invalidateOnUnauthorized(credential, authenticated);
+    }
+    invalidateOnUnauthorized(credential, 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.sessions.invalidate(credential);
+            }
+            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.
+ *
+ * One cause is not covered by that fix: a principal Xpod authenticated for itself (a gateway
+ * access key, or a runtime invocation token) is not a Pod principal, so it reports the missing
+ * key even though the caller's remedy is to present a Pod credential. Splitting that into its
+ * own reason is tracked in `docs/pod-interface-key.md` decision 4.
+ */
+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);
+}
+//# sourceMappingURL=OwnerPodAccess.js.map

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

@@ -0,0 +1,54 @@
+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);
+    /** Every owner with a stored key, for the migration into the task layer. */
+    listOwners(): Promise<string[]>;
+    /** 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,66 @@
+"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;
+    }
+    /** Every owner with a stored key, for the migration into the task layer. */
+    async listOwners() {
+        const records = await this.repository.list();
+        return records.map((record) => record.ownerWebId);
+    }
+    /** 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.d.ts

@@ -1,25 +1,12 @@
 import type { IncomingMessage } from 'node:http';
 import type { Authenticator, AuthResult } from './Authenticator';
-/**
- * Cache keys bind the issuer and complete credentials, without storing secrets in keys.
- */
-export interface TokenCache {
-    get(credentialKey: string): Promise<{
-        token: string;
-        tokenType?: 'Bearer' | 'DPoP';
-        webId: string;
-        expiresAt: Date;
-    } | undefined>;
-    set(credentialKey: string, token: string, webId: string, expiresAt: Date, tokenType?: 'Bearer' | 'DPoP'): Promise<void>;
-}
+import { type SolidSessionFactory } from './SolidSessionFactory';
 export interface ClientCredentialsAuthenticatorOptions {
-    tokenCache?: TokenCache;
     /**
-     * CSS token endpoint URL
+     * Shared Solid session factory. Inbound bearer credentials and outbound Pod access resolve to
+     * the same session, so a credential is exchanged for a token only once.
      */
-    tokenEndpoint: string;
-    /** Canonical CSS URL represented by an internal token endpoint. */
-    publicBaseUrl?: string;
+    sessions: SolidSessionFactory;
 }
 /**
  * Authenticator for CSS client credentials wrapped in sk-xxx transport format.
@@ -34,12 +21,8 @@ export interface ClientCredentialsAuthenticatorOptions {
  */
 export declare class ClientCredentialsAuthenticator implements Authenticator {
     private readonly logger;
-    private readonly tokenCache?;
-    private readonly tokenEndpoint;
-    private readonly tokenEndpointHeaders;
-    private readonly tokenEndpointProofUrl;
+    private readonly sessions;
     constructor(options: ClientCredentialsAuthenticatorOptions);
     canAuthenticate(request: IncomingMessage): boolean;
     authenticate(request: IncomingMessage): Promise<AuthResult>;
-    private exchangeForToken;
 }