reallink-cli 0.1.5 → 0.1.7

package/README.md

@@ -8,11 +8,16 @@ Rust-based CLI for Reallink authentication, token workflows, and workspace file
 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 checks for updates in the background (cached daily) and prints a hint when a newer version is available.
+
 ## 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/bin/reallink.cjs

@@ -1,18 +1,53 @@
 #!/usr/bin/env node
 const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
 const path = require("node:path");
 
 const packageRoot = path.resolve(__dirname, "..");
 const manifestPath = path.join(packageRoot, "rust", "Cargo.toml");
-const cargoArgs = ["run", "--quiet", "--manifest-path", manifestPath, "--", ...process.argv.slice(2)];
+const args = process.argv.slice(2);
+const binaryName = process.platform === "win32" ? "reallink-cli.exe" : "reallink-cli";
+const releaseBinaryPath = path.join(packageRoot, "rust", "target", "release", binaryName);
 
-const result = spawnSync("cargo", cargoArgs, {
-  stdio: "inherit",
-  shell: process.platform === "win32"
-});
+function runBinary(binaryPath) {
+  return spawnSync(binaryPath, args, {
+    stdio: "inherit",
+    shell: false
+  });
+}
+
+function ensureBinary() {
+  if (fs.existsSync(releaseBinaryPath)) {
+    return true;
+  }
+
+  const build = spawnSync(
+    "cargo",
+    ["build", "--release", "--manifest-path", manifestPath],
+    {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    }
+  );
+
+  if (build.error) {
+    console.error(
+      `Failed to build reallink CLI with cargo: ${build.error.message}\n` +
+        "Install Rust (cargo) or reinstall using the one-line installer from real-agent.link."
+    );
+    return false;
+  }
+
+  return build.status === 0 && fs.existsSync(releaseBinaryPath);
+}
+
+if (!ensureBinary()) {
+  process.exit(1);
+}
 
+const result = runBinary(releaseBinaryPath);
 if (result.error) {
-  console.error(`Failed to run cargo: ${result.error.message}`);
+  console.error(`Failed to run reallink binary: ${result.error.message}`);
   process.exit(1);
 }
 

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "reallink-cli",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Rust-based CLI for Reallink auth and API operations",
   "bin": {
     "reallink": "bin/reallink.cjs"
   },
   "files": [
     "bin/reallink.cjs",
+    "scripts/postinstall.cjs",
     "rust/Cargo.toml",
     "rust/Cargo.lock",
     "rust/src",
     "README.md"
   ],
   "scripts": {
+    "postinstall": "node ./scripts/postinstall.cjs",
     "build": "cargo build --manifest-path ./rust/Cargo.toml --release",
     "dev": "node ./bin/reallink.cjs --help",
     "pack:local": "npm pack --json"

package/rust/Cargo.lock

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

package/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reallink-cli"
-version = "0.1.5"
+version = "0.1.7"
 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,6 +13,8 @@ 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;
 
 #[derive(Parser)]
 #[command(name = "reallink", version, about = "Reallink CLI")]
@@ -25,6 +28,7 @@ enum Commands {
     Login(LoginArgs),
     Whoami(BaseArgs),
     Logout,
+    SelfUpdate(SelfUpdateArgs),
     Project {
         #[command(subcommand)]
         command: ProjectCommands,
@@ -49,6 +53,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 +347,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 +627,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 +687,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 +710,87 @@ 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 response = with_cli_headers(client.get("https://registry.npmjs.org/reallink-cli/latest"))
+        .timeout(Duration::from_secs(2))
+        .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) {
+    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() {
+        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 +826,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 +838,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 +851,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 +908,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 +918,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 +955,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 +1835,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 +1921,15 @@ async fn main() -> Result<()> {
         .user_agent(concat!("reallink-cli/", env!("CARGO_PKG_VERSION")))
         .build()?;
 
+    if !matches!(&cli.command, Commands::SelfUpdate(_)) {
+        maybe_notify_update(&client, false).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?,

package/scripts/postinstall.cjs

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+
+const packageRoot = path.resolve(__dirname, "..");
+const manifestPath = path.join(packageRoot, "rust", "Cargo.toml");
+const binaryName = process.platform === "win32" ? "reallink-cli.exe" : "reallink-cli";
+const releaseBinaryPath = path.join(packageRoot, "rust", "target", "release", binaryName);
+
+if (process.env.REALLINK_SKIP_BUILD === "1") {
+  process.exit(0);
+}
+
+if (fs.existsSync(releaseBinaryPath)) {
+  process.exit(0);
+}
+
+const build = spawnSync(
+  "cargo",
+  ["build", "--release", "--manifest-path", manifestPath],
+  {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  }
+);
+
+if (build.error) {
+  console.error(
+    `reallink-cli postinstall failed: ${build.error.message}\n` +
+      "Rust toolchain is required for npm installation. " +
+      "Install Rust (https://rustup.rs) or use the hosted installer at https://real-agent.link/install.sh."
+  );
+  process.exit(1);
+}
+
+process.exit(build.status ?? 1);