Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Make Rust sessions easier to find and resume

Yeachan-Heo95f1e2ab6b47
diff --git a/rust/crates/api/src/client.rs b/rust/crates/api/src/client.rs
index f99bb8d0..b224fec0 100644
--- a/rust/crates/api/src/client.rs
+++ b/rust/crates/api/src/client.rs
@@ -311,18 +311,38 @@ mod tests {
#[test]
fn read_api_key_requires_presence() {
+ let previous_auth = std::env::var("ANTHROPIC_AUTH_TOKEN").ok();
+ let previous_key = std::env::var("ANTHROPIC_API_KEY").ok();
std::env::remove_var("ANTHROPIC_AUTH_TOKEN");
std::env::remove_var("ANTHROPIC_API_KEY");
let error = super::read_api_key().expect_err("missing key should error");
assert!(matches!(error, crate::error::ApiError::MissingApiKey));
+ match previous_auth {
+ Some(value) => std::env::set_var("ANTHROPIC_AUTH_TOKEN", value),
+ None => std::env::remove_var("ANTHROPIC_AUTH_TOKEN"),
+ }
+ match previous_key {
+ Some(value) => std::env::set_var("ANTHROPIC_API_KEY", value),
+ None => std::env::remove_var("ANTHROPIC_API_KEY"),
+ }
}
#[test]
fn read_api_key_requires_non_empty_value() {
+ let previous_auth = std::env::var("ANTHROPIC_AUTH_TOKEN").ok();
+ let previous_key = std::env::var("ANTHROPIC_API_KEY").ok();
std::env::set_var("ANTHROPIC_AUTH_TOKEN", "");
std::env::remove_var("ANTHROPIC_API_KEY");
let error = super::read_api_key().expect_err("empty key should error");
assert!(matches!(error, crate::error::ApiError::MissingApiKey));
+ match previous_auth {
+ Some(value) => std::env::set_var("ANTHROPIC_AUTH_TOKEN", value),
+ None => std::env::remove_var("ANTHROPIC_AUTH_TOKEN"),
+ }
+ match previous_key {
+ Some(value) => std::env::set_var("ANTHROPIC_API_KEY", value),
+ None => std::env::remove_var("ANTHROPIC_API_KEY"),
+ }
}
#[test]
diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rs
index a9009d92..bf6a0b3e 100644
--- a/rust/crates/rusty-claude-cli/src/main.rs
+++ b/rust/crates/rusty-claude-cli/src/main.rs
@@ -2,8 +2,10 @@ mod input;
mod render;
use std::env;
+use std::fs;
use std::io::{self, Write};
use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
use api::{
AnthropicClient, ContentBlockDelta, InputContentBlock, InputMessage, MessageRequest,
@@ -24,6 +26,7 @@ use tools::{execute_tool, mvp_tool_specs};
const DEFAULT_MODEL: &str = "claude-sonnet-4-20250514";
const DEFAULT_MAX_TOKENS: u32 = 32;
const DEFAULT_DATE: &str = "2026-03-31";
+const DEFAULT_SESSION_LIMIT: usize = 20;
fn main() {
if let Err(error) = run() {
@@ -42,6 +45,8 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
session_path,
command,
} => resume_session(&session_path, command),
+ CliAction::ResumeNamed { target, command } => resume_named_session(&target, command),
+ CliAction::ListSessions { query, limit } => list_sessions(query.as_deref(), limit),
CliAction::Prompt { prompt, model } => LiveCli::new(model, false)?.run_turn(&prompt)?,
CliAction::Repl { model } => run_repl(model)?,
CliAction::Help => print_help(),
@@ -61,6 +66,14 @@ enum CliAction {
session_path: PathBuf,
command: Option<String>,
},
+ ResumeNamed {
+ target: String,
+ command: Option<String>,
+ },
+ ListSessions {
+ query: Option<String>,
+ limit: usize,
+ },
Prompt {
prompt: String,
model: String,
@@ -109,6 +122,8 @@ fn parse_args(args: &[String]) -> Result<CliAction, String> {
match rest[0].as_str() {
"dump-manifests" => Ok(CliAction::DumpManifests),
"bootstrap-plan" => Ok(CliAction::BootstrapPlan),
+ "resume" => parse_named_resume_args(&rest[1..]),
+ "sessions" => parse_sessions_args(&rest[1..]),
"system-prompt" => parse_system_prompt_args(&rest[1..]),
"prompt" => {
let prompt = rest[1..].join(" ");
@@ -149,6 +164,48 @@ fn parse_system_prompt_args(args: &[String]) -> Result<CliAction, String> {
Ok(CliAction::PrintSystemPrompt { cwd, date })
}
+fn parse_named_resume_args(args: &[String]) -> Result<CliAction, String> {
+ let target = args
+ .first()
+ .ok_or_else(|| "missing session id, path, or 'latest' for resume".to_string())?
+ .clone();
+ let command = args.get(1).cloned();
+ if args.len() > 2 {
+ return Err("resume accepts at most one trailing slash command".to_string());
+ }
+ Ok(CliAction::ResumeNamed { target, command })
+}
+
+fn parse_sessions_args(args: &[String]) -> Result<CliAction, String> {
+ let mut query = None;
+ let mut limit = DEFAULT_SESSION_LIMIT;
+ let mut index = 0;
+
+ while index < args.len() {
+ match args[index].as_str() {
+ "--query" => {
+ let value = args
+ .get(index + 1)
+ .ok_or_else(|| "missing value for --query".to_string())?;
+ query = Some(value.clone());
+ index += 2;
+ }
+ "--limit" => {
+ let value = args
+ .get(index + 1)
+ .ok_or_else(|| "missing value for --limit".to_string())?;
+ limit = value
+ .parse::<usize>()
+ .map_err(|error| format!("invalid --limit value: {error}"))?;
+ index += 2;
+ }
+ other => return Err(format!("unknown sessions option: {other}")),
+ }
+ }
+
+ Ok(CliAction::ListSessions { query, limit })
+}
+
fn parse_resume_args(args: &[String]) -> Result<CliAction, String> {
let session_path = args
.first()
@@ -238,6 +295,43 @@ fn resume_session(session_path: &Path, command: Option<String>) {
}
}
+fn resume_named_session(target: &str, command: Option<String>) {
+ let session_path = match resolve_session_target(target) {
+ Ok(path) => path,
+ Err(error) => {
+ eprintln!("{error}");
+ std::process::exit(1);
+ }
+ };
+ resume_session(&session_path, command);
+}
+
+fn list_sessions(query: Option<&str>, limit: usize) {
+ match load_session_entries(query, limit) {
+ Ok(entries) => {
+ if entries.is_empty() {
+ println!("No saved sessions found.");
+ return;
+ }
+ println!("Saved sessions:");
+ for entry in entries {
+ println!(
+ "- {} | updated={} | messages={} | tokens={} | {}",
+ entry.id,
+ entry.updated_unix,
+ entry.message_count,
+ entry.total_tokens,
+ entry.preview
+ );
+ }
+ }
+ Err(error) => {
+ eprintln!("failed to list sessions: {error}");
+ std::process::exit(1);
+ }
+ }
+}
+
fn run_repl(model: String) -> Result<(), Box<dyn std::error::Error>> {
let mut cli = LiveCli::new(model, true)?;
let editor = input::LineEditor::new("› ");
@@ -271,11 +365,13 @@ struct LiveCli {
model: String,
system_prompt: Vec<String>,
runtime: ConversationRuntime<AnthropicRuntimeClient, CliToolExecutor>,
+ session_path: PathBuf,
}
impl LiveCli {
fn new(model: String, enable_tools: bool) -> Result<Self, Box<dyn std::error::Error>> {
let system_prompt = build_system_prompt()?;
+ let session_path = new_session_path()?;
let runtime = build_runtime(
Session::new(),
model.clone(),
@@ -286,6 +382,7 @@ impl LiveCli {
model,
system_prompt,
runtime,
+ session_path,
})
}
@@ -306,6 +403,7 @@ impl LiveCli {
&mut stdout,
)?;
println!();
+ self.persist_session()?;
self.print_turn_usage(turn.usage);
Ok(())
}
@@ -370,10 +468,152 @@ impl LiveCli {
let estimated_saved = estimated_before.saturating_sub(estimated_after);
println!("Estimated tokens saved: {estimated_saved}");
}
+ self.persist_session()?;
+ Ok(())
+ }
+
+ fn persist_session(&self) -> Result<(), Box<dyn std::error::Error>> {
+ self.runtime.session().save_to_path(&self.session_path)?;
Ok(())
}
}
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SessionListEntry {
+ id: String,
+ path: PathBuf,
+ updated_unix: u64,
+ message_count: usize,
+ total_tokens: u32,
+ preview: String,
+}
+
+fn new_session_path() -> io::Result<PathBuf> {
+ let session_dir = default_session_dir()?;
+ fs::create_dir_all(&session_dir)?;
+ let timestamp = current_unix_timestamp();
+ let process_id = std::process::id();
+ Ok(session_dir.join(format!("session-{timestamp}-{process_id}.json")))
+}
+
+fn default_session_dir() -> io::Result<PathBuf> {
+ Ok(env::current_dir()?.join(".rusty-claude").join("sessions"))
+}
+
+fn current_unix_timestamp() -> u64 {
+ SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map_or(0, |duration| duration.as_secs())
+}
+
+fn resolve_session_target(target: &str) -> io::Result<PathBuf> {
+ let direct_path = PathBuf::from(target);
+ if direct_path.is_file() {
+ return Ok(direct_path);
+ }
+
+ let entries = load_session_entries(None, usize::MAX)?;
+ if target == "latest" {
+ return entries
+ .into_iter()
+ .next()
+ .map(|entry| entry.path)
+ .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "no saved sessions found"));
+ }
+
+ let mut matches = entries
+ .into_iter()
+ .filter(|entry| entry.id.contains(target) || entry.preview.contains(target))
+ .collect::<Vec<_>>();
+ if matches.is_empty() {
+ return Err(io::Error::new(
+ io::ErrorKind::NotFound,
+ format!("no saved session matched '{target}'"),
+ ));
+ }
+ matches.sort_by(|left, right| right.updated_unix.cmp(&left.updated_unix));
+ Ok(matches.remove(0).path)
+}
+
+fn load_session_entries(query: Option<&str>, limit: usize) -> io::Result<Vec<SessionListEntry>> {
+ let session_dir = default_session_dir()?;
+ if !session_dir.exists() {
+ return Ok(Vec::new());
+ }
+
+ let query = query.map(str::to_lowercase);
+ let mut entries = Vec::new();
+ for entry in fs::read_dir(session_dir)? {
+ let entry = entry?;
+ let path = entry.path();
+ if path.extension().and_then(|extension| extension.to_str()) != Some("json") {
+ continue;
+ }
+
+ let Ok(session) = Session::load_from_path(&path) else {
+ continue;
+ };
+
+ let preview = session_preview(&session);
+ let id = path
+ .file_stem()
+ .map_or_else(String::new, |stem| stem.to_string_lossy().into_owned());
+ let searchable = format!("{} {}", id.to_lowercase(), preview.to_lowercase());
+ if let Some(query) = &query {
+ if !searchable.contains(query) {
+ continue;
+ }
+ }
+
+ let updated_unix = entry
+ .metadata()
+ .and_then(|metadata| metadata.modified())
+ .ok()
+ .and_then(|modified| modified.duration_since(UNIX_EPOCH).ok())
+ .map_or(0, |duration| duration.as_secs());
+
+ entries.push(SessionListEntry {
+ id,
+ path,
+ updated_unix,
+ message_count: session.messages.len(),
+ total_tokens: runtime::UsageTracker::from_session(&session)
+ .cumulative_usage()
+ .total_tokens(),
+ preview,
+ });
+ }
+
+ entries.sort_by(|left, right| right.updated_unix.cmp(&left.updated_unix));
+ if limit < entries.len() {
+ entries.truncate(limit);
+ }
+ Ok(entries)
+}
+
+fn session_preview(session: &Session) -> String {
+ for message in session.messages.iter().rev() {
+ for block in &message.blocks {
+ if let ContentBlock::Text { text } = block {
+ let trimmed = text.trim();
+ if !trimmed.is_empty() {
+ return truncate_preview(trimmed, 80);
+ }
+ }
+ }
+ }
+ "No text preview available".to_string()
+}
+
+fn truncate_preview(text: &str, max_chars: usize) -> String {
+ if text.chars().count() <= max_chars {
+ return text.to_string();
+ }
+ let mut output = text.chars().take(max_chars).collect::<String>();
+ output.push('…');
+ output
+}
+
fn build_system_prompt() -> Result<Vec<String>, Box<dyn std::error::Error>> {
Ok(load_system_prompt(
env::current_dir()?,
@@ -671,15 +911,19 @@ fn print_help() {
);
println!(" rusty-claude-cli dump-manifests");
println!(" rusty-claude-cli bootstrap-plan");
+ println!(" rusty-claude-cli sessions [--query TEXT] [--limit N]");
+ println!(" rusty-claude-cli resume <latest|SESSION|PATH> [/compact]");
println!(" rusty-claude-cli system-prompt [--cwd PATH] [--date YYYY-MM-DD]");
println!(" rusty-claude-cli --resume SESSION.json [/compact]");
}
#[cfg(test)]
mod tests {
- use super::{parse_args, CliAction, DEFAULT_MODEL};
- use runtime::{ContentBlock, ConversationMessage, MessageRole};
+ use super::{parse_args, resolve_session_target, session_preview, CliAction, DEFAULT_MODEL};
+ use runtime::{ContentBlock, ConversationMessage, MessageRole, Session};
+ use std::fs;
use std::path::PathBuf;
+ use std::time::{SystemTime, UNIX_EPOCH};
#[test]
fn defaults_to_repl_when_no_args() {
@@ -741,6 +985,40 @@ mod tests {
);
}
+ #[test]
+ fn parses_sessions_subcommand() {
+ let args = vec![
+ "sessions".to_string(),
+ "--query".to_string(),
+ "compact".to_string(),
+ "--limit".to_string(),
+ "5".to_string(),
+ ];
+ assert_eq!(
+ parse_args(&args).expect("args should parse"),
+ CliAction::ListSessions {
+ query: Some("compact".to_string()),
+ limit: 5,
+ }
+ );
+ }
+
+ #[test]
+ fn parses_named_resume_subcommand() {
+ let args = vec![
+ "resume".to_string(),
+ "latest".to_string(),
+ "/compact".to_string(),
+ ];
+ assert_eq!(
+ parse_args(&args).expect("args should parse"),
+ CliAction::ResumeNamed {
+ target: "latest".to_string(),
+ command: Some("/compact".to_string()),
+ }
+ );
+ }
+
#[test]
fn converts_tool_roundtrip_messages() {
let messages = vec![
@@ -767,4 +1045,30 @@ mod tests {
assert_eq!(converted[1].role, "assistant");
assert_eq!(converted[2].role, "user");
}
+
+ #[test]
+ fn builds_preview_from_latest_text_block() {
+ let session = Session {
+ version: 1,
+ messages: vec![
+ ConversationMessage::user_text("first"),
+ ConversationMessage::assistant(vec![ContentBlock::Text {
+ text: "latest preview".to_string(),
+ }]),
+ ],
+ };
+ assert_eq!(session_preview(&session), "latest preview");
+ }
+
+ #[test]
+ fn resolves_direct_session_path() {
+ let unique = SystemTime::now()
+ .duration_since(UNIX_EPOCH)
+ .map_or(0, |duration| duration.as_nanos());
+ let path = std::env::temp_dir().join(format!("rusty-claude-session-{unique}.json"));
+ fs::write(&path, "{\"version\":1,\"messages\":[]}").expect("temp session");
+ let resolved = resolve_session_target(path.to_string_lossy().as_ref()).expect("resolve");
+ assert_eq!(resolved, path);
+ fs::remove_file(resolved).expect("cleanup");
+ }
}