grammpars 0.1.0

Offline conversion between Telegram Desktop tdata, Telethon, and grammers sessions
Documentation
use clap::{Parser, Subcommand, ValueEnum};
use grammpars::api::SessionFormat;
use grammpars::td::TDesktop;
use std::path::{Path, PathBuf};

#[derive(Debug, Parser)]
#[command(
    version,
    about = "Convert Telegram Desktop, Telethon, and grammers sessions"
)]
struct Cli {
    #[command(subcommand)]
    command: Command,
}

#[derive(Debug, Subcommand)]
enum Command {
    /// Export an account from a Telegram Desktop tdata directory.
    Export {
        #[arg(long, value_name = "DIRECTORY")]
        tdata: PathBuf,
        #[arg(long, value_enum)]
        format: Format,
        #[arg(short, long, value_name = "FILE")]
        output: PathBuf,
        #[arg(long, default_value_t = 0)]
        account: u32,
        /// Environment variable containing the local tdata passcode.
        #[arg(long, default_value = "GRAMMPARS_PASSCODE")]
        passcode_env: String,
    },
    /// Import a Telethon or grammers session into a new tdata directory.
    Import {
        #[arg(long, value_name = "FILE")]
        session: PathBuf,
        #[arg(long, value_enum)]
        format: Format,
        #[arg(short, long, value_name = "DIRECTORY")]
        output: PathBuf,
        #[arg(long)]
        user_id: u64,
        /// Allow writing into a non-empty output directory.
        #[arg(long)]
        force: bool,
        /// Environment variable containing the new local tdata passcode.
        #[arg(long, default_value = "GRAMMPARS_PASSCODE")]
        passcode_env: String,
    },
}

#[derive(Clone, Copy, Debug, ValueEnum)]
enum Format {
    Telethon,
    Grammers,
}

impl From<Format> for SessionFormat {
    /// Converts the command line format selector into the library format type.
    fn from(value: Format) -> Self {
        match value {
            Format::Telethon => Self::Telethon,
            Format::Grammers => Self::Grammers,
        }
    }
}

/// Parses command line arguments, runs the requested conversion, and reports errors.
fn main() {
    if let Err(error) = run(Cli::parse()) {
        eprintln!("error: {error}");
        std::process::exit(1);
    }
}

/// Executes a parsed command line request.
fn run(cli: Cli) -> Result<(), Box<dyn std::error::Error>> {
    match cli.command {
        Command::Export {
            tdata,
            format,
            output,
            account,
            passcode_env,
        } => {
            let passcode = std::env::var(passcode_env).unwrap_or_default();
            let mut desktop = TDesktop::new(tdata)?.with_passcode(passcode);
            desktop.load_tdata()?;
            desktop.export_session(&output, format.into(), account)?;
            println!("exported account {account} to {}", output.display());
        }
        Command::Import {
            session,
            format,
            output,
            user_id,
            force,
            passcode_env,
        } => {
            ensure_output_directory(&output, force)?;
            let passcode = std::env::var(passcode_env).unwrap_or_default();
            let desktop = TDesktop::import_session(&session, format.into(), user_id, &output)?
                .with_passcode(passcode);
            desktop.save_tdata()?;
            println!("created tdata directory at {}", output.display());
        }
    }
    Ok(())
}

/// Ensures that an import destination is safe to use under the selected policy.
fn ensure_output_directory(path: &Path, force: bool) -> Result<(), Box<dyn std::error::Error>> {
    if !path.exists() {
        return Ok(());
    }
    if !path.is_dir() {
        return Err(format!("output path {} is not a directory", path.display()).into());
    }
    if !force && path.read_dir()?.next().transpose()?.is_some() {
        return Err(format!(
            "output directory {} is not empty; pass --force to update it",
            path.display()
        )
        .into());
    }
    Ok(())
}