797 lines
33 KiB
TypeScript
797 lines
33 KiB
TypeScript
import type {
|
|
AiProviderListResponse,
|
|
AiProviderModelsResponse,
|
|
AiProviderRequest,
|
|
AiProviderResponse,
|
|
AiProviderStatusRequest,
|
|
AiProviderTestResponse,
|
|
AiProviderUpdateRequest,
|
|
AIInvocationRequest,
|
|
AIInvocationResponse,
|
|
AIConfigDiffApprovalResponse,
|
|
AIConfigDiffListResponse,
|
|
AlertListResponse,
|
|
AlertResponse,
|
|
AlertRetryResponse,
|
|
ApiErrorResponse,
|
|
ArtifactContentChunk,
|
|
ArtifactDownloadReferenceResponse,
|
|
ArtifactFilterRequest,
|
|
ArtifactListResponse,
|
|
AuthSessionResponse,
|
|
AuditEventListResponse,
|
|
ClientManagerBuildRequest,
|
|
ClientManagerControlRequest,
|
|
ClientManagerDeployRequest,
|
|
ClientManagerDistributionResponse,
|
|
ClientManagerDownloadRequest,
|
|
ClientManagerInstallationListResponse,
|
|
ClientManagerInstallationResponse,
|
|
ClientManagerRetryRequest,
|
|
ClientManagerRevokeSessionRequest,
|
|
ClientManagerUninstallRequest,
|
|
ClientManagerUpdateRequest,
|
|
ComponentKeyResponse,
|
|
ComponentKeyResetRequest,
|
|
CurrentUserResponse,
|
|
DependencyCatalogResponse,
|
|
DependencyJobRequest,
|
|
FileOperationDispatchRequest,
|
|
FileOperationDispatchResponse,
|
|
GameClientBridgeCancelRequest,
|
|
GameClientBridgeCancelResponse,
|
|
GameClientBridgeCommandFilterRequest,
|
|
GameClientBridgeCommandListResponse,
|
|
GameClientBridgeCommandResponse,
|
|
GameClientBridgeQueueRequest,
|
|
GameClientBridgeSnapshotListResponse,
|
|
GameClientBridgeSnapshotQuery,
|
|
GameClientBridgeStatusResponse,
|
|
GamePluginListResponse,
|
|
HealthResponse,
|
|
JobCreateRequest,
|
|
JobListResponse,
|
|
JobResponse,
|
|
LlmConfigSuggestionRequest,
|
|
LlmConfigSuggestionResponse,
|
|
LogBackfillRequest,
|
|
LogStreamCursorRequest,
|
|
LogStreamCursorResponse,
|
|
LogStreamListResponse,
|
|
LoginRequest,
|
|
MarketplacePluginFilterRequest,
|
|
MarketplacePluginListResponse,
|
|
MarketplacePluginResponse,
|
|
MarketplacePluginStateRequest,
|
|
PlatformResourceUsageResponse,
|
|
ProductionCapacitySummaryResponse,
|
|
CapacityAdmissionDecisionResponse,
|
|
PluginLifecycleActionRequest,
|
|
PluginLifecycleActionResponse,
|
|
PluginLifecycleListResponse,
|
|
PluginBridgeAuthorizeRequest,
|
|
PluginBridgeAuthorizeResponse,
|
|
PluginBridgeExecuteRequest,
|
|
PluginBridgeExecuteResponse,
|
|
RegisterRequest,
|
|
RunDistributionGenerateRequest,
|
|
RunDistributionResponse,
|
|
RunEndpointListResponse,
|
|
RunUpdateJobResponse,
|
|
RunUpdateJobListResponse,
|
|
RunUpdateRequest,
|
|
RuntimeBindingResponse,
|
|
RuntimeBindingUpdateRequest,
|
|
ServerConfigResponse,
|
|
ServerConfigDiffPreviewRequest,
|
|
ServerConfigDiffPreviewResponse,
|
|
ServerLifecycleCommandRequest,
|
|
ServerLifecycleCreateRequest,
|
|
ServerLifecycleResponse,
|
|
ServerDeploymentRequest,
|
|
ServerDeploymentRevealResponse,
|
|
ServerDeploymentResponse,
|
|
ServerConfigWriteApprovalRequest,
|
|
ServerConfigWriteDispatchResponse,
|
|
SourceRCONCommandRequest,
|
|
SourceRCONCommandResponse,
|
|
ServerInstanceListResponse,
|
|
ServerDeletionRequest,
|
|
ServerInstanceUpdateRequest,
|
|
ServerInstanceResponse,
|
|
ServerMemberListResponse,
|
|
ServerMemberRequest,
|
|
ServerMetricsListResponse,
|
|
MetricSampleListResponse,
|
|
BackupListResponse,
|
|
BackupResponse,
|
|
RemoteAdapterDeclarationListResponse,
|
|
RemoteAdapterRequest,
|
|
RemoteAdapterResponse,
|
|
ServerRuntimeActionsResponse,
|
|
UserCreateRequest,
|
|
UserListResponse,
|
|
UserProfileUpdateRequest,
|
|
UserResponse,
|
|
UserThemePreferenceRequest,
|
|
UserThemePreferenceResponse,
|
|
UserUpdateRequest
|
|
} from "./types";
|
|
import { readWebRuntimeEnv } from "../schemas/env";
|
|
import { parseSafeDependencyCatalog, parseSafeRunUpdate, parseSafeRunUpdateList } from "../schemas/runtimeUpdates";
|
|
import { parseSafeClientManagerLifecycle, parseSafeClientManagerLifecycleList } from "../schemas/clientManagerLifecycle";
|
|
import {
|
|
parseSafeGameClientBridgeCancellation,
|
|
parseSafeGameClientBridgeCommand,
|
|
parseSafeGameClientBridgeCommandList,
|
|
parseSafeGameClientBridgeSnapshotList,
|
|
parseSafeGameClientBridgeStatus
|
|
} from "../schemas/gameClientBridge";
|
|
import { safeDiagnosticText } from "../utils/safeDiagnosticText";
|
|
|
|
let platformApiSessionToken: string | null = null;
|
|
let platformApiAuthFailureHandler: ((error: PlatformApiError) => void) | null = null;
|
|
|
|
export function setPlatformApiSessionToken(token: string | null) {
|
|
platformApiSessionToken = token;
|
|
}
|
|
|
|
export function setPlatformApiAuthFailureHandler(handler: ((error: PlatformApiError) => void) | null) {
|
|
platformApiAuthFailureHandler = handler;
|
|
}
|
|
|
|
export class PlatformApiError extends Error {
|
|
constructor(
|
|
readonly status: number,
|
|
readonly code: string,
|
|
message: string
|
|
) {
|
|
super(message);
|
|
this.name = "PlatformApiError";
|
|
}
|
|
}
|
|
|
|
export class PlatformApiClient {
|
|
constructor(private readonly baseUrl = "/api/v1", private readonly sessionTokenProvider: () => string | null = () => platformApiSessionToken) {}
|
|
|
|
async health(): Promise<HealthResponse> {
|
|
return this.request<HealthResponse>("/healthz", { absolute: true });
|
|
}
|
|
|
|
async listGamePlugins(): Promise<GamePluginListResponse> {
|
|
return this.request<GamePluginListResponse>("/game-plugins");
|
|
}
|
|
|
|
async listMarketplacePlugins(filter: MarketplacePluginFilterRequest = {}): Promise<MarketplacePluginListResponse> {
|
|
return this.request<MarketplacePluginListResponse>(`/plugin-marketplace/plugins${marketplaceQuery(filter)}`);
|
|
}
|
|
|
|
async getMarketplacePlugin(id: string): Promise<MarketplacePluginResponse> {
|
|
return this.request<MarketplacePluginResponse>(`/plugin-marketplace/plugins/${encodeURIComponent(id)}`);
|
|
}
|
|
|
|
async setMarketplacePluginState(id: string, request: MarketplacePluginStateRequest): Promise<MarketplacePluginResponse> {
|
|
return this.request<MarketplacePluginResponse>(`/plugin-marketplace/plugins/${encodeURIComponent(id)}/state`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listServerInstances(): Promise<ServerInstanceListResponse> {
|
|
return this.request<ServerInstanceListResponse>("/server-instances");
|
|
}
|
|
|
|
async createServerWorkflow(request: ServerLifecycleCreateRequest): Promise<ServerLifecycleResponse> {
|
|
return this.request<ServerLifecycleResponse>("/server-instances/workflows/create", {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async getServerDeployment(id: string): Promise<ServerDeploymentResponse> {
|
|
return this.request<ServerDeploymentResponse>(`/server-instances/${encodeURIComponent(id)}/deployment`);
|
|
}
|
|
|
|
async revealServerDeployment(id: string): Promise<ServerDeploymentRevealResponse> {
|
|
return this.request<ServerDeploymentRevealResponse>(`/server-instances/${encodeURIComponent(id)}/deployment/reveal`);
|
|
}
|
|
|
|
async updateServerDeployment(id: string, request: ServerDeploymentRequest): Promise<ServerDeploymentResponse> {
|
|
return this.request<ServerDeploymentResponse>(`/server-instances/${encodeURIComponent(id)}/deployment`, { method: "PUT", body: request });
|
|
}
|
|
|
|
async deployServerInstance(id: string, request: ServerLifecycleCommandRequest): Promise<ServerLifecycleResponse> {
|
|
return this.request<ServerLifecycleResponse>(`/server-instances/${encodeURIComponent(id)}/deploy`, { method: "POST", body: request });
|
|
}
|
|
|
|
async getServerRuntimeBinding(id: string): Promise<RuntimeBindingResponse> {
|
|
return this.request<RuntimeBindingResponse>(`/server-instances/${encodeURIComponent(id)}/runtime-binding`);
|
|
}
|
|
|
|
async updateServerRuntimeBinding(id: string, request: RuntimeBindingUpdateRequest): Promise<RuntimeBindingResponse> {
|
|
return this.request<RuntimeBindingResponse>(`/server-instances/${encodeURIComponent(id)}/runtime-binding`, { method: "PUT", body: request });
|
|
}
|
|
|
|
async startServerInstance(id: string, request: ServerLifecycleCommandRequest): Promise<ServerLifecycleResponse> {
|
|
return this.request<ServerLifecycleResponse>(`/server-instances/${encodeURIComponent(id)}/start`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async stopServerInstance(id: string, request: ServerLifecycleCommandRequest): Promise<ServerLifecycleResponse> {
|
|
return this.request<ServerLifecycleResponse>(`/server-instances/${encodeURIComponent(id)}/stop`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async queryServerProcessStatus(id: string, request: ServerLifecycleCommandRequest): Promise<ServerLifecycleResponse> {
|
|
return this.request<ServerLifecycleResponse>(`/server-instances/${encodeURIComponent(id)}/process/status`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listServerAdministratorCandidates(id: string): Promise<ServerMemberListResponse> {
|
|
return this.request<ServerMemberListResponse>(`/server-instances/${encodeURIComponent(id)}/administrators/candidates`);
|
|
}
|
|
|
|
async addServerAdministrator(id: string, request: ServerMemberRequest): Promise<ServerInstanceResponse> {
|
|
return this.request<ServerInstanceResponse>(`/server-instances/${encodeURIComponent(id)}/administrators`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async removeServerAdministrator(id: string, userId: string): Promise<ServerInstanceResponse> {
|
|
return this.request<ServerInstanceResponse>(`/server-instances/${encodeURIComponent(id)}/administrators/${encodeURIComponent(userId)}`, {
|
|
method: "DELETE"
|
|
});
|
|
}
|
|
|
|
async listRunEndpoints(): Promise<RunEndpointListResponse> {
|
|
return this.request<RunEndpointListResponse>("/run/endpoints");
|
|
}
|
|
|
|
async listJobs(serverInstanceId?: string): Promise<JobListResponse> {
|
|
const params = serverInstanceId ? `?serverInstanceId=${encodeURIComponent(serverInstanceId)}` : "";
|
|
return this.request<JobListResponse>(`/jobs${params}`);
|
|
}
|
|
|
|
async listArtifacts(filter: ArtifactFilterRequest = {}): Promise<ArtifactListResponse> {
|
|
return this.request<ArtifactListResponse>(`/artifacts${artifactQuery(filter)}`);
|
|
}
|
|
|
|
async openArtifactDownload(id: string): Promise<ArtifactDownloadReferenceResponse> {
|
|
return this.request<ArtifactDownloadReferenceResponse>(`/artifacts/${encodeURIComponent(id)}/download`, { method: "POST", body: {} });
|
|
}
|
|
|
|
async readArtifactContent(id: string, offset = 0, limit?: number): Promise<ArtifactContentChunk> {
|
|
const params = new URLSearchParams({ offset: String(offset) });
|
|
if (limit !== undefined) {
|
|
params.set("limit", String(limit));
|
|
}
|
|
const headers = new Headers();
|
|
const sessionToken = this.sessionTokenProvider();
|
|
if (sessionToken) {
|
|
headers.set("Authorization", `Bearer ${sessionToken}`);
|
|
}
|
|
const response = await fetch(`${this.baseUrl}/artifacts/${encodeURIComponent(id)}/content?${params.toString()}`, { headers, credentials: "same-origin" });
|
|
if (!response.ok) {
|
|
throw await responseError(response);
|
|
}
|
|
const payload = await response.arrayBuffer();
|
|
return {
|
|
artifactId: response.headers.get("X-Artifact-Id") ?? undefined,
|
|
payload,
|
|
contentType: response.headers.get("Content-Type") ?? "application/octet-stream",
|
|
contentLength: Number(response.headers.get("Content-Length") ?? payload.byteLength),
|
|
contentRange: response.headers.get("Content-Range") ?? undefined,
|
|
checksum: response.headers.get("X-Artifact-Checksum") ?? undefined,
|
|
contentChecksum: response.headers.get("X-Artifact-Content-Checksum") ?? undefined,
|
|
storageBehavior: response.headers.get("X-Artifact-Storage") ?? undefined
|
|
};
|
|
}
|
|
|
|
async getJob(id: string): Promise<JobResponse> {
|
|
return this.request<JobResponse>(`/jobs/${encodeURIComponent(id)}`);
|
|
}
|
|
|
|
async getServerRuntimeActions(id: string): Promise<ServerRuntimeActionsResponse> {
|
|
return this.request<ServerRuntimeActionsResponse>(`/server-instances/${encodeURIComponent(id)}/runtime/actions`);
|
|
}
|
|
|
|
async generateRunDistribution(id: string, request: RunDistributionGenerateRequest): Promise<RunDistributionResponse> {
|
|
return this.request<RunDistributionResponse>(`/server-instances/${encodeURIComponent(id)}/run/generate`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async downloadLatestRunDistribution(id: string): Promise<ArtifactDownloadReferenceResponse> {
|
|
return this.request<ArtifactDownloadReferenceResponse>(`/server-instances/${encodeURIComponent(id)}/run/download`, {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
}
|
|
|
|
async resetRunKey(id: string): Promise<ComponentKeyResponse> {
|
|
return this.request<ComponentKeyResponse>(`/server-instances/${encodeURIComponent(id)}/run/key/reset`, {
|
|
method: "POST",
|
|
body: {}
|
|
});
|
|
}
|
|
|
|
async pushRunUpdate(id: string, request: RunUpdateRequest): Promise<RunUpdateJobResponse> {
|
|
const response = await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/run/update`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
return parseSafeRunUpdate(response);
|
|
}
|
|
|
|
async listRunUpdates(id: string): Promise<RunUpdateJobListResponse> {
|
|
return parseSafeRunUpdateList(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/run/update`));
|
|
}
|
|
|
|
async generateClientManager(id: string, request: ClientManagerBuildRequest): Promise<ClientManagerDistributionResponse> {
|
|
return this.request<ClientManagerDistributionResponse>(`/server-instances/${encodeURIComponent(id)}/client-managers/generate`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async downloadLatestClientManager(id: string, request: ClientManagerDownloadRequest = {}): Promise<ArtifactDownloadReferenceResponse> {
|
|
return this.request<ArtifactDownloadReferenceResponse>(`/server-instances/${encodeURIComponent(id)}/client-managers/download`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async resetClientManagerKey(id: string, request: ComponentKeyResetRequest): Promise<ComponentKeyResponse> {
|
|
return this.request<ComponentKeyResponse>(`/server-instances/${encodeURIComponent(id)}/client-managers/key/reset`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listClientManagerLifecycles(id: string): Promise<ClientManagerInstallationListResponse> {
|
|
return parseSafeClientManagerLifecycleList(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers`));
|
|
}
|
|
|
|
async getClientManagerLifecycle(id: string, profileKey: string): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/${encodeURIComponent(profileKey)}`));
|
|
}
|
|
|
|
async deployClientManager(id: string, request: ClientManagerDeployRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/deploy`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async controlClientManager(id: string, request: ClientManagerControlRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/control`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async updateClientManager(id: string, request: ClientManagerUpdateRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/update`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async retryClientManagerLifecycle(id: string, request: ClientManagerRetryRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/retry`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async revokeClientManagerSession(id: string, request: ClientManagerRevokeSessionRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/revoke-session`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async uninstallClientManager(id: string, request: ClientManagerUninstallRequest): Promise<ClientManagerInstallationResponse> {
|
|
return parseSafeClientManagerLifecycle(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/client-managers/uninstall`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async getGameClientBridgeStatus(id: string): Promise<GameClientBridgeStatusResponse> {
|
|
return parseSafeGameClientBridgeStatus(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge`));
|
|
}
|
|
|
|
async listGameClientBridgeCommands(id: string, filter: GameClientBridgeCommandFilterRequest = {}): Promise<GameClientBridgeCommandListResponse> {
|
|
const params = new URLSearchParams();
|
|
if (filter.profileKey) params.set("profileKey", filter.profileKey);
|
|
if (filter.state) params.set("state", filter.state);
|
|
if (filter.commandType) params.set("commandType", filter.commandType);
|
|
const query = params.toString();
|
|
return parseSafeGameClientBridgeCommandList(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge/commands${query ? `?${query}` : ""}`));
|
|
}
|
|
|
|
async queueGameClientBridgeCommand(id: string, request: GameClientBridgeQueueRequest): Promise<GameClientBridgeCommandResponse> {
|
|
return parseSafeGameClientBridgeCommand(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge/commands`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async getGameClientBridgeCommand(id: string, commandId: string): Promise<GameClientBridgeCommandResponse> {
|
|
return parseSafeGameClientBridgeCommand(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge/commands/${encodeURIComponent(commandId)}`));
|
|
}
|
|
|
|
async cancelGameClientBridgeCommand(id: string, commandId: string, request: GameClientBridgeCancelRequest = {}): Promise<GameClientBridgeCancelResponse> {
|
|
return parseSafeGameClientBridgeCancellation(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge/commands/${encodeURIComponent(commandId)}/cancel`, { method: "POST", body: request }));
|
|
}
|
|
|
|
async listGameClientBridgeSnapshots(id: string, query: GameClientBridgeSnapshotQuery = {}): Promise<GameClientBridgeSnapshotListResponse> {
|
|
const params = new URLSearchParams();
|
|
if (query.profileKey) params.set("profileKey", query.profileKey);
|
|
if (query.type) params.set("type", query.type);
|
|
if (query.streamKey) params.set("streamKey", query.streamKey);
|
|
if (query.observedAfter) params.set("observedAfter", query.observedAfter);
|
|
if (query.limit !== undefined) params.set("limit", String(query.limit));
|
|
const search = params.toString();
|
|
return parseSafeGameClientBridgeSnapshotList(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/game-client-bridge/snapshots${search ? `?${search}` : ""}`));
|
|
}
|
|
|
|
async checkDependencies(id: string, request: DependencyJobRequest): Promise<JobResponse> {
|
|
return this.request<JobResponse>(`/server-instances/${encodeURIComponent(id)}/dependencies/check`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async getDependencyCatalog(id: string): Promise<DependencyCatalogResponse> {
|
|
return parseSafeDependencyCatalog(await this.request<unknown>(`/server-instances/${encodeURIComponent(id)}/dependencies`));
|
|
}
|
|
|
|
async installDependencies(id: string, request: DependencyJobRequest): Promise<JobResponse> {
|
|
return this.request<JobResponse>(`/server-instances/${encodeURIComponent(id)}/dependencies/install`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listServerLiveLogs(id: string): Promise<LogStreamListResponse> {
|
|
return this.request<LogStreamListResponse>(`/server-instances/${encodeURIComponent(id)}/logs/live`);
|
|
}
|
|
|
|
async requestLogBackfill(id: string, request: LogBackfillRequest): Promise<JobResponse> {
|
|
return this.request<JobResponse>(`/server-instances/${encodeURIComponent(id)}/logs/backfill`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async createJob(request: JobCreateRequest): Promise<JobResponse> {
|
|
return this.request<JobResponse>("/jobs", { method: "POST", body: request });
|
|
}
|
|
|
|
async register(request: RegisterRequest): Promise<AuthSessionResponse> {
|
|
return this.request<AuthSessionResponse>("/auth/register", { method: "POST", body: request });
|
|
}
|
|
|
|
async login(request: LoginRequest): Promise<AuthSessionResponse> {
|
|
return this.request<AuthSessionResponse>("/auth/login", { method: "POST", body: request });
|
|
}
|
|
|
|
async logout(): Promise<void> {
|
|
await this.request<void>("/auth/logout", { method: "POST", parseJson: false });
|
|
}
|
|
|
|
async getCurrentUser(): Promise<CurrentUserResponse> {
|
|
return this.request<CurrentUserResponse>("/users/current");
|
|
}
|
|
|
|
async listUsers(): Promise<UserListResponse> {
|
|
return this.request<UserListResponse>("/users");
|
|
}
|
|
|
|
async createUser(request: UserCreateRequest): Promise<UserResponse> {
|
|
return this.request<UserResponse>("/users", { method: "POST", body: request });
|
|
}
|
|
|
|
async updateUser(id: string, request: UserUpdateRequest): Promise<UserResponse> {
|
|
return this.request<UserResponse>(`/users/${encodeURIComponent(id)}`, { method: "PUT", body: request });
|
|
}
|
|
|
|
async updateCurrentUserProfile(request: UserProfileUpdateRequest): Promise<CurrentUserResponse> {
|
|
return this.request<CurrentUserResponse>("/users/current/profile", { method: "PUT", body: request });
|
|
}
|
|
|
|
async updateCurrentUserTheme(request: UserThemePreferenceRequest): Promise<UserThemePreferenceResponse> {
|
|
return this.request<UserThemePreferenceResponse>("/users/current/theme", { method: "PUT", body: request });
|
|
}
|
|
|
|
async getServerInstance(id: string): Promise<ServerInstanceResponse> {
|
|
return this.request<ServerInstanceResponse>(`/server-instances/${encodeURIComponent(id)}`);
|
|
}
|
|
|
|
async updateServerInstance(id: string, request: ServerInstanceUpdateRequest): Promise<ServerInstanceResponse> {
|
|
return this.request<ServerInstanceResponse>(`/server-instances/${encodeURIComponent(id)}`, {
|
|
method: "PUT",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async deleteServerInstance(id: string, request: ServerDeletionRequest): Promise<void> {
|
|
return this.request<void>(`/server-instances/${encodeURIComponent(id)}`, { method: "DELETE", body: request, parseJson: false });
|
|
}
|
|
|
|
async getPlatformResourceUsage(): Promise<PlatformResourceUsageResponse> {
|
|
return this.request<PlatformResourceUsageResponse>("/metrics/platform");
|
|
}
|
|
|
|
async getProductionCapacity(): Promise<ProductionCapacitySummaryResponse> {
|
|
return this.request<ProductionCapacitySummaryResponse>("/production/capacity");
|
|
}
|
|
|
|
async checkCapacityAdmission(request: { serverInstanceId?: string; runEndpointId?: string; capability: string; targetKey?: string; idempotencyKey?: string }): Promise<CapacityAdmissionDecisionResponse> {
|
|
return this.request<CapacityAdmissionDecisionResponse>("/production/capacity/admission", { method: "POST", body: request });
|
|
}
|
|
|
|
async listAlerts(filter: { state?: string; sourceKind?: string; sourceId?: string; severity?: string } = {}): Promise<AlertListResponse> {
|
|
const params = new URLSearchParams();
|
|
Object.entries(filter).forEach(([key, value]) => { if (value) params.set(key, value); });
|
|
const query = params.toString();
|
|
return this.request<AlertListResponse>(`/alerts${query ? `?${query}` : ""}`);
|
|
}
|
|
|
|
async acknowledgeAlert(id: string, note = ""): Promise<AlertResponse> {
|
|
return this.request<AlertResponse>(`/alerts/${encodeURIComponent(id)}/acknowledge`, { method: "POST", body: { note } });
|
|
}
|
|
|
|
async resolveAlert(id: string, note = ""): Promise<AlertResponse> {
|
|
return this.request<AlertResponse>(`/alerts/${encodeURIComponent(id)}/resolve`, { method: "POST", body: { note } });
|
|
}
|
|
|
|
async retryAlert(id: string, idempotencyKey: string): Promise<AlertRetryResponse> {
|
|
return this.request<AlertRetryResponse>(`/alerts/${encodeURIComponent(id)}/retry`, { method: "POST", body: { idempotencyKey } });
|
|
}
|
|
|
|
async listPluginLifecycles(filter: { pluginId?: string; serverInstanceId?: string; currentState?: string } = {}): Promise<PluginLifecycleListResponse> {
|
|
const params = new URLSearchParams();
|
|
Object.entries(filter).forEach(([key, value]) => { if (value) params.set(key, value); });
|
|
const query = params.toString();
|
|
return this.request<PluginLifecycleListResponse>(`/plugin-lifecycles${query ? `?${query}` : ""}`);
|
|
}
|
|
|
|
async runPluginLifecycle(pluginId: string, request: PluginLifecycleActionRequest): Promise<PluginLifecycleActionResponse> {
|
|
return this.request<PluginLifecycleActionResponse>(`/plugin-lifecycles/${encodeURIComponent(pluginId)}/actions`, { method: "POST", body: request });
|
|
}
|
|
|
|
async listAIConfigDiffs(filter: { serverInstanceId?: string; pluginId?: string; state?: string } = {}): Promise<AIConfigDiffListResponse> {
|
|
const params = new URLSearchParams();
|
|
Object.entries(filter).forEach(([key, value]) => { if (value) params.set(key, value); });
|
|
const query = params.toString();
|
|
return this.request<AIConfigDiffListResponse>(`/ai/config-diffs${query ? `?${query}` : ""}`);
|
|
}
|
|
|
|
async approveAIConfigDiff(id: string, idempotencyKey: string): Promise<AIConfigDiffApprovalResponse> {
|
|
return this.request<AIConfigDiffApprovalResponse>(`/ai/config-diffs/${encodeURIComponent(id)}/approve`, { method: "POST", body: { idempotencyKey } });
|
|
}
|
|
|
|
async listServerMetrics(): Promise<ServerMetricsListResponse> {
|
|
return this.request<ServerMetricsListResponse>("/metrics/server-instances");
|
|
}
|
|
|
|
async listMetricHistory(serverInstanceId: string, limit = 100): Promise<MetricSampleListResponse> {
|
|
const params = new URLSearchParams({ serverInstanceId, limit: String(limit) });
|
|
return this.request<MetricSampleListResponse>(`/metrics/server-instances/history?${params.toString()}`);
|
|
}
|
|
|
|
async listBackups(serverInstanceId: string): Promise<BackupListResponse> {
|
|
return this.request<BackupListResponse>(`/backups?serverInstanceId=${encodeURIComponent(serverInstanceId)}`);
|
|
}
|
|
|
|
async getBackup(id: string): Promise<BackupResponse> {
|
|
return this.request<BackupResponse>(`/backups/${encodeURIComponent(id)}`);
|
|
}
|
|
|
|
async listRemoteAdapters(serverInstanceId: string): Promise<RemoteAdapterDeclarationListResponse> {
|
|
return this.request<RemoteAdapterDeclarationListResponse>(`/server-instances/${encodeURIComponent(serverInstanceId)}/remote-adapters`);
|
|
}
|
|
|
|
async requestRemoteAdapter(serverInstanceId: string, request: RemoteAdapterRequest): Promise<RemoteAdapterResponse> {
|
|
return this.request<RemoteAdapterResponse>(`/server-instances/${encodeURIComponent(serverInstanceId)}/remote-adapters`, { method: "POST", body: request });
|
|
}
|
|
|
|
async sendSourceRCONCommand(serverInstanceId: string, request: SourceRCONCommandRequest): Promise<SourceRCONCommandResponse> {
|
|
return this.request<SourceRCONCommandResponse>(`/server-instances/${encodeURIComponent(serverInstanceId)}/rcon/commands`, { method: "POST", body: request });
|
|
}
|
|
|
|
async getServerConfig(id: string): Promise<ServerConfigResponse> {
|
|
return this.request<ServerConfigResponse>(`/server-instances/${encodeURIComponent(id)}/config`);
|
|
}
|
|
|
|
async previewServerConfigDiff(id: string, request: ServerConfigDiffPreviewRequest): Promise<ServerConfigDiffPreviewResponse> {
|
|
return this.request<ServerConfigDiffPreviewResponse>(`/server-instances/${encodeURIComponent(id)}/config/diff`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async approveServerConfigWrite(id: string, request: ServerConfigWriteApprovalRequest): Promise<ServerConfigWriteDispatchResponse> {
|
|
return this.request<ServerConfigWriteDispatchResponse>(`/server-instances/${encodeURIComponent(id)}/config/approve`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async dispatchFileOperation(request: FileOperationDispatchRequest): Promise<FileOperationDispatchResponse> {
|
|
return this.request<FileOperationDispatchResponse>("/file-operations/dispatch", {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listLogStreams(): Promise<LogStreamListResponse> {
|
|
return this.request<LogStreamListResponse>("/log-streams");
|
|
}
|
|
|
|
async queryLogStream(request: LogStreamCursorRequest): Promise<LogStreamCursorResponse> {
|
|
return this.request<LogStreamCursorResponse>("/log-streams/query", { method: "POST", body: request });
|
|
}
|
|
|
|
async listAuditEvents(): Promise<AuditEventListResponse> {
|
|
return this.request<AuditEventListResponse>("/audit-events");
|
|
}
|
|
|
|
async suggestServerConfig(request: LlmConfigSuggestionRequest): Promise<LlmConfigSuggestionResponse> {
|
|
return this.request<LlmConfigSuggestionResponse>("/ai/config-suggestions", { method: "POST", body: request });
|
|
}
|
|
|
|
async invokeAI(request: AIInvocationRequest): Promise<AIInvocationResponse> {
|
|
return this.request<AIInvocationResponse>("/ai/invocations", { method: "POST", body: request });
|
|
}
|
|
|
|
async authorizePluginBridge(request: PluginBridgeAuthorizeRequest): Promise<PluginBridgeAuthorizeResponse> {
|
|
return this.request<PluginBridgeAuthorizeResponse>("/plugin-bridge/authorize", {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async executePluginBridge(request: PluginBridgeExecuteRequest): Promise<PluginBridgeExecuteResponse> {
|
|
return this.request<PluginBridgeExecuteResponse>("/plugin-bridge/execute", {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async listAiProviders(): Promise<AiProviderListResponse> {
|
|
return this.request<AiProviderListResponse>("/ai-providers");
|
|
}
|
|
|
|
async createAiProvider(request: AiProviderRequest): Promise<AiProviderResponse> {
|
|
return this.request<AiProviderResponse>("/ai-providers", {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async updateAiProvider(id: string, request: AiProviderUpdateRequest): Promise<AiProviderResponse> {
|
|
return this.request<AiProviderResponse>(`/ai-providers/${encodeURIComponent(id)}`, {
|
|
method: "PUT",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async setAiProviderStatus(id: string, request: AiProviderStatusRequest): Promise<AiProviderResponse> {
|
|
return this.request<AiProviderResponse>(`/ai-providers/${encodeURIComponent(id)}/status`, {
|
|
method: "POST",
|
|
body: request
|
|
});
|
|
}
|
|
|
|
async testAiProvider(id: string): Promise<AiProviderTestResponse> {
|
|
return this.request<AiProviderTestResponse>(`/ai-providers/${encodeURIComponent(id)}/test`, {
|
|
method: "POST"
|
|
});
|
|
}
|
|
|
|
async listAiProviderModels(id: string): Promise<AiProviderModelsResponse> {
|
|
return this.request<AiProviderModelsResponse>(`/ai-providers/${encodeURIComponent(id)}/models`);
|
|
}
|
|
|
|
private async request<T>(path: string, options: ApiRequestOptions = {}): Promise<T> {
|
|
const headers = new Headers(options.init?.headers);
|
|
if (options.body !== undefined) {
|
|
headers.set("Content-Type", "application/json");
|
|
}
|
|
const sessionToken = this.sessionTokenProvider();
|
|
if (sessionToken && !headers.has("Authorization")) {
|
|
headers.set("Authorization", `Bearer ${sessionToken}`);
|
|
}
|
|
|
|
const response = await fetch(options.absolute ? path : `${this.baseUrl}${path}`, {
|
|
...options.init,
|
|
credentials: options.init?.credentials ?? "same-origin",
|
|
method: options.method ?? options.init?.method ?? "GET",
|
|
headers,
|
|
body: options.body === undefined ? options.init?.body : JSON.stringify(options.body)
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw await responseError(response);
|
|
}
|
|
|
|
if (options.parseJson === false || response.status === 204) {
|
|
return undefined as T;
|
|
}
|
|
|
|
return response.json() as Promise<T>;
|
|
}
|
|
}
|
|
|
|
interface ApiRequestOptions {
|
|
absolute?: boolean;
|
|
method?: string;
|
|
body?: unknown;
|
|
init?: RequestInit;
|
|
parseJson?: boolean;
|
|
}
|
|
|
|
async function safeReadError(response: Response): Promise<ApiErrorResponse | null> {
|
|
try {
|
|
return (await response.json()) as ApiErrorResponse;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
async function responseError(response: Response): Promise<PlatformApiError> {
|
|
const apiError = await safeReadError(response);
|
|
const message = response.status === 401
|
|
? "会话已失效，请重新登录。"
|
|
: response.status === 403
|
|
? safeForbiddenMessage(apiError?.message)
|
|
: apiError?.message ?? `request failed: ${response.status}`;
|
|
const error = new PlatformApiError(response.status, apiError?.code ?? "request_failed", message);
|
|
if (response.status === 401) {
|
|
platformApiSessionToken = null;
|
|
platformApiAuthFailureHandler?.(error);
|
|
}
|
|
return error;
|
|
}
|
|
|
|
function safeForbiddenMessage(apiMessage?: string): string {
|
|
const sanitized = safeDiagnosticText(apiMessage, "")?.trim();
|
|
if (!sanitized || sanitized === "account is not allowed to access this resource") {
|
|
return "没有权限访问该资源。";
|
|
}
|
|
const missingPermission = sanitized.match(/^plugin does not declare required permission:\s*([a-z0-9._-]+)$/i);
|
|
if (missingPermission) {
|
|
return `插件未声明所需权限：${missingPermission[1]}`;
|
|
}
|
|
if (sanitized === "plugin is not installed") {
|
|
return "插件未安装，不能执行该操作。";
|
|
}
|
|
return "没有权限访问该资源。";
|
|
}
|
|
|
|
function marketplaceQuery(filter: MarketplacePluginFilterRequest): string {
|
|
const params = new URLSearchParams();
|
|
if (filter.status && filter.status !== "all") {
|
|
params.set("status", filter.status);
|
|
}
|
|
if (filter.serverType) {
|
|
params.set("serverType", filter.serverType);
|
|
}
|
|
if (filter.capability) {
|
|
params.set("capability", filter.capability);
|
|
}
|
|
if (filter.keyword) {
|
|
params.set("keyword", filter.keyword);
|
|
}
|
|
const query = params.toString();
|
|
return query ? `?${query}` : "";
|
|
}
|
|
|
|
function artifactQuery(filter: ArtifactFilterRequest): string {
|
|
const params = new URLSearchParams();
|
|
if (filter.ownerKind) {
|
|
params.set("ownerKind", filter.ownerKind);
|
|
}
|
|
if (filter.ownerId) {
|
|
params.set("ownerId", filter.ownerId);
|
|
}
|
|
if (filter.state) {
|
|
params.set("state", filter.state);
|
|
}
|
|
const query = params.toString();
|
|
return query ? `?${query}` : "";
|
|
}
|
|
|
|
export const platformApiClient = new PlatformApiClient(readWebRuntimeEnv().platformApiBaseUrl);
|