@getpaseo/server 0.1.101 → 0.1.102-beta.2

package/dist/server/server/web-ui.js

@@ -0,0 +1,205 @@
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+const EXCLUDED_PATH_PREFIXES = ["/api/", "/mcp/", "/public/"];
+const EXCLUDED_PATHS = new Set(["/api", "/mcp", "/public"]);
+function isExcludedPath(requestPath) {
+    for (const prefix of EXCLUDED_PATH_PREFIXES) {
+        if (requestPath.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return EXCLUDED_PATHS.has(requestPath);
+}
+const CONTENT_TYPES = {
+    ".html": "text/html; charset=utf-8",
+    ".js": "application/javascript; charset=utf-8",
+    ".mjs": "application/javascript; charset=utf-8",
+    ".css": "text/css; charset=utf-8",
+    ".json": "application/json; charset=utf-8",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".gif": "image/gif",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+    ".otf": "font/otf",
+    ".eot": "application/vnd.ms-fontobject",
+    ".map": "application/json",
+};
+function getContentType(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return CONTENT_TYPES[ext] ?? "application/octet-stream";
+}
+function selectEncoding(acceptEncoding) {
+    if (!acceptEncoding) {
+        return null;
+    }
+    const normalized = acceptEncoding.toLowerCase();
+    if (normalized.includes("br")) {
+        return "br";
+    }
+    if (normalized.includes("gzip")) {
+        return "gzip";
+    }
+    return null;
+}
+function isHashedAsset(filePath) {
+    const base = path.basename(filePath);
+    // Match content hashes like index-abc123def456.js or main.abc123def456.css.
+    return /[-.][0-9a-f]{16,}[-.]/i.test(base);
+}
+function isInsideDir(targetPath, dirPath) {
+    const resolvedDir = path.resolve(dirPath);
+    const resolvedTarget = path.resolve(targetPath);
+    return resolvedTarget === resolvedDir || resolvedTarget.startsWith(resolvedDir + path.sep);
+}
+function resolveTargetFile(distDir, requestPath) {
+    const safePath = path.normalize(requestPath).replace(/^(\.\.[/\\])+/, "");
+    let filePath = path.join(distDir, safePath);
+    const stat = safeStat(filePath);
+    if (stat?.isDirectory()) {
+        filePath = path.join(filePath, "index.html");
+    }
+    const finalStat = safeStat(filePath);
+    if (!finalStat?.isFile()) {
+        filePath = path.join(distDir, "index.html");
+        const fallbackStat = safeStat(filePath);
+        if (!fallbackStat?.isFile()) {
+            return null;
+        }
+    }
+    if (!isInsideDir(filePath, distDir)) {
+        return null;
+    }
+    const resolvedFile = path.resolve(filePath);
+    const isIndexHtml = path.basename(resolvedFile).toLowerCase() === "index.html";
+    return { resolvedFile, isIndexHtml };
+}
+function safeStat(filePath) {
+    try {
+        return statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveContentEncoding(resolvedFile, acceptEncoding) {
+    const encoding = selectEncoding(acceptEncoding);
+    if (!encoding) {
+        return { finalFile: resolvedFile, contentEncoding: null };
+    }
+    const compressedFile = `${resolvedFile}.${encoding === "br" ? "br" : "gz"}`;
+    const compressedStat = safeStat(compressedFile);
+    if (compressedStat?.isFile()) {
+        return { finalFile: compressedFile, contentEncoding: encoding };
+    }
+    return { finalFile: resolvedFile, contentEncoding: null };
+}
+function setResponseCacheHeaders(res, isIndexHtml, resolvedFile) {
+    if (isIndexHtml) {
+        res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate, proxy-revalidate");
+        res.setHeader("Pragma", "no-cache");
+        res.setHeader("Expires", "0");
+    }
+    else if (isHashedAsset(resolvedFile)) {
+        res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+    }
+    else {
+        res.setHeader("Cache-Control", "no-cache");
+    }
+}
+export function createWebUiMiddleware(options) {
+    const { enabled, distDir, label, logger } = options;
+    const childLogger = logger.child({ module: "web-ui" });
+    if (!enabled || !distDir) {
+        childLogger.info({ enabled, hasDistDir: !!distDir }, "Daemon web UI disabled or missing dist directory");
+    }
+    else {
+        childLogger.info({ distDir }, "Daemon web UI mounted");
+    }
+    return (req, res, next) => {
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            next();
+            return;
+        }
+        if (isExcludedPath(req.path)) {
+            next();
+            return;
+        }
+        if (!enabled || !distDir) {
+            res.status(404).end();
+            return;
+        }
+        serveWebUiFile({ distDir, requestPath: req.path, label, req, res });
+    };
+}
+function serveWebUiFile(options) {
+    const { distDir, requestPath, label, req, res } = options;
+    const target = resolveTargetFile(distDir, requestPath);
+    if (!target) {
+        res.status(404).end();
+        return;
+    }
+    const { resolvedFile, isIndexHtml } = target;
+    const acceptEncoding = isIndexHtml ? undefined : req.headers["accept-encoding"];
+    const { finalFile, contentEncoding } = resolveContentEncoding(resolvedFile, acceptEncoding);
+    res.setHeader("Content-Type", getContentType(resolvedFile));
+    if (contentEncoding) {
+        res.setHeader("Content-Encoding", contentEncoding);
+        res.setHeader("Vary", "Accept-Encoding");
+    }
+    setResponseCacheHeaders(res, isIndexHtml, resolvedFile);
+    if (req.method === "HEAD") {
+        res.status(200).end();
+        return;
+    }
+    if (isIndexHtml) {
+        sendIndexHtml(res, finalFile, req, label);
+        return;
+    }
+    const stream = createReadStream(finalFile);
+    stream.on("error", () => {
+        if (!res.headersSent) {
+            res.status(500).end();
+        }
+        else {
+            res.end();
+        }
+    });
+    stream.pipe(res);
+}
+function sendIndexHtml(res, filePath, req, label) {
+    try {
+        const html = readFileSync(filePath, "utf-8");
+        const injected = injectConnectionHint(html, req, label);
+        res.status(200).send(injected);
+    }
+    catch {
+        res.status(500).end();
+    }
+}
+function serializeInlineScriptJson(value) {
+    return JSON.stringify(value)
+        .replace(/</g, "\\u003C")
+        .replace(/>/g, "\\u003E")
+        .replace(/&/g, "\\u0026");
+}
+function injectConnectionHint(html, req, label) {
+    const host = typeof req.headers.host === "string" ? req.headers.host : "";
+    const useTls = req.protocol === "https";
+    const hint = {
+        listen: host,
+        useTls,
+        label,
+    };
+    const script = `<script>window.__PASEO_INITIAL_DAEMON_CONNECTION__=${serializeInlineScriptJson(hint)}</script>`;
+    const headClose = /<\/head>/i;
+    if (headClose.test(html)) {
+        return html.replace(headClose, `${script}</head>`);
+    }
+    return script + html;
+}
+//# sourceMappingURL=web-ui.js.map

package/dist/server/server/websocket/runtime-metrics.d.ts

@@ -1,4 +1,5 @@
 import type { WSOutboundMessage } from "../messages.js";
+import type { ProcessMemoryDiagnostics } from "../process-diagnostics.js";
 export interface WebSocketRuntimeCounters {
     connectedAwaitingHello: number;
     helloResumed: number;
@@ -56,6 +57,8 @@ export interface WebSocketRuntimeDiagnosticSnapshot<TRuntime = unknown, TAgents
         p99Ms: number;
         maxMs: number;
     } | null;
+    uptimeSeconds: number;
+    memory: ProcessMemoryDiagnostics;
     runtime: TRuntime;
     agents: TAgents;
 }

package/dist/server/server/websocket-server.d.ts

@@ -26,6 +26,7 @@ import { type DaemonAuthConfig } from "./auth.js";
 export interface ExternalSocketMetadata {
     transport: "relay";
     externalSessionKey?: string;
+    relayConnectionId?: string;
 }
 interface WebSocketServerConfig {
     allowedOrigins: Set<string>;
@@ -50,6 +51,7 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly wss;
     private readonly pendingConnections;
     private readonly sessions;
+    private readonly socketIdentities;
     private readonly externalSessionsByKey;
     private readonly serverId;
     private readonly daemonVersion;
@@ -156,5 +158,6 @@ export declare class VoiceAssistantWebSocketServer {
     private broadcastAgentAttention;
     private broadcastTerminalAttention;
 }
+export declare function isWebSocketSameOrigin(origin: string | undefined, requestHost: string | null): boolean;
 export {};
 //# sourceMappingURL=websocket-server.d.ts.map

package/dist/server/server/websocket-server.js

@@ -1,6 +1,7 @@
 import { WebSocketServer } from "ws";
 import { basename, join } from "path";
 import { hostname as getHostname } from "node:os";
+import { randomUUID } from "node:crypto";
 import { monitorEventLoopDelay } from "node:perf_hooks";
 import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
 import { asUint8Array, decodeBinaryFrame } from "@getpaseo/protocol/binary-frames/index";
@@ -15,6 +16,8 @@ import { createGitHubService } from "../services/github-service.js";
 import { extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValid, } from "./auth.js";
 import { WebSocketRuntimeMetricsWindow, } from "./websocket/runtime-metrics.js";
 import { ProviderUsageService } from "../services/quota-fetcher/service.js";
+import { getProcessMemoryDiagnostics, getProcessUptimeSeconds } from "./process-diagnostics.js";
+import { CLIENT_SHUTDOWN_RPC_REASON, normalizeClientRestartRpcReason, } from "./lifecycle-reasons.js";
 const WS_CLOSE_DAEMON_AUTH_FAILED = 4401;
 function resolveTerminalAttentionReason(input) {
     if (input.attentionReason === "finished")
@@ -222,6 +225,7 @@ export class VoiceAssistantWebSocketServer {
     constructor(server, logger, serverId, agentManager, agentStorage, downloadTokenStore, paseoHome, daemonConfigStore, mcpBaseUrl, wsConfig, auth, speech, terminalManager, dictation, daemonVersion, onLifecycleIntent, projectRegistry, workspaceRegistry, chatService, loopService, scheduleService, checkoutDiffManager, serviceProxy, scriptRuntimeStore, onBranchChanged, getDaemonTcpPort, getDaemonTcpHost, resolveScriptHealth, workspaceGitService, github, pushNotificationSender, providerSnapshotManager, daemonRuntimeConfig, serviceProxyPublicBaseUrl) {
         this.pendingConnections = new Map();
         this.sessions = new Map();
+        this.socketIdentities = new Map();
         this.externalSessionsByKey = new Map();
         this.voiceSpeakHandlers = new Map();
         this.voiceCallerContexts = new Map();
@@ -391,9 +395,7 @@ export class VoiceAssistantWebSocketServer {
             callback(false, 403, "Host not allowed");
             return;
         }
-        const sameOrigin = !!origin &&
-            !!requestHost &&
-            (origin === `http://${requestHost}` || origin === `https://${requestHost}`);
+        const sameOrigin = isWebSocketSameOrigin(origin, requestHost);
         if (!origin || allowedOrigins.has("*") || allowedOrigins.has(origin) || sameOrigin) {
             callback(true);
         }
@@ -508,6 +510,7 @@ export class VoiceAssistantWebSocketServer {
         this.workspaceGitService.dispose();
         this.pendingConnections.clear();
         this.sessions.clear();
+        this.socketIdentities.clear();
         this.externalSessionsByKey.clear();
         this.wss.close();
     }
@@ -550,25 +553,13 @@ export class VoiceAssistantWebSocketServer {
     }
     async attachSocket(ws, request, metadata) {
         const requestMetadata = extractSocketRequestMetadata(request);
-        const connectionLoggerFields = {
-            transport: metadata?.transport === "relay" ? "relay" : "direct",
-        };
-        if (requestMetadata.host) {
-            connectionLoggerFields.host = requestMetadata.host;
-        }
-        if (requestMetadata.origin) {
-            connectionLoggerFields.origin = requestMetadata.origin;
-        }
-        if (requestMetadata.userAgent) {
-            connectionLoggerFields.userAgent = requestMetadata.userAgent;
-        }
-        if (requestMetadata.remoteAddress) {
-            connectionLoggerFields.remoteAddress = requestMetadata.remoteAddress;
-        }
-        const connectionLogger = this.logger.child(connectionLoggerFields);
+        const identity = createWebSocketConnectionIdentity(requestMetadata, metadata);
+        this.socketIdentities.set(ws, identity);
+        const connectionLogger = this.logger.child(toConnectionLogFields(identity));
         const pending = {
             connectionLogger,
             helloTimeout: null,
+            identity,
         };
         const timeout = setTimeout(() => {
             if (this.pendingConnections.get(ws) !== pending) {
@@ -576,7 +567,7 @@ export class VoiceAssistantWebSocketServer {
             }
             pending.helloTimeout = null;
             this.pendingConnections.delete(ws);
-            pending.connectionLogger.warn({ timeoutMs: HELLO_TIMEOUT_MS }, "Closing connection due to missing hello");
+            pending.connectionLogger.warn({ ...toConnectionLogFields(identity), timeoutMs: HELLO_TIMEOUT_MS }, "Closing connection due to missing hello");
             try {
                 ws.close(WS_CLOSE_HELLO_TIMEOUT, "Hello timeout");
             }
@@ -589,7 +580,8 @@ export class VoiceAssistantWebSocketServer {
         this.pendingConnections.set(ws, pending);
         this.incrementRuntimeCounter("connectedAwaitingHello");
         this.bindSocketHandlers(ws);
-        pending.connectionLogger.trace({
+        pending.connectionLogger.info({
+            ...toConnectionLogFields(identity),
             totalPendingConnections: this.pendingConnections.size,
         }, "Client connected; awaiting hello");
     }
@@ -744,6 +736,10 @@ export class VoiceAssistantWebSocketServer {
             return;
         }
         this.clearPendingConnection(ws);
+        pending.identity.clientId = clientId;
+        if (message.appVersion) {
+            pending.identity.appVersion = message.appVersion;
+        }
         const existing = this.externalSessionsByKey.get(clientId);
         if (existing) {
             this.incrementRuntimeCounter("helloResumed");
@@ -764,9 +760,10 @@ export class VoiceAssistantWebSocketServer {
             }
             existing.sockets.add(ws);
             this.sessions.set(ws, existing);
+            pending.identity.sessionId = existing.session.getSessionId();
             this.sendToClient(ws, this.createServerInfoMessage());
-            existing.connectionLogger.trace({
-                clientId,
+            pending.connectionLogger.info({
+                ...toConnectionLogFields(pending.identity),
                 resumed: true,
                 totalSessions: this.sessions.size,
             }, "Client connected via hello");
@@ -783,9 +780,10 @@ export class VoiceAssistantWebSocketServer {
         });
         this.sessions.set(ws, connection);
         this.externalSessionsByKey.set(clientId, connection);
+        pending.identity.sessionId = connection.session.getSessionId();
         this.sendToClient(ws, this.createServerInfoMessage());
-        connection.connectionLogger.trace({
-            clientId,
+        connection.connectionLogger.info({
+            ...toConnectionLogFields(pending.identity),
             resumed: false,
             totalSessions: this.sessions.size,
         }, "Client connected via hello");
@@ -825,6 +823,10 @@ export class VoiceAssistantWebSocketServer {
                 agentDetach: true,
                 // COMPAT(daemonDiagnostics): added in v0.1.100, remove gate after 2026-12-25 once daemon floor >= v0.1.100.
                 daemonDiagnostics: true,
+                // COMPAT(daemonSelfUpdate): added in v0.1.93, remove gate after 2026-12-13.
+                daemonSelfUpdate: true,
+                // COMPAT(agentForkContext): added in v0.1.102, remove gate after 2026-12-28.
+                agentForkContext: true,
             },
         };
     }
@@ -882,21 +884,34 @@ export class VoiceAssistantWebSocketServer {
         return this.voiceCallerContexts.get(callerAgentId) ?? null;
     }
     async detachSocket(ws, details) {
+        const identity = this.socketIdentities.get(ws);
+        const identityFields = identity ? toConnectionLogFields(identity) : {};
         const pending = this.clearPendingConnection(ws);
         if (pending) {
             this.incrementRuntimeCounter("pendingDisconnected");
-            pending.connectionLogger.trace({
+            pending.connectionLogger.info({
+                ...identityFields,
                 code: details.code,
                 reason: stringifyCloseReason(details.reason),
             }, "Pending client disconnected");
+            this.socketIdentities.delete(ws);
             return;
         }
         const connection = this.sessions.get(ws);
         if (!connection) {
+            if (identity) {
+                this.logger.info({
+                    ...identityFields,
+                    code: details.code,
+                    reason: stringifyCloseReason(details.reason),
+                }, "Client socket closed without active session");
+                this.socketIdentities.delete(ws);
+            }
             return;
         }
         this.sessions.delete(ws);
         connection.sockets.delete(ws);
+        this.socketIdentities.delete(ws);
         if (connection.sockets.size === 0) {
             this.incrementRuntimeCounter("sessionDisconnectedWaitingReconnect");
             if (connection.externalDisconnectCleanupTimeout) {
@@ -910,8 +925,8 @@ export class VoiceAssistantWebSocketServer {
                 void this.cleanupConnection(connection, "Client disconnected (grace timeout)");
             }, EXTERNAL_SESSION_DISCONNECT_GRACE_MS);
             connection.externalDisconnectCleanupTimeout = timeout;
-            connection.connectionLogger.trace({
-                clientId: connection.clientId,
+            connection.connectionLogger.info({
+                ...identityFields,
                 code: details.code,
                 reason: stringifyCloseReason(details.reason),
                 reconnectGraceMs: EXTERNAL_SESSION_DISCONNECT_GRACE_MS,
@@ -920,8 +935,8 @@ export class VoiceAssistantWebSocketServer {
         }
         if (connection.sockets.size > 0) {
             this.incrementRuntimeCounter("sessionSocketDisconnectedAttached");
-            connection.connectionLogger.trace({
-                clientId: connection.clientId,
+            connection.connectionLogger.info({
+                ...identityFields,
                 remainingSockets: connection.sockets.size,
                 code: details.code,
                 reason: stringifyCloseReason(details.reason),
@@ -938,6 +953,7 @@ export class VoiceAssistantWebSocketServer {
         }
         for (const socket of connection.sockets) {
             this.sessions.delete(socket);
+            this.socketIdentities.delete(socket);
         }
         connection.sockets.clear();
         const existing = this.externalSessionsByKey.get(connection.clientId);
@@ -1112,7 +1128,7 @@ export class VoiceAssistantWebSocketServer {
                 return;
             }
             if (message.type === "session") {
-                void this.dispatchSessionMessage(activeConnection, message).catch((error) => {
+                void this.dispatchSessionMessage(ws, activeConnection, message).catch((error) => {
                     this.handleRawMessageError({ ws, data, error, log: activeConnection.connectionLogger });
                 });
             }
@@ -1121,8 +1137,16 @@ export class VoiceAssistantWebSocketServer {
             this.handleRawMessageError({ ws, data, error, log });
         }
     }
-    async dispatchSessionMessage(activeConnection, message) {
+    async dispatchSessionMessage(ws, activeConnection, message) {
         this.recordInboundSessionRequestType(message.message.type);
+        const controlRpc = getControlRpcLogInfo(message.message);
+        if (controlRpc) {
+            const identity = this.socketIdentities.get(ws);
+            activeConnection.connectionLogger.warn({
+                ...(identity ? toConnectionLogFields(identity) : { clientId: activeConnection.clientId }),
+                ...controlRpc,
+            }, "ws_control_rpc_received");
+        }
         const startMs = performance.now();
         await activeConnection.session.handleMessage(message.message);
         const durationMs = performance.now() - startMs;
@@ -1258,6 +1282,8 @@ export class VoiceAssistantWebSocketServer {
             outboundBinaryFrameTypesTop: runtimeMetrics.outboundBinaryFrameTypesTop,
             bufferedAmount: runtimeMetrics.bufferedAmount,
             eventLoopDelay: this.snapshotEventLoopDelay(),
+            uptimeSeconds: getProcessUptimeSeconds(),
+            memory: getProcessMemoryDiagnostics(),
             runtime: sessionMetrics,
             latency: runtimeMetrics.latency,
             agents: agentSnapshot,
@@ -1390,6 +1416,31 @@ export class VoiceAssistantWebSocketServer {
         }
     }
 }
+function createWebSocketConnectionIdentity(requestMetadata, metadata) {
+    return {
+        connectionId: `conn_${randomUUID().replaceAll("-", "")}`,
+        transport: metadata?.transport === "relay" ? "relay" : "direct",
+        ...(requestMetadata.host ? { host: requestMetadata.host } : {}),
+        ...(requestMetadata.origin ? { origin: requestMetadata.origin } : {}),
+        ...(requestMetadata.userAgent ? { userAgent: requestMetadata.userAgent } : {}),
+        ...(requestMetadata.remoteAddress ? { remoteAddress: requestMetadata.remoteAddress } : {}),
+        ...(metadata?.relayConnectionId ? { relayConnectionId: metadata.relayConnectionId } : {}),
+    };
+}
+function toConnectionLogFields(identity) {
+    return {
+        connectionId: identity.connectionId,
+        transport: identity.transport,
+        ...(identity.host ? { host: identity.host } : {}),
+        ...(identity.origin ? { origin: identity.origin } : {}),
+        ...(identity.userAgent ? { userAgent: identity.userAgent } : {}),
+        ...(identity.remoteAddress ? { remoteAddress: identity.remoteAddress } : {}),
+        ...(identity.relayConnectionId ? { relayConnectionId: identity.relayConnectionId } : {}),
+        ...(identity.clientId ? { clientId: identity.clientId } : {}),
+        ...(identity.sessionId ? { sessionId: identity.sessionId } : {}),
+        ...(identity.appVersion ? { appVersion: identity.appVersion } : {}),
+    };
+}
 function extractSocketRequestMetadata(request) {
     if (!request || typeof request !== "object") {
         return {};
@@ -1406,6 +1457,88 @@ function extractSocketRequestMetadata(request) {
         ...(remoteAddress ? { remoteAddress } : {}),
     };
 }
+function stripIpv6Brackets(hostname) {
+    return hostname.startsWith("[") && hostname.endsWith("]") ? hostname.slice(1, -1) : hostname;
+}
+function parseHostAuthority(host) {
+    const trimmed = host.trim();
+    if (!trimmed) {
+        return null;
+    }
+    if (trimmed.startsWith("[")) {
+        const end = trimmed.indexOf("]");
+        if (end === -1) {
+            return null;
+        }
+        const hostname = stripIpv6Brackets(trimmed.slice(0, end + 1)).toLowerCase();
+        const rest = trimmed.slice(end + 1);
+        if (!rest) {
+            return { hostname, port: null };
+        }
+        if (!rest.startsWith(":")) {
+            return null;
+        }
+        const port = rest.slice(1);
+        return port ? { hostname, port } : null;
+    }
+    const firstColon = trimmed.indexOf(":");
+    if (firstColon === -1) {
+        return { hostname: trimmed.toLowerCase(), port: null };
+    }
+    if (trimmed.indexOf(":", firstColon + 1) !== -1) {
+        return { hostname: trimmed.toLowerCase(), port: null };
+    }
+    const hostname = trimmed.slice(0, firstColon).toLowerCase();
+    const port = trimmed.slice(firstColon + 1);
+    return hostname && port ? { hostname, port } : null;
+}
+function defaultPortForOriginProtocol(protocol) {
+    if (protocol === "http:") {
+        return "80";
+    }
+    if (protocol === "https:") {
+        return "443";
+    }
+    return null;
+}
+function isLoopbackAlias(hostname) {
+    const normalized = stripIpv6Brackets(hostname).toLowerCase();
+    if (normalized === "localhost" || normalized.endsWith(".localhost")) {
+        return true;
+    }
+    if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") {
+        return true;
+    }
+    return /^127(?:\.\d{1,3}){3}$/.test(normalized);
+}
+export function isWebSocketSameOrigin(origin, requestHost) {
+    if (!origin || !requestHost) {
+        return false;
+    }
+    if (origin === `http://${requestHost}` || origin === `https://${requestHost}`) {
+        return true;
+    }
+    let originUrl;
+    try {
+        originUrl = new URL(origin);
+    }
+    catch {
+        return false;
+    }
+    const originPort = originUrl.port || defaultPortForOriginProtocol(originUrl.protocol);
+    if (!originPort) {
+        return false;
+    }
+    const requestAuthority = parseHostAuthority(requestHost);
+    if (!requestAuthority) {
+        return false;
+    }
+    const requestPort = requestAuthority.port || defaultPortForOriginProtocol(originUrl.protocol);
+    if (originPort !== requestPort) {
+        return false;
+    }
+    return isLoopbackAlias(originUrl.hostname) && isLoopbackAlias(requestAuthority.hostname);
+}
 function selectWebSocketProtocol(protocols, password) {
     if (!password) {
         return protocols.values().next().value ?? false;
@@ -1432,6 +1565,31 @@ function stringifyCloseReason(reason) {
     const text = String(reason);
     return text.length > 0 ? text : null;
 }
+function getControlRpcLogInfo(message) {
+    if (message.type === "shutdown_server_request") {
+        return {
+            requestType: message.type,
+            requestId: message.requestId,
+            reason: CLIENT_SHUTDOWN_RPC_REASON,
+        };
+    }
+    if (message.type === "restart_server_request") {
+        const reason = normalizeClientRestartRpcReason(message.reason);
+        return {
+            requestType: message.type,
+            requestId: message.requestId,
+            reason,
+        };
+    }
+    if (message.type === "daemon.update.request") {
+        return {
+            requestType: message.type,
+            requestId: message.requestId,
+            reason: "daemon_update",
+        };
+    }
+    return null;
+}
 function extractRequestInfoFromUnknownWsInbound(payload) {
     if (!payload || typeof payload !== "object") {
         return null;

package/dist/server/services/quota-fetcher/manifest.js

@@ -4,6 +4,7 @@ import { CopilotQuotaProvider } from "./providers/copilot.js";
 import { CursorQuotaProvider } from "./providers/cursor.js";
 import { GrokQuotaProvider } from "./providers/grok.js";
 import { KimiQuotaProvider } from "./providers/kimi.js";
+import { MiniMaxQuotaProvider } from "./providers/minimax.js";
 import { ZaiQuotaProvider } from "./providers/zai.js";
 export const PROVIDER_USAGE_FETCHERS = [
     {
@@ -40,6 +41,10 @@ export const PROVIDER_USAGE_FETCHERS = [
         providerId: "kimi",
         create: (options) => new KimiQuotaProvider({ logger: options.logger, fetch: options.fetch }),
     },
+    {
+        providerId: "minimax",
+        create: (options) => new MiniMaxQuotaProvider({ logger: options.logger, fetch: options.fetch }),
+    },
 ];
 export function createProviderUsageFetchers(options) {
     return PROVIDER_USAGE_FETCHERS.map((entry) => entry.create(options));

package/dist/server/services/quota-fetcher/providers/minimax.d.ts

@@ -0,0 +1,29 @@
+import type { Logger } from "pino";
+import type { ProviderUsage } from "../../../server/messages.js";
+import type { ProviderApiFetch, ProviderUsageFetcher } from "../provider.js";
+interface MiniMaxQuotaProviderOptions {
+    logger: Logger;
+    fetch?: ProviderApiFetch;
+    configPath?: string;
+    credentialsPath?: string;
+    env?: NodeJS.ProcessEnv;
+    now?: () => number;
+}
+export declare class MiniMaxQuotaProvider implements ProviderUsageFetcher {
+    readonly providerId = "minimax";
+    readonly displayName = "MiniMax";
+    private readonly logger;
+    private readonly fetchApi;
+    private readonly configPath;
+    private readonly credentialsPath;
+    private readonly env;
+    private readonly now;
+    constructor(options: MiniMaxQuotaProviderOptions);
+    fetchUsage(): Promise<ProviderUsage>;
+    private resolveAuth;
+    private isExpired;
+    private readCredentials;
+    private readConfig;
+}
+export {};
+//# sourceMappingURL=minimax.d.ts.map