Better Launcher (Aerie)

use serde::{Deserialize, Serialize};
use std::env;

pub struct AerieClient {
    base_url: String,
    client: reqwest::Client,
    pub app_id: String,
}

#[derive(Deserialize, Debug)]
pub struct AerieUser {
    pub id: String,
    #[serde(rename = "displayName")]
    pub display_name: String,
    pub email: Option<String>,
}

#[derive(Serialize)]
pub struct FeedbackReport<'a> {
    #[serde(rename = "appId")]
    pub app_id: &'a str,
    pub category: &'a str,
    pub title: &'a str,
    pub content: &'a str,
}

impl AerieClient {
    pub fn new() -> Self {
        let port = env::var("BETTER_LAUNCHER_PORT").unwrap_or_else(|_| "27088".to_string());
        let app_id = env::var("BETTER_LAUNCHER_APP_ID").unwrap_or_default();
        Self {
            base_url: format!("http://127.0.0.1:{}", port),
            client: reqwest::Client::new(),
            app_id,
        }
    }

    pub async fn get_user(&self) -> Result<AerieUser, reqwest::Error> {
        self.client
            .get(format!("{}/api/user", self.base_url))
            .send()
            .await?
            .json::<AerieUser>()
            .await
    }

    pub async fn send_feedback(&self, title: &str, content: &str) -> Result<(), reqwest::Error> {
        let payload = FeedbackReport {
            app_id: &self.app_id,
            category: "bug",
            title,
            content,
        };
        self.client
            .post(format!("{}/api/feedback", self.base_url))
            .json(&payload)
            .send()
            .await?;
        Ok(())
    }
}

export class AerieSDK {
  private baseUrl: string;
  public appId: string;

  constructor() {
    const port = (typeof process !== 'undefined' && process.env.BETTER_LAUNCHER_PORT) || '27088';
    this.baseUrl = `http://127.0.0.1:${port}`;
    this.appId = (typeof process !== 'undefined' && process.env.BETTER_LAUNCHER_APP_ID) || '';
  }

  async getUser(): Promise<{ id: string; displayName: string; email?: string }> {
    const res = await fetch(`${this.baseUrl}/api/user`);
    return res.json();
  }

  async advertiseSession(sessionId: string, currentPlayers: number, maxPlayers: number) {
    return fetch(`${this.baseUrl}/api/session`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ appId: this.appId, sessionId, currentPlayers, maxPlayers, isJoinable: true })
    });
  }

  async pollPendingJoin(): Promise<string | null> {
    const res = await fetch(`${this.baseUrl}/api/session/pending-join`);
    const data = await res.json();
    return data.sessionId || null;
  }

  async sendFeedback(title: string, content: string, category: 'bug' | 'feature' = 'bug') {
    return fetch(`${this.baseUrl}/api/feedback`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ appId: this.appId, title, content, category })
    });
  }
}

import os
import json
import urllib.request

class AerieClient:
    def __init__(self):
        port = os.environ.get("BETTER_LAUNCHER_PORT", "27088")
        self.base_url = f"http://127.0.0.1:{port}"
        self.app_id = os.environ.get("BETTER_LAUNCHER_APP_ID", "")

    def get_user(self):
        req = urllib.request.Request(f"{self.base_url}/api/user")
        with urllib.request.urlopen(req) as response:
            return json.loads(response.read().decode())

    def send_feedback(self, title: str, content: str, category: str = "bug"):
        payload = json.dumps({
            "appId": self.app_id,
            "title": title,
            "content": content,
            "category": category
        }).encode("utf-8")
        req = urllib.request.Request(f"{self.base_url}/api/feedback", data=payload, headers={"Content-Type": "application/json"})
        with urllib.request.urlopen(req) as response:
            return response.status == 200

#pragma once
#include <string>
#include <curl/curl.h>

class AerieClient {
private:
    std::string baseUrl;
    std::string appId;

    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
        ((std::string*)userp)->append((char*)contents, size * nmemb);
        return size * nmemb;
    }

public:
    AerieClient() {
        const char* port = std::getenv("BETTER_LAUNCHER_PORT");
        baseUrl = std::string("http://127.0.0.1:") + (port ? port : "27088");
        const char* app = std::getenv("BETTER_LAUNCHER_APP_ID");
        appId = app ? app : "";
    }

    std::string GetUser() {
        CURL* curl = curl_easy_init();
        std::string readBuffer;
        if (curl) {
            std::string url = baseUrl + "/api/user";
            curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
            curl_easy_perform(curl);
            curl_easy_cleanup(curl);
        }
        return readBuffer;
    }
};