atuin 18.24.1

atuin - magical shell history
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use std::num::NonZeroU64;
use std::sync::Arc;

use atuin_client::database::Sqlite;
use atuin_client::record::sqlite_store::SqliteStore;
use atuin_client::record::sync::{ClientSource, Operation, SyncSession};
use atuin_client::settings::Settings;
use atuin_common::encryption::paseto_v4;
use atuin_domain::record::RecordTag;
use clap::Args;
use eyre::{Context as _, Result};

use crate::i18n::fl;

#[derive(Args, Debug)]
pub struct Pull {
    #[arg(long, short, help = fl!("arg-store-tag"))]
    pub tag: Option<RecordTag>,

    #[arg(
        long,
        default_value = "false",
        help = fl!("arg-store-pull-force"),
        long_help = fl!("arg-store-pull-force", "long")
    )]
    pub force: bool,

    #[arg(
        long,
        default_value = "100",
        help = fl!("arg-store-pull-page"),
        long_help = fl!("arg-store-pull-page", "long")
    )]
    pub page: NonZeroU64,
}

impl Pull {
    pub async fn run(
        &self,
        settings: &Arc<Settings>,
        store: SqliteStore,
        db: &Sqlite,
    ) -> Result<()> {
        if !self.force {
            return self.pull(settings, store, db).await;
        }

        println!("Forcing local overwrite!");
        println!("Clearing local store");
        store.delete_all().await?;
        let pulled = self.pull(settings, store, db).await;
        // Records only this machine had are gone, and the threads index must forget what
        // they projected: rebuilt from what the store holds now, however far the pull got.
        let reset = super::reset_ai_sessions_after(settings).await;
        match (pulled, reset) {
            (Err(pull), Err(reset)) => {
                eprintln!("{reset:?}");
                Err(pull)
            }
            (pulled, reset) => pulled.and(reset),
        }
    }

    async fn pull(&self, settings: &Arc<Settings>, store: SqliteStore, db: &Sqlite) -> Result<()> {
        // We can actually just use the existing diff/etc to push
        // 1. Diff
        // 2. Get operations
        // 3. Filter operations by
        //  a) are they a download op?
        //  b) are they for the host/tag we are pushing here?
        let key = paseto_v4::Key::try_load_from_path(&settings.key_path)
            .context("could not load encryption key")?;
        let session = SyncSession::builder()
            .store(store.clone())
            .client_source(ClientSource::FromSettings {
                settings,
                caps: None,
            })
            .build()
            .connect()
            .await?
            .with_page_size(self.page);

        let keyed = session.keyed(&key);
        let (diff, remote_index) = session.diff().await?;

        // Skip on --force: local was already wiped above, mismatch is the user's call.
        if !self.force
            && let Some(err) = keyed.key_valid_against(&remote_index).await
        {
            return Err(crate::print_error::format_sync_error(err));
        }

        let operations = SyncSession::operations(diff)?;

        let operations = operations
            .into_iter()
            .filter(|op| match op {
                // No noops or downloads thx
                Operation::Noop { .. } | Operation::Upload { .. } => false,

                // pull, so yes plz to downloads!
                Operation::Download { series, .. } => {
                    if self.force {
                        return true;
                    }

                    if let Some(t) = self.tag.clone()
                        && t != series.tag
                    {
                        return false;
                    }

                    true
                }
            })
            .collect();

        let (_, downloaded) = keyed.sync_remote(operations).await?;

        println!("Downloaded {} records", downloaded.len());

        // On --force the daemon rebuilds the AI sessions from scratch after this.
        if self.force {
            crate::sync::build(settings, &store, db, Some(&downloaded)).await?;
        } else {
            crate::command::client::sync::build(settings, &store, db, &downloaded).await?;
        }

        Ok(())
    }
}