reallink-cli 0.1.6 → 0.1.9

package/README.md

@@ -9,12 +9,15 @@ npm install -g reallink-cli
 ```
 
 `npm install` performs a one-time Rust release build during postinstall. After that, `reallink` runs the compiled binary directly (no per-command cargo compile step).
+CLI caches update metadata daily. To keep command startup fast, network update checks run during `reallink login` (or explicitly via `reallink self-update --check`) rather than every command.
 
 ## Commands
 
 ```bash
 reallink login --base-url https://api.real-agent.link
 reallink login --force # replace current saved session
+reallink self-update --check
+reallink self-update
 reallink whoami
 reallink logout
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reallink-cli",
-  "version": "0.1.6",
+  "version": "0.1.9",
   "description": "Rust-based CLI for Reallink auth and API operations",
   "bin": {
     "reallink": "bin/reallink.cjs"

package/rust/Cargo.lock

@@ -910,7 +910,7 @@ dependencies = [
 
 [[package]]
 name = "reallink-cli"
-version = "0.1.6"
+version = "0.1.9"
 dependencies = [
  "anyhow",
  "clap",

package/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reallink-cli"
-version = "0.1.6"
+version = "0.1.9"
 edition = "2021"
 description = "CLI for Reallink auth and token workflows"
 license = "MIT"

package/rust/src/main.rs

@@ -5,6 +5,7 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 use tokio::time::sleep;
 
@@ -12,9 +13,12 @@ const DEFAULT_BASE_URL: &str = "https://api.real-agent.link";
 const CONFIG_DIR_ENV: &str = "REALLINK_CONFIG_DIR";
 const SESSION_DIR_NAME: &str = "reallink";
 const SESSION_FILE_NAME: &str = "session.json";
+const UPDATE_CACHE_FILE_NAME: &str = "update-check.json";
+const VERSION_CHECK_INTERVAL_MS: u128 = 24 * 60 * 60 * 1000;
+const DEFAULT_VERSION_FETCH_TIMEOUT_MS: u64 = 800;
 
 #[derive(Parser)]
-#[command(name = "reallink", version, about = "Reallink CLI")]
+#[command(name = "reallink", bin_name = "reallink", version, about = "Reallink CLI")]
 struct Cli {
     #[command(subcommand)]
     command: Commands,
@@ -25,6 +29,7 @@ enum Commands {
     Login(LoginArgs),
     Whoami(BaseArgs),
     Logout,
+    SelfUpdate(SelfUpdateArgs),
     Project {
         #[command(subcommand)]
         command: ProjectCommands,
@@ -49,6 +54,12 @@ struct BaseArgs {
     base_url: Option<String>,
 }
 
+#[derive(Args)]
+struct SelfUpdateArgs {
+    #[arg(long, help = "Only check for updates; do not install")]
+    check: bool,
+}
+
 #[derive(Args)]
 struct LoginArgs {
     #[arg(long, default_value = DEFAULT_BASE_URL)]
@@ -337,6 +348,12 @@ struct SessionConfig {
     updated_at_epoch_ms: u128,
 }
 
+#[derive(Debug, Serialize, Deserialize, Clone)]
+struct UpdateCheckCache {
+    last_checked_epoch_ms: u128,
+    latest_version: Option<String>,
+}
+
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DeviceCodeRequest {
@@ -611,6 +628,11 @@ fn config_path() -> Result<PathBuf> {
     Ok(base.join(SESSION_DIR_NAME).join(SESSION_FILE_NAME))
 }
 
+fn update_cache_path() -> Result<PathBuf> {
+    let base = resolve_config_root()?;
+    Ok(base.join(SESSION_DIR_NAME).join(UPDATE_CACHE_FILE_NAME))
+}
+
 fn session_path_display() -> String {
     config_path()
         .map(|path| path.display().to_string())
@@ -666,6 +688,22 @@ fn clear_session() -> Result<bool> {
     Ok(false)
 }
 
+fn load_update_cache() -> Option<UpdateCheckCache> {
+    let path = update_cache_path().ok()?;
+    let raw = fs::read(path).ok()?;
+    serde_json::from_slice(&raw).ok()
+}
+
+fn save_update_cache(cache: &UpdateCheckCache) -> Result<()> {
+    let path = update_cache_path()?;
+    if let Some(parent) = path.parent() {
+        fs::create_dir_all(parent).with_context(|| format!("Failed to create {}", parent.display()))?;
+    }
+    let payload = serde_json::to_vec_pretty(cache)?;
+    write_atomic(&path, &payload)?;
+    Ok(())
+}
+
 async fn read_error_body(response: reqwest::Response) -> String {
     match response.text().await {
         Ok(text) if !text.trim().is_empty() => text,
@@ -673,6 +711,92 @@ async fn read_error_body(response: reqwest::Response) -> String {
     }
 }
 
+fn with_cli_headers(request: reqwest::RequestBuilder) -> reqwest::RequestBuilder {
+    request
+        .header("x-reallink-client", "cli")
+        .header("x-reallink-cli-version", env!("CARGO_PKG_VERSION"))
+}
+
+fn parse_semver_triplet(version: &str) -> Option<(u64, u64, u64)> {
+    let core = version.trim().split('-').next()?;
+    let mut parts = core.split('.');
+    let major = parts.next()?.parse::<u64>().ok()?;
+    let minor = parts.next().unwrap_or("0").parse::<u64>().ok()?;
+    let patch = parts.next().unwrap_or("0").parse::<u64>().ok()?;
+    Some((major, minor, patch))
+}
+
+fn is_newer_version(current: &str, latest: &str) -> bool {
+    match (parse_semver_triplet(current), parse_semver_triplet(latest)) {
+        (Some(current_parts), Some(latest_parts)) => latest_parts > current_parts,
+        _ => false,
+    }
+}
+
+async fn fetch_latest_cli_version(client: &reqwest::Client) -> Option<String> {
+    let timeout_ms = std::env::var("REALLINK_UPDATE_CHECK_TIMEOUT_MS")
+        .ok()
+        .and_then(|value| value.parse::<u64>().ok())
+        .filter(|value| *value > 0)
+        .unwrap_or(DEFAULT_VERSION_FETCH_TIMEOUT_MS);
+    let response = with_cli_headers(client.get("https://registry.npmjs.org/reallink-cli/latest"))
+        .timeout(Duration::from_millis(timeout_ms))
+        .send()
+        .await
+        .ok()?;
+    if !response.status().is_success() {
+        return None;
+    }
+    let payload: serde_json::Value = response.json().await.ok()?;
+    payload
+        .get("version")
+        .and_then(|value| value.as_str())
+        .map(|value| value.trim().to_string())
+        .filter(|value| !value.is_empty())
+}
+
+async fn maybe_notify_update(client: &reqwest::Client, force_refresh: bool, allow_network_fetch: bool) {
+    if std::env::var("REALLINK_DISABLE_AUTO_UPDATE_CHECK")
+        .map(|value| value == "1")
+        .unwrap_or(false)
+    {
+        return;
+    }
+
+    let now = now_epoch_ms();
+    let cached = load_update_cache();
+    let mut latest_version = if !force_refresh {
+        cached.as_ref().and_then(|cache| {
+            let age = now.saturating_sub(cache.last_checked_epoch_ms);
+            if age < VERSION_CHECK_INTERVAL_MS {
+                cache.latest_version.clone()
+            } else {
+                None
+            }
+        })
+    } else {
+        None
+    };
+
+    if latest_version.is_none() && allow_network_fetch {
+        latest_version = fetch_latest_cli_version(client).await;
+        let _ = save_update_cache(&UpdateCheckCache {
+            last_checked_epoch_ms: now,
+            latest_version: latest_version.clone(),
+        });
+    }
+
+    let current = env!("CARGO_PKG_VERSION");
+    if let Some(latest) = latest_version {
+        if is_newer_version(current, &latest) {
+            eprintln!(
+                "Update available: {} -> {}. Run `reallink self-update`.",
+                current, latest
+            );
+        }
+    }
+}
+
 fn clean_virtual_path(value: &str) -> String {
     value
         .split('/')
@@ -708,9 +832,8 @@ async fn authed_request(
     body: Option<serde_json::Value>,
 ) -> Result<reqwest::Response> {
     let url = format!("{}{}", normalize_base_url(&session.base_url), path);
-    let mut request = client
-        .request(method.clone(), &url)
-        .bearer_auth(&session.access_token);
+    let mut request =
+        with_cli_headers(client.request(method.clone(), &url).bearer_auth(&session.access_token));
     if let Some(ref body_value) = body {
         request = request.json(body_value);
     }
@@ -721,9 +844,7 @@ async fn authed_request(
 
     refresh_session(client, session).await?;
 
-    let mut retry = client
-        .request(method, &url)
-        .bearer_auth(&session.access_token);
+    let mut retry = with_cli_headers(client.request(method, &url).bearer_auth(&session.access_token));
     if let Some(ref body_value) = body {
         retry = retry.json(body_value);
     }
@@ -736,7 +857,7 @@ async fn refresh_session(client: &reqwest::Client, session: &mut SessionConfig)
         refresh_token: session.refresh_token.clone(),
         session_id: session.session_id.clone(),
     };
-    let response = client.post(url).json(&payload).send().await?;
+    let response = with_cli_headers(client.post(url).json(&payload)).send().await?;
     if !response.status().is_success() {
         let body = read_error_body(response).await;
         return Err(anyhow!("Refresh failed: {}", body));
@@ -793,6 +914,9 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
             "assets:write".to_string(),
             "trace:read".to_string(),
             "trace:write".to_string(),
+            "tools:read".to_string(),
+            "tools:write".to_string(),
+            "tools:run".to_string(),
             "org:admin".to_string(),
             "project:admin".to_string(),
         ]
@@ -800,8 +924,7 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
         args.scope
     };
 
-    let device_code_response = client
-        .post(format!("{}/auth/device/code", base_url))
+    let device_code_response = with_cli_headers(client.post(format!("{}/auth/device/code", base_url)))
         .json(&DeviceCodeRequest {
             client_id: args.client_id.clone(),
             scope,
@@ -838,8 +961,7 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
 
         sleep(poll_interval).await;
 
-        let token_response = client
-            .post(format!("{}/auth/device/token", base_url))
+        let token_response = with_cli_headers(client.post(format!("{}/auth/device/token", base_url)))
             .json(&DeviceTokenRequest {
                 grant_type: "urn:ietf:params:oauth:grant-type:device_code".to_string(),
                 device_code: device_code.device_code.clone(),
@@ -1719,6 +1841,85 @@ async fn tool_get_run_command(client: &reqwest::Client, args: ToolGetRunArgs) ->
     Ok(())
 }
 
+fn run_and_check_status(mut command: Command, context: &str) -> Result<()> {
+    let status = command
+        .status()
+        .with_context(|| format!("Failed to execute {}", context))?;
+    if !status.success() {
+        return Err(anyhow!("{} exited with status {}", context, status));
+    }
+    Ok(())
+}
+
+async fn self_update_command(client: &reqwest::Client, args: SelfUpdateArgs) -> Result<()> {
+    let current = env!("CARGO_PKG_VERSION");
+    let latest = fetch_latest_cli_version(client).await;
+
+    let Some(latest_version) = latest else {
+        println!("Could not check latest version right now.");
+        return Ok(());
+    };
+
+    if !is_newer_version(current, &latest_version) {
+        println!("reallink is up to date ({})", current);
+        return Ok(());
+    }
+
+    println!("Update available: {} -> {}", current, latest_version);
+    if args.check {
+        println!("Run `reallink self-update` to install the update.");
+        return Ok(());
+    }
+
+    let npm_available = Command::new("npm")
+        .arg("--version")
+        .status()
+        .map(|status| status.success())
+        .unwrap_or(false);
+
+    if npm_available {
+        run_and_check_status(
+            {
+                let mut command = Command::new("npm");
+                command.args(["install", "-g", "reallink-cli@latest"]);
+                command
+            },
+            "npm self-update",
+        )?;
+        println!("Updated via npm. Restart your shell if `reallink --version` still shows old version.");
+        return Ok(());
+    }
+
+    if cfg!(windows) {
+        run_and_check_status(
+            {
+                let mut command = Command::new("powershell");
+                command.args([
+                    "-NoProfile",
+                    "-ExecutionPolicy",
+                    "Bypass",
+                    "-Command",
+                    "irm https://real-agent.link/install.ps1 | iex",
+                ]);
+                command
+            },
+            "PowerShell installer update",
+        )?;
+    } else {
+        run_and_check_status(
+            {
+                let mut command = Command::new("sh");
+                command.args(["-c", "curl -fsSL https://real-agent.link/install.sh | bash"]);
+                command
+            },
+            "shell installer update",
+        )?;
+    }
+
+    println!("Update installed. Verify with `reallink --version`.");
+    Ok(())
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
     let cli = Cli::parse();
@@ -1726,10 +1927,16 @@ async fn main() -> Result<()> {
         .user_agent(concat!("reallink-cli/", env!("CARGO_PKG_VERSION")))
         .build()?;
 
+    if !matches!(&cli.command, Commands::SelfUpdate(_)) {
+        let allow_update_fetch = matches!(&cli.command, Commands::Login(_));
+        maybe_notify_update(&client, false, allow_update_fetch).await;
+    }
+
     match cli.command {
         Commands::Login(args) => login_command(&client, args).await?,
         Commands::Whoami(args) => whoami_command(&client, args).await?,
         Commands::Logout => logout_command(&client).await?,
+        Commands::SelfUpdate(args) => self_update_command(&client, args).await?,
         Commands::Project { command } => match command {
             ProjectCommands::List(args) => project_list_command(&client, args).await?,
             ProjectCommands::Create(args) => project_create_command(&client, args).await?,