feature: atproto-record-cid

CLAUDE.md

···
 #### Record Operations
 - **Sign records**: `cargo run --features clap --bin atproto-record-sign -- <issuer_did> <signing_key> <record_input> repository=<repo> collection=<collection>`
 - **Verify records**: `cargo run --features clap --bin atproto-record-verify -- <issuer_did> <key> <record_input> repository=<repo> collection=<collection>`
+- **Generate CID**: `cat record.json | cargo run --features clap --bin atproto-record-cid` (reads JSON from stdin, outputs CID)
 
 #### Client Tools
 - **App password auth**: `cargo run --features clap --bin atproto-client-app-password -- <subject> <access_token> <xrpc_path>`
···
 - **atproto-xrpcs-helloworld**: Complete example XRPC service
 
 Features:
-- **12 CLI tools** with consistent clap-based command-line interfaces (optional via `clap` feature)
+- **13 CLI tools** with consistent clap-based command-line interfaces (optional via `clap` feature)
 - **Rust edition 2024** with modern async/await patterns
 - **Comprehensive error handling** with structured error types
 - **Full test coverage** with unit tests across all modules
···
 #### Record Operations (atproto-record)
 - **`src/bin/atproto-record-sign.rs`**: Sign AT Protocol records with cryptographic signatures
 - **`src/bin/atproto-record-verify.rs`**: Verify AT Protocol record signatures
+- **`src/bin/atproto-record-cid.rs`**: Generate CID (Content Identifier) for AT Protocol records using DAG-CBOR serialization
 
 #### Client Tools (atproto-client)
 - **`src/bin/atproto-client-app-password.rs`**: Make XRPC calls using app password authentication

Cargo.lock

···
  "atproto-identity",
  "base64",
  "chrono",
+ "cid",
  "clap",
+ "multihash",
  "serde",
  "serde_ipld_dagcbor",
  "serde_json",
+ "sha2",
  "thiserror 2.0.12",
  "tokio",
 ]

crates/atproto-client/src/client.rs

···
     Ok(value)
 }
 
-
+/// Performs a DPoP-authenticated HTTP POST request with raw bytes body and additional headers, and parses the response as JSON.
+///
+/// This function is similar to `post_dpop_json_with_headers` but accepts a raw bytes payload
+/// instead of JSON. Useful for sending pre-serialized data or binary payloads while maintaining
+/// DPoP authentication and custom headers.
+///
+/// # Arguments
+///
+/// * `http_client` - The HTTP client to use for the request
+/// * `dpop_auth` - DPoP authentication credentials
+/// * `url` - The URL to request
+/// * `payload` - The raw bytes to send in the request body
+/// * `additional_headers` - Additional HTTP headers to include in the request
+///
+/// # Returns
+///
+/// The parsed JSON response as a `serde_json::Value`
+///
+/// # Errors
+///
+/// Returns `DPoPError::ProofGenerationFailed` if DPoP proof generation fails,
+/// `DPoPError::HttpRequestFailed` if the HTTP request fails,
+/// or `DPoPError::JsonParseFailed` if JSON parsing fails.
+///
+/// # Example
+///
+/// ```no_run
+/// use atproto_client::client::{DPoPAuth, post_dpop_bytes_with_headers};
+/// use atproto_identity::key::identify_key;
+/// use reqwest::{Client, header::{HeaderMap, CONTENT_TYPE}};
+/// use bytes::Bytes;
+///
+/// # async fn example() -> anyhow::Result<()> {
+/// let client = Client::new();
+/// let dpop_auth = DPoPAuth {
+///     dpop_private_key_data: identify_key("did:key:zQ3sh...")?,
+///     oauth_access_token: "access_token".to_string(),
+/// };
+///
+/// let mut headers = HeaderMap::new();
+/// headers.insert(CONTENT_TYPE, "application/json".parse()?);
+///
+/// let payload = Bytes::from(r#"{"text": "Hello!"}"#);
+/// let response = post_dpop_bytes_with_headers(
+///     &client,
+///     &dpop_auth,
+///     "https://pds.example.com/xrpc/com.atproto.repo.createRecord",
+///     payload,
+///     &headers
+/// ).await?;
+/// # Ok(())
+/// # }
+/// ```
 pub async fn post_dpop_bytes_with_headers(
     http_client: &reqwest::Client,
     dpop_auth: &DPoPAuth,

crates/atproto-record/Cargo.toml

···
 doc = true
 required-features = ["clap", "tokio"]
 
-[[bin]]         
+[[bin]]
 name = "atproto-record-verify"
 test = false
 bench = false
 doc = true
 required-features = ["clap", "tokio"]
 
+[[bin]]
+name = "atproto-record-cid"
+test = false
+bench = false
+doc = true
+required-features = ["clap"]
+
 [dependencies]
 atproto-identity.workspace = true
 
···
 tokio = { workspace = true, optional = true }
 chrono = {version = "0.4.41", default-features = false, features = ["std", "now", "serde"]}
 clap = { workspace = true, optional = true }
+cid = "0.11"
+multihash = "0.19"
+sha2 = { workspace = true }
 
 [features]
 default = ["hickory-dns"]

crates/atproto-record/src/bin/atproto-record-cid.rs

···
+//! Command-line tool for generating CIDs from JSON records.
+//!
+//! This tool reads JSON from stdin, serializes it using IPLD DAG-CBOR format,
+//! and outputs the corresponding CID (Content Identifier) using CIDv1 with
+//! SHA-256 hashing. This matches the AT Protocol specification for content
+//! addressing of records.
+//!
+//! # AT Protocol CID Format
+//!
+//! The tool generates CIDs that follow the AT Protocol specification:
+//! - **CID Version**: CIDv1
+//! - **Codec**: DAG-CBOR (0x71)
+//! - **Hash Function**: SHA-256 (0x12)
+//! - **Encoding**: Base32 (default for CIDv1)
+//!
+//! # Example Usage
+//!
+//! ```bash
+//! # Generate CID from a simple JSON object
+//! echo '{"text":"Hello, AT Protocol!"}' | cargo run --features clap --bin atproto-record-cid
+//!
+//! # Generate CID from a file
+//! cat post.json | cargo run --features clap --bin atproto-record-cid
+//!
+//! # Generate CID from a complex record
+//! echo '{
+//!   "$type": "app.bsky.feed.post",
+//!   "text": "Hello world",
+//!   "createdAt": "2025-01-19T10:00:00.000Z"
+//! }' | cargo run --features clap --bin atproto-record-cid
+//! ```
+//!
+//! # Output Format
+//!
+//! The tool outputs the CID as a single line string in the format:
+//! ```text
+//! bafyreibjzlvhtyxnhbvvzl3gj4qmg2ufl2jbhh5qr3gvvxlm7ksf3qwxqq
+//! ```
+//!
+//! # Error Handling
+//!
+//! The tool will return an error if:
+//! - Input is not valid JSON
+//! - JSON cannot be serialized to DAG-CBOR
+//! - CID generation fails
+//!
+//! # Technical Details
+//!
+//! The CID generation process:
+//! 1. Read JSON from stdin
+//! 2. Parse JSON into serde_json::Value
+//! 3. Serialize to DAG-CBOR bytes using serde_ipld_dagcbor
+//! 4. Hash the bytes using SHA-256
+//! 5. Create CIDv1 with DAG-CBOR codec
+//! 6. Output the CID string
+
+use anyhow::Result;
+use atproto_record::errors::CliError;
+use cid::Cid;
+use clap::Parser;
+use multihash::Multihash;
+use sha2::{Digest, Sha256};
+use std::io::{self, Read};
+
+/// AT Protocol Record CID Generator
+#[derive(Parser)]
+#[command(
+    name = "atproto-record-cid",
+    version,
+    about = "Generate CID for AT Protocol DAG-CBOR records from JSON",
+    long_about = "
+A command-line tool for generating Content Identifiers (CIDs) from JSON records
+using the AT Protocol DAG-CBOR serialization format.
+
+The tool reads JSON from stdin, serializes it using IPLD DAG-CBOR format, and
+outputs the corresponding CID using CIDv1 with SHA-256 hashing. This matches
+the AT Protocol specification for content addressing of records.
+
+CID FORMAT:
+  Version:  CIDv1
+  Codec:    DAG-CBOR (0x71)
+  Hash:     SHA-256 (0x12)
+  Encoding: Base32 (default for CIDv1)
+
+EXAMPLES:
+  # Generate CID from stdin:
+  echo '{\"text\":\"Hello!\"}' | atproto-record-cid
+
+  # Generate CID from a file:
+  cat post.json | atproto-record-cid
+
+  # Complex record with AT Protocol fields:
+  echo '{
+    \"$type\": \"app.bsky.feed.post\",
+    \"text\": \"Hello world\",
+    \"createdAt\": \"2025-01-19T10:00:00.000Z\"
+  }' | atproto-record-cid
+
+OUTPUT:
+  The tool outputs a single line containing the CID:
+  bafyreibjzlvhtyxnhbvvzl3gj4qmg2ufl2jbhh5qr3gvvxlm7ksf3qwxqq
+
+NOTES:
+  - Input must be valid JSON
+  - The same JSON input will always produce the same CID
+  - Field order in JSON objects may affect the CID due to DAG-CBOR serialization
+  - Special AT Protocol fields like $type, $sig, and $link are preserved
+"
+)]
+struct Args {}
+
+fn main() -> Result<()> {
+    let _args = Args::parse();
+
+    // Read JSON from stdin
+    let mut stdin_content = String::new();
+    io::stdin()
+        .read_to_string(&mut stdin_content)
+        .map_err(|_| CliError::StdinReadFailed)?;
+
+    // Parse JSON
+    let json_value: serde_json::Value =
+        serde_json::from_str(&stdin_content).map_err(|_| CliError::StdinJsonParseFailed)?;
+
+    // Serialize to DAG-CBOR
+    let dag_cbor_bytes = serde_ipld_dagcbor::to_vec(&json_value).map_err(|error| {
+        CliError::RecordSerializationFailed {
+            error: error.to_string(),
+        }
+    })?;
+
+    // Hash the bytes using SHA-256
+    // Code 0x12 is SHA-256, size 32 bytes
+    let mut hasher = Sha256::new();
+    hasher.update(&dag_cbor_bytes);
+    let hash_result = hasher.finalize();
+
+    let multihash =
+        Multihash::wrap(0x12, &hash_result).map_err(|error| CliError::CidGenerationFailed {
+            error: error.to_string(),
+        })?;
+
+    // Create CIDv1 with DAG-CBOR codec (0x71)
+    let cid = Cid::new_v1(0x71, multihash);
+
+    // Output the CID
+    println!("{}", cid);
+
+    Ok(())
+}

crates/atproto-record/src/errors.rs

···
         /// The name of the missing value
         name: String,
     },
+
+    /// Occurs when record serialization to DAG-CBOR fails
+    #[error("error-atproto-record-cli-9 Failed to serialize record to DAG-CBOR: {error}")]
+    RecordSerializationFailed {
+        /// The underlying serialization error
+        error: String,
+    },
+
+    /// Occurs when CID generation fails
+    #[error("error-atproto-record-cli-10 Failed to generate CID: {error}")]
+    CidGenerationFailed {
+        /// The underlying CID generation error
+        error: String,
+    },
 }