Struct Store 

pub struct Store { /* private fields */ }

Implementations

impl Store

pub fn open(paths: &Paths) -> Result<Store>

pub fn lock(&self) -> Result<LockGuard, LockError>

Exclusive lock around the read-current -> backup -> apply compound; refuse (rather than block) if another swapdex is mid-switch.

pub fn lock_tool(&self, tool: &str) -> Result<LockGuard, LockError>

A per-tool credential lock, distinct from the whole-store lock. login holds it across its interactive sign-in - during which the store lock is deliberately RELEASED so unrelated swapdex ops proceed - and use/restore take it for the tools they switch. So a concurrent switch can never interleave with a sign-in on the SAME tool (the credential-race the store lock alone can’t prevent once it is released for the wait). It try-locks: a caller fails fast with Busy rather than blocking.

pub fn save(&self, name: &str, snap: &Snapshot) -> Result<()>

pub fn load(&self, name: &str, tool: &str) -> Result<Option<Snapshot>>

pub fn list(&self) -> Vec<ProfileInfo>

pub fn remove(&self, name: &str) -> Result<bool>

pub fn drop_tool(&self, name: &str, tool: &str) -> Result<bool>

Rename a profile. Returns false if old does not exist; errors if new already exists. Drop ONE tool from a profile, leaving the rest of it alone.

add defaults to every tool, so signing into one sweeps in whatever else happens to be logged in - and until now there was no way to take one back out short of deleting the whole profile. A profile ended up carrying Gemini and Antigravity logins its owner never asked swapdex to manage, which then went stale and nagged about tools he does not use.

Returns false when that profile has no such tool: asking to remove something already absent is the outcome the caller wanted, not an error.

pub fn profile_dir_exists(&self, name: &str) -> bool

Whether ANY directory (even a ghost one hidden from list()) claims this name - the collision test for rename targets.

pub fn rename(&self, old: &str, new: &str) -> Result<bool>

pub fn backup(&self, snap: &Snapshot) -> Result<()>

Back up a live snapshot before a switch; keep only the newest 2 per tool.

pub fn load_backup(&self, tool: &str) -> Result<Option<(u128, Snapshot)>>

The newest backup snapshot for a tool (taken by use before each switch), with its unix-nanos stamp. None when no backup exists.

pub fn append_timeline( &self, tool: &str, account: &str, action: &str, ) -> Result<()>

pub fn append_timeline_at( &self, tool: &str, account: &str, action: &str, ts: u64, ) -> Result<()>

Append with an explicit timestamp so every tool touched by ONE use / restore invocation shares the same ts - that shared ts is what lets a bare restore scope itself to exactly the last switch.

pub fn append_timeline_inv( &self, tool: &str, account: &str, action: &str, ts: u64, inv: u128, ) -> Result<()>

inv is a per-INVOCATION discriminator (nanos): whole-second ts alone collides when two separate invocations run inside one second, and bare restore scopes to “the last invocation’s tools” by it. 0 = legacy/unknown (grouping falls back to ts equality).