@undefineds.co/xpod 0.4.15 → 0.4.17

package/dist/api/handlers/TaskCredentialHandler.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskCredentialRoutes = registerTaskCredentialRoutes;
+const TaskCredentialStore_1 = require("../tasks/TaskCredentialStore");
+/**
+ * Grants the task layer may use while nobody is present.
+ *
+ * The store is the task layer's, so this surface only ever exposes metadata: no endpoint returns a
+ * secret, and every route resolves the grant from the caller's own WebID.
+ */
+function registerTaskCredentialRoutes(server, options) {
+    const requireOwner = (request, response) => {
+        const auth = request.auth;
+        if (!auth || auth.type !== 'solid' || !auth.webId) {
+            sendJson(response, 401, { error: 'Authentication required' });
+            return undefined;
+        }
+        return auth.webId;
+    };
+    /**
+     * The user's explicit grant: a credential the task layer may use while nobody is present.
+     *
+     * It takes the same `sk-` wrapper registration does, because that wrapper is the user's own
+     * credential; the difference is what is stored - a task-layer grant, not an API-side copy.
+     */
+    server.post('/api/ai/task-credentials', async (request, response) => {
+        const owner = requireOwner(request, response);
+        if (!owner)
+            return;
+        if (!options.taskCredentials) {
+            sendJson(response, 503, { error: 'task_credential_storage_unconfigured' });
+            return;
+        }
+        if (!options.validateClientCredential || !options.clientCredentialIssuer) {
+            sendJson(response, 503, { error: 'task_credential_grant_unavailable' });
+            return;
+        }
+        const body = await readJsonObject(request, response, options.jsonBodyLimitBytes ?? 64 * 1024);
+        if (!body)
+            return;
+        const apiKey = typeof body.apiKey === 'string' ? body.apiKey : '';
+        if (!validClientCredentialWrapper(apiKey)) {
+            sendJson(response, 400, { error: 'A CSS client credential wrapper is required' });
+            return;
+        }
+        const verified = await options.validateClientCredential(apiKey);
+        if (!verified.success || verified.context?.type !== 'solid') {
+            sendJson(response, verified.category === 'service_unavailable' ? 503 : 401, {
+                error: 'CSS client credential verification failed',
+            });
+            return;
+        }
+        if (verified.context.webId !== owner) {
+            sendJson(response, 403, { error: 'CSS client credential belongs to another WebID' });
+            return;
+        }
+        if (!verified.context.clientId || !verified.context.clientSecret) {
+            sendJson(response, 400, { error: 'CSS client credential is incomplete' });
+            return;
+        }
+        try {
+            // The user granted it just now, so it is active immediately; a program that needs the user
+            // to confirm later creates a pending grant instead.
+            const credential = await options.taskCredentials.grant({
+                ownerWebId: owner,
+                issuer: options.clientCredentialIssuer,
+                clientId: verified.context.clientId,
+                clientSecret: verified.context.clientSecret,
+                status: 'active',
+            });
+            sendJson(response, 201, { credential });
+        }
+        catch (error) {
+            sendTaskCredentialError(response, error);
+        }
+    });
+    server.get('/api/ai/task-credentials', async (request, response) => {
+        const owner = requireOwner(request, response);
+        if (!owner)
+            return;
+        if (!options.taskCredentials) {
+            sendJson(response, 503, { error: 'task_credential_storage_unconfigured' });
+            return;
+        }
+        const data = await options.taskCredentials.listForOwner(owner);
+        sendJson(response, 200, { data });
+    });
+    server.post('/api/ai/task-credentials/:credentialRef/activate', async (request, response, params) => {
+        const owner = requireOwner(request, response);
+        if (!owner)
+            return;
+        if (!options.taskCredentials) {
+            sendJson(response, 503, { error: 'task_credential_storage_unconfigured' });
+            return;
+        }
+        const credentialRef = params.credentialRef;
+        if (!await isOwnedBy(options.taskCredentials, credentialRef, owner)) {
+            sendJson(response, 404, { error: TaskCredentialStore_1.TASK_CREDENTIAL_NOT_FOUND });
+            return;
+        }
+        try {
+            const activated = await options.taskCredentials.activate(credentialRef);
+            sendJson(response, 200, { credential: activated });
+        }
+        catch (error) {
+            sendTaskCredentialError(response, error);
+        }
+    });
+    server.delete('/api/ai/task-credentials/:credentialRef', async (request, response, params) => {
+        const owner = requireOwner(request, response);
+        if (!owner)
+            return;
+        if (!options.taskCredentials) {
+            sendJson(response, 503, { error: 'task_credential_storage_unconfigured' });
+            return;
+        }
+        const credentialRef = params.credentialRef;
+        if (!await isOwnedBy(options.taskCredentials, credentialRef, owner)) {
+            sendJson(response, 404, { error: TaskCredentialStore_1.TASK_CREDENTIAL_NOT_FOUND });
+            return;
+        }
+        try {
+            await options.taskCredentials.revoke(credentialRef);
+            sendJson(response, 200, { revoked: credentialRef });
+        }
+        catch (error) {
+            sendTaskCredentialError(response, error);
+        }
+    });
+}
+/** Resolve a grant only when it belongs to the caller; another owner's reference looks absent. */
+async function isOwnedBy(store, credentialRef, ownerWebId) {
+    const grants = await store.listForOwner(ownerWebId);
+    return grants.some((grant) => grant.credentialRef === credentialRef);
+}
+function sendTaskCredentialError(response, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.startsWith(TaskCredentialStore_1.TASK_CREDENTIAL_NOT_FOUND)) {
+        sendJson(response, 404, { error: TaskCredentialStore_1.TASK_CREDENTIAL_NOT_FOUND });
+        return;
+    }
+    if (message.startsWith(TaskCredentialStore_1.TASK_CREDENTIAL_NOT_ACTIVE)) {
+        sendJson(response, 409, { error: TaskCredentialStore_1.TASK_CREDENTIAL_NOT_ACTIVE });
+        return;
+    }
+    if (message.startsWith(TaskCredentialStore_1.TASK_CREDENTIAL_VERSION_CONFLICT)) {
+        sendJson(response, 409, { error: TaskCredentialStore_1.TASK_CREDENTIAL_VERSION_CONFLICT });
+        return;
+    }
+    if (message.startsWith(TaskCredentialStore_1.TASK_CREDENTIAL_OWNER_MISMATCH)) {
+        sendJson(response, 403, { error: TaskCredentialStore_1.TASK_CREDENTIAL_OWNER_MISMATCH });
+        return;
+    }
+    sendJson(response, 500, { error: 'task_credential_operation_failed' });
+}
+function sendJson(response, status, data) {
+    response.statusCode = status;
+    response.setHeader('Content-Type', 'application/json');
+    response.end(JSON.stringify(data));
+}
+function validClientCredentialWrapper(value) {
+    if (!value.startsWith('sk-'))
+        return false;
+    const encoded = value.slice(3);
+    const decoded = Buffer.from(encoded, 'base64').toString('utf8');
+    return Buffer.from(decoded, 'utf8').toString('base64') === encoded
+        && /^[^\s\x00-\x1f\x7f:]+:[^\s\x00-\x1f\x7f]+$/u.test(decoded);
+}
+async function readJsonObject(request, response, limitBytes) {
+    const chunks = [];
+    let size = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        size += buffer.byteLength;
+        if (size > limitBytes) {
+            sendJson(response, 413, { error: 'Request body is too large' });
+            return undefined;
+        }
+        chunks.push(buffer);
+    }
+    if (size === 0) {
+        sendJson(response, 400, { error: 'Request body is required' });
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            sendJson(response, 400, { error: 'Request body must be a JSON object' });
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        sendJson(response, 400, { error: 'Request body must be valid JSON' });
+        return undefined;
+    }
+}
+//# sourceMappingURL=TaskCredentialHandler.js.map

package/dist/api/network/EndpointReachabilityProbe.d.ts

@@ -0,0 +1,40 @@
+import { type HeadProbeRequest, type ResolveAddresses } from '../../edge/ProbeTargetGuard';
+/**
+ * "Is my public entry actually serving?" — asked on demand, never on a timer (audit N12).
+ *
+ * The settings page used to answer only "the address is configured". The operator now gets a
+ * real measurement, but the probe is deliberately narrow, because it makes the node issue an
+ * outbound request to a configured address:
+ *
+ *   - it only ever runs when the operator asks (the diagnose action), never periodically;
+ *   - only `https` targets are accepted: an entry that serves plaintext is a configuration
+ *     error, and probing it would put the operator's traffic on the wire unencrypted;
+ *   - every resolved address must be public (the same guard the Cloud probe uses), so the
+ *     entry cannot bounce the node into loopback, RFC1918, link-local or the metadata
+ *     endpoint, and each redirect hop is validated again;
+ *   - the connection is pinned to the address that was validated, so a second DNS answer
+ *     cannot swap in a private address between check and connect;
+ *   - the verdict says "reachable from this node" and nothing more: many networks do not
+ *     support NAT hairpin, so a node failing to reach its own public entry is not proof that
+ *     remote users cannot, and vice versa.
+ */
+export interface EndpointReachabilityProbeOptions {
+    resolveAddresses?: ResolveAddresses;
+    headRequest?: HeadProbeRequest;
+    timeoutMs?: number;
+    maxRedirects?: number;
+    now?: () => Date;
+}
+export type EndpointReachabilityVerdict = 'reachable-from-this-node' | 'unreachable' | 'blocked';
+export interface EndpointReachabilityResult {
+    target: string;
+    verdict: EndpointReachabilityVerdict;
+    /** Present whenever the entry answered at all (including 4xx: the entry is serving). */
+    httpStatus?: number;
+    /** Time from the first request to the final answer, including redirects. */
+    latencyMs?: number;
+    reason?: string;
+    detail: string;
+    checkedAt: string;
+}
+export declare function probeEndpointReachability(endpoint: string, options?: EndpointReachabilityProbeOptions): Promise<EndpointReachabilityResult>;

package/dist/api/network/EndpointReachabilityProbe.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeEndpointReachability = probeEndpointReachability;
+const ProbeTargetGuard_1 = require("../../edge/ProbeTargetGuard");
+const DEFAULT_TIMEOUT_MS = 5_000;
+const DEFAULT_MAX_REDIRECTS = 3;
+async function probeEndpointReachability(endpoint, options = {}) {
+    const now = options.now ?? (() => new Date());
+    const checkedAt = now().toISOString();
+    const timeoutMs = positive(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+    const maxRedirects = Math.max(0, Math.trunc(options.maxRedirects ?? DEFAULT_MAX_REDIRECTS));
+    const resolveAddresses = options.resolveAddresses;
+    const headRequest = options.headRequest ?? (0, ProbeTargetGuard_1.createPinnedHeadProbeRequest)();
+    const startUrl = parseEndpointUrl(endpoint);
+    if (!startUrl) {
+        return {
+            target: endpoint,
+            verdict: 'blocked',
+            reason: 'invalid-url',
+            detail: 'cannot probe: the address is not a usable URL',
+            checkedAt,
+        };
+    }
+    // Plaintext entries are not probed: the point of the check is the entry users reach, and an
+    // operator needs to fix the scheme before anything else is meaningful.
+    if (startUrl.protocol !== 'https:') {
+        return {
+            target: startUrl.toString(),
+            verdict: 'blocked',
+            reason: `insecure-scheme:${startUrl.protocol}`,
+            detail: 'not probed: only https entries are probed',
+            checkedAt,
+        };
+    }
+    const startedAt = Date.now();
+    let url = startUrl;
+    for (let hop = 0; hop <= maxRedirects; hop += 1) {
+        const decision = await (0, ProbeTargetGuard_1.assertPublicProbeTarget)(url, resolveAddresses);
+        if (!decision.allowed) {
+            return {
+                target: startUrl.toString(),
+                verdict: 'blocked',
+                reason: `blocked-target:${decision.reason}`,
+                detail: `not probed: ${decision.reason}（只对公网地址发探测）`,
+                checkedAt,
+            };
+        }
+        let response;
+        try {
+            response = await headRequest(url, { address: decision.address, timeoutMs });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const timedOut = /timed? ?out|ETIMEDOUT|aborted/iu.test(message);
+            return {
+                target: startUrl.toString(),
+                verdict: 'unreachable',
+                reason: timedOut ? 'timeout' : `connection-error:${message}`,
+                latencyMs: Date.now() - startedAt,
+                detail: timedOut
+                    ? `unreachable from this node: no answer within ${timeoutMs}ms`
+                    : `unreachable from this node: ${message}`,
+                checkedAt,
+            };
+        }
+        if (response.status >= 300 && response.status < 400 && response.location) {
+            const next = safeUrl(response.location, url);
+            if (!next) {
+                return {
+                    target: startUrl.toString(),
+                    verdict: 'unreachable',
+                    reason: 'invalid-redirect',
+                    latencyMs: Date.now() - startedAt,
+                    detail: 'unreachable from this node: the entry redirected to an unusable address',
+                    checkedAt,
+                };
+            }
+            url = next;
+            continue;
+        }
+        const latencyMs = Date.now() - startedAt;
+        return {
+            target: startUrl.toString(),
+            verdict: 'reachable-from-this-node',
+            httpStatus: response.status,
+            latencyMs,
+            detail: `reachable from this node: HTTP ${response.status} in ${latencyMs}ms`
+                + '（网络可能不支持回环，不代表外部用户可达）',
+            checkedAt,
+        };
+    }
+    return {
+        target: startUrl.toString(),
+        verdict: 'unreachable',
+        reason: 'too-many-redirects',
+        latencyMs: Date.now() - startedAt,
+        detail: `unreachable from this node: more than ${maxRedirects} redirects`,
+        checkedAt,
+    };
+}
+function parseEndpointUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    try {
+        return new URL(trimmed);
+    }
+    catch {
+        try {
+            return new URL(`https://${trimmed}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function safeUrl(value, base) {
+    try {
+        return new URL(value, base);
+    }
+    catch {
+        return undefined;
+    }
+}
+function positive(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.trunc(value) : fallback;
+}
+//# sourceMappingURL=EndpointReachabilityProbe.js.map

package/dist/api/runtime.d.ts

@@ -17,6 +17,8 @@ export interface ApiServiceHandle {
     inngestRuntimeConfig?: EmbeddedInngestRuntimeConfig;
     stop: () => Promise<void>;
 }
+/** One source of truth for the Cloud identity: the local edition's default issuer. */
+export declare const OFFICIAL_CLOUD_IDENTITY_ORIGIN: string;
 export declare function autoProvisionFirstRunLocal(config: ApiContainerConfig, logger: ReturnType<typeof getLoggerFor>): Promise<ApiContainerConfig>;
 /**
  * Port a managed tunnel forwards to.

package/dist/api/runtime.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFICIAL_CLOUD_IDENTITY_ORIGIN = void 0;
 exports.autoProvisionFirstRunLocal = autoProvisionFirstRunLocal;
 exports.resolveTunnelIngressPort = resolveTunnelIngressPort;
 exports.startApiService = startApiService;
@@ -9,12 +10,14 @@ const ConfigurableLoggerFactory_1 = require("../logging/ConfigurableLoggerFactor
 const log_file_1 = require("../logging/log-file");
 const container_1 = require("./container");
 const routes_1 = require("./container/routes");
+const background_service_supervisor_1 = require("./background-service-supervisor");
 const OpenAuthMiddleware_1 = require("./middleware/OpenAuthMiddleware");
 const EmbeddedInngestService_1 = require("./runs/EmbeddedInngestService");
 const LocalProvisionState_1 = require("../provision/LocalProvisionState");
 const oidc_issuer_1 = require("../runtime/oidc-issuer");
 const OFFICIAL_CLOUD_API_ORIGIN = 'https://api.undefineds.co';
-const OFFICIAL_CLOUD_IDENTITY_ORIGIN = 'https://id.undefineds.co';
+/** One source of truth for the Cloud identity: the local edition's default issuer. */
+exports.OFFICIAL_CLOUD_IDENTITY_ORIGIN = new URL(oidc_issuer_1.DEFAULT_LOCAL_OIDC_ISSUER).origin;
 function ensureTrailingSlash(url) {
     return url.endsWith('/') ? url : `${url}/`;
 }
@@ -250,7 +253,7 @@ function resolveCloudIdentityUrl(config) {
     try {
         const endpoint = new URL(config.cloudApiEndpoint ?? OFFICIAL_CLOUD_API_ORIGIN);
         const official = new URL(OFFICIAL_CLOUD_API_ORIGIN);
-        return endpoint.hostname === official.hostname ? OFFICIAL_CLOUD_IDENTITY_ORIGIN : undefined;
+        return endpoint.hostname === official.hostname ? exports.OFFICIAL_CLOUD_IDENTITY_ORIGIN : undefined;
     }
     catch {
         return undefined;
@@ -274,6 +277,27 @@ function normalizeUrl(value) {
         return value.trim();
     }
 }
+/**
+ * Move the API's legacy owner keys into the task layer before anything serves traffic.
+ *
+ * A failure here is reported and left for the next boot: the legacy table stays readable, and the
+ * migration is idempotent, so a half-done run is repeatable rather than a data loss.
+ */
+async function migrateLegacyPodKeys(container, logger) {
+    const migrate = container.resolve('legacyPodKeyMigration', { allowUnregistered: true });
+    if (!migrate) {
+        return;
+    }
+    try {
+        const result = await migrate();
+        if (result.migrated > 0 || result.failed > 0) {
+            logger.info(`Legacy Pod keys migrated into the task layer: ${JSON.stringify(result)}`);
+        }
+    }
+    catch (error) {
+        logger.warn(`Legacy Pod key migration failed: ${String(error)}`);
+    }
+}
 async function registerPrimaryServiceToken(container, config, logger) {
     try {
         const serviceToken = config.serviceToken;
@@ -341,6 +365,13 @@ function resolveTunnelIngressPort(env = process.env) {
     }
     return 3000;
 }
+/**
+ * 后台服务由 supervisor 接管（审计 N18）。
+ *
+ * 此前每个服务只 start 一次，失败只写日志：开机时断网、provider 抖动的隧道会一直躺着，
+ * 跑着跑着死掉的也没人发现。现在启动失败按退避重试，起来之后按间隔复查存活。
+ */
+const backgroundSupervisors = [];
 async function startBackgroundServices(container, logger) {
     try {
         const localNetworkManager = container.resolve('localNetworkManager', { allowUnregistered: true });
@@ -354,8 +385,18 @@ async function startBackgroundServices(container, logger) {
     try {
         const ddnsManager = container.resolve('ddnsManager', { allowUnregistered: true });
         if (ddnsManager) {
-            await ddnsManager.start();
-            logger.info('DDNS Manager started');
+            const supervisor = new background_service_supervisor_1.BackgroundServiceSupervisor({
+                name: 'ddns',
+                start: async () => {
+                    await ddnsManager.start();
+                },
+                stop: async () => {
+                    ddnsManager.stop?.();
+                },
+                logger,
+            });
+            backgroundSupervisors.push(supervisor);
+            supervisor.start();
         }
     }
     catch (error) {
@@ -365,13 +406,25 @@ async function startBackgroundServices(container, logger) {
         const localTunnelProvider = container.resolve('localTunnelProvider', { allowUnregistered: true });
         if (localTunnelProvider) {
             logger.info('Starting local tunnel provider...');
-            const config = await localTunnelProvider.setup({
-                subdomain: 'local',
-                localPort: resolveTunnelIngressPort(),
-                localProtocol: 'http',
+            const supervisor = new background_service_supervisor_1.BackgroundServiceSupervisor({
+                name: `tunnel:${String(localTunnelProvider.name ?? 'local')}`,
+                start: async () => {
+                    const config = await localTunnelProvider.setup({
+                        subdomain: 'local',
+                        localPort: resolveTunnelIngressPort(),
+                        localProtocol: 'http',
+                    });
+                    await localTunnelProvider.start(config);
+                },
+                stop: async () => {
+                    await localTunnelProvider.stop?.();
+                },
+                // 隧道进程退出后 provider 自己知道状态，supervisor 据此重启。
+                isRunning: () => Boolean(localTunnelProvider.getStatus?.().running),
+                logger,
             });
-            await localTunnelProvider.start(config);
-            logger.info('Local tunnel provider started');
+            backgroundSupervisors.push(supervisor);
+            supervisor.start();
         }
     }
     catch (error) {
@@ -379,12 +432,10 @@ async function startBackgroundServices(container, logger) {
     }
 }
 async function stopBackgroundServices(container) {
-    try {
-        const ddnsManager = container.resolve('ddnsManager', { allowUnregistered: true });
-        ddnsManager?.stop();
-    }
-    catch {
-        // ignore shutdown errors
+    // 先停监督器：否则一次关停会被自己排的重试撤销（ddns/tunnel 的 stop 由它们负责调用）。
+    while (backgroundSupervisors.length > 0) {
+        const supervisor = backgroundSupervisors.pop();
+        await supervisor?.stop();
     }
     try {
         const localNetworkManager = container.resolve('localNetworkManager', { allowUnregistered: true });
@@ -393,13 +444,8 @@ async function stopBackgroundServices(container) {
     catch {
         // ignore shutdown errors
     }
-    try {
-        const localTunnelProvider = container.resolve('localTunnelProvider', { allowUnregistered: true });
-        await localTunnelProvider?.stop();
-    }
-    catch {
-        // ignore shutdown errors
-    }
+    // The tunnel provider's stop is owned by its supervisor above; stopping it twice would kill
+    // the same process twice and make the shutdown path look like it did more than it did.
 }
 async function stopApiRuntimeServices(container) {
     try {
@@ -485,6 +531,7 @@ async function startApiService(options = {}) {
         (0, routes_1.registerRoutes)(container);
         server = container.resolve('apiServer');
         await container.resolve('rdfEngine', { allowUnregistered: true })?.open?.();
+        await migrateLegacyPodKeys(container, logger);
         await registerPrimaryServiceToken(container, config, logger);
         await reconcileLocalOwnerRoles(container, config, logger);
         await startBackgroundServices(container, logger);

package/dist/api/tasks/PodInterfaceKeyMigration.d.ts

@@ -0,0 +1,27 @@
+import type { PodInterfaceKeySource } from '../ai-gateway/pod/PodInterfaceKeyStore';
+import type { TaskCredentialStore } from './TaskCredentialStore';
+export interface PodInterfaceKeyMigrationResult {
+    scanned: number;
+    migrated: number;
+    skipped: number;
+    failed: number;
+}
+export interface MigratePodInterfaceKeysOptions {
+    /** Legacy store: one sealed owner key per WebID. Read-only here. */
+    keys: PodInterfaceKeySource & {
+        listOwners(): Promise<string[]>;
+    };
+    /** Where the rows are moved to. */
+    taskCredentials: TaskCredentialStore;
+    /** Issuer the legacy rows belong to. */
+    issuer: string;
+}
+/**
+ * Move the deployment's stored owner keys into the task layer.
+ *
+ * Runs once per boot and is safe to repeat: a row that is already a grant of the same owner and
+ * issuer resolves to the same reference, and the grant is idempotent when the secret matches. A
+ * row that cannot be opened is reported and left alone - the legacy table stays readable, which is
+ * what keeps a failed migration reversible.
+ */
+export declare function migratePodInterfaceKeysToTaskCredentials(options: MigratePodInterfaceKeysOptions): Promise<PodInterfaceKeyMigrationResult>;

package/dist/api/tasks/PodInterfaceKeyMigration.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migratePodInterfaceKeysToTaskCredentials = migratePodInterfaceKeysToTaskCredentials;
+const global_logger_factory_1 = require("global-logger-factory");
+/**
+ * Move the deployment's stored owner keys into the task layer.
+ *
+ * Runs once per boot and is safe to repeat: a row that is already a grant of the same owner and
+ * issuer resolves to the same reference, and the grant is idempotent when the secret matches. A
+ * row that cannot be opened is reported and left alone - the legacy table stays readable, which is
+ * what keeps a failed migration reversible.
+ */
+async function migratePodInterfaceKeysToTaskCredentials(options) {
+    const logger = (0, global_logger_factory_1.getLoggerFor)('PodInterfaceKeyMigration');
+    const result = { scanned: 0, migrated: 0, skipped: 0, failed: 0 };
+    let owners;
+    try {
+        owners = await options.keys.listOwners();
+    }
+    catch (error) {
+        logger.warn(`Legacy Pod interface keys could not be listed: ${String(error)}`);
+        return result;
+    }
+    for (const ownerWebId of owners) {
+        result.scanned += 1;
+        try {
+            const credential = await options.keys.read(ownerWebId);
+            if (!credential) {
+                result.skipped += 1;
+                continue;
+            }
+            await options.taskCredentials.grant({
+                ownerWebId,
+                issuer: options.issuer,
+                clientId: credential.clientId,
+                clientSecret: credential.clientSecret,
+                status: 'active',
+            });
+            result.migrated += 1;
+        }
+        catch (error) {
+            // The row stays readable; nothing is deleted here, so a failure is never a data loss.
+            logger.warn(`Legacy Pod interface key for ${ownerWebId} was not migrated: ${String(error)}`);
+            result.failed += 1;
+        }
+    }
+    if (result.scanned > 0) {
+        logger.info(`Legacy Pod interface keys: ${result.migrated} migrated, ${result.skipped} skipped, `
+            + `${result.failed} failed of ${result.scanned}`);
+    }
+    return result;
+}
+//# sourceMappingURL=PodInterfaceKeyMigration.js.map

package/dist/api/tasks/TaskAuthBinding.d.ts

@@ -1,4 +1,5 @@
 import type { StoreContext } from '../chatkit/store';
+import type { TaskCredentialSource } from '../ai-gateway/pod/OwnerPodAccess';
 export declare const TaskAuthBindingKind: {
     readonly SOLID_CLIENT_CREDENTIALS: "solid-client-credentials";
 };
@@ -49,14 +50,35 @@ export interface TaskAuthBindingRepository<TContext extends StoreContext = Store
 export interface TaskAuthBindingServiceOptions<TContext extends StoreContext = StoreContext> {
     repository: TaskAuthBindingRepository<TContext>;
     buildContext?: (binding: TaskAuthBindingSnapshot, clientSecret: string, context: TContext) => TContext;
+    /**
+     * The task layer's own credentials. A binding that names one of these grants resolves without
+     * reading a secret out of the Pod at all, which is what unattended work should use.
+     */
+    taskCredentials?: Pick<TaskCredentialSource, 'forRef'>;
 }
 export declare class TaskAuthBindingService<TContext extends StoreContext = StoreContext> {
     private readonly repository;
     private readonly buildContext;
+    private readonly taskCredentials?;
     constructor(options: TaskAuthBindingServiceOptions<TContext>);
     createBinding(input: CreateTaskAuthBindingInput, context: TContext): Promise<TaskAuthBindingSnapshot>;
     loadBinding(id: string, context: TContext): Promise<TaskAuthBindingSnapshot>;
+    /**
+     * Restore Pod access for an unattended run.
+     *
+     * A binding id that names a task-layer grant is resolved from there, so the Pod never has to
+     * hold the secret; anything else falls back to the stored credential for the migration period.
+     * Either way the run keeps the owner the binding names, not whoever happened to trigger it.
+     */
     resolveRunContext(bindingId: string, context: TContext): Promise<TContext | undefined>;
+    /**
+     * A task-layer grant whose reference is the binding id, when this deployment has one.
+     *
+     * The owner comes from the context the caller restored, never from the binding id, so a forged
+     * id cannot point somebody else's grant at this run.
+     */
+    private resolveTaskGrant;
+    private ownerFromContext;
     private snapshotFromCredential;
     private solidAuthFromContext;
     private defaultBuildContext;