Hugging Face's logo

Spaces:
devin15
/
cursor2api-rust
Sleeping

App Files Community
cursor2api-rust
File size: 3,689 Bytes 
2887ce2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
 
use crate::{
    app::constant::{
        CURSOR_API2_HOST, CURSOR_HOST, DEFAULT_TOKEN_FILE_NAME, DEFAULT_TOKEN_LIST_FILE_NAME,
        EMPTY_STRING,
    },
    common::utils::{parse_ascii_char_from_env, parse_string_from_env},
};
use std::sync::LazyLock;

macro_rules! def_pub_static {
    // 基础版本：直接存储 String
    ($name:ident, $value:expr) => {
        pub static $name: LazyLock<String> = LazyLock::new(|| $value);
    };

    // 环境变量版本
    ($name:ident, env: $env_key:expr, default: $default:expr) => {
        pub static $name: LazyLock<String> =
            LazyLock::new(|| parse_string_from_env($env_key, $default).trim().to_string());
    };
}

// macro_rules! def_pub_static_getter {
//     ($name:ident) => {
//         paste::paste! {
//             pub fn [<get_ $name:lower>]() -> String {
//                 (*$name).clone()
//             }
//         }
//     };
// }

def_pub_static!(ROUTE_PREFIX, env: "ROUTE_PREFIX", default: EMPTY_STRING);
def_pub_static!(AUTH_TOKEN, env: "AUTH_TOKEN", default: EMPTY_STRING);
def_pub_static!(TOKEN_FILE, env: "TOKEN_FILE", default: DEFAULT_TOKEN_FILE_NAME);
def_pub_static!(TOKEN_LIST_FILE, env: "TOKEN_LIST_FILE", default: DEFAULT_TOKEN_LIST_FILE_NAME);
def_pub_static!(ROUTE_MODELS_PATH, format!("{}/v1/models", *ROUTE_PREFIX));
def_pub_static!(
    ROUTE_CHAT_PATH,
    format!("{}/v1/chat/completions", *ROUTE_PREFIX)
);

pub static START_TIME: LazyLock<chrono::DateTime<chrono::Local>> =
    LazyLock::new(chrono::Local::now);

pub fn get_start_time() -> chrono::DateTime<chrono::Local> {
    *START_TIME
}

def_pub_static!(DEFAULT_INSTRUCTIONS, env: "DEFAULT_INSTRUCTIONS", default: "Respond in Chinese by default");

def_pub_static!(REVERSE_PROXY_HOST, env: "REVERSE_PROXY_HOST", default: EMPTY_STRING);

def_pub_static!(SHARED_AUTH_TOKEN, env: "SHARED_AUTH_TOKEN", default: EMPTY_STRING);

pub static USE_SHARE: LazyLock<bool> = LazyLock::new(|| !SHARED_AUTH_TOKEN.is_empty());

pub static TOKEN_DELIMITER: LazyLock<char> = LazyLock::new(|| {
    let delimiter = parse_ascii_char_from_env("TOKEN_DELIMITER", ',');
    if delimiter.is_ascii_alphabetic()
        || delimiter.is_ascii_digit()
        || delimiter == '+'
        || delimiter == '/'
    {
        ','
    } else {
        delimiter
    }
});

pub static TOKEN_DELIMITER_LEN: LazyLock<usize> = LazyLock::new(|| TOKEN_DELIMITER.len_utf8());

pub static USE_PROXY: LazyLock<bool> = LazyLock::new(|| !REVERSE_PROXY_HOST.is_empty());

pub static CURSOR_API2_CHAT_URL: LazyLock<String> = LazyLock::new(|| {
    let host = if *USE_PROXY {
        &*REVERSE_PROXY_HOST
    } else {
        CURSOR_API2_HOST
    };
    format!("https://{}/aiserver.v1.AiService/StreamChat", host)
});

pub static CURSOR_API2_STRIPE_URL: LazyLock<String> = LazyLock::new(|| {
    let host = if *USE_PROXY {
        &*REVERSE_PROXY_HOST
    } else {
        CURSOR_API2_HOST
    };
    format!("https://{}/auth/full_stripe_profile", host)
});

pub static CURSOR_USAGE_API_URL: LazyLock<String> = LazyLock::new(|| {
    let host = if *USE_PROXY {
        &*REVERSE_PROXY_HOST
    } else {
        CURSOR_HOST
    };
    format!("https://{}/api/usage", host)
});

pub static CURSOR_USER_API_URL: LazyLock<String> = LazyLock::new(|| {
    let host = if *USE_PROXY {
        &*REVERSE_PROXY_HOST
    } else {
        CURSOR_HOST
    };
    format!("https://{}/api/auth/me", host)
});

// pub static DEBUG: LazyLock<bool> = LazyLock::new(|| parse_bool_from_env("DEBUG", false));

// #[macro_export]
// macro_rules! debug_println {
//     ($($arg:tt)*) => {
//         if *crate::app::statics::DEBUG {
//             println!($($arg)*);
//         }
//     };
// }