@undefineds.co/xpod 0.4.18 → 0.4.20

package/dist/api/handlers/MatrixHandler.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerMatrixRoutes = registerMatrixRoutes;
-const AuthContext_1 = require("../auth/AuthContext");
+const readBoundedRequestBody_1 = require("./readBoundedRequestBody");
+const MatrixPodResolver_1 = require("../matrix/MatrixPodResolver");
+const MatrixError_1 = require("../matrix/MatrixError");
 /**
  * Register the Matrix Client-Server compatibility adapter.
  *
@@ -18,36 +20,22 @@ function registerMatrixRoutes(server, options) {
     server.get('/.well-known/matrix/client', async (request, response) => {
         sendJson(response, 200, {
             'm.homeserver': {
-                base_url: requestBaseUrl(request),
+                base_url: options.baseUrl?.replace(/\/$/, '') ?? requestBaseUrl(request),
             },
         });
     }, { public: true });
     server.get('/_matrix/client/versions', async (_request, response) => {
         sendJson(response, 200, {
-            versions: [
-                'r0.6.1',
-                'v1.1',
-                'v1.2',
-                'v1.3',
-                'v1.4',
-                'v1.5',
-                'v1.6',
-                'v1.7',
-                'v1.8',
-                'v1.9',
-                'v1.10',
-                'v1.11',
-            ],
+            versions: ['v1.11'],
             unstable_features: {
                 'co.undefineds.matrix.pod_storage': true,
+                'co.undefineds.matrix.solid_auth_subset': true,
             },
         });
     }, { public: true });
     server.get('/_matrix/client/v3/login', async (_request, response) => {
         sendJson(response, 200, {
-            flows: [
-                { type: 'm.login.token' },
-            ],
+            flows: [],
         });
     }, { public: true });
     server.post('/_matrix/client/v3/login', async (_request, response) => {
@@ -55,219 +43,238 @@ function registerMatrixRoutes(server, options) {
     }, { public: true });
     server.get('/_matrix/client/v3/account/whoami', async (request, response) => {
         try {
-            const account = await store.getAccount(buildContext(request));
+            const context = await buildContext(request, options);
+            const account = await store.getAccount(context);
             sendJson(response, 200, {
                 user_id: account.userId,
                 ...(account.deviceId ? { device_id: account.deviceId } : {}),
                 is_guest: false,
+                'co.undefineds.pod_url': context.podUrl,
+                'co.undefineds.webid': context.webId,
             });
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_UNKNOWN', formatError(error));
+            sendError(response, error);
         }
     });
     server.post('/_matrix/client/v3/createRoom', async (request, response) => {
         try {
             const body = await readJson(request);
-            const room = await store.createRoom(body ?? {}, buildContext(request));
+            validateCreateRoom(body ?? {});
+            const room = await store.createRoom(body ?? {}, await buildContext(request, options));
             sendJson(response, 200, { room_id: room.roomId });
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_BAD_JSON', formatError(error));
+            sendError(response, error);
         }
     });
     server.put('/_matrix/client/v3/rooms/:roomId/send/:eventType/:txnId', async (request, response, params) => {
         try {
             const content = await readJson(request);
-            const event = await store.sendEvent(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), decodeURIComponent(params.txnId), content ?? {}, buildContext(request));
+            const event = await store.sendEvent(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), decodeURIComponent(params.txnId), content ?? {}, await buildContext(request, options));
             sendJson(response, 200, { event_id: event.eventId });
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_BAD_JSON', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/joined_rooms', async (request, response) => {
         try {
-            const joinedRooms = await store.listJoinedRooms(buildContext(request));
+            const joinedRooms = await store.listJoinedRooms(await buildContext(request, options));
             sendJson(response, 200, { joined_rooms: joinedRooms });
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_UNKNOWN', formatError(error));
+            sendError(response, error);
         }
     });
     server.post('/_matrix/client/v3/join/:roomIdOrAlias', async (request, response, params) => {
         try {
-            const result = await store.joinRoom(decodeURIComponent(params.roomIdOrAlias), buildContext(request));
+            const result = await store.joinRoom(decodeURIComponent(params.roomIdOrAlias), await buildContext(request, options));
             sendJson(response, 200, { room_id: result.roomId });
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.post('/_matrix/client/v3/rooms/:roomId/join', async (request, response, params) => {
         try {
-            const result = await store.joinRoom(decodeURIComponent(params.roomId), buildContext(request));
+            const result = await store.joinRoom(decodeURIComponent(params.roomId), await buildContext(request, options));
             sendJson(response, 200, { room_id: result.roomId });
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.post('/_matrix/client/v3/rooms/:roomId/invite', async (request, response, params) => {
         try {
             const body = await readJson(request);
             if (!body || typeof body.user_id !== 'string' || body.user_id.length === 0) {
-                throw new Error('Invite requires user_id');
+                throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Invite requires user_id');
             }
-            await store.inviteUser(decodeURIComponent(params.roomId), body.user_id, buildContext(request));
+            await store.inviteUser(decodeURIComponent(params.roomId), body.user_id, await buildContext(request, options));
             sendJson(response, 200, {});
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_BAD_JSON', formatError(error));
+            sendError(response, error);
         }
     });
     server.post('/_matrix/client/v3/rooms/:roomId/leave', async (request, response, params) => {
         try {
-            await store.leaveRoom(decodeURIComponent(params.roomId), buildContext(request));
+            await store.leaveRoom(decodeURIComponent(params.roomId), await buildContext(request, options));
             sendJson(response, 200, {});
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/sync', async (request, response) => {
         try {
-            const url = new URL(request.url ?? '', `http://${request.headers.host ?? 'localhost'}`);
-            const sync = await store.sync(buildContext(request), {
-                since: url.searchParams.get('since') ?? undefined,
-                limit: parseOptionalNumber(url.searchParams.get('limit')),
-            });
-            sendJson(response, 200, sync);
+            const url = new URL(request.url ?? '', 'http://localhost');
+            const abort = new AbortController();
+            const onDisconnect = () => abort.abort();
+            request.once('aborted', onDisconnect);
+            response.once?.('close', onDisconnect);
+            let sync;
+            try {
+                sync = await store.sync(await buildContext(request, options), {
+                    since: url.searchParams.get('since') ?? undefined,
+                    limit: parseOptionalNumber(url.searchParams.get('limit'), 'limit', 1, 1000),
+                    timeout: parseOptionalNumber(url.searchParams.get('timeout'), 'timeout', 0, 30000),
+                    signal: abort.signal,
+                });
+            }
+            finally {
+                request.removeListener('aborted', onDisconnect);
+                response.removeListener?.('close', onDisconnect);
+            }
+            if (!abort.signal.aborted) {
+                sendJson(response, 200, sync);
+            }
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_UNKNOWN', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/rooms/:roomId/messages', async (request, response, params) => {
         try {
-            const url = new URL(request.url ?? '', `http://${request.headers.host ?? 'localhost'}`);
-            const messages = await store.listMessages(decodeURIComponent(params.roomId), buildContext(request), {
+            const url = new URL(request.url ?? '', 'http://localhost');
+            const messages = await store.listMessages(decodeURIComponent(params.roomId), await buildContext(request, options), {
                 from: url.searchParams.get('from') ?? undefined,
-                dir: url.searchParams.get('dir') === 'f' ? 'f' : 'b',
-                limit: parseOptionalNumber(url.searchParams.get('limit')),
+                dir: parseDirection(url.searchParams.get('dir')),
+                limit: parseOptionalNumber(url.searchParams.get('limit'), 'limit', 1, 1000),
             });
             sendJson(response, 200, messages);
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/rooms/:roomId/members', async (request, response, params) => {
         try {
-            const members = await store.getMembers(decodeURIComponent(params.roomId), buildContext(request));
+            const members = await store.getMembers(decodeURIComponent(params.roomId), await buildContext(request, options));
             sendJson(response, 200, { chunk: members });
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/rooms/:roomId/event/:eventId', async (request, response, params) => {
         try {
-            const event = await store.getEvent(decodeURIComponent(params.roomId), decodeURIComponent(params.eventId), buildContext(request));
+            const event = await store.getEvent(decodeURIComponent(params.roomId), decodeURIComponent(params.eventId), await buildContext(request, options));
             sendJson(response, 200, event);
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     });
     server.get('/_matrix/client/v3/rooms/:roomId/state/:eventType', async (request, response, params) => {
         await sendState(request, response, params, '');
     });
     server.get('/_matrix/client/v3/rooms/:roomId/state/:eventType/:stateKey', async (request, response, params) => {
-        await sendState(request, response, params, decodeURIComponent(params.stateKey ?? ''));
+        await sendState(request, response, params, params.stateKey ?? '');
     });
     server.put('/_matrix/client/v3/rooms/:roomId/state/:eventType', async (request, response, params) => {
         await putState(request, response, params, '');
     });
     server.put('/_matrix/client/v3/rooms/:roomId/state/:eventType/:stateKey', async (request, response, params) => {
-        await putState(request, response, params, decodeURIComponent(params.stateKey ?? ''));
+        await putState(request, response, params, params.stateKey ?? '');
     });
     async function sendState(request, response, params, stateKey) {
         try {
-            const state = await store.getState(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), stateKey, buildContext(request));
+            const state = await store.getState(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), decodeURIComponent(stateKey), await buildContext(request, options));
             sendJson(response, 200, state);
         }
         catch (error) {
-            sendMatrixError(response, 404, 'M_NOT_FOUND', formatError(error));
+            sendError(response, error);
         }
     }
     async function putState(request, response, params, stateKey) {
         try {
             const content = await readJson(request);
-            const event = await store.setState(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), stateKey, content ?? {}, buildContext(request));
+            const event = await store.setState(decodeURIComponent(params.roomId), decodeURIComponent(params.eventType), decodeURIComponent(stateKey), content ?? {}, await buildContext(request, options));
             sendJson(response, 200, { event_id: event.eventId });
         }
         catch (error) {
-            sendMatrixError(response, 400, 'M_BAD_JSON', formatError(error));
+            sendError(response, error);
         }
     }
 }
-function buildContext(request) {
-    const auth = request.auth;
-    const webId = auth ? (0, AuthContext_1.getWebId)(auth) : undefined;
-    if (!webId) {
-        throw new Error('Matrix API requires Solid WebID authentication');
+async function buildContext(request, options) {
+    if (!options.resolvePodUrl) {
+        throw new MatrixError_1.MatrixError(503, 'M_UNAVAILABLE', 'Matrix Pod lookup is unavailable');
     }
-    return {
-        webId,
-        podUrl: deriveRequestPodUrl(request, webId),
-        auth,
-    };
+    return (0, MatrixPodResolver_1.resolveMatrixContext)(request, options.resolvePodUrl);
 }
+const MAX_BODY_BYTES = 1024 * 1024;
 async function readJson(request) {
-    const chunks = [];
-    for await (const chunk of request) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    }
+    const chunks = await (0, readBoundedRequestBody_1.readBoundedRequestBody)(request, MAX_BODY_BYTES, 'Request body exceeds 1 MiB');
     const raw = Buffer.concat(chunks).toString('utf8').trim();
-    if (!raw) {
+    if (!raw)
         return undefined;
+    const value = JSON.parse(raw);
+    if (!isObject(value))
+        throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Request body must be an object');
+    return value;
+}
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateCreateRoom(input) {
+    const invalid = () => { throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Invalid createRoom fields'); };
+    for (const value of [input.name, input.topic, input.room_alias_name, input.preset]) {
+        if (value !== undefined && typeof value !== 'string')
+            invalid();
     }
-    return JSON.parse(raw);
+    if (input.visibility !== undefined && !['private', 'public'].includes(input.visibility))
+        invalid();
+    if (input.invite !== undefined && (!Array.isArray(input.invite) || input.invite.some(id => typeof id !== 'string' || !id)))
+        invalid();
+    if (input.creation_content !== undefined && !isObject(input.creation_content))
+        invalid();
+    if (input.initial_state !== undefined && (!Array.isArray(input.initial_state) || input.initial_state.some(state => !isObject(state) || typeof state.type !== 'string' || !state.type ||
+        (state.state_key !== undefined && typeof state.state_key !== 'string') ||
+        (state.content !== undefined && !isObject(state.content)))))
+        invalid();
 }
-function parseOptionalNumber(value) {
-    if (!value) {
+function parseOptionalNumber(value, name, min, max) {
+    if (value === null)
         return undefined;
+    const parsed = Number(value);
+    if (!/^\d+$/.test(value) || !Number.isSafeInteger(parsed) || parsed < min || parsed > max) {
+        throw new MatrixError_1.MatrixError(400, 'M_INVALID_PARAM', `${name} must be an integer between ${min} and ${max}`);
     }
-    const parsed = Number.parseInt(value, 10);
-    return Number.isFinite(parsed) ? parsed : undefined;
+    return parsed;
 }
-function requestBaseUrl(request) {
-    const forwardedProto = headerValue(request.headers['x-forwarded-proto']);
-    const forwardedHost = headerValue(request.headers['x-forwarded-host']);
-    const proto = forwardedProto?.split(',')[0]?.trim() || 'http';
-    const host = forwardedHost?.split(',')[0]?.trim() || request.headers.host || 'localhost';
-    return `${proto}://${host}`;
+function parseDirection(value) {
+    if (value === null || value === 'b')
+        return 'b';
+    if (value === 'f')
+        return 'f';
+    throw new MatrixError_1.MatrixError(400, 'M_INVALID_PARAM', 'dir must be b or f');
 }
-function deriveRequestPodUrl(request, webId) {
-    try {
-        const baseUrl = `${requestBaseUrl(request).replace(/\/$/, '')}/`;
-        const webIdUrl = new URL(webId);
-        const normalizedPath = webIdUrl.pathname.replace(/\/+$/, '');
-        let podPath = '';
-        if (normalizedPath.endsWith('/profile/card')) {
-            podPath = normalizedPath.slice(0, -'/profile/card'.length);
-        }
-        else {
-            const firstSegment = normalizedPath.split('/').filter(Boolean)[0];
-            podPath = firstSegment ? `/${firstSegment}` : '';
-        }
-        const relativePodPath = podPath.replace(/^\/+/, '');
-        return new URL(relativePodPath ? `${relativePodPath}/` : './', baseUrl).toString();
-    }
-    catch {
-        return undefined;
-    }
+function requestBaseUrl(request) {
+    // Forwarded headers are not authoritative without a configured trusted proxy.
+    return `http://${request.headers.host ?? 'localhost'}`;
 }
 function headerValue(value) {
     return Array.isArray(value) ? value[0] : value;
@@ -280,7 +287,15 @@ function sendJson(response, status, data) {
 function sendMatrixError(response, status, errcode, error) {
     sendJson(response, status, { errcode, error });
 }
-function formatError(error) {
-    return error instanceof Error ? error.message : String(error);
+function sendError(response, error) {
+    if (error instanceof MatrixError_1.MatrixError) {
+        sendMatrixError(response, error.status, error.errcode, error.message);
+    }
+    else if (error instanceof SyntaxError || error instanceof URIError) {
+        sendMatrixError(response, 400, 'M_BAD_JSON', 'Malformed JSON or URL encoding');
+    }
+    else {
+        sendMatrixError(response, 500, 'M_UNKNOWN', 'Internal server error');
+    }
 }
 //# sourceMappingURL=MatrixHandler.js.map

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

@@ -1,7 +1,4 @@
 import { getLoggerFor } from 'global-logger-factory';
-import { type EndpointReachabilityResult } from '../network/EndpointReachabilityProbe';
-import { type TunnelClientInspection } from '../../tunnel/TunnelClientManager';
-import type { TunnelProviderId } from '../../tunnel/TunnelProviderCatalog';
 import type { ApiServer } from '../ApiServer';
 import type { AuthContext } from '../auth/AuthContext';
 import { type TunnelProviderDescriptor } from '../../tunnel/TunnelProviderCatalog';
@@ -112,15 +109,7 @@ export interface NetworkDiagnosticCheckResult {
     label: string;
     status: DiagnosticStatus;
     detail?: string;
-    /**
-     * How long the check itself took — **not** a network latency (audit N12).
-     *
-     * These checks read local state (is an address configured, what does the TLS/DNS/tunnel
-     * capability say); a duration here says nothing about reachability, so it is named after the
-     * check and consumers must not render it as a round-trip time. A real probe would have to add
-     * its own measurement.
-     */
-    checkDurationMs?: number;
+    durationMs?: number;
     checkedAt?: string;
 }
 export interface NetworkDiagnosticCheck {
@@ -161,25 +150,6 @@ export interface NetworkPublicAddressReaderOptions {
 }
 export interface NetworkSettingsHandlerOptions {
     endpoint: string | (() => string | undefined);
-    /**
-     * On-demand reachability probe for the declared public entry (audit N12).
-     *
-     * It runs only when the operator triggers a diagnose pass — never on a timer — and defaults to
-     * the public-address-only probe; tests inject a stub.
-     */
-    endpointReachabilityProbe?: (endpoint: string) => Promise<EndpointReachabilityResult>;
-    /**
-     * Tunnel-client plugin actions for the settings page (audit N16): list where each provider's
-     * client would come from, and install one on request. Injectable for tests.
-     */
-    tunnelClients?: {
-        inspectAll: () => Promise<TunnelClientInspection[]>;
-        install: (provider: TunnelProviderId) => Promise<{
-            installedPath: string;
-            version?: string;
-            sourceUrl: string;
-        }>;
-    };
     localAddresses?: () => string[];
     lanAddresses?: () => string[];
     publicAddresses?: () => string[];

package/dist/api/handlers/NetworkSettingsHandler.js

@@ -12,8 +12,6 @@ exports.createCertificateCapability = createCertificateCapability;
 exports.redactSecretText = redactSecretText;
 const node_os_1 = require("node:os");
 const global_logger_factory_1 = require("global-logger-factory");
-const EndpointReachabilityProbe_1 = require("../network/EndpointReachabilityProbe");
-const TunnelClientManager_1 = require("../../tunnel/TunnelClientManager");
 const readBoundedJsonBody_1 = require("../http/readBoundedJsonBody");
 const AdminHandler_1 = require("./AdminHandler");
 const TunnelProviderCatalog_1 = require("../../tunnel/TunnelProviderCatalog");
@@ -68,46 +66,6 @@ function registerNetworkSettingsRoutes(server, options) {
             sendJson(response, 500, { error: 'Failed to run network diagnostics' });
         }
     }, { optionalAuth: true });
-    // The tunnel-client plugin actions live next to the tunnel configuration they serve: one
-    // "check" that says where each client comes from, one "download" that installs it (N16).
-    server.get('/api/network/settings/tunnel-clients', async (request, response) => {
-        if (!await requireNetworkPermission(request, response, authorizer, 'read', options.internalAdminAuthSecret)) {
-            return;
-        }
-        try {
-            const manager = options.tunnelClients ?? new TunnelClientManager_1.TunnelClientManager();
-            sendJson(response, 200, { clients: await manager.inspectAll() });
-        }
-        catch (error) {
-            logger.error(`Failed to inspect tunnel clients: ${redactSecretText(error)}`);
-            sendJson(response, 500, { error: 'Failed to inspect tunnel clients' });
-        }
-    }, { optionalAuth: true });
-    server.post('/api/network/settings/tunnel-clients/:provider/install', async (request, response, params) => {
-        const provider = String(params?.provider ?? '');
-        const known = ['ngrok', 'cloudflare', 'sakura_frp', 'frp'].includes(provider);
-        if (!known) {
-            sendJson(response, 404, { error: `Unknown tunnel provider: ${provider}` });
-            return;
-        }
-        if (!await requireNetworkPermission(request, response, authorizer, 'write', options.internalAdminAuthSecret)) {
-            return;
-        }
-        try {
-            const manager = options.tunnelClients ?? new TunnelClientManager_1.TunnelClientManager();
-            const installed = await manager.install(provider);
-            sendJson(response, 200, {
-                installed,
-                clients: await manager.inspectAll(),
-            });
-        }
-        catch (error) {
-            // A refused download is a normal answer (no pinned asset), not a server fault.
-            const message = redactSecretText(error);
-            logger.warn(`Tunnel client install refused for ${provider}: ${message}`);
-            sendJson(response, 400, { error: message });
-        }
-    }, { optionalAuth: true });
     if (options.certificateRenewer) {
         server.post('/api/network/settings/certificate/renew', async (request, response) => {
             if (!await requireNetworkPermission(request, response, authorizer, 'write', options.internalAdminAuthSecret)) {
@@ -386,28 +344,6 @@ function buildDefaultDiagnostics(options, logger) {
                     : { status: 'unsupported', detail: 'endpoint_unavailable' };
             },
         },
-        {
-            // Only runs because the operator asked for a diagnose pass; it never polls. The verdict
-            // is deliberately "from this node": a node reaching its own public entry says nothing
-            // about a remote user's path (NAT hairpin), so the wording keeps that distinction.
-            id: 'endpoint-reachability',
-            label: 'Endpoint reachability from this node',
-            run: async () => {
-                const endpoint = normalizeEndpoint(resolveValue(options.endpoint));
-                if (!endpoint) {
-                    return { status: 'unsupported', detail: 'endpoint_unavailable' };
-                }
-                const probe = options.endpointReachabilityProbe ?? EndpointReachabilityProbe_1.probeEndpointReachability;
-                const result = await probe(endpoint);
-                if (result.verdict === 'reachable-from-this-node') {
-                    return { status: 'ok', detail: result.detail };
-                }
-                if (result.verdict === 'blocked') {
-                    return { status: 'unsupported', detail: result.detail };
-                }
-                return { status: 'warning', detail: result.detail };
-            },
-        },
         {
             id: 'tls',
             label: 'TLS',
@@ -427,7 +363,7 @@ function buildDefaultDiagnostics(options, logger) {
 }
 async function runDiagnostic(check, logger) {
     const startedAt = Date.now();
-    const evidence = () => ({ checkDurationMs: Math.max(0, Date.now() - startedAt), checkedAt: new Date().toISOString() });
+    const evidence = () => ({ durationMs: Math.max(0, Date.now() - startedAt), checkedAt: new Date().toISOString() });
     try {
         const result = await check.run();
         if (typeof result === 'string') {
@@ -446,23 +382,14 @@ async function runDiagnostic(check, logger) {
         return { id: check.id, label: check.label, status: 'error', detail: redactSecretText(error), ...evidence() };
     }
 }
-/**
- * Maps a provider capability onto a diagnostic level.
- *
- * Only statuses that positively mean "verified" become `ok`, and known-bad ones become `error`
- * (an invalid or expired certificate is a failure, not something to warn about). Anything else
- * stays a warning: a status we cannot place must never be rendered as a pass (audit N12).
- */
-const VERIFIED_CAPABILITY_STATUSES = new Set(['active', 'valid', 'synced', 'direct', 'ready']);
-const FAILED_CAPABILITY_STATUSES = new Set(['error', 'invalid', 'failed', 'expired', 'untrusted', 'mismatch']);
 function capabilityToDiagnostic(capability) {
     if (!capability.supported) {
         return { status: 'unsupported', detail: capability.status };
     }
-    if (VERIFIED_CAPABILITY_STATUSES.has(capability.status)) {
+    if (capability.status === 'active' || capability.status === 'valid' || capability.status === 'synced' || capability.status === 'direct') {
         return { status: 'ok', detail: capability.status };
     }
-    if (FAILED_CAPABILITY_STATUSES.has(capability.status)) {
+    if (capability.status === 'error') {
         return { status: 'error', detail: capability.status };
     }
     return { status: 'warning', detail: capability.status };

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

@@ -1,5 +1,4 @@
 import type { ServerResponse } from 'node:http';
-import type { RouteHandler } from '../ApiServer';
 /** The wire code callers already report when Xpod cannot open the Pod for them. */
 export declare const SERVICE_ACCESS_MISSING = "service_access_missing";
 export interface PodAccessFailureResponse {
@@ -21,4 +20,4 @@ export declare function sendPodAccessFailure(response: ServerResponse, error: un
  *
  * Anything else keeps propagating, so unrelated bugs are not reported as missing Pod access.
  */
-export declare function guardPodAccessRoute(handler: RouteHandler): RouteHandler;
+export declare function guardPodAccessRoute<T extends (...args: any[]) => Promise<unknown>>(handler: T): T;

package/dist/api/handlers/PodAccessFailureResponse.js

@@ -45,15 +45,16 @@ function sendPodAccessFailure(response, error) {
  * Anything else keeps propagating, so unrelated bugs are not reported as missing Pod access.
  */
 function guardPodAccessRoute(handler) {
-    return async (request, response, params) => {
+    return (async (...args) => {
         try {
-            await handler(request, response, params);
+            await handler(...args);
         }
         catch (error) {
-            if (!sendPodAccessFailure(response, error)) {
+            const response = args[1];
+            if (!response || !sendPodAccessFailure(response, error)) {
                 throw error;
             }
         }
-    };
+    });
 }
 //# sourceMappingURL=PodAccessFailureResponse.js.map

package/dist/api/handlers/ReachabilityHandler.js

@@ -64,7 +64,6 @@ 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);
             }
@@ -77,10 +76,6 @@ 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/readBoundedRequestBody.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage } from 'node:http';
+/** Reject oversize bodies while draining the request, preserving its response socket. */
+export declare function readBoundedRequestBody(request: IncomingMessage, maxBytes: number, message: string): Promise<Buffer[]>;