@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/api/handlers/PodDeletionGrantHandler.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPodDeletionGrantRoutes = registerPodDeletionGrantRoutes;
+function registerPodDeletionGrantRoutes(server, operations, authenticator, authorization) {
+    for (const action of ['claim', 'complete']) {
+        server.post(`/api/pod-deletions/:operationId/${action}`, async (request, response, params) => {
+            const send = (status, body) => {
+                response.statusCode = status;
+                response.setHeader('content-type', 'application/json');
+                response.end(JSON.stringify(body));
+            };
+            if (!authenticator.canAuthenticate(request)) {
+                send(401, { error: 'POD_DELETE_NODE_AUTH_REQUIRED' });
+                return;
+            }
+            const auth = await authenticator.authenticate(request);
+            if (!auth.success || auth.context?.type !== 'node' || !auth.context.nodeId) {
+                send(401, { error: 'POD_DELETE_NODE_AUTH_REQUIRED' });
+                return;
+            }
+            let body;
+            try {
+                let data = '';
+                for await (const chunk of request) {
+                    data += chunk.toString();
+                    if (data.length > 4096) {
+                        throw new Error('Request too large');
+                    }
+                }
+                body = JSON.parse(data);
+            }
+            catch {
+                send(400, { error: 'POD_DELETE_INVALID_COMMAND' });
+                return;
+            }
+            if (typeof body.grant !== 'string' || typeof body.storageUrl !== 'string') {
+                send(400, { error: 'POD_DELETE_INVALID_COMMAND' });
+                return;
+            }
+            const original = await operations.get(params.operationId);
+            if (!original || original.storageUrl !== body.storageUrl || original.nodeId !== auth.context.nodeId) {
+                send(403, { error: 'POD_DELETE_INVALID_GRANT' });
+                return;
+            }
+            if (action === 'claim') {
+                const operation = await operations.claim(params.operationId, auth.context.nodeId, body.grant);
+                if (!operation) {
+                    send(403, { error: 'POD_DELETE_INVALID_GRANT' });
+                    return;
+                }
+                send(200, { operation });
+            }
+            else {
+                const accepted = await operations.acknowledge(params.operationId, auth.context.nodeId, body.grant, body.storageUrl);
+                send(accepted ? 200 : 403, accepted ? { success: true } : { error: 'POD_DELETE_INVALID_GRANT' });
+            }
+        }, { public: true });
+    }
+    if (authorization) {
+        for (const action of ['authorize-details', 'authorize']) {
+            const register = action === 'authorize-details' ? server.get.bind(server) : server.post.bind(server);
+            register(`/api/pod-deletions/:operationId/${action}`, async (request, response, params) => {
+                const send = (status, body) => {
+                    response.statusCode = status;
+                    response.setHeader('content-type', 'application/json');
+                    response.end(JSON.stringify(body));
+                };
+                if (!authenticator.canAuthenticate(request)) {
+                    send(401, { error: 'POD_DELETE_NODE_AUTH_REQUIRED' });
+                    return;
+                }
+                const auth = await authenticator.authenticate(request);
+                const nodeId = auth.success && auth.context?.type === 'node' ? auth.context.nodeId : undefined;
+                if (!nodeId) {
+                    send(401, { error: 'POD_DELETE_NODE_AUTH_REQUIRED' });
+                    return;
+                }
+                const challenge = request.headers['x-xpod-pod-authorization'];
+                if (typeof challenge !== 'string' || challenge.split('.')[0] !== params.operationId) {
+                    send(403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                    return;
+                }
+                const details = await operations.authorizationDetails(challenge, nodeId);
+                if (!details) {
+                    send(403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                    return;
+                }
+                const pod = await authorization.pods.findById(details.podId);
+                const node = await authorization.nodes.findSpNodeByStorageUrl(details.storageUrl);
+                if (!pod || pod.accountId !== details.accountId || pod.baseUrl !== details.storageUrl || node?.nodeId !== nodeId) {
+                    send(403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                    return;
+                }
+                if (await operations.find(details.accountId, details.podId) || await operations.remoteGeneration(details.podId, nodeId, details.storageUrl)) {
+                    send(409, { error: 'POD_DELETE_AUTHORIZATION_CONFLICT' });
+                    return;
+                }
+                if (action === 'authorize-details') {
+                    send(200, { authorization: details });
+                    return;
+                }
+                let body;
+                try {
+                    let data = '';
+                    for await (const chunk of request) {
+                        data += chunk.toString();
+                        if (data.length > 8192) {
+                            throw new Error('Body too large');
+                        }
+                    }
+                    body = JSON.parse(data);
+                }
+                catch {
+                    send(400, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                    return;
+                }
+                const owners = [pod.webId, ...(pod.webIds ?? [])].filter(Boolean);
+                if (body.storageUrl !== details.storageUrl || typeof body.remotePodId !== 'string' || !body.remotePodId ||
+                    !Array.isArray(body.ownerWebIds) || !body.ownerWebIds.some((owner) => typeof owner === 'string' && owners.includes(owner))) {
+                    send(403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                    return;
+                }
+                const accepted = await operations.authorizeGeneration(challenge, nodeId, body.remotePodId);
+                send(accepted ? 200 : 409, accepted ? { success: true, returnUrl: details.returnUrl } : { error: 'POD_DELETE_AUTHORIZATION_CONFLICT' });
+            }, { public: true });
+        }
+    }
+}
+//# sourceMappingURL=PodDeletionGrantHandler.js.map

package/dist/api/handlers/PodManagementHandler.d.ts

@@ -3,6 +3,7 @@ import type { PodLookupRepository } from '../../identity/drizzle/PodLookupReposi
 export interface PodManagementHandlerOptions {
     /** Pod 存储根目录 */
     rootDir: string;
+    internalAdminAuthSecret?: string;
     /** 验证 IdP service token */
     verifyServiceToken: (token: string) => Promise<boolean>;
     /** 可选：限制允许的 pod 名称正则 */
@@ -12,6 +13,7 @@ export interface PodManagementHandlerOptions {
         createPod(input: CreatePodRequest): Promise<{
             podUrl: string;
             webId?: string;
+            podId?: string;
         }>;
     };
     /** SP-local Pod lookup used by Cloud consent to scope account WebIDs. */

package/dist/api/handlers/PodManagementHandler.js

@@ -25,6 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerPodManagementRoutes = registerPodManagementRoutes;
 const global_logger_factory_1 = require("global-logger-factory");
+const AdminHandler_1 = require("./AdminHandler");
+const LocalProvisionState_1 = require("../../provision/LocalProvisionState");
 const ProvisionReceiptCodec_1 = require("../../provision/ProvisionReceiptCodec");
 /**
  * Pod Management Handler
@@ -45,6 +47,88 @@ function registerPodManagementRoutes(server, options) {
     const logger = (0, global_logger_factory_1.getLoggerFor)('PodManagementHandler');
     const { rootDir, verifyServiceToken, podNameRegex = /^[a-zA-Z0-9_-]+$/, provisioningService, podLookupRepository, receiptSigningSecret, } = options;
     const storageProviderRoot = normalizeStorageRoot(options.storageProviderBaseUrl);
+    const setupPath = (0, LocalProvisionState_1.resolveLocalSetupPath)(process.env.XPOD_LOCAL_SETUP_PATH, rootDir);
+    const providerId = (0, LocalProvisionState_1.resolveLocalSetupProviderId)(process.env.XPOD_PROVIDER_ID);
+    async function deletionAuthorization(request, response, body) {
+        if (!(0, AdminHandler_1.isAdminMutationAllowed)(request, { internalAdminAuthSecret: options.internalAdminAuthSecret, allowLoopback: !request.headers.authorization && !request.headers['x-xpod-admin-token'] })) {
+            sendJson(response, 403, { error: 'POD_DELETE_OPERATOR_REQUIRED' });
+            return;
+        }
+        const origin = request.headers.origin;
+        let sameOrigin = false;
+        try {
+            const parsed = new URL(typeof origin === 'string' ? origin : '');
+            const canonical = storageProviderRoot && new URL(storageProviderRoot).origin;
+            const localAlias = parsed.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(parsed.hostname) && parsed.host === request.headers.host;
+            sameOrigin = ['http:', 'https:'].includes(parsed.protocol) && parsed.origin === origin && parsed.host === request.headers.host && (parsed.origin === canonical || localAlias);
+        }
+        catch { /* An absent/opaque Origin never grants browser operator authority. */ }
+        if (!sameOrigin) {
+            sendJson(response, 403, { error: 'POD_DELETE_ORIGIN_REQUIRED' });
+            return;
+        }
+        const { challenge, podName, expectedLocalPodId } = body;
+        if (typeof challenge !== 'string' || !/^[a-f0-9-]{36}\.[a-zA-Z0-9_-]{43}$/u.test(challenge) || typeof podName !== 'string' || !validatePodName(podName) || !storageProviderRoot) {
+            sendJson(response, 403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+            return;
+        }
+        const state = (0, LocalProvisionState_1.readLocalProvisionState)(setupPath, providerId);
+        if (!state?.nodeId || !state.nodeToken || !state.cloudApiUrl) {
+            sendJson(response, 403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+            return;
+        }
+        const storageUrl = new URL(`${podName}/`, storageProviderRoot).href;
+        const callback = async (action, payload) => {
+            const callbackRoot = new URL(state.cloudApiUrl);
+            if (!['http:', 'https:'].includes(callbackRoot.protocol) || callbackRoot.username || callbackRoot.password || callbackRoot.search || callbackRoot.hash) {
+                throw new Error('Invalid registered callback');
+            }
+            const result = await fetch(new URL(`api/pod-deletions/${challenge.split('.')[0]}/${action}`, callbackRoot.href.replace(/\/?$/u, '/')), {
+                method: payload ? 'POST' : 'GET', redirect: 'error', signal: AbortSignal.timeout(15_000),
+                headers: { authorization: `XpodNode ${state.nodeId}:${state.nodeToken}`, 'x-xpod-pod-authorization': challenge, ...(payload ? { 'content-type': 'application/json' } : {}) },
+                ...(payload ? { body: JSON.stringify(payload) } : {}),
+            });
+            return { status: result.status, body: await result.json() };
+        };
+        try {
+            const result = await callback('authorize-details');
+            if (result.status !== 200) {
+                sendAuthorizationFailure(response, result.status);
+                return;
+            }
+            const details = result.body.authorization;
+            if (!details || details.storageUrl !== storageUrl || details.nodeId !== state.nodeId || details.challengeId !== challenge.split('.')[0]) {
+                sendJson(response, 403, { error: 'POD_DELETE_AUTHORIZATION_INVALID' });
+                return;
+            }
+            const pod = await podLookupRepository?.findByResourceIdentifier?.(storageUrl);
+            if (!pod || pod.baseUrl !== storageUrl || !pod.podId) {
+                sendJson(response, 404, { error: 'POD_DELETE_NOT_FOUND' });
+                return;
+            }
+            const ownerWebIds = [...new Set([pod.webId, ...(pod.webIds ?? [])].filter((value) => Boolean(value)))];
+            if (body.action === 'inspectDeletionAuthorization') {
+                sendJson(response, 200, { deletionAuthorization: { challenge, podName, expiresAt: details.expiresAt,
+                        cloudAccountId: details.accountId, cloudPodId: details.podId, nodeId: details.nodeId, storageUrl,
+                        currentLocalPodId: pod.podId, ownerWebIds, returnUrl: details.returnUrl } });
+                return;
+            }
+            if (expectedLocalPodId !== pod.podId) {
+                sendJson(response, 409, { error: 'POD_DELETE_GENERATION_CHANGED' });
+                return;
+            }
+            const accepted = await callback('authorize', { storageUrl, remotePodId: pod.podId, ownerWebIds });
+            if (accepted.status !== 200) {
+                sendAuthorizationFailure(response, accepted.status);
+                return;
+            }
+            sendJson(response, 200, { success: true, returnUrl: details.returnUrl });
+        }
+        catch (error) {
+            logger.warn('Pod deletion authorization callback failed');
+            sendJson(response, 502, { error: 'POD_DELETE_NODE_UNAVAILABLE' });
+        }
+    }
     /**
      * 验证 service token
      */
@@ -82,18 +166,34 @@ function registerPodManagementRoutes(server, options) {
      *   409: { error: "Pod already exists" }
      */
     server.post('/provision/pods', async (request, response) => {
-        // 1. 认证
-        if (!await authenticate(request)) {
-            sendJson(response, 401, { error: 'Unauthorized', message: 'Invalid or missing service token' });
+        const serviceAuthorized = Boolean(await authenticate(request));
+        if (!serviceAuthorized && !(0, AdminHandler_1.isAdminMutationAllowed)(request, { internalAdminAuthSecret: options.internalAdminAuthSecret, allowLoopback: !request.headers.authorization && !request.headers['x-xpod-admin-token'] })) {
+            sendJson(response, 401, { error: 'Unauthorized' });
             return;
         }
-        // 2. 解析请求体
         let body;
         try {
             body = await readJsonBody(request);
         }
         catch (error) {
-            sendJson(response, 400, { error: 'Bad Request', message: 'Invalid JSON body' });
+            if (error instanceof Error && error.message === 'Request body too large') {
+                sendJson(response, 413, { error: 'Request body too large' });
+                return;
+            }
+            sendJson(response, serviceAuthorized ? 400 : 401, { error: 'Invalid request' });
+            return;
+        }
+        if (!body || typeof body !== 'object' || Array.isArray(body)) {
+            sendJson(response, 400, { error: 'Invalid request' });
+            return;
+        }
+        const action = body.action;
+        if (action === 'inspectDeletionAuthorization' || action === 'authorizeDeletion') {
+            await deletionAuthorization(request, response, body);
+            return;
+        }
+        if (!serviceAuthorized) {
+            sendJson(response, 401, { error: 'Unauthorized', message: 'Invalid or missing service token' });
             return;
         }
         const { podName, initialResources } = body;
@@ -117,6 +217,7 @@ function registerPodManagementRoutes(server, options) {
                         success: true,
                         podUrl: existing.storageUrl,
                         webId: existing.webId,
+                        // A network access token may retry provisioning but cannot acquire deletion authority over an existing Pod.
                         provisionReceipt: createReceipt({ secret: receiptSigningSecret, podName, podUrl: existing.storageUrl, webId: existing.webId }),
                         message: `Pod ${podName} already exists for this WebID`,
                     });
@@ -148,7 +249,7 @@ function registerPodManagementRoutes(server, options) {
                 podUrl,
                 ...(webId ? {
                     webId,
-                    provisionReceipt: createReceipt({ secret: receiptSigningSecret, podName, podUrl, webId }),
+                    provisionReceipt: createReceipt({ secret: receiptSigningSecret, podName, podUrl, webId, podId: result?.podId }),
                 } : {}),
                 message: `Pod ${podName} created successfully`
             });
@@ -236,7 +337,8 @@ function registerPodManagementRoutes(server, options) {
         }
     }, { public: true });
     async function findExistingProvisionedPod(body, podName) {
-        if (!podLookupRepository || !storageProviderRoot) {
+        if (!podLookupRepository || !storageProviderRoot || typeof body.webId !== 'string' ||
+            !body.webId || body.webId !== body.webId.trim() || /[\r\n\t]/u.test(body.webId)) {
             return undefined;
         }
         try {
@@ -250,70 +352,20 @@ function registerPodManagementRoutes(server, options) {
                         storageUrlBelongsToRoot(storageUrl, storageProviderRoot) &&
                         Boolean(resolveMatchedWebId(pod.webId, pod.webIds, [requestedWebId]));
                 });
-                return match ? { storageUrl: expectedPodUrl, webId: requestedWebId } : undefined;
+                return match ? { storageUrl: expectedPodUrl, webId: requestedWebId, podId: match.podId } : undefined;
             }
-            const pod = await podLookupRepository.findByResourceIdentifier?.(expectedPodUrl);
-            const storageUrl = canonicalizeStorageProviderUrl(pod?.storageUrl ?? pod?.baseUrl, storageProviderRoot);
-            const webId = getFirstWebId(pod);
-            return storageUrl === expectedPodUrl && webId ? { storageUrl: expectedPodUrl, webId } : undefined;
+            return undefined;
         }
         catch (error) {
             logger.warn(`Failed to verify existing pod ownership for ${podName}: ${error.message}`);
             return undefined;
         }
     }
-    /**
-     * DELETE /provision/pods/:podName
-     *
-     * 删除 Pod 目录
-     *
-     * Request:
-     *   Authorization: Bearer {service_token}
-     *
-     * Response:
-     *   200: { success: true }
-     *   401: { error: "Unauthorized" }
-     *   404: { error: "Pod not found" }
-     */
-    server.delete('/provision/pods/:podName', async (request, response, params) => {
-        // 1. 认证
-        if (!await authenticate(request)) {
-            sendJson(response, 401, { error: 'Unauthorized', message: 'Invalid or missing service token' });
-            return;
-        }
-        const podName = decodeURIComponent(params.podName);
-        // 2. 验证 pod 名称
-        if (!validatePodName(podName)) {
-            sendJson(response, 400, { error: 'Bad Request', message: `Invalid pod name: ${podName}` });
-            return;
-        }
-        // 3. 检查是否存在
-        const podPath = `${rootDir}/${podName}`;
-        try {
-            const exists = await fileExists(podPath);
-            if (!exists) {
-                sendJson(response, 404, { error: 'Not Found', message: `Pod ${podName} not found` });
-                return;
-            }
-        }
-        catch (error) {
-            logger.error(`Error checking pod existence: ${error.message}`);
-            sendJson(response, 500, { error: 'Internal Server Error', message: 'Failed to check pod existence' });
-            return;
-        }
-        // 4. 删除 Pod 目录
-        try {
-            await deletePodDirectory(podPath);
-            logger.info(`Deleted pod: ${podName}`);
-            sendJson(response, 200, {
-                success: true,
-                message: `Pod ${podName} deleted successfully`
-            });
-        }
-        catch (error) {
-            logger.error(`Failed to delete pod: ${error.message}`);
-            sendJson(response, 500, { error: 'Internal Server Error', message: 'Failed to delete pod' });
-        }
+    // Pod deletion runs in CSS with its actual data accessor, indexes and AccountStorage.
+    // Direct API callers fail closed instead of removing only a filesystem directory.
+    server.delete('/provision/pods/:podName', async (_request, response) => {
+        response.setHeader('Allow', 'GET');
+        sendJson(response, 405, { error: 'POD_DELETE_USE_GATEWAY', message: 'Pod deletion must use the Gateway lifecycle endpoint' });
     }, { public: true });
     /**
      * GET /provision/pods/:podName
@@ -359,19 +411,40 @@ function createReceipt(input) {
         podName: input.podName,
         webId: input.webId,
         podUrl: input.podUrl,
+        podId: input.podId,
     });
 }
+function sendAuthorizationFailure(response, status) {
+    if (status >= 500) {
+        sendJson(response, 502, { error: 'POD_DELETE_NODE_UNAVAILABLE' });
+        return;
+    }
+    sendJson(response, status === 409 ? 409 : 403, { error: status === 409 ? 'POD_DELETE_AUTHORIZATION_CONFLICT' : 'POD_DELETE_AUTHORIZATION_INVALID' });
+}
 /**
  * 读取 JSON 请求体
  */
 async function readJsonBody(request) {
     return new Promise((resolve, reject) => {
         let data = '';
+        let tooLarge = false;
         request.setEncoding('utf8');
         request.on('data', (chunk) => {
+            if (tooLarge) {
+                return;
+            }
+            if (Buffer.byteLength(data) + Buffer.byteLength(chunk) > 1_048_576) {
+                tooLarge = true;
+                data = '';
+                reject(new Error('Request body too large'));
+                return;
+            }
             data += chunk;
         });
         request.on('end', () => {
+            if (tooLarge) {
+                return;
+            }
             if (!data) {
                 resolve({});
                 return;
@@ -512,11 +585,4 @@ async function createPodDirectory(podPath, initialResources) {
         }
     }
 }
-/**
- * 删除 Pod 目录
- */
-async function deletePodDirectory(podPath) {
-    const { rm } = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
-    await rm(podPath, { recursive: true, force: true });
-}
 //# sourceMappingURL=PodManagementHandler.js.map

package/dist/api/handlers/ProvisionHandler.d.ts

@@ -58,6 +58,8 @@ export interface ProvisionStatusOptions {
     serviceToken?: string;
     /** 当前 SP canonical public URL */
     publicUrl?: string;
+    /** Internal provenance: a transport fallback is not an allocated/canonical node address. */
+    publicUrlIsFallback?: boolean;
     /** SP 子域名 */
     spDomain?: string;
     /** 本地端口，供 Cloud 管理 tunnel 元数据 */

package/dist/api/handlers/ProvisionHandler.js

@@ -21,6 +21,7 @@ exports.registerProvisionStatusRoute = registerProvisionStatusRoute;
 exports.createLocalSetupProvisionStateWriter = createLocalSetupProvisionStateWriter;
 const node_crypto_1 = require("node:crypto");
 const global_logger_factory_1 = require("global-logger-factory");
+const ServiceInfoHandler_1 = require("./ServiceInfoHandler");
 const TunnelProviderCatalog_1 = require("../../tunnel/TunnelProviderCatalog");
 const ProvisionCodeCodec_1 = require("../../provision/ProvisionCodeCodec");
 const ServiceAccessTokenCodec_1 = require("../../provision/ServiceAccessTokenCodec");
@@ -468,12 +469,19 @@ function registerProvisionStatusRoute(server, options) {
         nodeToken: options.nodeToken,
         serviceToken: options.serviceToken,
         publicUrl: normalizeUrl(options.publicUrl),
+        publicUrlIsFallback: options.publicUrlIsFallback ?? false,
         spDomain: options.spDomain,
         tunnelToken: undefined,
         tunnelProvider: undefined,
         tunnelEndpoint: undefined,
     };
     let refreshPromise;
+    (0, ServiceInfoHandler_1.registerServiceInfoRoute)(server, () => ({
+        edition: 'local',
+        managed: Boolean(options.cloudUrl),
+        publicUrl: state.publicUrlIsFallback ? undefined : state.publicUrl,
+        oidcIssuer: options.cloudBaseUrl ?? options.cloudUrl,
+    }));
     server.get('/provision/status', async (_request, response) => {
         const registered = Boolean(options.nodeId && options.nodeToken && options.cloudUrl);
         const body = {
@@ -687,7 +695,11 @@ async function refreshProvisionStatus(options) {
     state.nodeToken = payload.nodeToken;
     state.serviceToken = payload.serviceToken;
     state.provisionCode = payload.provisionCode;
-    state.publicUrl = normalizeUrl(payload.publicUrl) ?? state.publicUrl;
+    const assignedPublicUrl = normalizeUrl(payload.publicUrl);
+    if (assignedPublicUrl) {
+        state.publicUrl = assignedPublicUrl;
+        state.publicUrlIsFallback = false;
+    }
     state.spDomain = typeof payload.spDomain === 'string' ? payload.spDomain : state.spDomain;
     state.tunnelToken = typeof payload.tunnelToken === 'string' ? payload.tunnelToken : state.tunnelToken;
     state.tunnelProvider = typeof payload.tunnelProvider === 'string' ? payload.tunnelProvider : state.tunnelProvider;

package/dist/api/handlers/ReachabilityHandler.js

@@ -64,6 +64,7 @@ function registerReachabilityRoutes(server, options) {
                     ...(access.kind === 'solid' ? { owner: { type: 'solid', webId: access.webId } } : {}),
                     capabilities: Array.isArray(body.capabilities) ? body.capabilities.filter((entry) => typeof entry === 'string') : [],
                     candidates: enrichP2PCandidatesWithObservedAddress(Array.isArray(body.candidates) ? body.candidates : [], resolveObservedAddress(request)),
+                    ...(typeof body.dataPlaneSecret === 'string' ? { dataPlaneSecret: body.dataPlaneSecret } : {}),
                 });
                 sendJson(response, 201, session);
             }
@@ -76,6 +77,10 @@ function registerReachabilityRoutes(server, options) {
                     sendJson(response, 429, { error: 'P2P active session limit exceeded' });
                     return;
                 }
+                if (error instanceof ReachabilitySessionService_1.InvalidP2PSessionRequestError) {
+                    sendJson(response, 400, { error: error.message });
+                    return;
+                }
                 if (error instanceof ReachabilitySessionService_1.P2PCandidateUpdateLimitExceededError) {
                     sendJson(response, 429, { error: 'P2P candidate update limit exceeded' });
                     return;

package/dist/api/handlers/RunHandler.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerRunRoutes = registerRunRoutes;
 const global_logger_factory_1 = require("global-logger-factory");
 const AuthContext_1 = require("../auth/AuthContext");
-const types_1 = require("../chatkit/types");
+const RunCancellation_1 = require("../runs/RunCancellation");
 const schema_1 = require("../runs/schema");
 const store_1 = require("../runs/store");
-const types_2 = require("../workspace/types");
+const types_1 = require("../workspace/types");
 function registerRunRoutes(server, options) {
     const logger = (0, global_logger_factory_1.getLoggerFor)('RunHandler');
     const { runStore } = options;
@@ -52,30 +52,10 @@ function registerRunRoutes(server, options) {
     server.post('/v1/runs/:runId/cancel', async (request, response, params) => {
         try {
             const context = buildStoreContext(request);
-            const run = await runStore.loadRun(decodeURIComponent(params.runId), context);
-            const now = (0, types_1.nowTimestamp)();
-            run.cancelRequestedAt = run.cancelRequestedAt ?? now;
-            run.updatedAt = now;
-            if (run.status === schema_1.RunStatus.QUEUED) {
-                run.status = schema_1.RunStatus.CANCELLED;
-                run.completedAt = now;
-                run.leaseOwner = undefined;
-                run.leaseExpiresAt = undefined;
-            }
-            await runStore.saveRun(run, context);
-            await runStore.appendRunStep({
-                id: (0, store_1.generateRunStepResourceId)({
-                    key: (0, types_1.generateId)('run-step'),
-                    runId: run.id,
-                    createdAt: now,
-                }),
-                runId: run.id,
-                run: resolveRunResource(run, context),
-                type: schema_1.RunStepType.CANCEL_REQUESTED,
-                message: 'Run cancellation requested',
-                data: { status: run.status },
-                createdAt: now,
-            }, context);
+            const run = await (0, RunCancellation_1.cancelRun)({
+                store: runStore, runId: decodeURIComponent(params.runId), context,
+                resourceIri: value => resolveRunResource(value, context),
+            });
             sendJson(response, 200, { run: projectRunForApi(run) });
         }
         catch (error) {
@@ -98,7 +78,7 @@ function projectRunStepForApi(step) {
 }
 function parseRunListRequest(url) {
     const workspace = url.searchParams.get('workspace') ?? undefined;
-    if (workspace && !(0, types_2.isWorkspaceRef)(workspace)) {
+    if (workspace && !(0, types_1.isWorkspaceRef)(workspace)) {
         throw new Error('workspace must be an http(s):// or file:// workspace reference');
     }
     return {

package/dist/api/handlers/ServiceInfoHandler.d.ts

@@ -0,0 +1,10 @@
+import type { ApiServer } from '../ApiServer';
+interface ServiceInfo {
+    edition: 'cloud' | 'local';
+    managed: boolean;
+    publicUrl?: string;
+    oidcIssuer?: string;
+}
+/** Read from the deployment owner on each request; never duplicate provisioning state. */
+export declare function registerServiceInfoRoute(server: ApiServer, read: () => ServiceInfo): void;
+export {};

package/dist/api/handlers/ServiceInfoHandler.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerServiceInfoRoute = registerServiceInfoRoute;
+function displayUrl(value) {
+    if (!value)
+        return undefined;
+    try {
+        const url = new URL(value);
+        if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash)
+            return undefined;
+        return url.href;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Read from the deployment owner on each request; never duplicate provisioning state. */
+function registerServiceInfoRoute(server, read) {
+    server.get('/api/service-info', async (_req, res) => {
+        const info = read();
+        res.statusCode = 200;
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Cache-Control', 'no-store');
+        res.end(JSON.stringify({
+            edition: info.edition,
+            managed: info.managed,
+            publicUrl: displayUrl(info.publicUrl) ?? null,
+            ...(info.managed ? { oidcIssuer: displayUrl(info.oidcIssuer) } : {}),
+        }));
+    }, { public: true });
+}
+//# sourceMappingURL=ServiceInfoHandler.js.map

package/dist/api/handlers/SettingsHandler.js

@@ -7,6 +7,11 @@ function registerSettingsRoutes(server, options) {
         ['/settings', 'Settings'],
         ['/ai-connections', 'AI Connections'],
         ['/ai-config', 'AI Config'],
+        ['/tasks', 'Tasks'],
+        ['/pod', 'Pod'],
+        ['/device', 'This device'],
+        ['/inbox', 'Inbox'],
+        ['/notifications', 'Notifications'],
     ]) {
         (0, StaticSpaHandler_1.registerStaticSpaRoutes)(server, {
             prefix,