@undefineds.co/xpod 0.4.20 → 0.4.27

package/dist/api/handlers/AdminHandler.js

@@ -7,11 +7,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALLOWED_ADMIN_CONFIG_KEYS = void 0;
-exports.isAdminSecretEnvKey = isAdminSecretEnvKey;
+exports.sanitizeLogMessage = exports.isAdminSecretEnvKey = exports.ALLOWED_ADMIN_CONFIG_KEYS = void 0;
 exports.sanitizeEnvForRead = sanitizeEnvForRead;
 exports.createAllowedAdminConfigPatch = createAllowedAdminConfigPatch;
-exports.sanitizeLogMessage = sanitizeLogMessage;
 exports.isAdminMutationAllowed = isAdminMutationAllowed;
 exports.createAdminServicesCapabilities = createAdminServicesCapabilities;
 exports.readDurableAdminEnvironment = readDurableAdminEnvironment;
@@ -26,6 +24,8 @@ const fs_2 = require("fs");
 const readline_1 = require("readline");
 const runtime_1 = require("../../runtime");
 const log_file_1 = require("../../logging/log-file");
+const normalize_log_1 = require("../../logging/normalize-log");
+const log_secrets_1 = require("../../logging/log-secrets");
 const TunnelProviderCatalog_1 = require("../../tunnel/TunnelProviderCatalog");
 const TunnelProfiles_1 = require("../../tunnel/TunnelProfiles");
 const GatewayAdminProxyAuth_1 = require("../../runtime/GatewayAdminProxyAuth");
@@ -84,25 +84,13 @@ exports.ALLOWED_ADMIN_CONFIG_KEYS = [
     'CSS_SHOW_STACK_TRACE',
 ];
 const ALLOWED_ADMIN_CONFIG_KEY_SET = new Set(exports.ALLOWED_ADMIN_CONFIG_KEYS);
-function isAdminSecretEnvKey(key) {
-    const normalized = key.toUpperCase();
-    if (normalized.endsWith('_KEY_PATH') || normalized.endsWith('_CERT_PATH')) {
-        return false;
-    }
-    return (normalized.includes('AUTHTOKEN') ||
-        normalized.endsWith('_TOKEN') ||
-        normalized.endsWith('_SECRET') ||
-        normalized.endsWith('_API_KEY') ||
-        normalized.includes('PASSWORD') ||
-        normalized.includes('CLIENT_SECRET') ||
-        normalized.endsWith('_DB_URL') ||
-        normalized.includes('DATABASE_URL'));
-}
+var log_secrets_2 = require("../../logging/log-secrets");
+Object.defineProperty(exports, "isAdminSecretEnvKey", { enumerable: true, get: function () { return log_secrets_2.isSecretEnvKey; } });
 function sanitizeEnvForRead(env) {
     const sanitized = {};
     const secrets = {};
     for (const [key, value] of Object.entries(env)) {
-        if (isAdminSecretEnvKey(key)) {
+        if ((0, log_secrets_1.isSecretEnvKey)(key)) {
             secrets[key] = { configured: Boolean(value) };
             continue;
         }
@@ -116,30 +104,19 @@ function createAllowedAdminConfigPatch(input) {
         if (!ALLOWED_ADMIN_CONFIG_KEY_SET.has(key) && !(0, TunnelProviderCatalog_1.isTunnelProfileCredentialEnvKey)(key)) {
             continue;
         }
-        if (isAdminSecretEnvKey(key) && !value) {
+        if ((0, log_secrets_1.isSecretEnvKey)(key) && !value) {
             continue;
         }
         patch[key] = value;
     }
     return patch;
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function sanitizeLogMessage(message, env) {
-    let sanitized = message;
-    const secretEntries = Object.entries(env)
-        .filter(([key, value]) => isAdminSecretEnvKey(key) && value.length >= 6)
-        .sort((a, b) => b[1].length - a[1].length);
-    for (const [key, value] of secretEntries) {
-        sanitized = sanitized.replace(new RegExp(escapeRegExp(value), 'g'), `[redacted:${key}]`);
-    }
-    return sanitized;
-}
+var log_secrets_3 = require("../../logging/log-secrets");
+Object.defineProperty(exports, "sanitizeLogMessage", { enumerable: true, get: function () { return log_secrets_3.redactConfiguredLogSecrets; } });
 function sanitizeLogEntry(entry, env) {
     return {
         ...entry,
-        message: sanitizeLogMessage(entry.message, env),
+        message: (0, log_secrets_1.redactConfiguredLogSecrets)(entry.message, env),
     };
 }
 function safeTokenEquals(actual, expected) {
@@ -156,6 +133,9 @@ function isAdminMutationAllowed(req, options = {}) {
         safeTokenEquals(providedToken, configuredToken)) {
         return true;
     }
+    if (options.allowLoopback === false) {
+        return false;
+    }
     const peerLoopback = (0, GatewayAdminProxyAuth_1.isLoopbackRemoteAddress)(req.socket?.remoteAddress);
     const proxyMarker = (0, GatewayAdminProxyAuth_1.verifyGatewayAdminProxyHeaders)({
         headers: req.headers,
@@ -164,7 +144,10 @@ function isAdminMutationAllowed(req, options = {}) {
         url: req.url,
     });
     if (proxyMarker.present) {
-        return peerLoopback && proxyMarker.valid && proxyMarker.originalClientLoopback;
+        // Unix peers have no IP address. Only the Gateway's authenticated provenance
+        // can authorize that transport; an unsigned Unix request stays untrusted.
+        const unixPeer = Boolean(req.socket && req.socket.remoteAddress === undefined);
+        return (peerLoopback || unixPeer) && proxyMarker.valid && proxyMarker.originalClientLoopback;
     }
     return peerLoopback;
 }
@@ -529,9 +512,8 @@ function registerAdminRoutes(server, options = {}) {
     function addLog(level, source, message) {
         const entry = {
             timestamp: new Date().toISOString(),
-            level,
             source,
-            message: message.trim(),
+            ...(0, normalize_log_1.normalizeLog)(message, level),
         };
         logBuffer.push(entry);
         if (logBuffer.length > MAX_LOG_BUFFER) {
@@ -541,13 +523,19 @@ function registerAdminRoutes(server, options = {}) {
     // Intercept stdout
     process.stdout.write = (chunk, ...args) => {
         const message = chunk.toString();
-        addLog('info', 'xpod', message);
+        for (const line of message.split('\n')) {
+            if (line.trim())
+                addLog('info', 'api', line);
+        }
         return originalStdoutWrite(chunk, ...args);
     };
     // Intercept stderr
     process.stderr.write = (chunk, ...args) => {
         const message = chunk.toString();
-        addLog('error', 'xpod', message);
+        for (const line of message.split('\n')) {
+            if (line.trim())
+                addLog('error', 'api', line);
+        }
         return originalStderrWrite(chunk, ...args);
     };
     // GET /api/admin/logs - Get recent logs
@@ -637,7 +625,7 @@ function registerAdminRoutes(server, options = {}) {
             const lastLines = fileLogs.slice(-lines);
             sendJson(res, 200, {
                 file: logPath,
-                lines: lastLines.map((line) => sanitizeLogMessage(line, env)),
+                lines: lastLines.map((line) => (0, log_secrets_1.redactConfiguredLogSecrets)(line, env)),
             });
         }
         catch (error) {

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

@@ -41,6 +41,14 @@ export type AiConfigPolicyPatch = {
     lifecycle?: Partial<AiConfigPolicy['lifecycle']>;
 };
 export interface AiConfigCapabilities {
+    /** Deployment policy, projected from the same authority that validates assignments. */
+    embeddingModels?: {
+        restricted: boolean;
+        allowed: Array<{
+            provider: string;
+            model: string;
+        }>;
+    };
     textBackends: Array<'fts5' | 'postgres-fts'>;
     vectorBackends: Array<'vec' | 'pgvector'>;
     rebuildSupported: boolean;
@@ -99,5 +107,9 @@ export interface AiConfigHandlerOptions {
      * Cloud runtimes only accept models the ai-gateway catalog provides.
      */
     embeddingModelPolicy?: EmbeddingModelPolicy;
+    embeddingModels?: () => Array<{
+        provider: string;
+        model: string;
+    }>;
 }
 export declare function registerAiConfigRoutes(server: ApiServer, options: AiConfigHandlerOptions): void;

package/dist/api/handlers/AiConfigHandler.js

@@ -19,9 +19,6 @@ function registerAiConfigRoutes(server, options) {
             });
         }
         catch (error) {
-            // A caller whose Pod credential cannot be replayed (a DPoP session) is refused, not
-            // broken: the session retries with its own client credential only when it sees this
-            // stable 403, so reporting it as an internal error would strand the read.
             if ((0, PodAccessFailureResponse_1.sendPodAccessFailure)(response, error))
                 return;
             sendJson(response, 500, { error: 'Failed to read AI Config' });
@@ -89,7 +86,9 @@ function registerAiConfigRoutes(server, options) {
         try {
             sendJson(response, 202, { job: await options.lifecycle.schedule({ ...owner, target }) });
         }
-        catch {
+        catch (error) {
+            if ((0, PodAccessFailureResponse_1.sendPodAccessFailure)(response, error))
+                return;
             sendJson(response, 500, { error: 'Failed to schedule index rebuild' });
         }
     });
@@ -231,7 +230,10 @@ function defaultCapabilities() {
 function resolveCapabilities(options) {
     const capabilities = options.capabilities?.() ?? defaultCapabilities();
     const rebuildTargets = options.lifecycle?.supportedTargets() ?? [];
-    return { ...capabilities, rebuildSupported: rebuildTargets.length > 0, rebuildTargets };
+    return { ...capabilities, rebuildSupported: rebuildTargets.length > 0, rebuildTargets, embeddingModels: {
+            restricted: options.embeddingModelPolicy?.isEnforced() ?? false,
+            allowed: (options.embeddingModels?.() ?? []).filter(model => options.embeddingModelPolicy?.isAllowed(model) ?? true),
+        } };
 }
 function emptyLifecycle(configurationVersion) { return { configurationVersion, pending: 0, recent: [] }; }
 function parseRebuildTarget(value) {

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

@@ -18,6 +18,7 @@ export declare class AiGatewayHandler {
     handleModels(request: AuthenticatedRequest, response: ServerResponse): Promise<void>;
     handleAcceptanceProvenance(request: AuthenticatedRequest, response: ServerResponse): Promise<void>;
     private sendEventStream;
+    private logTaskGatewayFailure;
     private logInference;
     private writeTerminalStreamError;
     private sendGatewayError;

package/dist/api/handlers/AiGatewayHandler.js

@@ -5,7 +5,10 @@ exports.registerAiGatewayRoutes = registerAiGatewayRoutes;
 const global_logger_factory_1 = require("global-logger-factory");
 const readBoundedJsonBody_1 = require("../http/readBoundedJsonBody");
 const errors_1 = require("../ai-gateway/errors");
+const InvocationMetadata_1 = require("../ai-gateway/InvocationMetadata");
+const task_model_diagnostics_1 = require("../../util/task-model-diagnostics");
 const DEFAULT_JSON_BODY_LIMIT_BYTES = 2 * 1024 * 1024;
+const TASK_GATEWAY_CODES = new Set(task_model_diagnostics_1.TASK_GATEWAY_DIAGNOSTIC_CODES);
 function registerAiGatewayRoutes(server, options) {
     const handler = new AiGatewayHandler(options);
     server.post('/v1/responses', (request, response) => handler.handleInference(request, response, 'responses'));
@@ -24,12 +27,20 @@ class AiGatewayHandler {
     }
     async handleInference(request, response, protocol) {
         const startedAt = Date.now();
+        // Observation only: preserve the existing body/header validation ordering.
+        let correlationHash;
+        try {
+            correlationHash = (0, task_model_diagnostics_1.hashTaskModelDiagnosticSession)((0, InvocationMetadata_1.readGatewayInvocationMetadata)(request.headers, request.rawHeaders).sessionId);
+        }
+        catch { /* Invalid invocation metadata is rejected by the existing path. */ }
         const bodyResult = await (0, readBoundedJsonBody_1.readBoundedJsonBody)(request, { limitBytes: this.jsonBodyLimitBytes });
         if (!bodyResult.ok) {
-            this.sendGatewayError(response, new errors_1.GatewayProtocolError(bodyResult.error, {
+            const error = new errors_1.GatewayProtocolError(bodyResult.error, {
                 code: 'invalid_request',
                 status: bodyResult.status,
-            }));
+            });
+            this.sendGatewayError(response, error);
+            this.logTaskGatewayFailure(correlationHash, response, protocol, startedAt, false, taskGatewayFailure(error));
             return;
         }
         const model = readRequestedModel(bodyResult.value);
@@ -37,6 +48,7 @@ class AiGatewayHandler {
         const abort = () => controller.abort();
         response.once('close', abort);
         try {
+            const invocationMetadata = (0, InvocationMetadata_1.readGatewayInvocationMetadata)(request.headers, request.rawHeaders);
             const stream = isStreamRequest(bodyResult.value);
             if (!stream) {
                 const result = await this.service.complete({
@@ -44,6 +56,7 @@ class AiGatewayHandler {
                     protocol,
                     body: bodyResult.value,
                     signal: controller.signal,
+                    invocationMetadata,
                 });
                 sendJson(response, 200, result);
                 this.logInference({
@@ -62,19 +75,29 @@ class AiGatewayHandler {
                 protocol,
                 body: bodyResult.value,
                 signal: controller.signal,
+                invocationMetadata,
             });
             const outcome = await this.sendEventStream(response, execution.frontend, execution.events);
             this.logInference({ protocol, model, stream: true, startedAt, ...outcome });
+            if (outcome.failure) {
+                this.logTaskGatewayFailure(correlationHash, response, protocol, startedAt, true, outcome.failure);
+            }
         }
         catch (error) {
             if (controller.signal.aborted || response.destroyed) {
                 return;
             }
             if (response.headersSent) {
-                await this.writeTerminalStreamError(response, error);
+                try {
+                    await this.writeTerminalStreamError(response, error);
+                }
+                finally {
+                    this.logTaskGatewayFailure(correlationHash, response, protocol, startedAt, isStreamRequest(bodyResult.value), taskGatewayFailure(error));
+                }
                 return;
             }
             this.sendGatewayError(response, error);
+            this.logTaskGatewayFailure(correlationHash, response, protocol, startedAt, false, taskGatewayFailure(error));
         }
         finally {
             response.off('close', abort);
@@ -171,6 +194,7 @@ class AiGatewayHandler {
         }
         catch (error) {
             outcome.outcome = disconnected ? 'disconnected' : 'failed';
+            outcome.failure = taskGatewayFailure(error);
             await returnIterator();
             if (!disconnected) {
                 await this.writeTerminalStreamError(response, error);
@@ -184,9 +208,26 @@ class AiGatewayHandler {
         }
         if (disconnected) {
             outcome.outcome = 'disconnected';
+            outcome.failure ??= taskGatewayFailure(undefined);
         }
         return outcome;
     }
+    logTaskGatewayFailure(correlationHash, response, protocol, startedAt, streamOpen, failure) {
+        if (!correlationHash || !diagnosticHTTPStatus(response.statusCode))
+            return;
+        const route = protocol === 'chatCompletions' ? 'chat_completions'
+            : protocol === 'responses' ? 'responses' : 'anthropic_messages';
+        try {
+            const receipt = (0, task_model_diagnostics_1.selectTaskModelDiagnosticReceipt)({
+                event: 'xpod.task-gateway-diagnostic', schemaVersion: 1, scope: 'session', correlationHash, route,
+                callerHTTPstatus: response.statusCode, ...failure, streamOpen,
+                durationMs: Math.min(2_147_483_647, Math.max(0, Math.floor(Date.now() - startedAt))),
+            });
+            if (receipt)
+                this.logger.error(JSON.stringify(receipt));
+        }
+        catch { /* An observational receipt must not alter the response or cleanup. */ }
+    }
     logInference(summary) {
         const fields = [
             `protocol=${summary.protocol}`,
@@ -228,6 +269,19 @@ class AiGatewayHandler {
     }
 }
 exports.AiGatewayHandler = AiGatewayHandler;
+function diagnosticHTTPStatus(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 100 && value <= 599 ? value : undefined;
+}
+function taskGatewayFailure(error) {
+    const code = (0, errors_1.normalizeGatewayError)(error).error.code;
+    const source = error && typeof error === 'object' ? error : undefined;
+    const cause = source?.cause && typeof source.cause === 'object' ? source.cause : undefined;
+    const underlyingErrorStatus = diagnosticHTTPStatus(cause?.status) ?? diagnosticHTTPStatus(source?.status);
+    return {
+        code: TASK_GATEWAY_CODES.has(code) ? code : 'internal_error',
+        ...(underlyingErrorStatus !== undefined ? { underlyingErrorStatus } : {}),
+    };
+}
 async function writeSerializedEvents(response, serialized) {
     for (const event of Array.isArray(serialized) ? serialized : [serialized]) {
         await writeWithBackpressure(response, `data: ${JSON.stringify(event)}\n\n`);

package/dist/api/handlers/AiGatewayManagementHandler.js

@@ -1200,6 +1200,11 @@ function publicGatewayAccessKeyRecord(record, plaintextAvailable, plaintext) {
 }
 function normalizeCredentialPatch(body) {
     const patch = {};
+    if (Object.prototype.hasOwnProperty.call(body, 'apiKey')) {
+        if (typeof body.apiKey !== 'string' || !body.apiKey.trim())
+            return undefined;
+        patch.apiKey = body.apiKey.trim();
+    }
     if (body.label !== undefined) {
         const label = normalizeOptionalString(body.label);
         if (!label) {
@@ -1330,6 +1335,10 @@ function sendCredentialPoolError(response, error) {
         sendJson(response, message === 'local_session_refresh_failed' ? 502 : 409, { error: message });
         return;
     }
+    if (message === 'invalid_api_key' || message === 'credential_auth_mode_mismatch') {
+        sendJson(response, 400, { error: message });
+        return;
+    }
     if (message === 'credential_version_conflict') {
         sendJson(response, 409, { error: 'credential_version_conflict' });
         return;
@@ -1454,6 +1463,10 @@ function sendModelsError(response, error) {
         return;
     }
     const message = error instanceof Error ? error.message : String(error);
+    if (message === 'provider_request_timeout') {
+        sendJson(response, 504, { error: 'provider_request_timeout' });
+        return;
+    }
     if (message === 'models_credential_not_found') {
         sendJson(response, 404, { error: 'Provider credential not found for current identity' });
         return;
@@ -1634,6 +1647,10 @@ function publicCredentialPoolCredential(value) {
         enabled: record.enabled ?? (record.status ? record.status === 'active' : undefined),
         priority: record.priority ?? numberMetadata(metadata, 'priority'),
         health: record.health ?? stringMetadata(metadata, 'health'),
+        lastFailureCode: record.lastFailureCode,
+        lastFailureAt: record.lastFailureAt,
+        rateLimitResetAt: record.rateLimitResetAt,
+        failCount: record.failCount,
         maskedHint: record.maskedHint ?? stringMetadata(metadata, 'maskedHint'),
         expiresAt: record.expiresAt instanceof Date ? record.expiresAt.toISOString() : record.expiresAt,
         baseUrl: record.baseUrl ?? stringMetadata(metadata, 'baseUrl'),

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

@@ -21,6 +21,6 @@ export interface DeviceNotificationRuntimeHandle {
         ticketEndpoint: string;
         webSocketEndpoint: string;
     };
-    stop(): void;
+    stop(): Promise<void>;
 }
 export declare function registerDeviceNotificationRuntime(server: ApiServer, options: DeviceNotificationRuntimeOptions): DeviceNotificationRuntimeHandle;

package/dist/api/handlers/DeviceNotificationRuntime.js

@@ -48,22 +48,19 @@ function registerDeviceNotificationRuntime(server, options) {
         webSocketServer.handleUpgrade(request, socket, head);
     });
     ObservableResourceStore_1.ObservableResourceStore.addGlobalListener(resourceListener);
-    server.addShutdownHandler(() => {
-        webSocketServer.stop();
+    const stop = () => {
         ticketStore.clear();
         ObservableResourceStore_1.ObservableResourceStore.removeGlobalListener(resourceListener);
-    });
+        return webSocketServer.stop();
+    };
+    server.addShutdownHandler(stop);
     return {
         hub,
         ticketHandler,
         webSocketServer,
         resourceListener,
         descriptor,
-        stop: () => {
-            webSocketServer.stop();
-            ticketStore.clear();
-            ObservableResourceStore_1.ObservableResourceStore.removeGlobalListener(resourceListener);
-        },
+        stop,
     };
 }
 function sendJson(response, status, body) {

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

@@ -7,5 +7,12 @@ export interface InngestHandlerOptions {
     backend: InngestRunExecutionBackend;
     taskScheduler?: InngestTaskScheduler<StoreContext>;
     runtimeConfig?: EmbeddedInngestRuntimeConfig;
+    /**
+     * Shared secret the Gateway uses to sign its internal proxy marker. Required
+     * to keep the spawned dev executor's unsigned callback local: the dev Inngest
+     * SDK skips signature validation, so this route must reject a callback that
+     * the Gateway reports came from a non-loopback (tunnelled/P2P) client.
+     */
+    gatewayAdminProxyAuthSecret?: string;
 }
 export declare function registerInngestRoutes(server: ApiServer, options: InngestHandlerOptions): void;

package/dist/api/handlers/InngestHandler.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerInngestRoutes = registerInngestRoutes;
 const node_1 = require("inngest/node");
+const GatewayAdminProxyAuth_1 = require("../../runtime/GatewayAdminProxyAuth");
 function registerInngestRoutes(server, options) {
     if (options.runtimeConfig?.enabled !== true) {
         return;
@@ -18,10 +19,54 @@ function registerInngestRoutes(server, options) {
         serveOrigin: functionEndpoint?.origin,
         servePath: functionEndpoint?.pathname,
     });
+    // A managed executor signs its callbacks, so the SDK itself rejects anything
+    // unsigned or forged. The spawned `inngest dev` executor cannot sign, so the
+    // dev route must prove the caller is local instead; otherwise the public
+    // callback route would let any client that reaches the Gateway execute Runs.
+    const authorizeDevCallback = options.runtimeConfig.mode === 'spawn'
+        ? createDevCallbackAuthorizer(options.gatewayAdminProxyAuthSecret)
+        : undefined;
     const routeHandler = async (req, res) => {
+        if (authorizeDevCallback && !authorizeDevCallback(req, res)) {
+            return;
+        }
         handler(req, res);
     };
     server.all('/api/inngest', routeHandler, { public: true });
     server.all('/api/inngest/*path', routeHandler, { public: true });
 }
+function createDevCallbackAuthorizer(secret) {
+    return (req, res) => {
+        // Trust model mirrors ConfiguredLoopbackDPoPWebIdExtractor.trustedLocalRouteTransport.
+        // A present marker is authoritative: accept it only when the Gateway's HMAC
+        // verifies AND it reports the original client as loopback. The default
+        // non-Windows transport is a Unix domain socket where req.socket.remoteAddress
+        // is undefined, so a legitimate signed local Gateway callback has a marker
+        // but no peer address - requiring both would reject it.
+        const marker = (0, GatewayAdminProxyAuth_1.verifyGatewayAdminProxyHeaders)({
+            headers: req.headers,
+            secret,
+            method: req.method,
+            url: req.url,
+        });
+        if (marker.present) {
+            if (marker.valid && marker.originalClientLoopback) {
+                return true;
+            }
+            return denyDevCallback(res);
+        }
+        // No marker: only a direct TCP loopback caller may be the dev executor.
+        // A non-loopback peer (or a socket with no peer address) is not local.
+        if ((0, GatewayAdminProxyAuth_1.isLoopbackRemoteAddress)(req.socket?.remoteAddress)) {
+            return true;
+        }
+        return denyDevCallback(res);
+    };
+}
+function denyDevCallback(res) {
+    res.statusCode = 403;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({ error: 'Inngest dev callback is restricted to the local executor' }));
+    return false;
+}
 //# sourceMappingURL=InngestHandler.js.map

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

@@ -1,4 +1,7 @@
 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';
@@ -109,7 +112,15 @@ export interface NetworkDiagnosticCheckResult {
     label: string;
     status: DiagnosticStatus;
     detail?: string;
-    durationMs?: number;
+    /**
+     * 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;
     checkedAt?: string;
 }
 export interface NetworkDiagnosticCheck {
@@ -150,6 +161,25 @@ 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[];