feat(accounts): add export/import commands for portable account transfer (#43)

* feat(accounts): add export/import commands for portable account transfer

Adds two new subcommands to `shard account`:

- `shard account export [-o output.json]` - Exports all accounts including
  tokens to a portable JSON file. Useful for transferring accounts between
  machines or backing up before system changes.

- `shard account import <file> [--replace]` - Imports accounts from an
  exported JSON file. By default, skips accounts that already exist (same UUID).
  Use `--replace` to overwrite existing accounts with imported data.

The exported JSON format includes:
- Account metadata (uuid, username, xuid)
- MSA tokens (access_token, refresh_token, expires_at)
- Minecraft tokens (access_token, expires_at)

Security warning is displayed after export reminding users to keep the file
secure and delete after use, as it contains sensitive authentication tokens.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* refactor(accounts): simplify merge_accounts logic

Collapse nested if statements in merge_accounts to satisfy clippy
and improve code readability.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix(accounts): properly propagate load_accounts errors during import

Replace `unwrap_or_default()` with `?` to avoid silently dropping existing
accounts when there's a keyring error during import. This matches the error
handling pattern used by all other `load_accounts` call sites.

Fixes Bugbot review comment about potential silent data loss.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* chore: bump version to 0.1.25

- Update version in launcher/Cargo.toml
- Update version in desktop/src-tauri/Cargo.toml
- Update version in desktop/package.json
- Update metainfo with release history

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Thomas Musik <music@music2music.fr>
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: 3 people

desktop/package.json

@@ -1,7 +1,7 @@
 {
   "name": "shard-ui",
   "private": true,
-  "version": "0.1.24",
+  "version": "0.1.25",
   "type": "module",
   "scripts": {
     "dev": "vite",

desktop/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shard_ui"
-version = "0.1.24"
+version = "0.1.25"
 description = "Shard launcher UI"
 authors = ["you"]
 edition = "2021"

launcher/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "shard"
-version = "0.1.24"
+version = "0.1.25"
 edition = "2024"
 description = "A minimal, content-addressed Minecraft launcher"
 license = "MIT"

launcher/src/accounts.rs

@@ -389,3 +389,104 @@ pub fn set_active(accounts: &mut Accounts, id: &str) -> bool {
     }
     false
 }
+
+/// Portable account format for export/import (includes tokens in the JSON)
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExportedAccounts {
+    #[serde(default)]
+    pub active: Option<String>,
+    #[serde(default)]
+    pub accounts: Vec<ExportedAccount>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ExportedAccount {
+    pub uuid: String,
+    pub username: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub xuid: Option<String>,
+    pub msa: MsaTokens,
+    pub minecraft: MinecraftTokens,
+}
+
+impl From<&Account> for ExportedAccount {
+    fn from(account: &Account) -> Self {
+        ExportedAccount {
+            uuid: account.uuid.clone(),
+            username: account.username.clone(),
+            xuid: account.xuid.clone(),
+            msa: account.msa.clone(),
+            minecraft: account.minecraft.clone(),
+        }
+    }
+}
+
+impl From<ExportedAccount> for Account {
+    fn from(exported: ExportedAccount) -> Self {
+        Account {
+            uuid: exported.uuid,
+            username: exported.username,
+            xuid: exported.xuid,
+            msa: exported.msa,
+            minecraft: exported.minecraft,
+        }
+    }
+}
+
+/// Export all accounts to a portable JSON format (includes tokens)
+pub fn export_accounts(accounts: &Accounts) -> ExportedAccounts {
+    ExportedAccounts {
+        active: accounts.active.clone(),
+        accounts: accounts.accounts.iter().map(ExportedAccount::from).collect(),
+    }
+}
+
+/// Export accounts to a JSON file
+pub fn export_accounts_to_file(accounts: &Accounts, path: &Path) -> Result<()> {
+    let exported = export_accounts(accounts);
+    let data = serde_json::to_string_pretty(&exported).context("failed to serialize accounts for export")?;
+    fs::write(path, data).with_context(|| format!("failed to write export file: {}", path.display()))?;
+    Ok(())
+}
+
+/// Import accounts from a portable JSON format
+pub fn import_accounts(exported: ExportedAccounts) -> Accounts {
+    Accounts {
+        active: exported.active,
+        accounts: exported.accounts.into_iter().map(Account::from).collect(),
+    }
+}
+
+/// Import accounts from a JSON file
+pub fn import_accounts_from_file(path: &Path) -> Result<Accounts> {
+    let data = fs::read_to_string(path)
+        .with_context(|| format!("failed to read import file: {}", path.display()))?;
+    let exported: ExportedAccounts = serde_json::from_str(&data)
+        .with_context(|| format!("failed to parse import file: {}", path.display()))?;
+    Ok(import_accounts(exported))
+}
+
+/// Merge imported accounts into existing accounts, optionally replacing duplicates
+pub fn merge_accounts(existing: &mut Accounts, imported: Accounts, replace: bool) -> usize {
+    let mut count = 0;
+    for account in imported.accounts {
+        if let Some(existing_account) = existing
+            .accounts
+            .iter_mut()
+            .find(|a| a.uuid == account.uuid)
+        {
+            if replace {
+                *existing_account = account;
+                count += 1;
+            }
+        } else {
+            existing.accounts.push(account);
+            count += 1;
+        }
+    }
+    // Update active if not set and imported has one
+    if existing.active.is_none() {
+        existing.active = imported.active;
+    }
+    count
+}

launcher/src/main.rs

@@ -4,7 +4,10 @@ use reqwest::blocking::Client;
 use reqwest::header::CONTENT_TYPE;
 use semver::Version;
 use serde::Deserialize;
-use shard::accounts::{delete_account_tokens, load_accounts, remove_account, save_accounts, set_active};
+use shard::accounts::{
+    delete_account_tokens, export_accounts_to_file, import_accounts_from_file, load_accounts,
+    merge_accounts, remove_account, save_accounts, set_active,
+};
 use shard::auth::request_device_code;
 use shard::config::{load_config, save_config};
 use shard::content_store::{ContentStore, ContentType, Platform, SearchOptions};
@@ -237,6 +240,20 @@ enum AccountCommand {
     Remove { id: String },
     /// Show account profile info (skin, cape)
     Info { id: Option<String> },
+    /// Export accounts to a JSON file (includes tokens for portability)
+    Export {
+        /// Output file path (default: accounts_export.json)
+        #[arg(short, long, default_value = "accounts_export.json")]
+        output: PathBuf,
+    },
+    /// Import accounts from a JSON file
+    Import {
+        /// Input file path
+        input: PathBuf,
+        /// Replace existing accounts with same UUID
+        #[arg(long)]
+        replace: bool,
+    },
     /// Skin management
     Skin {
         #[command(subcommand)]
@@ -1124,6 +1141,34 @@ fn handle_account_command(paths: &Paths, command: AccountCommand) -> Result<()>
                 }
             }
         }
+        AccountCommand::Export { output } => {
+            let accounts = load_accounts(paths)?;
+            if accounts.accounts.is_empty() {
+                bail!("no accounts to export");
+            }
+            export_accounts_to_file(&accounts, &output)?;
+            println!(
+                "exported {} account(s) to {}",
+                accounts.accounts.len(),
+                output.display()
+            );
+            println!("⚠️  WARNING: This file contains sensitive authentication tokens.");
+            println!("   Keep it secure and delete after use.");
+        }
+        AccountCommand::Import { input, replace } => {
+            let mut existing = load_accounts(paths)?;
+            let imported = import_accounts_from_file(&input)?;
+            let import_count = imported.accounts.len();
+            let added = merge_accounts(&mut existing, imported, replace);
+            save_accounts(paths, &existing)?;
+            println!(
+                "imported {added} account(s) from {} ({import_count} in file)",
+                input.display()
+            );
+            if added < import_count && !replace {
+                println!("tip: use --replace to overwrite existing accounts with same UUID");
+            }
+        }
         AccountCommand::Skin { command } => handle_skin_command(paths, command)?,
         AccountCommand::Cape { command } => handle_cape_command(paths, command)?,
     }

packaging/flathub/md.thomas.shard.launcher.metainfo.xml

@@ -61,6 +61,11 @@
     </screenshot>
   </screenshots>
   <releases>
+    <release version="0.1.25" date="2026-02-09">
+      <description>
+        <p>Add account export/import for portable account transfer</p>
+      </description>
+    </release>
     <release version="0.1.24" date="2026-01-29">
       <description>
         <p>Fix Flatpak build with correct binary name for Tauri v2</p>