fix: client save logs item ID early, stores compression via proper field and size via update endpoint

- Client save now logs 'New item: {id}' immediately after server response
- Compression type sent as query param, stored in DB compression field (not _client_compression metadata)
- Client set_item_size() sends uncompressed size via POST /api/item/{id}/update?size=N
- Server raw content GET uses actual file size for Content-Length (not uncompressed item.size)
- Removed _client_compression metadata hack from client save and get
- Fixed server handle_update_item to support size-only updates
- Fixed clippy: collapsible_if, too_many_arguments, unnecessary mut refs
- Fixed ListItemsQuery doctest missing meta field

src/modes/client/save.rs

@@ -37,6 +37,7 @@ pub fn mode(
 
     // Determine compression type from settings
     let compression_type = settings_compression_type(cmd, settings);
+    let compression_type_str = compression_type.to_string();
     let server_compress = matches!(compression_type, CompressionType::None);
 
     // Shared metadata collection: plugins write here via save_meta closure
@@ -72,8 +73,8 @@ pub fn mode(
         // Wrap pipe writer with appropriate compression
         let mut compressor: Box<dyn Write> = match compression_type_clone {
             CompressionType::GZip => {
-                use flate2::Compression;
                 use flate2::write::GzEncoder;
+                use flate2::Compression;
                 Box::new(GzEncoder::new(pipe_writer, Compression::default()))
             }
             CompressionType::LZ4 => Box::new(lz4_flex::frame::FrameEncoder::new(pipe_writer)),
@@ -114,6 +115,7 @@ pub fn mode(
     let client_password = client.password().cloned();
     let client_jwt = client.jwt().cloned();
     let tags_clone = tags.clone();
+    let compression_type_str_clone = compression_type_str.clone();
 
     let streamer_handle = std::thread::spawn(move || -> Result<ItemInfo> {
         let streaming_client =
@@ -122,7 +124,18 @@ pub fn mode(
             ("compress".to_string(), server_compress.to_string()),
             ("meta".to_string(), "false".to_string()),
             ("tags".to_string(), tags_clone.join(",")),
+            (
+                "compression_type".to_string(),
+                if !server_compress {
+                    compression_type_str_clone
+                } else {
+                    String::new()
+                },
+            ),
         ];
+        // Filter out empty params
+        let params: Vec<(String, String)> =
+            params.into_iter().filter(|(_, v)| !v.is_empty()).collect();
         let param_refs: Vec<(&str, &str)> = params
             .iter()
             .map(|(k, v)| (k.as_str(), v.as_str()))
@@ -153,31 +166,20 @@ pub fn mode(
         }
     }
 
-    // Add uncompressed_size (always tracked by client)
-    local_metadata.insert(
-        "uncompressed_size".to_string(),
-        uncompressed_size.to_string(),
-    );
-
-    // Record client compression type so the client can decompress on retrieval.
-    if !matches!(compression_type, CompressionType::None) {
-        local_metadata.insert(
-            "_client_compression".to_string(),
-            compression_type.to_string(),
-        );
-    }
+    // Send uncompressed size to server (proper field, not metadata)
+    client.set_item_size(item_info.id, uncompressed_size)?;
 
     // Send metadata to server
     if !local_metadata.is_empty() {
         client.post_metadata(item_info.id, &local_metadata)?;
     }
 
-    // Print status to stderr
+    // Print status to stderr (item ID is known immediately from server response)
     if !settings.quiet {
         if std::io::stderr().is_terminal() {
-            eprintln!("KEEP: New item (streaming)  tags: {}", tags.join(" "));
+            eprintln!("KEEP: New item: {}  tags: {}", item_info.id, tags.join(" "));
         } else {
-            eprintln!("KEEP: New item (streaming)  tags: {tags:?}");
+            eprintln!("KEEP: New item: {}  tags: {tags:?}", item_info.id);
         }
     }