lib.rs

// SPDX-License-Identifier: MPL-2.0
// Copyright (c) Jonathan D.A. Jewell <j.d.a.jewell@open.ac.uk>
// SPDX-FileCopyrightText: 2026 Jonathan D.A. Jewell
//
// JanusKey CLI: Provably Reversible File Operations
// Through Maximal Principle Reduction (MPR)
//
// Core types are provided by reversible-core. This crate adds:
// - Filesystem operation execution (operations.rs)
// - Key management (keys.rs)
// - Audit trail (attestation.rs)
// - Secure deletion (obliteration.rs, delta.rs)
// - CLI interface (main.rs, keys_cli.rs)

#![forbid(unsafe_code)]

pub mod attestation;
pub mod delta;
pub mod keys;
pub mod obliteration;
pub mod operations;

// Re-export core types from reversible-core for backward compatibility
pub use reversible_core::content_store::{self, ContentHash, ContentStore};
/// Error module — re-exports reversible-core error types with JanusKey naming
pub mod error {
    pub use reversible_core::error::ReversibleError as JanusError;
    pub use reversible_core::error::Result;
}
pub use error::{JanusError, Result};
pub use reversible_core::manifest::{self, ManifestEmitter};
pub use reversible_core::metadata::{self, MetadataStore, OperationMetadata, OperationType};
pub use reversible_core::transaction::{
    self, Transaction, TransactionManager, TransactionPreview,
};
pub use reversible_core::ReversibleExecutor;

pub use attestation::{AuditEntry, AuditEventType, AuditLog, IntegrityReport, KeyEventDetails};
pub use keys::{KeyAlgorithm, KeyError, KeyManager, KeyMetadata, KeyPurpose, KeyState};
pub use operations::{FileOperation, OperationExecutor};

/// JanusKey configuration
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct Config {
    /// Path to JanusKey metadata storage
    pub storage_path: std::path::PathBuf,
    /// Enable compression for stored content
    pub compression: bool,
    /// Maximum number of operations to keep in history
    pub max_history: usize,
    /// Auto-confirm dangerous operations
    pub auto_confirm: bool,
    /// Default to dry-run mode
    pub dry_run_default: bool,
    /// Enable audit trail
    pub audit_enabled: bool,
}

impl Default for Config {
    fn default() -> Self {
        let storage_path = dirs::data_local_dir()
            .unwrap_or_else(|| std::path::PathBuf::from("."))
            .join("januskey");

        Self {
            storage_path,
            compression: true,
            max_history: 10000,
            auto_confirm: false,
            dry_run_default: false,
            audit_enabled: true,
        }
    }
}

impl Config {
    /// Load config from directory's .januskey/config.json or use defaults
    pub fn load(dir: &std::path::Path) -> Self {
        let config_path = dir.join(".januskey").join("config.json");
        if config_path.exists() {
            if let Ok(content) = ({ use std::io::Read; std::fs::File::open(&config_path).and_then(|mut f| { let mut buf = String::new(); f.take(10 * 1024 * 1024).read_to_string(&mut buf)?; Ok(buf) }) }) {
                if let Ok(config) = serde_json::from_str(&content) {
                    return config;
                }
            }
        }
        Self::default()
    }

    /// Save config to directory
    pub fn save(&self, dir: &std::path::Path) -> Result<()> {
        let config_dir = dir.join(".januskey");
        std::fs::create_dir_all(&config_dir)?;
        let config_path = config_dir.join("config.json");
        let content = serde_json::to_string_pretty(self)?;
        std::fs::write(config_path, content)?;
        Ok(())
    }
}

/// Main JanusKey instance for a directory
pub struct JanusKey {
    /// Working directory
    pub root: std::path::PathBuf,
    /// Configuration
    pub config: Config,
    /// Content-addressed storage
    pub content_store: ContentStore,
    /// Metadata/operation log store
    pub metadata_store: MetadataStore,
    /// Transaction manager
    pub transaction_manager: TransactionManager,
}

impl JanusKey {
    /// Initialize JanusKey for a directory
    pub fn init(root: &std::path::Path) -> Result<Self> {
        let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
        let jk_dir = root.join(".januskey");
        std::fs::create_dir_all(&jk_dir)?;

        let config = Config::load(&root);
        config.save(&root)?;

        let content_store = ContentStore::new(jk_dir.join("content"), config.compression)?;
        let metadata_store = MetadataStore::new(jk_dir.join("metadata.json"))?;
        let transaction_manager = TransactionManager::new(jk_dir.join("transactions"))?;

        Ok(Self {
            root,
            config,
            content_store,
            metadata_store,
            transaction_manager,
        })
    }

    /// Open existing JanusKey directory
    pub fn open(root: &std::path::Path) -> Result<Self> {
        let root = root.canonicalize().unwrap_or_else(|_| root.to_path_buf());
        let jk_dir = root.join(".januskey");

        if !jk_dir.exists() {
            return Err(JanusError::NotInitialized(root.display().to_string()));
        }

        let config = Config::load(&root);
        let content_store = ContentStore::new(jk_dir.join("content"), config.compression)?;
        let metadata_store = MetadataStore::new(jk_dir.join("metadata.json"))?;
        let transaction_manager = TransactionManager::new(jk_dir.join("transactions"))?;

        Ok(Self {
            root,
            config,
            content_store,
            metadata_store,
            transaction_manager,
        })
    }

    /// Check if directory is initialized
    pub fn is_initialized(root: &std::path::Path) -> bool {
        root.join(".januskey").exists()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::TempDir;

    #[test]
    fn test_init_and_open() {
        let tmp = TempDir::new().unwrap();
        let jk = JanusKey::init(tmp.path()).unwrap();
        assert!(JanusKey::is_initialized(tmp.path()));

        let jk2 = JanusKey::open(tmp.path()).unwrap();
        assert_eq!(jk.root, jk2.root);
    }
}