reallink-cli 0.1.9 → 0.1.11

package/README.md

@@ -8,7 +8,9 @@ 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).
+On supported published platforms, npm installs a bundled prebuilt binary so install/update is fast.
+If a prebuilt binary is not available for your OS/arch, npm falls back to a one-time Rust release build during postinstall.
+After install, `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
@@ -34,6 +36,9 @@ reallink token revoke --token-id tok_xxx
 
 reallink file list --project-id prj_xxx
 reallink file get --asset-id ast_xxx
+reallink file stat --asset-id ast_xxx
+reallink file download --asset-id ast_xxx --output ./downloads/report.json
+reallink file download --asset-id ast_xxx --output ./downloads/report.json --resume
 reallink file upload --project-id prj_xxx --source ./local/report.json --path reports/daily
 reallink file mkdir --project-id prj_xxx --path reports/archive
 reallink file move --asset-id ast_xxx --file-name reports/archive/report.json
@@ -60,4 +65,5 @@ reallink tool get-run --run-id trun_xxx
 
 ## Requirements
 
-- Rust toolchain (`cargo`) must be installed.
+- Prebuilt platforms: no Rust toolchain required.
+- Fallback build path (when no prebuilt binary exists): Rust toolchain (`cargo`) required.

package/bin/reallink.cjs

@@ -7,7 +7,25 @@ const packageRoot = path.resolve(__dirname, "..");
 const manifestPath = path.join(packageRoot, "rust", "Cargo.toml");
 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 prebuiltBinaryPath = path.join(
+  packageRoot,
+  "prebuilt",
+  `${process.platform}-${process.arch}`,
+  binaryName
+);
+const releaseBinaryCandidates = [
+  path.resolve(packageRoot, "..", "..", "target", "release", binaryName),
+  path.join(packageRoot, "rust", "target", "release", binaryName)
+];
+
+function resolveExistingReleaseBinary() {
+  for (const candidate of releaseBinaryCandidates) {
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 
 function runBinary(binaryPath) {
   return spawnSync(binaryPath, args, {
@@ -17,7 +35,7 @@ function runBinary(binaryPath) {
 }
 
 function ensureBinary() {
-  if (fs.existsSync(releaseBinaryPath)) {
+  if (resolveExistingReleaseBinary() || fs.existsSync(prebuiltBinaryPath)) {
     return true;
   }
 
@@ -38,14 +56,15 @@ function ensureBinary() {
     return false;
   }
 
-  return build.status === 0 && fs.existsSync(releaseBinaryPath);
+  return build.status === 0 && !!resolveExistingReleaseBinary();
 }
 
 if (!ensureBinary()) {
   process.exit(1);
 }
 
-const result = runBinary(releaseBinaryPath);
+const binaryPath = resolveExistingReleaseBinary() || prebuiltBinaryPath;
+const result = runBinary(binaryPath);
 if (result.error) {
   console.error(`Failed to run reallink binary: ${result.error.message}`);
   process.exit(1);

package/package.json

@@ -1,19 +1,22 @@
 {
   "name": "reallink-cli",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "Rust-based CLI for Reallink auth and API operations",
   "bin": {
     "reallink": "bin/reallink.cjs"
   },
   "files": [
     "bin/reallink.cjs",
+    "prebuilt",
     "scripts/postinstall.cjs",
+    "scripts/prepare-prebuilt.cjs",
     "rust/Cargo.toml",
     "rust/Cargo.lock",
     "rust/src",
     "README.md"
   ],
   "scripts": {
+    "prepack": "node ./scripts/prepare-prebuilt.cjs",
     "postinstall": "node ./scripts/postinstall.cjs",
     "build": "cargo build --manifest-path ./rust/Cargo.toml --release",
     "dev": "node ./bin/reallink.cjs --help",

package/rust/Cargo.lock

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

package/rust/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reallink-cli"
-version = "0.1.9"
+version = "0.1.11"
 edition = "2021"
 description = "CLI for Reallink auth and token workflows"
 license = "MIT"
@@ -13,5 +13,5 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 json5 = "0.4"
-tokio = { version = "1.42", features = ["macros", "rt-multi-thread", "time"] }
+tokio = { version = "1.42", features = ["macros", "rt-multi-thread", "time", "fs", "io-util"] }
 webbrowser = "1.0"

package/rust/src/main.rs

@@ -7,6 +7,8 @@ use std::io::{self, Write};
 use std::path::{Path, PathBuf};
 use std::process::Command;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use tokio::fs as tokio_fs;
+use tokio::io::AsyncWriteExt;
 use tokio::time::sleep;
 
 const DEFAULT_BASE_URL: &str = "https://api.real-agent.link";
@@ -18,7 +20,12 @@ const VERSION_CHECK_INTERVAL_MS: u128 = 24 * 60 * 60 * 1000;
 const DEFAULT_VERSION_FETCH_TIMEOUT_MS: u64 = 800;
 
 #[derive(Parser)]
-#[command(name = "reallink", bin_name = "reallink", version, about = "Reallink CLI")]
+#[command(
+    name = "reallink",
+    bin_name = "reallink",
+    version,
+    about = "Reallink CLI"
+)]
 struct Cli {
     #[command(subcommand)]
     command: Commands,
@@ -92,6 +99,8 @@ enum ProjectCommands {
 enum FileCommands {
     List(FileListArgs),
     Get(FileGetArgs),
+    Stat(FileStatArgs),
+    Download(FileDownloadArgs),
     Upload(FileUploadArgs),
     Mkdir(FileMkdirArgs),
     Move(FileMoveArgs),
@@ -151,6 +160,29 @@ struct FileGetArgs {
     base_url: Option<String>,
 }
 
+#[derive(Args)]
+struct FileStatArgs {
+    #[arg(long)]
+    asset_id: String,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
+#[derive(Args)]
+struct FileDownloadArgs {
+    #[arg(long)]
+    asset_id: String,
+    #[arg(long)]
+    output: Option<PathBuf>,
+    #[arg(
+        long,
+        help = "Resume download from existing output file size using HTTP Range"
+    )]
+    resume: bool,
+    #[arg(long)]
+    base_url: Option<String>,
+}
+
 #[derive(Args)]
 struct FileUploadArgs {
     #[arg(long)]
@@ -508,6 +540,20 @@ struct AssetResponse {
     asset: AssetRecord,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AssetContentMetadata {
+    part_count: i64,
+    content_length: i64,
+    accept_ranges: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AssetMetadataResponse {
+    asset: AssetRecord,
+    content: AssetContentMetadata,
+}
+
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 struct UploadIntentRequest {
@@ -598,7 +644,10 @@ fn load_jsonc_file(path: &Path, label: &str) -> Result<serde_json::Value> {
     parse_jsonc_str(&raw, &format!("{} file {}", label, path.display()))
 }
 
-fn parse_object_from_value(value: serde_json::Value, context: &str) -> Result<serde_json::Map<String, serde_json::Value>> {
+fn parse_object_from_value(
+    value: serde_json::Value,
+    context: &str,
+) -> Result<serde_json::Map<String, serde_json::Value>> {
     match value {
         serde_json::Value::Object(map) => Ok(map),
         _ => Err(anyhow!("{} must be a JSON object", context)),
@@ -659,7 +708,8 @@ fn write_atomic(path: &Path, payload: &[u8]) -> Result<()> {
 fn save_session(session: &SessionConfig) -> Result<()> {
     let path = config_path()?;
     if let Some(parent) = path.parent() {
-        fs::create_dir_all(parent).with_context(|| format!("Failed to create {}", parent.display()))?;
+        fs::create_dir_all(parent)
+            .with_context(|| format!("Failed to create {}", parent.display()))?;
     }
     let payload = serde_json::to_vec_pretty(session)?;
     write_atomic(&path, &payload)?;
@@ -697,7 +747,8 @@ fn load_update_cache() -> Option<UpdateCheckCache> {
 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()))?;
+        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)?;
@@ -755,7 +806,11 @@ async fn fetch_latest_cli_version(client: &reqwest::Client) -> Option<String> {
         .filter(|value| !value.is_empty())
 }
 
-async fn maybe_notify_update(client: &reqwest::Client, force_refresh: bool, allow_network_fetch: bool) {
+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)
@@ -824,16 +879,43 @@ fn join_remote_path(prefix: Option<&str>, file_name: &str) -> String {
     format!("{}/{}", prefix_clean, file_clean)
 }
 
+fn base_name_from_virtual_path(path: &str) -> String {
+    let normalized = clean_virtual_path(path);
+    normalized
+        .split('/')
+        .filter(|segment| !segment.is_empty())
+        .next_back()
+        .unwrap_or("download.bin")
+        .to_string()
+}
+
 async fn authed_request(
     client: &reqwest::Client,
     session: &mut SessionConfig,
     method: Method,
     path: &str,
     body: Option<serde_json::Value>,
+) -> Result<reqwest::Response> {
+    authed_request_with_headers(client, session, method, path, body, &[]).await
+}
+
+async fn authed_request_with_headers(
+    client: &reqwest::Client,
+    session: &mut SessionConfig,
+    method: Method,
+    path: &str,
+    body: Option<serde_json::Value>,
+    extra_headers: &[(String, String)],
 ) -> Result<reqwest::Response> {
     let url = format!("{}{}", normalize_base_url(&session.base_url), path);
-    let mut request =
-        with_cli_headers(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),
+    );
+    for (key, value) in extra_headers {
+        request = request.header(key, value);
+    }
     if let Some(ref body_value) = body {
         request = request.json(body_value);
     }
@@ -844,7 +926,14 @@ async fn authed_request(
 
     refresh_session(client, session).await?;
 
-    let mut retry = with_cli_headers(client.request(method, &url).bearer_auth(&session.access_token));
+    let mut retry = with_cli_headers(
+        client
+            .request(method, &url)
+            .bearer_auth(&session.access_token),
+    );
+    for (key, value) in extra_headers {
+        retry = retry.header(key, value);
+    }
     if let Some(ref body_value) = body {
         retry = retry.json(body_value);
     }
@@ -857,7 +946,9 @@ async fn refresh_session(client: &reqwest::Client, session: &mut SessionConfig)
         refresh_token: session.refresh_token.clone(),
         session_id: session.session_id.clone(),
     };
-    let response = with_cli_headers(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));
@@ -924,13 +1015,14 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
         args.scope
     };
 
-    let device_code_response = with_cli_headers(client.post(format!("{}/auth/device/code", base_url)))
-        .json(&DeviceCodeRequest {
-            client_id: args.client_id.clone(),
-            scope,
-        })
-        .send()
-        .await?;
+    let device_code_response =
+        with_cli_headers(client.post(format!("{}/auth/device/code", base_url)))
+            .json(&DeviceCodeRequest {
+                client_id: args.client_id.clone(),
+                scope,
+            })
+            .send()
+            .await?;
 
     if !device_code_response.status().is_success() {
         let body = read_error_body(device_code_response).await;
@@ -961,14 +1053,15 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
 
         sleep(poll_interval).await;
 
-        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(),
-                client_id: args.client_id.clone(),
-            })
-            .send()
-            .await?;
+        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(),
+                    client_id: args.client_id.clone(),
+                })
+                .send()
+                .await?;
 
         if token_response.status().is_success() {
             let tokens: DeviceTokenSuccess = token_response.json().await?;
@@ -988,10 +1081,8 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
             return Ok(());
         }
 
-        let error_payload: DeviceTokenError = token_response
-            .json()
-            .await
-            .unwrap_or(DeviceTokenError {
+        let error_payload: DeviceTokenError =
+            token_response.json().await.unwrap_or(DeviceTokenError {
                 error: "unknown_error".to_string(),
                 error_description: Some("Could not parse auth error".to_string()),
             });
@@ -1018,7 +1109,7 @@ async fn login_command(client: &reqwest::Client, args: LoginArgs) -> Result<()>
                     "Device login failed: {} ({})",
                     error_payload.error,
                     error_payload.error_description.unwrap_or_default()
-                ))
+                ));
             }
         }
     }
@@ -1060,7 +1151,10 @@ async fn logout_command(client: &reqwest::Client) -> Result<()> {
     }
 
     if remote_revoked {
-        println!("Logged out. Server session revoked and local session removed from {}.", path_display);
+        println!(
+            "Logged out. Server session revoked and local session removed from {}.",
+            path_display
+        );
     } else if remote_unavailable {
         println!("Logged out locally. Removed session from {}.", path_display);
         println!("Server logout endpoint is not available on this API deployment yet.");
@@ -1119,7 +1213,14 @@ async fn token_create_command(client: &reqwest::Client, args: TokenCreateArgs) -
         expires_in_days: args.expires_in_days,
     })?;
 
-    let response = authed_request(client, &mut session, Method::POST, "/auth/tokens", Some(body)).await?;
+    let response = authed_request(
+        client,
+        &mut session,
+        Method::POST,
+        "/auth/tokens",
+        Some(body),
+    )
+    .await?;
     if !response.status().is_success() {
         let body_text = read_error_body(response).await;
         return Err(anyhow!("token create failed: {}", body_text));
@@ -1151,7 +1252,9 @@ async fn project_list_command(client: &reqwest::Client, args: ProjectListArgs) -
     apply_base_url_override(&mut session, args.base_url);
 
     let path = match args.org_id {
-        Some(org_id) if !org_id.trim().is_empty() => format!("/core/projects?orgId={}", org_id.trim()),
+        Some(org_id) if !org_id.trim().is_empty() => {
+            format!("/core/projects?orgId={}", org_id.trim())
+        }
         _ => "/core/projects".to_string(),
     };
 
@@ -1303,11 +1406,23 @@ async fn upload_asset_via_intent(
     let complete_payload = if strategy == "multipart" {
         let part_size = intent
             .part_size_bytes
-            .and_then(|value| if value > 0 { Some(value as usize) } else { None })
+            .and_then(|value| {
+                if value > 0 {
+                    Some(value as usize)
+                } else {
+                    None
+                }
+            })
             .ok_or_else(|| anyhow!("multipart upload intent is missing partSizeBytes"))?;
         let part_count = intent
             .part_count
-            .and_then(|value| if value > 0 { Some(value as usize) } else { None })
+            .and_then(|value| {
+                if value > 0 {
+                    Some(value as usize)
+                } else {
+                    None
+                }
+            })
             .ok_or_else(|| anyhow!("multipart upload intent is missing partCount"))?;
         let session_id = intent
             .session_id
@@ -1459,6 +1574,144 @@ async fn file_get_command(client: &reqwest::Client, args: FileGetArgs) -> Result
     Ok(())
 }
 
+async fn file_stat_command(client: &reqwest::Client, args: FileStatArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    let path = format!("/assets/{}/metadata", args.asset_id);
+    let response = authed_request(client, &mut session, Method::GET, &path, None).await?;
+    if !response.status().is_success() {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("file stat failed: {}", body));
+    }
+    let payload: AssetMetadataResponse = response.json().await?;
+    println!("{}", serde_json::to_string_pretty(&payload)?);
+    save_session(&session)?;
+    Ok(())
+}
+
+async fn file_download_command(client: &reqwest::Client, args: FileDownloadArgs) -> Result<()> {
+    let mut session = load_session()?;
+    apply_base_url_override(&mut session, args.base_url);
+
+    let metadata_path = format!("/assets/{}/metadata", args.asset_id);
+    let metadata_response =
+        authed_request(client, &mut session, Method::GET, &metadata_path, None).await?;
+    if !metadata_response.status().is_success() {
+        let body = read_error_body(metadata_response).await;
+        return Err(anyhow!("file metadata fetch failed: {}", body));
+    }
+    let metadata_payload: AssetMetadataResponse = metadata_response.json().await?;
+    let fallback_name = base_name_from_virtual_path(&metadata_payload.asset.file_name);
+
+    let mut output_path = args
+        .output
+        .unwrap_or_else(|| PathBuf::from(fallback_name.as_str()));
+    if output_path.exists() && output_path.is_dir() {
+        output_path = output_path.join(fallback_name.as_str());
+    }
+
+    if let Some(parent) = output_path.parent() {
+        if !parent.as_os_str().is_empty() {
+            tokio_fs::create_dir_all(parent).await.with_context(|| {
+                format!("Failed to create output directory {}", parent.display())
+            })?;
+        }
+    }
+
+    let mut resume_from: Option<u64> = None;
+    if args.resume && output_path.exists() && output_path.is_file() {
+        let existing_size = tokio_fs::metadata(&output_path)
+            .await
+            .with_context(|| {
+                format!(
+                    "Failed to read output file metadata {}",
+                    output_path.display()
+                )
+            })?
+            .len();
+        if existing_size > 0 {
+            let remote_size = metadata_payload.content.content_length.max(0) as u64;
+            if existing_size >= remote_size && remote_size > 0 {
+                println!(
+                    "{}",
+                    serde_json::to_string_pretty(&serde_json::json!({
+                        "assetId": metadata_payload.asset.id,
+                        "fileName": metadata_payload.asset.file_name,
+                        "output": output_path.display().to_string(),
+                        "bytesWritten": 0,
+                        "resumedFrom": existing_size,
+                        "alreadyComplete": true
+                    }))?
+                );
+                save_session(&session)?;
+                return Ok(());
+            }
+            resume_from = Some(existing_size);
+        }
+    }
+
+    let download_path = format!("/assets/{}/download", args.asset_id);
+    let mut headers = Vec::new();
+    if let Some(offset) = resume_from {
+        headers.push(("range".to_string(), format!("bytes={}-", offset)));
+    }
+    let mut response = authed_request_with_headers(
+        client,
+        &mut session,
+        Method::GET,
+        &download_path,
+        None,
+        &headers,
+    )
+    .await?;
+    if !(response.status().is_success() || response.status() == StatusCode::PARTIAL_CONTENT) {
+        let body = read_error_body(response).await;
+        return Err(anyhow!("file download failed: {}", body));
+    }
+
+    let append_mode = resume_from.is_some() && response.status() == StatusCode::PARTIAL_CONTENT;
+    let mut output_file = if append_mode {
+        tokio_fs::OpenOptions::new()
+            .append(true)
+            .open(&output_path)
+            .await
+            .with_context(|| {
+                format!(
+                    "Failed to open output file for append {}",
+                    output_path.display()
+                )
+            })?
+    } else {
+        tokio_fs::File::create(&output_path)
+            .await
+            .with_context(|| format!("Failed to create output file {}", output_path.display()))?
+    };
+    let mut bytes_written: u64 = 0;
+    while let Some(chunk) = response.chunk().await? {
+        output_file
+            .write_all(&chunk)
+            .await
+            .with_context(|| format!("Failed to write to {}", output_path.display()))?;
+        bytes_written = bytes_written.saturating_add(chunk.len() as u64);
+    }
+    output_file.flush().await?;
+
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&serde_json::json!({
+            "assetId": metadata_payload.asset.id,
+            "fileName": metadata_payload.asset.file_name,
+            "output": output_path.display().to_string(),
+            "bytesWritten": bytes_written,
+            "resumedFrom": resume_from,
+            "partialContent": response.status() == StatusCode::PARTIAL_CONTENT
+        }))?
+    );
+    save_session(&session)?;
+    Ok(())
+}
+
 async fn file_upload_command(client: &reqwest::Client, args: FileUploadArgs) -> Result<()> {
     let mut session = load_session()?;
     apply_base_url_override(&mut session, args.base_url);
@@ -1589,12 +1842,16 @@ async fn tool_register_command(client: &reqwest::Client, args: ToolRegisterArgs)
     apply_base_url_override(&mut session, args.base_url);
 
     let manifest = load_jsonc_file(&args.manifest, "tool manifest")?;
-    let body = serde_json::Value::Object(parse_object_from_value(
-        manifest,
-        "tool manifest payload",
-    )?);
-    let response =
-        authed_request(client, &mut session, Method::POST, "/tools/definitions", Some(body)).await?;
+    let body =
+        serde_json::Value::Object(parse_object_from_value(manifest, "tool manifest payload")?);
+    let response = authed_request(
+        client,
+        &mut session,
+        Method::POST,
+        "/tools/definitions",
+        Some(body),
+    )
+    .await?;
     if !response.status().is_success() {
         let body = read_error_body(response).await;
         return Err(anyhow!("tool register failed: {}", body));
@@ -1637,13 +1894,19 @@ async fn tool_set_entitlement_command(
         body.insert("orgId".to_string(), serde_json::Value::String(org_id));
     }
     if let Some(project_id) = project_id {
-        body.insert("projectId".to_string(), serde_json::Value::String(project_id));
+        body.insert(
+            "projectId".to_string(),
+            serde_json::Value::String(project_id),
+        );
     }
     if let Some(user_id) = user_id {
         body.insert("userId".to_string(), serde_json::Value::String(user_id));
     }
     if let Some(expires_at) = expires_at {
-        body.insert("expiresAt".to_string(), serde_json::Value::String(expires_at));
+        body.insert(
+            "expiresAt".to_string(),
+            serde_json::Value::String(expires_at),
+        );
     }
     if let Some(path) = metadata_file {
         let metadata = load_jsonc_file(&path, "tool entitlement metadata")?;
@@ -1731,19 +1994,23 @@ async fn tool_run_command(client: &reqwest::Client, args: ToolRunArgs) -> Result
         serde_json::Value::Object(serde_json::Map::new())
     };
 
-    let input_object = serde_json::Value::Object(parse_object_from_value(
-        input_value,
-        "tool run input",
-    )?);
+    let input_object =
+        serde_json::Value::Object(parse_object_from_value(input_value, "tool run input")?);
 
     let mut body = serde_json::Map::new();
-    body.insert("toolId".to_string(), serde_json::Value::String(args.tool_id));
+    body.insert(
+        "toolId".to_string(),
+        serde_json::Value::String(args.tool_id),
+    );
     body.insert("input".to_string(), input_object);
     if let Some(org_id) = args.org_id {
         body.insert("orgId".to_string(), serde_json::Value::String(org_id));
     }
     if let Some(project_id) = args.project_id {
-        body.insert("projectId".to_string(), serde_json::Value::String(project_id));
+        body.insert(
+            "projectId".to_string(),
+            serde_json::Value::String(project_id),
+        );
     }
     let mut metadata_map = if let Some(path) = args.metadata_file {
         let metadata = load_jsonc_file(&path, "tool run metadata")?;
@@ -1761,7 +2028,10 @@ async fn tool_run_command(client: &reqwest::Client, args: ToolRunArgs) -> Result
         }
     }
     if !metadata_map.is_empty() {
-        body.insert("metadata".to_string(), serde_json::Value::Object(metadata_map));
+        body.insert(
+            "metadata".to_string(),
+            serde_json::Value::Object(metadata_map),
+        );
     }
 
     let response = authed_request(
@@ -1886,7 +2156,9 @@ async fn self_update_command(client: &reqwest::Client, args: SelfUpdateArgs) ->
             },
             "npm self-update",
         )?;
-        println!("Updated via npm. Restart your shell if `reallink --version` still shows old version.");
+        println!(
+            "Updated via npm. Restart your shell if `reallink --version` still shows old version."
+        );
         return Ok(());
     }
 
@@ -1952,6 +2224,8 @@ async fn main() -> Result<()> {
         Commands::File { command } => match command {
             FileCommands::List(args) => file_list_command(&client, args).await?,
             FileCommands::Get(args) => file_get_command(&client, args).await?,
+            FileCommands::Stat(args) => file_stat_command(&client, args).await?,
+            FileCommands::Download(args) => file_download_command(&client, args).await?,
             FileCommands::Upload(args) => file_upload_command(&client, args).await?,
             FileCommands::Mkdir(args) => file_mkdir_command(&client, args).await?,
             FileCommands::Move(args) => file_move_command(&client, args).await?,

package/scripts/postinstall.cjs

@@ -6,13 +6,26 @@ 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);
+const prebuiltBinaryPath = path.join(
+  packageRoot,
+  "prebuilt",
+  `${process.platform}-${process.arch}`,
+  binaryName
+);
+const releaseBinaryCandidates = [
+  path.resolve(packageRoot, "..", "..", "target", "release", binaryName),
+  path.join(packageRoot, "rust", "target", "release", binaryName)
+];
+
+function hasReleaseBinary() {
+  return releaseBinaryCandidates.some((candidate) => fs.existsSync(candidate));
+}
 
 if (process.env.REALLINK_SKIP_BUILD === "1") {
   process.exit(0);
 }
 
-if (fs.existsSync(releaseBinaryPath)) {
+if (hasReleaseBinary() || fs.existsSync(prebuiltBinaryPath)) {
   process.exit(0);
 }
 

package/scripts/prepare-prebuilt.cjs

@@ -0,0 +1,49 @@
+#!/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 releaseBinaryCandidates = [
+  path.resolve(packageRoot, "..", "..", "target", "release", binaryName),
+  path.join(packageRoot, "rust", "target", "release", binaryName)
+];
+const prebuiltDir = path.join(packageRoot, "prebuilt", `${process.platform}-${process.arch}`);
+const prebuiltBinaryPath = path.join(prebuiltDir, binaryName);
+
+function resolveNewestReleaseBinary() {
+  const existing = releaseBinaryCandidates
+    .filter((candidate) => fs.existsSync(candidate))
+    .map((candidate) => ({
+      candidate,
+      mtimeMs: fs.statSync(candidate).mtimeMs
+    }))
+    .sort((a, b) => b.mtimeMs - a.mtimeMs);
+  return existing.length > 0 ? existing[0].candidate : null;
+}
+
+const build = spawnSync(
+  "cargo",
+  ["build", "--release", "--manifest-path", manifestPath],
+  {
+    stdio: "inherit",
+    shell: process.platform === "win32"
+  }
+);
+
+if (build.error) {
+  console.error(`prepare-prebuilt failed: ${build.error.message}`);
+  process.exit(1);
+}
+
+const releaseBinaryPath = resolveNewestReleaseBinary();
+if (build.status !== 0 || !releaseBinaryPath) {
+  console.error("prepare-prebuilt failed: release binary was not produced");
+  process.exit(build.status ?? 1);
+}
+
+fs.mkdirSync(prebuiltDir, { recursive: true });
+fs.copyFileSync(releaseBinaryPath, prebuiltBinaryPath);
+console.log(`Prepared prebuilt binary: ${prebuiltBinaryPath}`);