alix 0.5.0

A learning tool built for understanding, not just remembering.
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
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
133
134

//! `alix share`/`receive`: send or receive a deck, folder, or workspace over
//! magic-wormhole (or a `.zip` fallback), staging out personal state so only
//! deck content travels.

use std::path::{Path, PathBuf};

use alix::{config::Config, workspace};
use anyhow::{Context, Result, bail};

use crate::{ReceiveArgs, ShareArgs, common::deck_out_dir};

/// `alix share`: stage a personal-state-free copy and hand it to wormhole.
/// The wormhole binary prints the code mnemonic and the progress itself.
pub(crate) fn share_cmd(args: ShareArgs) -> Result<()> {
    let path = &args.path;
    let name = path
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("shared-decks")
        .to_string();

    // A single deck has no personal state and travels as-is (its augmentations
    // live in a shared per-store cache and stay home). A folder is staged
    // first, so progress and personal config never leave.
    let tmp = tempfile::tempdir().context("cannot create a staging directory")?;
    let (to_send, staged) = if path.is_file() {
        (path.clone(), 1)
    } else {
        if !path.is_dir() {
            bail!("`{}` is neither a deck file nor a folder", path.display());
        }
        if !workspace::has_decks(path) {
            bail!("no decks in `{}` — nothing to share", path.display());
        }
        let stage = tmp.path().join(&name);
        let staged = alix::share::stage_dir(path, &stage)?;
        (stage, staged)
    };

    // `--zip`: the offline fallback — write an archive instead of sending.
    if args.zip {
        let stem = name.strip_suffix(".txt").unwrap_or(&name);
        let out = match &args.output {
            Some(p) if p.is_dir() => p.join(format!("{stem}.zip")),
            Some(p) => p.clone(),
            None => PathBuf::from(format!("{stem}.zip")),
        };
        let entries = alix::share::zip_to(&to_send, &out)?;
        println!(
            "Wrote {} ({entries} files — progress and personal config stay home).",
            out.display()
        );
        return Ok(());
    }

    println!(
        "Sharing {name} ({staged} files — progress and personal config stay home). \
         Tell the receiver the code below."
    );
    alix::share::wormhole(&["send", &to_send.to_string_lossy()], None)
}

/// `alix receive`: run wormhole in a scratch dir, strip any leaked personal
/// files, and move the result where it belongs.
pub(crate) fn receive_cmd(args: ReceiveArgs) -> Result<()> {
    let config = Config::load(None)?;
    let tmp = tempfile::tempdir().context("cannot create a receiving directory")?;
    // A `.zip` path skips the wormhole entirely — same staging, same landing.
    let zip_path = Path::new(&args.code);
    if args.code.ends_with(".zip") && zip_path.is_file() {
        alix::share::unzip_to(zip_path, tmp.path())?;
    } else {
        alix::share::wormhole(&["receive", "--accept-file", &args.code], Some(tmp.path()))?;
    }

    // Whatever arrived is the single new entry in the scratch dir.
    let mut entries: Vec<PathBuf> = std::fs::read_dir(tmp.path())?
        .flatten()
        .map(|e| e.path())
        .collect();
    let Some(got) = entries.pop().filter(|_| entries.is_empty()) else {
        bail!("expected exactly one received file or folder");
    };
    let name = got
        .file_name()
        .and_then(|n| n.to_str())
        .unwrap_or("received")
        .to_string();

    if got.is_dir() {
        if args.workspace.is_some() {
            bail!(
                "--workspace places a received deck; a folder lands under the decks dir as `{name}`"
            );
        }
        let removed = alix::share::sanitize_received(&got)?;
        for r in &removed {
            println!("stripped a leaked personal file: {r}");
        }
        let dest = config
            .decks_dir()
            .context("cannot determine the decks directory")?
            .join(&name);
        if dest.exists() {
            bail!(
                "{} already exists — move it aside first (folders are never overwritten)",
                dest.display()
            );
        }
        alix::share::move_into(&got, &dest)?;
        println!(
            "Received {} — open it:  alix {}",
            dest.display(),
            dest.display()
        );
    } else {
        let dest_dir = deck_out_dir(args.workspace.as_deref(), &config)?;
        std::fs::create_dir_all(&dest_dir)
            .with_context(|| format!("cannot create {}", dest_dir.display()))?;
        let dest = dest_dir.join(&name);
        if dest.exists() && !args.force {
            bail!(
                "{} already exists; pass --force to overwrite",
                dest.display()
            );
        }
        alix::share::move_into(&got, &dest)?;
        println!(
            "Received {} — it shows up in the picker (`alix`).",
            dest.display()
        );
    }
    Ok(())
}