litvc 1.5.1

Lit - The agentic-first distributed version control system. A complete Git replacement designed for AI agents first and humans second.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! `lit agent` — start, inspect, and stop the passphrase agent.
//!
//! See `crate::crypto::agent` for what the agent does and, more importantly,
//! what it does not protect against.

use crate::crypto::agent;
use crate::crypto::encryption::{prompt_for_passphrase, EncryptionConfig};
use crate::errors::LitError;
use crate::response::AgentResponse;
use std::time::Duration;

/// Which repository an entry belongs to.
///
/// This must be the exact string `EncryptionManager::new_auto` looks up under,
/// which is the repository root. Keying on anything else — the key file, say —
/// would let `lit agent unlock` report success while every later command went
/// on prompting, because it would be searching under a different name.
fn repo_key() -> Result<String, LitError> {
    let root = crate::core::find_repo_root()
        .map_err(|e| LitError::Repository(format!("Not inside a repository: {e}")))?;
    Ok(root.to_string_lossy().to_string())
}

pub fn start(timeout_secs: Option<u64>) -> Result<AgentResponse, LitError> {
    let timeout = timeout_secs.unwrap_or(agent::DEFAULT_IDLE_TIMEOUT_SECS);

    // `serve` blocks until the agent is told to stop, so anything printed here
    // would not reach the user until then. The caller is expected to background
    // this process; `lit agent status` is how you check on it.
    agent::serve(Duration::from_secs(timeout)).map_err(LitError::Encryption)?;

    Ok(AgentResponse {
        action: "stop".to_string(),
        entries: Some(0),
        idle_timeout_secs: Some(timeout),
        message: "Agent stopped".to_string(),
    })
}

pub fn unlock(timeout_secs: Option<u64>) -> Result<AgentResponse, LitError> {
    let key = repo_key()?;
    let root = crate::core::find_repo_root()
        .map_err(|e| LitError::Repository(format!("Not inside a repository: {e}")))?;
    let config = EncryptionConfig::load(&root).map_err(LitError::Config)?;

    let passphrase = prompt_for_passphrase(&key, &config, "Passphrase: ")
        .map_err(|e| LitError::Encryption(format!("Could not read passphrase: {e}")))?;

    agent::put(&key, &passphrase).map_err(LitError::Encryption)?;

    let (entries, idle) = agent::status().map_err(LitError::Encryption)?;
    Ok(AgentResponse {
        action: "unlock".to_string(),
        entries: Some(entries),
        idle_timeout_secs: Some(timeout_secs.unwrap_or(idle)),
        message: format!("Passphrase held for {key}"),
    })
}

pub fn lock(all: bool) -> Result<AgentResponse, LitError> {
    let target = if all { None } else { Some(repo_key()?) };
    agent::drop_entry(target.as_deref()).map_err(LitError::Encryption)?;

    let (entries, idle) = agent::status().map_err(LitError::Encryption)?;
    Ok(AgentResponse {
        action: "lock".to_string(),
        entries: Some(entries),
        idle_timeout_secs: Some(idle),
        message: if all {
            "Forgot every held passphrase".to_string()
        } else {
            "Forgot this repository's passphrase".to_string()
        },
    })
}

pub fn status() -> Result<AgentResponse, LitError> {
    match agent::status() {
        Ok((entries, idle_timeout_secs)) => Ok(AgentResponse {
            action: "status".to_string(),
            entries: Some(entries),
            idle_timeout_secs: Some(idle_timeout_secs),
            message: format!(
                "Agent running, holding {entries} passphrase(s), idle timeout {idle_timeout_secs}s"
            ),
        }),
        // Not running is an ordinary answer to "is it running", not a failure.
        Err(_) => Ok(AgentResponse {
            action: "status".to_string(),
            entries: None,
            idle_timeout_secs: None,
            message: "No agent is running".to_string(),
        }),
    }
}

pub fn stop() -> Result<AgentResponse, LitError> {
    agent::shutdown().map_err(LitError::Encryption)?;
    Ok(AgentResponse {
        action: "stop".to_string(),
        entries: Some(0),
        idle_timeout_secs: None,
        message: "Agent stopped".to_string(),
    })
}