@getpaseo/server 0.1.101 → 0.1.102

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

package/dist/server/services/quota-fetcher/providers/minimax.js

@@ -0,0 +1,227 @@
+import { existsSync, promises as fs } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { ApiNumberSchema, ApiOptionalStringSchema, fetchProviderApi, unavailableUsage, windowFromUsedPct, } from "../usage.js";
+const MINIMAX_GLOBAL_BASE_URL = "https://api.minimax.io";
+const MINIMAX_CN_BASE_URL = "https://api.minimaxi.com";
+const MINIMAX_CREDENTIALS_PATH = join(homedir(), ".mmx", "credentials.json");
+const MINIMAX_CONFIG_PATH = join(homedir(), ".mmx", "config.json");
+const MiniMaxModelRemainSchema = z.object({
+    model_name: ApiOptionalStringSchema,
+    start_time: ApiNumberSchema.optional(),
+    end_time: ApiNumberSchema.optional(),
+    remains_time: ApiNumberSchema.optional(),
+    current_interval_total_count: ApiNumberSchema.optional(),
+    current_interval_usage_count: ApiNumberSchema.optional(),
+    current_interval_remaining_percent: ApiNumberSchema.optional(),
+    current_weekly_total_count: ApiNumberSchema.optional(),
+    current_weekly_usage_count: ApiNumberSchema.optional(),
+    current_weekly_remaining_percent: ApiNumberSchema.optional(),
+    current_interval_status: ApiNumberSchema.optional(),
+    current_weekly_status: ApiNumberSchema.optional(),
+    weekly_start_time: ApiNumberSchema.optional(),
+    weekly_end_time: ApiNumberSchema.optional(),
+    weekly_remains_time: ApiNumberSchema.optional(),
+    weekly_boost_permille: ApiNumberSchema.optional(),
+});
+const MiniMaxQuotaResponseSchema = z.object({
+    model_remains: z.array(MiniMaxModelRemainSchema).optional(),
+});
+const MiniMaxCredentialsSchema = z.object({
+    access_token: z.string().optional(),
+    refresh_token: z.string().optional(),
+    expires_at: ApiOptionalStringSchema,
+    resource_url: ApiOptionalStringSchema,
+});
+const MiniMaxConfigSchema = z.object({
+    api_key: z.string().optional(),
+    region: z.string().optional(),
+    base_url: ApiOptionalStringSchema,
+    oauth: MiniMaxCredentialsSchema.optional(),
+});
+function resolveBaseUrl(input) {
+    const explicit = input.baseUrl;
+    if (explicit && explicit.startsWith("http"))
+        return explicit;
+    if (input.region === "cn")
+        return MINIMAX_CN_BASE_URL;
+    return MINIMAX_GLOBAL_BASE_URL;
+}
+function computeUsedPct(remaining, total) {
+    if (typeof remaining !== "number" || typeof total !== "number")
+        return null;
+    if (!Number.isFinite(total) || total <= 0)
+        return null;
+    if (!Number.isFinite(remaining))
+        return null;
+    const used = total - remaining;
+    return Math.max(0, Math.min(100, (used / total) * 100));
+}
+function epochMsToIso(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
+        return null;
+    return new Date(value).toISOString();
+}
+function toneForStatus(status) {
+    if (status === 2)
+        return "danger";
+    if (status === 3)
+        return "default";
+    return "ok";
+}
+function toIntervalWindow(modelName, model) {
+    const total = model.current_interval_total_count ?? null;
+    const used = model.current_interval_usage_count ?? null;
+    const remainingPercent = model.current_interval_remaining_percent ?? null;
+    const usedPct = typeof remainingPercent === "number" && Number.isFinite(remainingPercent)
+        ? Math.max(0, Math.min(100, 100 - remainingPercent))
+        : computeUsedPct(typeof total === "number" && typeof used === "number" ? total - used : null, total);
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `interval_${modelName}`,
+        label: `${modelName} · Interval`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.end_time),
+        tone: toneForStatus(model.current_interval_status),
+    });
+}
+function toWeeklyWindow(modelName, model) {
+    const total = model.current_weekly_total_count ?? null;
+    const used = model.current_weekly_usage_count ?? null;
+    const remainingPercent = model.current_weekly_remaining_percent ?? null;
+    let usedPct = null;
+    if (typeof remainingPercent === "number" && Number.isFinite(remainingPercent)) {
+        usedPct = Math.max(0, Math.min(100, 100 - remainingPercent));
+    }
+    else if (typeof total === "number" && typeof used === "number") {
+        usedPct = computeUsedPct(total - used, total);
+    }
+    if (usedPct === null)
+        return null;
+    return windowFromUsedPct({
+        id: `weekly_${modelName}`,
+        label: `${modelName} · Weekly`,
+        utilizationPct: usedPct,
+        resetsAt: epochMsToIso(model.weekly_end_time),
+        tone: toneForStatus(model.current_weekly_status),
+    });
+}
+export class MiniMaxQuotaProvider {
+    constructor(options) {
+        this.providerId = "minimax";
+        this.displayName = "MiniMax";
+        this.logger = options.logger;
+        this.fetchApi = options.fetch ?? fetch;
+        this.configPath = options.configPath ?? MINIMAX_CONFIG_PATH;
+        this.credentialsPath = options.credentialsPath ?? MINIMAX_CREDENTIALS_PATH;
+        this.env = options.env ?? process.env;
+        this.now = options.now ?? Date.now;
+    }
+    async fetchUsage() {
+        const auth = await this.resolveAuth();
+        if (!auth)
+            return unavailableUsage(this);
+        const res = await fetchProviderApi(this.fetchApi, `${auth.baseUrl}/v1/token_plan/remains`, {
+            headers: {
+                Authorization: `Bearer ${auth.token}`,
+                Accept: "application/json",
+            },
+        });
+        if (!res.ok) {
+            this.logger.debug({ status: res.status }, "MiniMax usage fetch failed");
+            return unavailableUsage(this);
+        }
+        const resp = MiniMaxQuotaResponseSchema.parse(await res.json());
+        const models = resp.model_remains ?? [];
+        const windows = [];
+        for (const model of models) {
+            const name = model.model_name ?? "token-plan";
+            const intervalWindow = toIntervalWindow(name, model);
+            if (intervalWindow)
+                windows.push(intervalWindow);
+            const weeklyWindow = toWeeklyWindow(name, model);
+            if (weeklyWindow)
+                windows.push(weeklyWindow);
+        }
+        return {
+            providerId: this.providerId,
+            displayName: this.displayName,
+            status: windows.length > 0 ? "available" : "unavailable",
+            planLabel: null,
+            windows,
+            balances: [],
+            details: [],
+            error: null,
+        };
+    }
+    async resolveAuth() {
+        const envToken = this.env["MINIMAX_API_KEY"];
+        if (envToken) {
+            const envBase = this.env["MINIMAX_BASE_URL"];
+            return {
+                token: envToken,
+                baseUrl: resolveBaseUrl({ baseUrl: envBase }),
+            };
+        }
+        const credentials = await this.readCredentials();
+        if (credentials?.access_token && !this.isExpired(credentials.expires_at)) {
+            return {
+                token: credentials.access_token,
+                baseUrl: resolveBaseUrl({ baseUrl: credentials.resource_url }),
+            };
+        }
+        const config = await this.readConfig();
+        if (config?.api_key) {
+            return {
+                token: config.api_key,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        if (config?.oauth?.access_token && !this.isExpired(config.oauth.expires_at)) {
+            return {
+                token: config.oauth.access_token,
+                baseUrl: resolveBaseUrl({
+                    baseUrl: config.oauth.resource_url ?? config.base_url,
+                    region: config.region,
+                }),
+            };
+        }
+        return null;
+    }
+    isExpired(expiresAt) {
+        if (!expiresAt)
+            return false;
+        const parsed = Date.parse(expiresAt);
+        if (!Number.isFinite(parsed))
+            return false;
+        return parsed <= this.now();
+    }
+    async readCredentials() {
+        if (!existsSync(this.credentialsPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.credentialsPath, "utf8"));
+            return MiniMaxCredentialsSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    async readConfig() {
+        if (!existsSync(this.configPath))
+            return null;
+        try {
+            const raw = JSON.parse(await fs.readFile(this.configPath, "utf8"));
+            return MiniMaxConfigSchema.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+//# sourceMappingURL=minimax.js.map

package/dist/server/terminal/agent-hooks/agent-hook-installer.js

@@ -42,11 +42,11 @@ function resolveAgentHookInstallPath(install, options) {
 }
 export function buildAgentHookShellCommand(provider, event) {
     const hookCommand = `"\${PASEO_HOOK_CLI:-paseo}" hooks ${shellToken(provider.id)} ${shellToken(event.event)}`;
-    return `[ -n "$PASEO_TERMINAL_ID" ] && ${hookCommand}`;
+    return `if [ -n "$PASEO_TERMINAL_ID" ]; then ${hookCommand}; fi`;
 }
 export function buildAgentHookWindowsCommand(provider, event) {
     const hookArgs = `hooks ${windowsToken(provider.id)} ${windowsToken(event.event)}`;
-    return `if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" ${hookArgs}) else (paseo ${hookArgs}))`;
+    return `if defined PASEO_TERMINAL_ID (if defined PASEO_HOOK_CLI ("%PASEO_HOOK_CLI%" ${hookArgs}) else (paseo ${hookArgs})) else (exit /b 0)`;
 }
 function installAgentHookPluginFile(install, options) {
     const configPath = resolveAgentHookInstallPath(install, options);