feature: Added stdin support to binaries.

* The atproto-record-sign tool can read records from stdin.
* The atproto-record-verify tool can read records from stdin.
* Added a top-level project README.md file.
* Added missing LICENSE file.

CLAUDE.prompts.md

···
 
 Write a project `README.md` file that describes the project as a library that supports ATProtocol identity record signing and verifying. Note that parts of this was extracted from the open sourced https://tangled.sh/@smokesignal.events/smokesignal project. This project is open source under the MIT license.
 
+The `REAADME.md` file should provide a high level overview of both the `atproto-identity` and `atproto-record` crates. It should also concisely reference the available binaries and provide a minimal example of how to use them.
+
 ## Check and clippy
 
 Using `cargo clippy`, satisfy warnings. Think very hard about how to do this.

LICENSE

···
+MIT License
+
+Copyright (c) 2024 Nick Gerakines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

···
+# AT Protocol Identity & Record Library
+
+A comprehensive Rust library for AT Protocol identity management and record signing/verification. This library provides full functionality for DID resolution, handle resolution, identity document management, and cryptographic record operations across multiple DID methods.
+
+Parts of this library were extracted from the open-sourced [Smokesignal](https://tangled.sh/@smokesignal.events/smokesignal) project.
+
+## Crates
+
+This workspace contains two main crates:
+
+### `atproto-identity`
+
+A comprehensive AT Protocol identity management library providing:
+
+- **DID Resolution**: Support for `did:plc`, `did:web`, and `did:key` methods
+- **Handle Resolution**: DNS-based handle resolution with validation
+- **Identity Documents**: Complete DID document parsing and management
+- **Cryptographic Operations**: P-256 and K-256 elliptic curve support
+- **Validation**: Input validation for handles and DIDs
+- **Configuration**: Environment-based configuration management
+
+### `atproto-record`
+
+AT Protocol record signature operations library providing:
+
+- **Record Signing**: Create cryptographic signatures for AT Protocol records
+- **Signature Verification**: Verify existing signatures against records and public keys
+- **IPLD Integration**: Proper IPLD DAG-CBOR serialization for signature content
+- **Multi-curve Support**: Support for P-256 and K-256 elliptic curves
+
+## CLI Tools
+
+The library includes several command-line utilities:
+
+### atproto-identity
+
+- `atproto-identity-resolve` - Resolve DIDs and handles to identity documents
+- `atproto-identity-sign` - Sign identity-related operations
+- `atproto-identity-validate` - Validate DID and handle formats
+
+### atproto-record
+
+- `atproto-record-sign` - Sign AT Protocol records from files or stdin
+- `atproto-record-verify` - Verify AT Protocol record signatures from files or stdin
+
+## Quick Start
+
+Add the crates to your `Cargo.toml`:
+
+```toml
+[dependencies]
+atproto-identity = "0.3.0"
+atproto-record = "0.3.0"
+```
+
+### Basic Identity Resolution
+
+```rust
+use atproto_identity::resolve::resolve_handle;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Resolve a handle to a DID
+    let did = resolve_handle("alice.bsky.social").await?;
+    println!("Resolved DID: {}", did);
+    
+    Ok(())
+}
+```
+
+### Record Signing and Verification
+
+```rust
+use atproto_identity::key::identify_key;
+use atproto_record::signature;
+use serde_json::json;
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    // Parse DID key for signing operations
+    let signing_key = identify_key("did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW")?;
+    
+    // Create a record to sign
+    let record = json!({
+        "$type": "app.bsky.feed.post",
+        "text": "Hello AT Protocol!",
+        "createdAt": "2024-01-01T00:00:00.000Z"
+    });
+    
+    // Create signature object with issuer and timestamp
+    let signature_object = json!({
+        "issuer": "did:plc:tgudj2fjm77pzkuawquqhsxm",
+        "issued_at": "2024-01-01T00:00:00.000Z"
+    });
+    
+    // Sign the record
+    let signed_record = signature::create(
+        &signing_key,
+        &record,
+        "did:plc:4zutorghlchjxzgceklue4la", // repository
+        "app.bsky.feed.post",              // collection
+        signature_object,
+    ).await?;
+    
+    // Verify the signature
+    signature::verify(
+        "did:plc:tgudj2fjm77pzkuawquqhsxm", // issuer
+        &signing_key,                       // verification key
+        signed_record,                      // signed record
+        "did:plc:4zutorghlchjxzgceklue4la", // repository
+        "app.bsky.feed.post",               // collection
+    ).await?;
+    
+    println!("Signature verification successful");
+    
+    Ok(())
+}
+```
+
+### CLI Usage Examples
+
+```bash
+# Resolve a handle or DID
+cargo run --bin atproto-identity-resolve -- alice.bsky.social
+
+# Get full DID document
+cargo run --bin atproto-identity-resolve -- --did-document did:plc:abc123
+
+# Sign a record from file
+cargo run --bin atproto-record-sign -- \
+  did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+  ./record.json \
+  did:plc:tgudj2fjm77pzkuawquqhsxm \
+  repository=did:plc:4zutorghlchjxzgceklue4la \
+  collection=app.bsky.feed.post
+
+# Sign a record from stdin
+echo '{"$type":"app.bsky.feed.post","text":"Hello!"}' | \
+cargo run --bin atproto-record-sign -- \
+  did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+  -- \
+  did:plc:tgudj2fjm77pzkuawquqhsxm \
+  repository=did:plc:4zutorghlchjxzgceklue4la \
+  collection=app.bsky.feed.post
+
+# Verify a signature from file
+cargo run --bin atproto-record-verify -- \
+  did:plc:tgudj2fjm77pzkuawquqhsxm \
+  did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+  ./signed_record.json \
+  repository=did:plc:4zutorghlchjxzgceklue4la \
+  collection=app.bsky.feed.post
+
+# Verify a signature from stdin
+echo '{"signatures":[...],"text":"Hello!"}' | \
+cargo run --bin atproto-record-verify -- \
+  did:plc:tgudj2fjm77pzkuawquqhsxm \
+  did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+  -- \
+  repository=did:plc:4zutorghlchjxzgceklue4la \
+  collection=app.bsky.feed.post
+```
+
+## Development
+
+### Building
+
+```bash
+cargo build
+```
+
+### Running Tests
+
+```bash
+cargo test
+```
+
+### Code Quality
+
+```bash
+# Format code
+cargo fmt
+
+# Lint
+cargo clippy
+
+# Check without building
+cargo check
+```
+
+## Features
+
+- **Async/Await**: Built with modern Rust async patterns using Tokio
+- **Error Handling**: Comprehensive structured error types using `thiserror`
+- **Logging**: Structured logging with `tracing`
+- **Security**: Forbids unsafe code and follows security best practices
+- **Standards Compliance**: Full AT Protocol specification compliance
+- **Multi-platform**: Works on all major platforms
+
+## Architecture
+
+The library follows a modular architecture with clear separation of concerns:
+
+- **Identity Management**: Handle DID resolution, validation, and document management
+- **Cryptographic Operations**: Secure key operations and signature handling
+- **Network Operations**: HTTP and DNS resolution with proper error handling
+- **Data Models**: Comprehensive type definitions for AT Protocol entities
+- **CLI Tools**: Ready-to-use command-line utilities
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Contributing
+
+Contributions are welcome! This project follows standard Rust conventions and includes comprehensive testing and documentation requirements.
+
+## Repository
+
+https://tangled.sh/@smokesignal.events/atproto-identity-rs

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

···
 use atproto_record::signature::create;
 use chrono::{SecondsFormat, Utc};
 use serde_json::json;
-use std::{collections::HashMap, env, fs};
+use std::{
+    collections::HashMap,
+    env, fs,
+    io::{self, Read},
+};
 
 /// AT Protocol Record Signing Tool
 ///
 /// This command-line tool provides cryptographic signing capabilities for AT Protocol records.
-/// It reads a JSON record from a file, applies a cryptographic signature using a DID key,
+/// It reads a JSON record from a file or stdin, applies a cryptographic signature using a DID key,
 /// and outputs the signed record with embedded signature metadata.
 ///
 /// ## Overview
···
 /// The tool performs the following operations:
 /// 1. **Command Line Parsing**: Extracts signing parameters from command line arguments
 /// 2. **Key Resolution**: Converts DID key strings to cryptographic key material
-/// 3. **Record Loading**: Reads and parses JSON records from disk files
+/// 3. **Record Loading**: Reads and parses JSON records from disk files or stdin
 /// 4. **Signature Creation**: Generates cryptographic signatures using IPLD DAG-CBOR serialization
 /// 5. **Output Generation**: Produces signed records with embedded signature objects
 ///
···
 /// The tool accepts flexible argument ordering:
 /// - **DID Key** (`did:key:...`) - Cryptographic key for signing operations
 /// - **Issuer DID** (`did:plc:...` or `did:web:...`) - Identity of the signature issuer  
-/// - **Record File** (file path) - JSON file containing the record to sign
+/// - **Record Input** (file path or `--`) - JSON file containing the record to sign, or `--` to read from stdin
 /// - **Parameters** (`key=value`) - Repository, collection, and signature metadata
 ///
 /// ## Required Parameters
···
 ///   issued_at=2025-05-16T14:00:02.000Z
 /// ```
 ///
+/// ### Reading from Stdin
+/// ```bash
+/// echo '{"$type":"app.bsky.feed.post","text":"Hello from stdin!"}' | \
+/// atproto-record-sign \
+///   did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+///   -- \
+///   did:plc:tgudj2fjm77pzkuawquqhsxm \
+///   repository=did:plc:4zutorghlchjxzgceklue4la \
+///   collection=app.bsky.feed.post
+/// ```
+///
 /// ### Input Record Example (`post.json`)
 /// ```json
 /// {
···
         println!("AT Protocol Record Signing Tool");
         println!();
         println!("USAGE:");
-        println!("    atproto-record-sign <ISSUER_DID> <SIGNING_KEY> <RECORD_FILE> repository=<REPO> collection=<COLLECTION> [key=value...]");
+        println!("    atproto-record-sign <ISSUER_DID> <SIGNING_KEY> <RECORD_INPUT> repository=<REPO> collection=<COLLECTION> [key=value...]");
         println!();
         println!("ARGUMENTS:");
-        println!("    <ISSUER_DID>    DID of the issuer (e.g., did:plc:...)");
-        println!("    <SIGNING_KEY>   DID key for signing (e.g., did:key:z42tv1...)");
-        println!("    <RECORD_FILE>   Path to JSON file containing the record to sign");
+        println!("    <ISSUER_DID>     DID of the issuer (e.g., did:plc:...)");
+        println!("    <SIGNING_KEY>    DID key for signing (e.g., did:key:z42tv1...)");
+        println!("    <RECORD_INPUT>   Path to JSON file containing the record to sign, or '--' to read from stdin");
         println!();
         println!("REQUIRED PARAMETERS:");
         println!("    repository=<REPO>       Repository DID context");
···
         println!("    issued_at=<TIMESTAMP>   RFC 3339 timestamp (defaults to current time)");
         println!("    [key=value...]          Additional fields for signature object");
         println!();
-        println!("EXAMPLE:");
+        println!("EXAMPLES:");
+        println!("    # Sign from file:");
         println!("    atproto-record-sign \\");
         println!("      did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \\");
         println!("      ./record.json \\");
         println!("      did:plc:tgudj2fjm77pzkuawquqhsxm \\");
         println!("      repository=did:plc:4zutorghlchjxzgceklue4la \\");
         println!("      collection=community.lexicon.badge.award");
+        println!();
+        println!("    # Sign from stdin:");
+        println!("    echo '{{\"$type\":\"app.bsky.feed.post\",\"text\":\"Hello!\"}}' | atproto-record-sign \\");
+        println!("      did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \\");
+        println!("      -- \\");
+        println!("      did:plc:tgudj2fjm77pzkuawquqhsxm \\");
+        println!("      repository=did:plc:4zutorghlchjxzgceklue4la \\");
+        println!("      collection=app.bsky.feed.post");
         return Ok(());
     }
 
···
                 }
                 Ok(_) => return Err(anyhow!("Unsupported DID method: {}", argument)),
                 Err(e) => return Err(anyhow!("Failed to parse DID {}: {}", argument, e)),
+            }
+        } else if argument == "--" {
+            // Read record from stdin
+            if record.is_none() {
+                let mut stdin_content = String::new();
+                io::stdin()
+                    .read_to_string(&mut stdin_content)
+                    .map_err(|e| anyhow!("Failed to read from stdin: {}", e))?;
+                record = Some(
+                    serde_json::from_str(&stdin_content)
+                        .map_err(|e| anyhow!("Failed to parse JSON from stdin: {}", e))?,
+                );
+            } else {
+                return Err(anyhow!("Unexpected argument: {}", argument));
             }
         } else {
             // Assume it's a file path to read the record from

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

···
     resolve::{parse_input, InputType},
 };
 use atproto_record::signature::verify;
-use std::{env, fs};
+use std::{
+    env, fs,
+    io::{self, Read},
+};
 
 /// AT Protocol Record Verification Tool
 ///
 /// This command-line tool provides cryptographic signature verification capabilities for AT Protocol records.
-/// It reads a signed JSON record from a file, validates the embedded cryptographic signatures using a public key,
+/// It reads a signed JSON record from a file or stdin, validates the embedded cryptographic signatures using a public key,
 /// and reports whether the signature verification succeeds or fails.
 ///
 /// ## Overview
···
 /// The tool performs the following operations:
 /// 1. **Command Line Parsing**: Extracts verification parameters from command line arguments
 /// 2. **Key Resolution**: Converts DID key strings to cryptographic key material for verification
-/// 3. **Record Loading**: Reads and parses signed JSON records from disk files
+/// 3. **Record Loading**: Reads and parses signed JSON records from disk files or stdin
 /// 4. **Signature Verification**: Validates cryptographic signatures using IPLD DAG-CBOR deserialization
 /// 5. **Result Reporting**: Outputs verification success or detailed failure information
 ///
···
 /// The tool accepts flexible argument ordering:
 /// - **Issuer DID** (`did:plc:...` or `did:web:...`) - Identity of the expected signature issuer
 /// - **Verification Key** (`did:key:...`) - Public key for signature verification
-/// - **Record File** (file path) - JSON file containing the signed record to verify
+/// - **Record Input** (file path or `--`) - JSON file containing the signed record to verify, or `--` to read from stdin
 /// - **Parameters** (`key=value`) - Repository and collection context for verification
 ///
 /// ## Required Parameters
···
 ///   collection=community.lexicon.badge.award
 /// ```
 ///
+/// ### Verifying from Stdin
+/// ```bash
+/// echo '{"signatures":[...],"text":"Hello!"}' | \
+/// atproto-record-verify \
+///   did:plc:tgudj2fjm77pzkuawquqhsxm \
+///   did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \
+///   -- \
+///   repository=did:plc:4zutorghlchjxzgceklue4la \
+///   collection=app.bsky.feed.post
+/// ```
+///
 /// ### Input Signed Record Example (`signed_post.json`)
 /// ```json
 /// {
···
         println!("AT Protocol Record Verifying Tool");
         println!();
         println!("USAGE:");
-        println!("    atproto-record-verify <ISSUER_DID> <KEY> <RECORD_FILE> repository=<REPO> collection=<COLLECTION> [key=value...]");
+        println!("    atproto-record-verify <ISSUER_DID> <KEY> <RECORD_INPUT> repository=<REPO> collection=<COLLECTION> [key=value...]");
         println!();
         println!("ARGUMENTS:");
-        println!("    <ISSUER_DID>    DID of the issuer (e.g., did:plc:...)");
-        println!("    <KEY>           DID key for verifying (e.g., did:key:z42tv1...)");
-        println!("    <RECORD_FILE>   Path to JSON file containing the record to verify");
+        println!("    <ISSUER_DID>     DID of the issuer (e.g., did:plc:...)");
+        println!("    <KEY>            DID key for verifying (e.g., did:key:z42tv1...)");
+        println!("    <RECORD_INPUT>   Path to JSON file containing the record to verify, or '--' to read from stdin");
         println!();
         println!("REQUIRED PARAMETERS:");
         println!("    repository=<REPO>       Repository DID context");
         println!("    collection=<COLLECTION> Collection name context");
         println!();
-        println!("EXAMPLE:");
+        println!("EXAMPLES:");
+        println!("    # Verify from file:");
         println!("    atproto-record-verify \\");
         println!("      did:plc:tgudj2fjm77pzkuawquqhsxm \\");
         println!("      did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \\");
-        println!("      ./record.json \\");
+        println!("      ./signed_record.json \\");
         println!("      repository=did:plc:4zutorghlchjxzgceklue4la \\");
         println!("      collection=community.lexicon.badge.award");
+        println!();
+        println!("    # Verify from stdin:");
+        println!("    echo '{{\"signatures\":[...],...}}' | atproto-record-verify \\");
+        println!("      did:plc:tgudj2fjm77pzkuawquqhsxm \\");
+        println!("      did:key:z42tv1pb3Dzog28Q1udyieg1YJP3x1Un5vraE1bttXeCDSpW \\");
+        println!("      -- \\");
+        println!("      repository=did:plc:4zutorghlchjxzgceklue4la \\");
+        println!("      collection=app.bsky.feed.post");
         return Ok(());
     }
 
···
                 }
                 Ok(_) => return Err(anyhow!("Unsupported DID method: {}", argument)),
                 Err(e) => return Err(anyhow!("Failed to parse DID {}: {}", argument, e)),
+            }
+        } else if argument == "--" {
+            // Read record from stdin
+            if record.is_none() {
+                let mut stdin_content = String::new();
+                io::stdin()
+                    .read_to_string(&mut stdin_content)
+                    .map_err(|e| anyhow!("Failed to read from stdin: {}", e))?;
+                record = Some(
+                    serde_json::from_str(&stdin_content)
+                        .map_err(|e| anyhow!("Failed to parse JSON from stdin: {}", e))?,
+                );
+            } else {
+                return Err(anyhow!("Unexpected argument: {}", argument));
             }
         } else {
             // Assume it's a file path to read the record from