Multiple workspaces: oxy workspace add|list|forget, secondary .oxy file, per-workspace snapshot lock (spec 0.6i) 4e88e774777a

//! Multiple workspaces (spec §12.2): extra checkout directories sharing one

//! `.oxy`. A secondary workspace holds a `.oxy` *file* of the form

//! `oxydir: <path>\nworkspace: <id>`; the repository lists workspaces under

//! `.oxy/workspaces/<id>/path`. Each workspace has its own working-copy

//! change, manifest, and short-lived snapshot lock.

use super::*;

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct WorkspaceInfo {

    pub id: WorkspaceId,

    pub path: PathBuf,

    /// Working-copy change hash from the current view, if the workspace is registered there.

    pub working_copy: Option<ChangeHash>,

    pub current: bool,

}

/// Held while a workspace is snapshotted; a stale lock (older than a

/// minute, its process gone) is taken over.

pub struct SnapshotLock {

    path: PathBuf,

}

impl Drop for SnapshotLock {

    fn drop(&mut self) {

        let _ = fs::remove_file(&self.path);

    }

}

/// Parse a secondary workspace's `.oxy` file.

pub(crate) fn parse_workspace_file(text: &str) -> Option<(PathBuf, WorkspaceId)> {

    let mut dir = None;

    let mut id = None;

    for line in text.lines() {

        if let Some(v) = line.strip_prefix("oxydir:") {

            dir = Some(PathBuf::from(v.trim()));

        } else if let Some(v) = line.strip_prefix("workspace:") {

            id = WorkspaceId::from_hex(v.trim());

        }

    }

    Some((dir?, id?))

}

impl Repo {

    fn workspace_dir(&self, id: &WorkspaceId) -> PathBuf {

        self.oxy.join("workspaces").join(id.to_hex())

    }

    /// Record where a workspace lives.

    pub(crate) fn register_workspace(&self, id: &WorkspaceId, path: &Path) -> Result<()> {

        let dir = self.workspace_dir(id);

        fs::create_dir_all(&dir)?;

        write_atomic(&dir.join("path"), path.to_string_lossy().as_bytes())

    }

    /// The directory of a workspace, if registered.

    pub fn workspace_path(&self, id: &WorkspaceId) -> Option<PathBuf> {

        fs::read_to_string(self.workspace_dir(id).join("path")).ok().map(|s| PathBuf::from(s.trim()))

    }

    /// Every workspace this repository knows about.

    pub fn workspaces(&self) -> Result<Vec<WorkspaceInfo>> {

        let view = self.view()?;

        let mut ids: BTreeSet<WorkspaceId> = view.workspaces.keys().copied().collect();

        if let Ok(rd) = fs::read_dir(self.oxy.join("workspaces")) {

            for e in rd.flatten() {

                if let Some(id) = WorkspaceId::from_hex(&e.file_name().to_string_lossy()) {

                    if e.path().join("path").exists() {

                        ids.insert(id);

                    }

                }

            }

        }

        let mut out = Vec::new();

        for id in ids {

            let path = if id == self.workspace {

                self.root.clone()

            } else {

                self.workspace_path(&id).unwrap_or_else(|| PathBuf::from("(unknown)"))

            };

            out.push(WorkspaceInfo { id, path, working_copy: view.workspaces.get(&id).copied(), current: id == self.workspace });

        }

        Ok(out)

    }

    /// Create a workspace at `dir` checked out on `heads` (default the

    /// bookmark's), and return a `Repo` rooted there.

    pub fn workspace_add(&self, dir: &Path, heads: Option<&[ChangeHash]>) -> Result<Repo> {

        if dir.exists() && fs::read_dir(dir)?.next().is_some() {

            return fail(format!("{} exists and is not empty", dir.display()));

        }

        fs::create_dir_all(dir)?;

        let dir = dir.canonicalize()?;

        if dir == self.root || dir.starts_with(&self.root) || self.root.starts_with(&dir) {

            return fail("a workspace cannot be inside another workspace of the same repository");

        }

        let heads = match heads {

            Some(h) => h.to_vec(),

            None => self.bookmark_heads()?,

        };

        let id = WorkspaceId::random();

        let wc = self.new_working_copy(heads.clone(), "");

        let wc_hash = self.store.put_change(&wc)?;

        let (op_ref, op) = self.head_op()?;

        let mut view = op.view.clone();

        view.workspaces.insert(id, wc_hash);

        self.record_op(&[op_ref], &format!("oxy workspace add {}", dir.display()), view)?;

        self.register_workspace(&id, &dir)?;

        write_atomic(&dir.join(OXY_DIR), format!("oxydir: {}\nworkspace: {}\n", self.oxy.display(), id.to_hex()).as_bytes())?;

        let repo = Repo::open(&dir)?.with_home(self.keys_dir.parent().unwrap_or(&self.keys_dir));

        repo.checkout(&heads, true, "oxy workspace add (checkout)")?;

        Ok(repo)

    }

    /// Drop a workspace from the view and registry; its files stay.

    pub fn workspace_forget(&self, id: &WorkspaceId) -> Result<()> {

        if *id == self.workspace {

            return fail("cannot forget the workspace you are in");

        }

        let (op_ref, op) = self.head_op()?;

        let mut view = op.view.clone();

        if view.workspaces.remove(id).is_none() && self.workspace_path(id).is_none() {

            return fail(format!("no workspace {}", id.short(8)));

        }

        self.record_op(&[op_ref], &format!("oxy workspace forget {}", id.short(8)), view)?;

        let _ = fs::remove_dir_all(self.workspace_dir(id));

        Ok(())

    }

    /// Take this workspace's snapshot lock (spec §12.1).

    pub(crate) fn lock_snapshot(&self) -> Result<SnapshotLock> {

        let dir = self.workspace_dir(&self.workspace);

        fs::create_dir_all(&dir)?;

        let path = dir.join("lock");

        for _ in 0..50 {

            match fs::OpenOptions::new().write(true).create_new(true).open(&path) {

                Ok(mut f) => {

                    let _ = write!(f, "{}", std::process::id());

                    return Ok(SnapshotLock { path });

                }

                Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {

                    let stale = fs::metadata(&path)

                        .and_then(|m| m.modified())

                        .map(|t| t.elapsed().map(|d| d.as_secs() > 60).unwrap_or(false))

                        .unwrap_or(true);

                    if stale {

                        let _ = fs::remove_file(&path);

                        continue;

                    }

                    std::thread::sleep(std::time::Duration::from_millis(100));

                }

                Err(e) => return Err(e.into()),

            }

        }

        fail("another oxy process is snapshotting this workspace")

    }

}

mod workspace;

pub use workspace::{SnapshotLock, WorkspaceInfo};

        repo.register_workspace(&workspace, &repo.root)?;

            if oxy.is_file() {

                // A secondary workspace (spec §12.2): the file points at the repository.

                let text = fs::read_to_string(&oxy)?;

                let Some((shared, workspace)) = workspace::parse_workspace_file(&text) else {

                    return fail(format!("{} is not a valid workspace file", oxy.display()));

                };

                let format = fs::read_to_string(shared.join("format"))?;

                if format != FORMAT_LINE {

                    return fail(format!("unsupported repository format: {}", format.trim()));

                }

                let config = Config::load(Some(&default_user_config()), &shared.join("config"))?;

                let store = Store::open(shared.join("objects"))?;

                return Ok(Repo { root: d.to_path_buf(), oxy: shared, store, workspace, keys_dir: default_keys_dir(), user_config: default_user_config(), config });

            }

        let _lock = self.lock_snapshot()?;

#[test]

fn multiple_workspaces_share_a_repository() {

    hermetic();

    let dir = tempfile::tempdir().unwrap();

    let root = dir.path();

    let main_dir = root.join("main");

    let repo = Repo::init(&main_dir).unwrap().with_home(root.join("home"));

    write(&main_dir, "a.txt", b"a\n");

    let h1 = repo.commit("a", &[]).unwrap();

    assert_eq!(repo.workspaces().unwrap().len(), 1);

    // A second workspace elsewhere, checked out on the bookmark.

    let ws_dir = root.join("ws2");

    let ws = repo.workspace_add(&ws_dir, None).unwrap();

    assert!(ws_dir.join(".oxy").is_file());

    assert_eq!(fs::read(ws_dir.join("a.txt")).unwrap(), b"a\n");

    assert_ne!(ws.workspace(), repo.workspace());

    let list = repo.workspaces().unwrap();

    assert_eq!(list.len(), 2);

    assert!(list.iter().any(|w| w.id == ws.workspace() && w.path == ws_dir.canonicalize().unwrap() && !w.current));

    assert!(!ws.snapshot("status").unwrap().changed);

    // Work in the second workspace: its own working copy, shared bookmark.

    write(&ws_dir, "b.txt", b"b\n");

    let s = ws.snapshot("status").unwrap();

    assert_eq!(s.statuses.len(), 1);

    assert!(!repo.snapshot("status").unwrap().changed, "the first workspace is untouched");

    let h2 = ws.commit("b from ws2", &[]).unwrap();

    let mut heads = repo.bookmark_heads().unwrap();

    heads.sort();

    let mut want = vec![h1, h2];

    want.sort();

    assert_eq!(heads, want, "both workspaces see the bookmark move");

    assert!(!main_dir.join("b.txt").exists());

    repo.checkout(&repo.bookmark_heads().unwrap(), false, "co").unwrap();

    assert!(main_dir.join("b.txt").exists());

    // Reopening from inside the second workspace finds the shared repository.

    let reopened = Repo::open(&ws_dir).unwrap();

    assert_eq!(reopened.workspace(), ws.workspace());

    assert_eq!(reopened.id().unwrap(), repo.id().unwrap());

    assert_eq!(reopened.quick_status().unwrap().heads, 2);

    // Workspaces cannot nest; forget drops one from the view but keeps files.

    assert!(repo.workspace_add(&main_dir.join("inner"), None).is_err());

    assert!(repo.workspace_forget(&repo.workspace()).is_err());

    repo.workspace_forget(&ws.workspace()).unwrap();

    assert_eq!(repo.workspaces().unwrap().len(), 1);

    assert!(ws_dir.join("b.txt").exists());

    assert!(ws.snapshot("status").is_err(), "a forgotten workspace is no longer in the view");

    // The snapshot lock: a fresh lock blocks a second, a stale one is taken over.

    let lock = repo.lock_snapshot().unwrap();

    drop(lock);

    let lock_path = main_dir.join(".oxy/workspaces").join(repo.workspace().to_hex()).join("lock");

    fs::write(&lock_path, "1").unwrap();

    let old = std::time::SystemTime::now() - std::time::Duration::from_secs(120);

    fs::File::open(&lock_path).unwrap().set_modified(old).unwrap();

    assert!(repo.lock_snapshot().is_ok(), "stale lock taken over");

}

| **Status** | Draft 0.6i |

A repository has one or more workspaces, each with a `WorkspaceId` (128-bit random) and a checkout directory. Each workspace has exactly one **working-copy change** at any time. The primary workspace is the directory holding `.oxy/`; a secondary workspace holds a `.oxy` file instead, `oxydir: <path>` and `workspace: <id>`, pointing at the shared repository, and the repository records each workspace's directory under `.oxy/workspaces/<id>/`. `oxy workspace add PATH [CHANGE..]` creates one, `list` shows them, and `forget` drops one from the view without touching its files. Workspaces do not nest.

*Changelog.* Draft 0.6i (2026-09-27): secondary workspaces and their `.oxy` file (§12.2).

Draft 0.6h (2026-09-27): tags in views, on the wire, and under policy (§5.5, §10.2, §16.3).

    /// Workspaces: extra checkout directories sharing this repository

    Workspace {

        #[command(subcommand)]

        cmd: WorkspaceCmd,

    },

enum WorkspaceCmd {

    /// Create a workspace at PATH checked out on CHANGE... (default: the bookmark heads)

    Add { path: PathBuf, changes: Vec<String> },

    List,

    /// Stop tracking a workspace (by id prefix or path); its files stay

    Forget { workspace: String },

}

#[derive(Subcommand)]

        Cmd::Workspace { cmd } => match cmd {

            WorkspaceCmd::Add { path, changes } => workspace::workspace_add(&path, &changes),

            WorkspaceCmd::List => workspace::workspace_list(),

            WorkspaceCmd::Forget { workspace } => workspace::workspace_forget(&workspace),

        },

pub fn workspace_add(path: &std::path::Path, changes: &[String]) -> Result<i32> {

    let repo = open()?;

    let heads = if changes.is_empty() {

        None

    } else {

        let mut heads = Vec::new();

        for c in changes {

            heads.extend(repo.resolve_heads(c)?);

        }

        Some(heads)

    };

    let sp = ui::spinner(&format!("Creating workspace at {}…", path.display()));

    let ws = repo.workspace_add(path, heads.as_deref())?;

    sp.done(&format!("{} {} (workspace {})", ui::ok("Workspace created at"), ui::path(ws.root().display()), ui::id(ws.workspace().short(8))));

    Ok(0)

}

pub fn workspace_list() -> Result<i32> {

    let repo = open()?;

    for w in repo.workspaces()? {

        println!(

            "{} {} {}{}",

            if w.current { ui::ok("*") } else { " ".into() },

            ui::id(w.id.short(8)),

            ui::path(w.path.display()),

            w.working_copy.map(|h| ui::dim(format!("  wc #{}", h.short(12)))).unwrap_or_else(|| ui::warn("  (not in view)"))

        );

    }

    Ok(0)

}

pub fn workspace_forget(spec: &str) -> Result<i32> {

    let repo = open()?;

    let all = repo.workspaces()?;

    let target = std::fs::canonicalize(spec).ok();

    let matches: Vec<_> = all.iter().filter(|w| w.id.starts_with_hex(spec) || target.as_ref().is_some_and(|t| *t == w.path)).collect();

    let w = match matches.as_slice() {

        [w] => *w,

        [] => anyhow::bail!("no workspace matches {spec:?}"),

        _ => anyhow::bail!("{spec:?} is ambiguous"),

    };

    repo.workspace_forget(&w.id)?;

    println!("{} workspace {} at {}; its files were left in place.", ui::ok("Forgot"), ui::id(w.id.short(8)), ui::path(w.path.display()));

    Ok(0)

}