safari 1.0.0

Terminal UI for capturing and restoring Safari sessions on macOS
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

use anyhow::{anyhow, Result};
use clap::{Parser, Subcommand};
use safari::{backend, tui};

#[derive(Parser)]
#[command(name = "safari")]
#[command(about = "Capture and restore Safari sessions on macOS", long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Option<Commands>,
}

#[derive(Subcommand)]
enum Commands {
    /// Capture the current Safari session
    #[command(alias = "dump")]
    Capture,
    /// Restore a saved Safari session
    #[command(alias = "reopen")]
    Restore {
        /// Restore the Nth session shown by `list`
        #[arg(short, long)]
        index: Option<usize>,
    },
    /// List saved Safari sessions
    List,
    /// Launch the terminal UI
    Tui,
}

fn main() -> Result<()> {
    let cli = Cli::parse();

    match cli.command {
        Some(Commands::Capture) => {
            let session = backend::safari::get_current_session()?;
            let path = backend::storage::save_session(&session)?;
            println!(
                "Saved {} window(s) and {} tab(s) to {}",
                session.window_count(),
                session.tab_count(),
                path.display()
            );
        }
        Some(Commands::Restore { index }) => {
            let sessions = backend::storage::list_sessions()?;
            let selected = resolve_session(index, &sessions)?;
            let session = backend::storage::load_session(&selected.path)?;
            backend::safari::restore_session(&session)?;
            println!(
                "Restored {} ({}, {} tabs)",
                backend::utils::format_timestamp(&selected.captured_at),
                selected.window_count,
                selected.tab_count
            );
        }
        Some(Commands::List) => {
            let sessions = backend::storage::list_sessions()?;
            if sessions.is_empty() {
                println!(
                    "No backups found in {}",
                    backend::storage::storage_dir()?.display()
                );
            } else {
                println!(
                    "{:<4} {:<16} {:<7} {:<6} File",
                    "#", "Captured", "Win", "Tabs"
                );
                for (index, session) in sessions.iter().enumerate() {
                    println!(
                        "{:<4} {:<16} {:<7} {:<6} {}",
                        index + 1,
                        backend::utils::format_timestamp(&session.captured_at),
                        session.window_count,
                        session.tab_count,
                        session.file_name
                    );
                }
            }
        }
        Some(Commands::Tui) | None => {
            tui::run()?;
        }
    }

    Ok(())
}

fn resolve_session<'a>(
    index: Option<usize>,
    sessions: &'a [backend::models::SessionSummary],
) -> Result<&'a backend::models::SessionSummary> {
    if sessions.is_empty() {
        return Err(anyhow!("No saved Safari sessions were found"));
    }

    match index {
        Some(0) => Err(anyhow!("Session indexes start at 1")),
        Some(index) => sessions
            .get(index - 1)
            .ok_or_else(|| anyhow!("Session {index} does not exist")),
        None => Ok(&sessions[0]),
    }
}