browser/platform_web/api/client.ts

import type {
  AiProviderListResponse,
  AiProviderModelsResponse,
  AiProviderRequest,
  AiProviderResponse,
  AiProviderStatusRequest,
  AiProviderTestResponse,
  AiProviderUpdateRequest,
  AIInvocationRequest,
  AIInvocationResponse,
  ApiErrorResponse,
  ArtifactContentChunk,
  ArtifactDownloadReferenceResponse,
  ArtifactFilterRequest,
  ArtifactListResponse,
  AuthSessionResponse,
  AuditEventListResponse,
  CurrentUserResponse,
  FileOperationDispatchRequest,
  FileOperationDispatchResponse,
  GamePluginListResponse,
  HealthResponse,
  JobCreateRequest,
  JobListResponse,
  JobResponse,
  LlmConfigSuggestionRequest,
  LlmConfigSuggestionResponse,
  LogStreamCursorRequest,
  LogStreamCursorResponse,
  LogStreamListResponse,
  LoginRequest,
  MarketplacePluginFilterRequest,
  MarketplacePluginListResponse,
  MarketplacePluginResponse,
  MarketplacePluginStateRequest,
  PlatformResourceUsageResponse,
  PluginBridgeAuthorizeRequest,
  PluginBridgeAuthorizeResponse,
  PluginBridgeExecuteRequest,
  PluginBridgeExecuteResponse,
  RegisterRequest,
  RunEndpointListResponse,
  ServerConfigResponse,
  ServerConfigDiffPreviewRequest,
  ServerConfigDiffPreviewResponse,
  ServerLifecycleCommandRequest,
  ServerLifecycleCreateRequest,
  ServerLifecycleResponse,
  ServerConfigWriteApprovalRequest,
  ServerConfigWriteDispatchResponse,
  ServerInstanceListResponse,
  ServerInstanceResponse,
  ServerMemberListResponse,
  ServerMemberRequest,
  ServerMetricsListResponse,
  UserCreateRequest,
  UserListResponse,
  UserProfileUpdateRequest,
  UserResponse,
  UserThemePreferenceRequest,
  UserThemePreferenceResponse,
  UserUpdateRequest
} from "./types";
import { readWebRuntimeEnv } from "../schemas/env";

let platformApiSessionToken: string | null = null;

export function setPlatformApiSessionToken(token: string | null) {
  platformApiSessionToken = token;
}

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 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 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 });
    if (!response.ok) {
      const apiError = await safeReadError(response);
      throw new Error(apiError?.message ?? `request failed: ${response.status}`);
    }
    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 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 getPlatformResourceUsage(): Promise<PlatformResourceUsageResponse> {
    return this.request<PlatformResourceUsageResponse>("/metrics/platform");
  }

  async listServerMetrics(): Promise<ServerMetricsListResponse> {
    return this.request<ServerMetricsListResponse>("/metrics/server-instances");
  }

  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,
      method: options.method ?? options.init?.method ?? "GET",
      headers,
      body: options.body === undefined ? options.init?.body : JSON.stringify(options.body)
    });

    if (!response.ok) {
      const apiError = await safeReadError(response);
      throw new Error(apiError?.message ?? `request failed: ${response.status}`);
    }

    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;
  }
}

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);