Struct CortexClient 

pub struct CortexClient { /* private fields */ }

AI Cortex SDK 客户端。

鉴权方式：用户 PAT（Authorization: Bearer actx_pat_...），由配置直接提供。 构造后自动启动心跳（除非 heartbeat_interval == 0），首次心跳即向服务端绑定当前设备。

Implementations

impl CortexClient

pub fn new(config: CortexConfig) -> Self

Examples found in repository

examples/auth_check.rs (line 17)

async fn main() {
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id 占位：心跳会按此软件的许可证校验设备上限。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new("http://localhost:40404", pat, software_id);
    let client = CortexClient::new(config);

    match client.list_software().await {
        Ok(items) => {
            println!("PAT valid. Software store returned {} item(s).", items.len());
        }
        Err(e) => {
            eprintln!("PAT check failed: {e}");
            std::process::exit(1);
        }
    }

    println!("\n--- My Devices ---");
    match client.list_devices().await {
        Ok(devices) => {
            println!("{} bound device(s).", devices.len());
            for d in devices {
                println!(
                    "- fingerprint={}, last_active={}",
                    d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

examples/offline_license.rs (line 36)

async fn main() {
    let server_url =
        std::env::var("CORTEX_SERVER_URL").unwrap_or_else(|_| "http://localhost:40404".into());
    let pat = std::env::args()
        .nth(1)
        .or_else(|| std::env::var("CORTEX_PAT").ok())
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());
    let software_id = std::env::args()
        .nth(2)
        .or_else(|| std::env::var("CORTEX_SOFTWARE_ID").ok())
        .unwrap_or_else(|| "00000000-0000-0000-0000-000000000000".to_string());
    let pinned_pk = std::env::args().nth(3);

    // 关闭心跳，避免示例对服务端产生副作用
    let config = CortexConfig::new(&server_url, &pat, &software_id)
        .without_heartbeat();
    let config = if let Some(pk) = &pinned_pk {
        config.with_software_public_key(pk)
    } else {
        config
    };
    let client = CortexClient::new(config);

    // 采集设备指纹
    let dev = ai_cortex_sdk::device::collect();
    let fingerprint = dev.fingerprint.as_str();
    println!("Device fingerprint: {fingerprint}");

    // 1. 拉取离线许可证
    println!("\n=== Fetch offline license ===");
    let file: OfflineLicenseFile = match client.fetch_offline_license(fingerprint).await {
        Ok(f) => f,
        Err(e) => {
            eprintln!("fetch failed: {e}");
            return;
        }
    };
    println!("public_key: {}", file.public_key);
    println!("signature : {}", file.signature);
    println!("payload   : {}", file.payload);

    // 2. 本地验签（钉扎公钥来自参数）
    println!("\n=== Verify offline license ===");
    match verify_offline_license(
        &file,
        &software_id,
        fingerprint,
        pinned_pk.as_deref(),
    ) {
        Ok(payload) => {
            println!("VALID. payload parsed:");
            println!("  license_id  : {}", payload.license_id);
            println!("  user_id     : {}", payload.user_id);
            println!("  software_id : {}", payload.software_id);
            println!("  fingerprint : {}", payload.fingerprint);
            println!("  max_devices : {}", payload.max_devices);
            println!("  issued_at   : {}", payload.issued_at);
            println!("  expire_time : {}", payload.expire_time);
        }
        Err(e) => {
            eprintln!("INVALID license: {e}");
        }
    }
}

examples/basic.rs (line 17)

async fn main() {
    let server_url = "http://localhost:40404";
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id：SDK 以哪个软件身份心跳/下载，需与用户持有的有效 auth_record.software_id 一致。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new(server_url, pat, software_id).with_timeout(30);
    let client = CortexClient::new(config);

    // --- List Software ---
    println!("=== Software Store ===");
    match client.list_software().await {
        Ok(items) => {
            if items.is_empty() {
                println!("No software available.");
            }
            for (i, item) in items.iter().enumerate() {
                let version_str = item
                    .latest_version
                    .as_ref()
                    .map(|v| format!("v{} ({} bytes)", v.version, v.file_size))
                    .unwrap_or_else(|| "no version".to_string());
                println!(
                    "{}. {} — {}  [{}]",
                    i + 1,
                    item.software.name,
                    item.software.description,
                    version_str
                );
            }

            // --- Download first software's latest version ---
            if let Some(item) = items.first() {
                if let Some(version) = &item.latest_version {
                    println!("\n=== Download ===");
                    match client.download(&version.id).await {
                        Ok(info) => {
                            println!(
                                "Download: v{}, size={} bytes\n  URL: {}",
                                info.version, info.file_size, info.download_url
                            );
                        }
                        Err(e) => eprintln!("Download failed: {e}"),
                    }
                }
            }
        }
        Err(e) => eprintln!("List software failed: {e}"),
    }

    // --- List Devices (PAT 所属用户的设备；心跳在后台自动绑定) ---
    println!("\n=== My Devices ===");
    match client.list_devices().await {
        Ok(devices) => {
            if devices.is_empty() {
                println!("No bound devices yet (heartbeat may not have fired yet).");
            }
            for d in devices {
                println!(
                    "- id={}, fingerprint={}, last_active={}",
                    d.id, d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

examples/auto_update.rs (line 29)

async fn main() {
    let server_url =
        std::env::var("CORTEX_SERVER_URL").unwrap_or_else(|_| "http://localhost:40404".into());
    let pat = std::env::args()
        .nth(1)
        .or_else(|| std::env::var("CORTEX_PAT").ok())
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());
    let software_id = std::env::args()
        .nth(2)
        .or_else(|| std::env::var("CORTEX_SOFTWARE_ID").ok())
        .unwrap_or_else(|| "00000000-0000-0000-0000-000000000000".to_string());
    // 第 3 个位置参数（任意值）= 演示 SSE 流
    let demo_stream = std::env::args().nth(3).is_some();

    // 关闭心跳，避免示例对服务端产生副作用
    let config = CortexConfig::new(&server_url, &pat, &software_id).without_heartbeat();
    let client = CortexClient::new(config);

    // --- 1. Pull：检查更新 ---
    println!("=== Check Update (Pull) ===");
    let platform = std::env::consts::OS; // linux / macos / windows
    let current_version = "1.0.0";
    match client
        .check_update(platform, current_version, None)
        .await
    {
        Ok(info) => {
            println!("current_version : {}", info.current_version);
            println!("has_update      : {}", info.has_update);
            println!("force_update    : {}", info.force_update);
            if let Some(t) = &info.target_version {
                println!("target_version  : {} (channel={}, size={} bytes)", t.version, t.channel, t.file_size);
                println!("release_notes   : {}", t.release_notes);
                println!("min_compatible  : {}", t.min_compatible);
            }
            // force_update 语义：客户端应阻止启动直到用户升级
            if info.has_update && info.force_update {
                println!("\n>>> 强制更新：当前版本被阻塞，必须升级后才能继续。");
            }
        }
        Err(e) => eprintln!("check_update failed: {e}"),
    }

    // --- 2. Push：订阅 SSE 更新事件流（可选） ---
    if demo_stream {
        println!("\n=== Update Events (Push / SSE) ===");
        match client.open_update_events(Some(&software_id), None).await {
            Ok(mut stream) => {
                println!("SSE connected. Waiting for events (will print 3 then exit)...");
                let mut count = 0usize;
                while let Some(ev) = stream.next().await {
                    match ev {
                        Ok(e) => {
                            println!(
                                "event #{}: software={} version={} platform={} channel={} force={}",
                                e.id, e.software_id, e.version, e.platform, e.channel, e.force_update
                            );
                            count += 1;
                            if count >= 3 {
                                println!("Received 3 events, exiting demo.");
                                break;
                            }
                        }
                        Err(e) => {
                            eprintln!("stream error: {e}");
                            break;
                        }
                    }
                }
            }
            Err(e) => eprintln!("open_update_events failed: {e}"),
        }
    }
}

pub async fn list_software(&self) -> SdkResult<Vec<SoftwareStoreItem>>

Examples found in repository

examples/auth_check.rs (line 19)

async fn main() {
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id 占位：心跳会按此软件的许可证校验设备上限。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new("http://localhost:40404", pat, software_id);
    let client = CortexClient::new(config);

    match client.list_software().await {
        Ok(items) => {
            println!("PAT valid. Software store returned {} item(s).", items.len());
        }
        Err(e) => {
            eprintln!("PAT check failed: {e}");
            std::process::exit(1);
        }
    }

    println!("\n--- My Devices ---");
    match client.list_devices().await {
        Ok(devices) => {
            println!("{} bound device(s).", devices.len());
            for d in devices {
                println!(
                    "- fingerprint={}, last_active={}",
                    d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

examples/basic.rs (line 21)

async fn main() {
    let server_url = "http://localhost:40404";
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id：SDK 以哪个软件身份心跳/下载，需与用户持有的有效 auth_record.software_id 一致。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new(server_url, pat, software_id).with_timeout(30);
    let client = CortexClient::new(config);

    // --- List Software ---
    println!("=== Software Store ===");
    match client.list_software().await {
        Ok(items) => {
            if items.is_empty() {
                println!("No software available.");
            }
            for (i, item) in items.iter().enumerate() {
                let version_str = item
                    .latest_version
                    .as_ref()
                    .map(|v| format!("v{} ({} bytes)", v.version, v.file_size))
                    .unwrap_or_else(|| "no version".to_string());
                println!(
                    "{}. {} — {}  [{}]",
                    i + 1,
                    item.software.name,
                    item.software.description,
                    version_str
                );
            }

            // --- Download first software's latest version ---
            if let Some(item) = items.first() {
                if let Some(version) = &item.latest_version {
                    println!("\n=== Download ===");
                    match client.download(&version.id).await {
                        Ok(info) => {
                            println!(
                                "Download: v{}, size={} bytes\n  URL: {}",
                                info.version, info.file_size, info.download_url
                            );
                        }
                        Err(e) => eprintln!("Download failed: {e}"),
                    }
                }
            }
        }
        Err(e) => eprintln!("List software failed: {e}"),
    }

    // --- List Devices (PAT 所属用户的设备；心跳在后台自动绑定) ---
    println!("\n=== My Devices ===");
    match client.list_devices().await {
        Ok(devices) => {
            if devices.is_empty() {
                println!("No bound devices yet (heartbeat may not have fired yet).");
            }
            for d in devices {
                println!(
                    "- id={}, fingerprint={}, last_active={}",
                    d.id, d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

pub async fn get_latest_version( &self, software_id: &str, ) -> SdkResult<SoftwareVersion>

pub async fn download(&self, version_id: &str) -> SdkResult<DownloadInfo>

Examples found in repository

examples/basic.rs (line 45)

async fn main() {
    let server_url = "http://localhost:40404";
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id：SDK 以哪个软件身份心跳/下载，需与用户持有的有效 auth_record.software_id 一致。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new(server_url, pat, software_id).with_timeout(30);
    let client = CortexClient::new(config);

    // --- List Software ---
    println!("=== Software Store ===");
    match client.list_software().await {
        Ok(items) => {
            if items.is_empty() {
                println!("No software available.");
            }
            for (i, item) in items.iter().enumerate() {
                let version_str = item
                    .latest_version
                    .as_ref()
                    .map(|v| format!("v{} ({} bytes)", v.version, v.file_size))
                    .unwrap_or_else(|| "no version".to_string());
                println!(
                    "{}. {} — {}  [{}]",
                    i + 1,
                    item.software.name,
                    item.software.description,
                    version_str
                );
            }

            // --- Download first software's latest version ---
            if let Some(item) = items.first() {
                if let Some(version) = &item.latest_version {
                    println!("\n=== Download ===");
                    match client.download(&version.id).await {
                        Ok(info) => {
                            println!(
                                "Download: v{}, size={} bytes\n  URL: {}",
                                info.version, info.file_size, info.download_url
                            );
                        }
                        Err(e) => eprintln!("Download failed: {e}"),
                    }
                }
            }
        }
        Err(e) => eprintln!("List software failed: {e}"),
    }

    // --- List Devices (PAT 所属用户的设备；心跳在后台自动绑定) ---
    println!("\n=== My Devices ===");
    match client.list_devices().await {
        Ok(devices) => {
            if devices.is_empty() {
                println!("No bound devices yet (heartbeat may not have fired yet).");
            }
            for d in devices {
                println!(
                    "- id={}, fingerprint={}, last_active={}",
                    d.id, d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

pub async fn check_update( &self, platform: &str, current_version: &str, channel: Option<&str>, ) -> SdkResult<UpdateInfo>

检查更新（Pull）。按配置的 software_id + 指定 platform/channel，与 current_version 比较。 channel 传 None 默认 “stable”。需对该 software 持有有效许可证，否则返回 ServerError。

Examples found in repository

examples/auto_update.rs (line 36)

async fn main() {
    let server_url =
        std::env::var("CORTEX_SERVER_URL").unwrap_or_else(|_| "http://localhost:40404".into());
    let pat = std::env::args()
        .nth(1)
        .or_else(|| std::env::var("CORTEX_PAT").ok())
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());
    let software_id = std::env::args()
        .nth(2)
        .or_else(|| std::env::var("CORTEX_SOFTWARE_ID").ok())
        .unwrap_or_else(|| "00000000-0000-0000-0000-000000000000".to_string());
    // 第 3 个位置参数（任意值）= 演示 SSE 流
    let demo_stream = std::env::args().nth(3).is_some();

    // 关闭心跳，避免示例对服务端产生副作用
    let config = CortexConfig::new(&server_url, &pat, &software_id).without_heartbeat();
    let client = CortexClient::new(config);

    // --- 1. Pull：检查更新 ---
    println!("=== Check Update (Pull) ===");
    let platform = std::env::consts::OS; // linux / macos / windows
    let current_version = "1.0.0";
    match client
        .check_update(platform, current_version, None)
        .await
    {
        Ok(info) => {
            println!("current_version : {}", info.current_version);
            println!("has_update      : {}", info.has_update);
            println!("force_update    : {}", info.force_update);
            if let Some(t) = &info.target_version {
                println!("target_version  : {} (channel={}, size={} bytes)", t.version, t.channel, t.file_size);
                println!("release_notes   : {}", t.release_notes);
                println!("min_compatible  : {}", t.min_compatible);
            }
            // force_update 语义：客户端应阻止启动直到用户升级
            if info.has_update && info.force_update {
                println!("\n>>> 强制更新：当前版本被阻塞，必须升级后才能继续。");
            }
        }
        Err(e) => eprintln!("check_update failed: {e}"),
    }

    // --- 2. Push：订阅 SSE 更新事件流（可选） ---
    if demo_stream {
        println!("\n=== Update Events (Push / SSE) ===");
        match client.open_update_events(Some(&software_id), None).await {
            Ok(mut stream) => {
                println!("SSE connected. Waiting for events (will print 3 then exit)...");
                let mut count = 0usize;
                while let Some(ev) = stream.next().await {
                    match ev {
                        Ok(e) => {
                            println!(
                                "event #{}: software={} version={} platform={} channel={} force={}",
                                e.id, e.software_id, e.version, e.platform, e.channel, e.force_update
                            );
                            count += 1;
                            if count >= 3 {
                                println!("Received 3 events, exiting demo.");
                                break;
                            }
                        }
                        Err(e) => {
                            eprintln!("stream error: {e}");
                            break;
                        }
                    }
                }
            }
            Err(e) => eprintln!("open_update_events failed: {e}"),
        }
    }
}

pub async fn open_update_events( &self, software_id: Option<&str>, last_event_id: Option<u64>, ) -> SdkResult<UpdateEventStream>

打开更新事件 SSE 流（Push）。software_id 传 None 订阅全部；last_event_id 用于断线重连补播。 返回的流需配合 futures_util::StreamExt 使用：while let Some(ev) = stream.next().await { ... }。 注意：SSE 是长连接，内部使用无读超时的 HTTP 客户端；靠服务端 15s keepalive 保活。

Examples found in repository

examples/auto_update.rs (line 59)

async fn main() {
    let server_url =
        std::env::var("CORTEX_SERVER_URL").unwrap_or_else(|_| "http://localhost:40404".into());
    let pat = std::env::args()
        .nth(1)
        .or_else(|| std::env::var("CORTEX_PAT").ok())
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());
    let software_id = std::env::args()
        .nth(2)
        .or_else(|| std::env::var("CORTEX_SOFTWARE_ID").ok())
        .unwrap_or_else(|| "00000000-0000-0000-0000-000000000000".to_string());
    // 第 3 个位置参数（任意值）= 演示 SSE 流
    let demo_stream = std::env::args().nth(3).is_some();

    // 关闭心跳，避免示例对服务端产生副作用
    let config = CortexConfig::new(&server_url, &pat, &software_id).without_heartbeat();
    let client = CortexClient::new(config);

    // --- 1. Pull：检查更新 ---
    println!("=== Check Update (Pull) ===");
    let platform = std::env::consts::OS; // linux / macos / windows
    let current_version = "1.0.0";
    match client
        .check_update(platform, current_version, None)
        .await
    {
        Ok(info) => {
            println!("current_version : {}", info.current_version);
            println!("has_update      : {}", info.has_update);
            println!("force_update    : {}", info.force_update);
            if let Some(t) = &info.target_version {
                println!("target_version  : {} (channel={}, size={} bytes)", t.version, t.channel, t.file_size);
                println!("release_notes   : {}", t.release_notes);
                println!("min_compatible  : {}", t.min_compatible);
            }
            // force_update 语义：客户端应阻止启动直到用户升级
            if info.has_update && info.force_update {
                println!("\n>>> 强制更新：当前版本被阻塞，必须升级后才能继续。");
            }
        }
        Err(e) => eprintln!("check_update failed: {e}"),
    }

    // --- 2. Push：订阅 SSE 更新事件流（可选） ---
    if demo_stream {
        println!("\n=== Update Events (Push / SSE) ===");
        match client.open_update_events(Some(&software_id), None).await {
            Ok(mut stream) => {
                println!("SSE connected. Waiting for events (will print 3 then exit)...");
                let mut count = 0usize;
                while let Some(ev) = stream.next().await {
                    match ev {
                        Ok(e) => {
                            println!(
                                "event #{}: software={} version={} platform={} channel={} force={}",
                                e.id, e.software_id, e.version, e.platform, e.channel, e.force_update
                            );
                            count += 1;
                            if count >= 3 {
                                println!("Received 3 events, exiting demo.");
                                break;
                            }
                        }
                        Err(e) => {
                            eprintln!("stream error: {e}");
                            break;
                        }
                    }
                }
            }
            Err(e) => eprintln!("open_update_events failed: {e}"),
        }
    }
}

pub async fn list_devices(&self) -> SdkResult<Vec<DeviceRecord>>

列出当前用户名下绑定的有效设备。

Examples found in repository

examples/auth_check.rs (line 30)

async fn main() {
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id 占位：心跳会按此软件的许可证校验设备上限。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new("http://localhost:40404", pat, software_id);
    let client = CortexClient::new(config);

    match client.list_software().await {
        Ok(items) => {
            println!("PAT valid. Software store returned {} item(s).", items.len());
        }
        Err(e) => {
            eprintln!("PAT check failed: {e}");
            std::process::exit(1);
        }
    }

    println!("\n--- My Devices ---");
    match client.list_devices().await {
        Ok(devices) => {
            println!("{} bound device(s).", devices.len());
            for d in devices {
                println!(
                    "- fingerprint={}, last_active={}",
                    d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

examples/basic.rs (line 62)

async fn main() {
    let server_url = "http://localhost:40404";
    let pat = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());

    // software_id：SDK 以哪个软件身份心跳/下载，需与用户持有的有效 auth_record.software_id 一致。
    let software_id = "00000000-0000-0000-0000-000000000000".to_string();

    let config = CortexConfig::new(server_url, pat, software_id).with_timeout(30);
    let client = CortexClient::new(config);

    // --- List Software ---
    println!("=== Software Store ===");
    match client.list_software().await {
        Ok(items) => {
            if items.is_empty() {
                println!("No software available.");
            }
            for (i, item) in items.iter().enumerate() {
                let version_str = item
                    .latest_version
                    .as_ref()
                    .map(|v| format!("v{} ({} bytes)", v.version, v.file_size))
                    .unwrap_or_else(|| "no version".to_string());
                println!(
                    "{}. {} — {}  [{}]",
                    i + 1,
                    item.software.name,
                    item.software.description,
                    version_str
                );
            }

            // --- Download first software's latest version ---
            if let Some(item) = items.first() {
                if let Some(version) = &item.latest_version {
                    println!("\n=== Download ===");
                    match client.download(&version.id).await {
                        Ok(info) => {
                            println!(
                                "Download: v{}, size={} bytes\n  URL: {}",
                                info.version, info.file_size, info.download_url
                            );
                        }
                        Err(e) => eprintln!("Download failed: {e}"),
                    }
                }
            }
        }
        Err(e) => eprintln!("List software failed: {e}"),
    }

    // --- List Devices (PAT 所属用户的设备；心跳在后台自动绑定) ---
    println!("\n=== My Devices ===");
    match client.list_devices().await {
        Ok(devices) => {
            if devices.is_empty() {
                println!("No bound devices yet (heartbeat may not have fired yet).");
            }
            for d in devices {
                println!(
                    "- id={}, fingerprint={}, last_active={}",
                    d.id, d.fingerprint, d.last_active_time
                );
            }
        }
        Err(e) => eprintln!("List devices failed: {e}"),
    }
}

pub async fn unbind_device(&self, device_id: &str) -> SdkResult<()>

解绑指定设备（将其 status 置 0，释放设备名额）。

pub async fn fetch_offline_license( &self, fingerprint: &str, ) -> SdkResult<OfflineLicenseFile>

向服务端拉取离线许可证（需有效 PAT 与有效软件授权）。 fingerprint 为当前设备指纹。返回未验签的许可证文件，需配合 verify_offline_license 进行本地验签后才可信任。

Examples found in repository

examples/offline_license.rs (line 45)

async fn main() {
    let server_url =
        std::env::var("CORTEX_SERVER_URL").unwrap_or_else(|_| "http://localhost:40404".into());
    let pat = std::env::args()
        .nth(1)
        .or_else(|| std::env::var("CORTEX_PAT").ok())
        .unwrap_or_else(|| "REPLACE_WITH_YOUR_PAT".to_string());
    let software_id = std::env::args()
        .nth(2)
        .or_else(|| std::env::var("CORTEX_SOFTWARE_ID").ok())
        .unwrap_or_else(|| "00000000-0000-0000-0000-000000000000".to_string());
    let pinned_pk = std::env::args().nth(3);

    // 关闭心跳，避免示例对服务端产生副作用
    let config = CortexConfig::new(&server_url, &pat, &software_id)
        .without_heartbeat();
    let config = if let Some(pk) = &pinned_pk {
        config.with_software_public_key(pk)
    } else {
        config
    };
    let client = CortexClient::new(config);

    // 采集设备指纹
    let dev = ai_cortex_sdk::device::collect();
    let fingerprint = dev.fingerprint.as_str();
    println!("Device fingerprint: {fingerprint}");

    // 1. 拉取离线许可证
    println!("\n=== Fetch offline license ===");
    let file: OfflineLicenseFile = match client.fetch_offline_license(fingerprint).await {
        Ok(f) => f,
        Err(e) => {
            eprintln!("fetch failed: {e}");
            return;
        }
    };
    println!("public_key: {}", file.public_key);
    println!("signature : {}", file.signature);
    println!("payload   : {}", file.payload);

    // 2. 本地验签（钉扎公钥来自参数）
    println!("\n=== Verify offline license ===");
    match verify_offline_license(
        &file,
        &software_id,
        fingerprint,
        pinned_pk.as_deref(),
    ) {
        Ok(payload) => {
            println!("VALID. payload parsed:");
            println!("  license_id  : {}", payload.license_id);
            println!("  user_id     : {}", payload.user_id);
            println!("  software_id : {}", payload.software_id);
            println!("  fingerprint : {}", payload.fingerprint);
            println!("  max_devices : {}", payload.max_devices);
            println!("  issued_at   : {}", payload.issued_at);
            println!("  expire_time : {}", payload.expire_time);
        }
        Err(e) => {
            eprintln!("INVALID license: {e}");
        }
    }
}

pub fn verify_offline_license( &self, file: &OfflineLicenseFile, expected_fingerprint: &str, ) -> SdkResult<OfflineLicensePayload>

使用配置中的 software_public_key（若设置）验签当前许可证并解析 payload。 若未钉扎公钥，则信任服务端下发公钥（依赖 TLS）。

Trait Implementations

impl Drop for CortexClient

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.