@undefineds.co/xpod 0.4.15 → 0.4.16

package/config/components-ignore.json

@@ -1,20 +1,32 @@
 [
   "ActivityEmitter",
+  "assertPublicProbeTarget",
+  "base64ByteLength",
   "BaseQuintStore",
   "ClaudeAuthenticationError",
   "CliCommandError",
   "CodeBuddyAuthError",
+  "createPinnedHeadProbeRequest",
+  "createPodOwnershipNodeAccessResolver",
   "DisabledSparqlFeatureError",
   "Error",
   "InvalidRelaySessionRequestError",
   "InvalidTunnelTokenError",
+  "isPublicIpAddress",
   "LEGACY_DERIVED_INDEX_CONSUMER_ID",
   "LOG_FILE_PATTERN",
   "NodeRouteSourceNotFoundError",
+  "normalizeContext",
   "Omit",
+  "P2P_DATA_PLANE_LIMITS",
+  "P2PDataPlaneAbortError",
+  "P2PDataPlaneLimitError",
   "P2PSessionExpiredError",
   "P2PSessionNotFoundError",
   "P2PSignalingRequestError",
+  "registerDeviceNotificationRuntime",
+  "resolveCurrentLogFile",
+  "resolveLogFilePattern",
   "SearchApiError",
   "SolidFsConflictError",
   "SolidFsNotFoundError",
@@ -23,12 +35,5 @@
   "UnsupportedSparqlQueryError",
   "VectorApiError",
   "WaitingRunnerError",
-  "assertPublicProbeTarget",
-  "createPinnedHeadProbeRequest",
-  "createPodOwnershipNodeAccessResolver",
-  "isPublicIpAddress",
-  "normalizeContext",
-  "registerDeviceNotificationRuntime",
-  "resolveCurrentLogFile",
-  "resolveLogFilePattern"
+  "XPOD_P2P_ACCEPT_HEADER"
 ]

package/dist/api/ai-gateway/auth/CallerPodAccess.d.ts

@@ -1,6 +1,22 @@
-import type { AuthContext } from '../../auth/AuthContext';
+import type { AuthContext, SolidAuthContext } from '../../auth/AuthContext';
 import { type HostedPodRoute } from '../pod/HostedPodRoute';
 export declare const CALLER_POD_ACCESS_UNAVAILABLE = "caller_pod_access_unavailable";
 export declare const CALLER_DPOP_REPLAY_UNSUPPORTED = "caller_dpop_replay_unsupported";
 export declare const CALLER_OWNER_MISMATCH = "caller_owner_mismatch";
+/**
+ * Whether the caller presented a token that is its own Pod credential.
+ *
+ * The token was already verified against the Solid issuer - signature, expiry and owner - and
+ * the owner check below binds it to the Pod being opened, so its origin does not matter: a
+ * caller that holds a valid Bearer token for the owner may use it, whether or not the token
+ * arrived wrapped as `sk-`. What is excluded is a principal Xpod authenticated for itself: a
+ * gateway access key or a runtime invocation token proves the caller to the gateway, not to the
+ * Pod, and forwarding one would turn a gateway credential into Pod access. A DPoP-bound token is
+ * excluded as well, because replaying it needs the caller's private key, which never leaves the
+ * caller.
+ */
+export declare function isCallerOwnPodBearer(owner: string, auth?: AuthContext): auth is SolidAuthContext & {
+    accessToken: string;
+    tokenType: 'Bearer';
+};
 export declare function createCallerAuthenticatedPodFetch(owner: string, auth?: AuthContext, upstream?: typeof fetch, route?: HostedPodRoute): typeof fetch | undefined;

package/dist/api/ai-gateway/auth/CallerPodAccess.js

@@ -1,19 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CALLER_OWNER_MISMATCH = exports.CALLER_DPOP_REPLAY_UNSUPPORTED = exports.CALLER_POD_ACCESS_UNAVAILABLE = void 0;
+exports.isCallerOwnPodBearer = isCallerOwnPodBearer;
 exports.createCallerAuthenticatedPodFetch = createCallerAuthenticatedPodFetch;
 const HostedPodRoute_1 = require("../pod/HostedPodRoute");
 exports.CALLER_POD_ACCESS_UNAVAILABLE = 'caller_pod_access_unavailable';
 exports.CALLER_DPOP_REPLAY_UNSUPPORTED = 'caller_dpop_replay_unsupported';
 exports.CALLER_OWNER_MISMATCH = 'caller_owner_mismatch';
+/**
+ * Whether the caller presented a token that is its own Pod credential.
+ *
+ * The token was already verified against the Solid issuer - signature, expiry and owner - and
+ * the owner check below binds it to the Pod being opened, so its origin does not matter: a
+ * caller that holds a valid Bearer token for the owner may use it, whether or not the token
+ * arrived wrapped as `sk-`. What is excluded is a principal Xpod authenticated for itself: a
+ * gateway access key or a runtime invocation token proves the caller to the gateway, not to the
+ * Pod, and forwarding one would turn a gateway credential into Pod access. A DPoP-bound token is
+ * excluded as well, because replaying it needs the caller's private key, which never leaves the
+ * caller.
+ */
+function isCallerOwnPodBearer(owner, auth) {
+    return auth?.type === 'solid'
+        && auth.webId === owner
+        && auth.viaGatewayApiKey !== true
+        && auth.internalInvocation !== true
+        && auth.tokenType === 'Bearer'
+        && typeof auth.accessToken === 'string'
+        && auth.accessToken.trim() !== '';
+}
 function createCallerAuthenticatedPodFetch(owner, auth, upstream = fetch, route) {
-    if (!auth
-        || auth.type !== 'solid'
-        || auth.webId !== owner
-        || auth.viaApiKey !== true
-        || auth.tokenType !== 'Bearer'
-        || typeof auth.accessToken !== 'string'
-        || auth.accessToken.trim() === '') {
+    if (!isCallerOwnPodBearer(owner, auth)) {
         return undefined;
     }
     const accessToken = auth.accessToken;

package/dist/api/ai-gateway/auth/PodGatewayAccessKeyRepository.js

@@ -4,6 +4,7 @@ exports.PodGatewayAccessKeyRepository = void 0;
 exports.clientCredentialProviderId = clientCredentialProviderId;
 const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
+const global_logger_factory_1 = require("global-logger-factory");
 const OwnerPodAccess_1 = require("../pod/OwnerPodAccess");
 const AiConnectionsServiceAccess_1 = require("../service-access/AiConnectionsServiceAccess");
 const PodBaseUrlResolver_1 = require("../pod/PodBaseUrlResolver");
@@ -173,11 +174,14 @@ class PodGatewayAccessKeyRepository {
             podBaseUrl: podUrl,
         });
         if (!trustedFetch) {
-            throw new Error((0, OwnerPodAccess_1.podAccessError)(owner, auth));
+            const reason = (0, OwnerPodAccess_1.podAccessError)(owner, auth);
+            // The reason decides what the user has to do, and it is invisible in the wire response.
+            (0, global_logger_factory_1.getLoggerFor)('PodGatewayAccessKeyRepository').warn(`No Pod fetch for ${owner}: ${reason}`);
+            throw new Error(reason);
         }
-        return this.wrapPodFetch(trustedFetch);
+        return this.wrapPodFetch(trustedFetch, owner);
     }
-    wrapPodFetch(trustedFetch) {
+    wrapPodFetch(trustedFetch, owner) {
         return async (input, init) => {
             // Comunica can inject a malformed content-length value; let the runtime recompute it.
             const headers = new Headers(input instanceof Request ? input.headers : undefined);
@@ -187,6 +191,8 @@ class PodGatewayAccessKeyRepository {
             headers.delete('content-length');
             const response = await trustedFetch(input, { ...init, headers });
             if (response.status === 403) {
+                const url = input instanceof Request ? input.url : String(input);
+                (0, global_logger_factory_1.getLoggerFor)('PodGatewayAccessKeyRepository').warn(`The Pod refused the caller's credential for ${owner}: ${url}`);
                 throw new Error('service_access_missing');
             }
             return response;

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

@@ -1,6 +1,7 @@
 import { type AuthContext } from '../../auth/AuthContext';
+import { type SolidSessionFactory } from '../../auth/SolidSessionFactory';
 import { type HostedPodRoute } from './HostedPodRoute';
-import type { PodInterfaceCredential, PodInterfaceKeyAccess, PodInterfaceKeyGrant } from './PodInterfaceKeyStore';
+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. */
@@ -10,6 +11,39 @@ export interface PodAccessRequestContext {
     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.
@@ -21,15 +55,20 @@ export interface PodAccessFetchProvider {
     getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
 }
 export interface OwnerPodAccessOptions {
-    keys: PodInterfaceKeyAccess;
-    /** Token endpoint of this deployment's Solid interface. */
-    tokenEndpoint: string;
-    /** Canonical base URL of that interface, used to keep the DPoP proof canonical. */
-    publicBaseUrl?: string;
+    /**
+     * 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;
-    now?: () => number;
 }
 /**
  * Reaches a Pod as its owner over the standard Solid interface.
@@ -42,23 +81,22 @@ export interface OwnerPodAccessOptions {
  * 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, PodInterfaceKeyGrant {
+export declare class OwnerPodAccess implements PodAccessFetchProvider {
     private readonly logger;
-    private readonly keys;
+    private readonly sessions;
+    private readonly taskCredentials?;
     private readonly fetchImpl;
-    private readonly now;
-    private readonly tokenRoute;
     private readonly route?;
-    private readonly podFetches;
+    private transport?;
     constructor(options: OwnerPodAccessOptions);
-    /** Grant, or rotate, the owner's Pod interface key. */
-    saveKey(owner: string, credential: PodInterfaceCredential): Promise<void>;
-    forgetKey(owner: string): Promise<void>;
-    hasKey(owner: string): Promise<boolean>;
     getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
-    private storedKeyFetch;
+    /**
+     * 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 exchange;
     private invalidateOnUnauthorized;
 }
 /**
@@ -68,6 +106,11 @@ export declare class OwnerPodAccess implements PodAccessFetchProvider, PodInterf
  * 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;
 /**

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

@@ -6,16 +6,13 @@ 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 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.
  *
@@ -30,97 +27,73 @@ const MAX_CACHED_TOKENS = 128;
 class OwnerPodAccess {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
-        this.podFetches = new Map();
-        this.keys = options.keys;
+        this.sessions = options.sessions;
+        this.taskCredentials = options.taskCredentials;
         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 (context.taskCredential) {
+            return await this.taskCredentialFetch(owner, context.taskCredential);
+        }
         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.
+            // 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 });
         }
-        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth, this.fetchImpl, this.route);
-        if (callerFetch) {
-            return callerFetch;
+        // 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;
         }
-        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;
+        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;
         }
-        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;
+        return await this.credentialFetch(owner, credential);
     }
-    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}`);
+    async credentialFetch(owner, credential) {
+        let session;
+        try {
+            session = await this.sessions.session(credential);
         }
-        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`);
+        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 (0, HostedPodRoute_1.createHostedPodRouteTransport)(this.fetchImpl, this.route);
-        const authenticated = (0, solid_client_authn_core_1.buildAuthenticatedFetch)(token.accessToken, {
-            ...(token.dpopBound ? { dpopKey } : {}),
+        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 {
-            fetch: this.invalidateOnUnauthorized(`${owner}\u0000${credential.clientId}`, authenticated),
-            expiresAt: this.now() + token.expiresInSeconds * 1000,
-        };
+        return this.invalidateOnUnauthorized(credential, authenticated);
     }
-    invalidateOnUnauthorized(cacheKey, podFetch) {
+    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.podFetches.delete(cacheKey);
+                this.sessions.invalidate(credential);
             }
             return response;
         };
@@ -134,6 +107,11 @@ exports.OwnerPodAccess = OwnerPodAccess;
  * 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') {
@@ -161,32 +139,4 @@ function isPodAccessFailure(message) {
         || 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

@@ -43,6 +43,8 @@ export declare class PodInterfaceKeyStore implements PodInterfaceKeyAccess {
     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>;

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

@@ -19,6 +19,11 @@ class PodInterfaceKeyStore {
         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 });

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;
 }