Milestone 0.3: bookmark picker (switch, create, merge, delete), fetch, pull, push and push bookmark with results, sync counter and Sync, push confirmation c8f955891224

## 0.3.0 (2026-09-27)

Milestone 0.3: bookmark picker in the status bar (switch, create, merge, delete), fetch, pull, push and push-bookmark with results, a sync counter and Sync action, confirmation before pushing.

  "version": "0.3.0",

      { "command": "oxygen.refreshOperations", "title": "Refresh Operations", "category": "Oxygen", "icon": "$(refresh)" },

      { "command": "oxygen.switchBookmark", "title": "Switch Bookmark…", "category": "Oxygen", "icon": "$(bookmark)" },

      { "command": "oxygen.createBookmark", "title": "Create Bookmark…", "category": "Oxygen" },

      { "command": "oxygen.mergeBookmark", "title": "Merge Bookmark…", "category": "Oxygen" },

      { "command": "oxygen.deleteBookmark", "title": "Delete Bookmark…", "category": "Oxygen" },

      { "command": "oxygen.fetch", "title": "Fetch", "category": "Oxygen" },

      { "command": "oxygen.pull", "title": "Pull", "category": "Oxygen" },

      { "command": "oxygen.push", "title": "Push", "category": "Oxygen" },

      { "command": "oxygen.pushBookmark", "title": "Push Bookmark…", "category": "Oxygen" },

      { "command": "oxygen.sync", "title": "Sync", "category": "Oxygen", "icon": "$(sync)" }

        { "command": "oxygen.sync", "group": "navigation@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.refresh", "group": "navigation@3", "when": "scmProvider == oxygen" },

        { "command": "oxygen.pull", "group": "4_sync@1", "when": "scmProvider == oxygen" },

        { "command": "oxygen.push", "group": "4_sync@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.pushBookmark", "group": "4_sync@3", "when": "scmProvider == oxygen" },

        { "command": "oxygen.fetch", "group": "4_sync@4", "when": "scmProvider == oxygen" },

        { "command": "oxygen.switchBookmark", "group": "5_bookmarks@1", "when": "scmProvider == oxygen" },

        { "command": "oxygen.createBookmark", "group": "5_bookmarks@2", "when": "scmProvider == oxygen" },

        { "command": "oxygen.mergeBookmark", "group": "5_bookmarks@3", "when": "scmProvider == oxygen" },

        { "command": "oxygen.deleteBookmark", "group": "5_bookmarks@4", "when": "scmProvider == oxygen" },

        "oxygen.confirmSync": {

          "type": "boolean",

          "default": true,

          "description": "Ask before pushing."

        },

    vscode.commands.registerCommand("oxygen.switchBookmark", (arg?: Repository | vscode.SourceControl) => switchBookmark(arg)),

    vscode.commands.registerCommand("oxygen.createBookmark", (arg?: Repository | vscode.SourceControl) => createBookmark(arg)),

    vscode.commands.registerCommand("oxygen.mergeBookmark", (arg?: Repository | vscode.SourceControl) => mergeBookmark(arg)),

    vscode.commands.registerCommand("oxygen.deleteBookmark", (arg?: Repository | vscode.SourceControl) => deleteBookmark(arg)),

    vscode.commands.registerCommand("oxygen.fetch", (arg?: Repository | vscode.SourceControl) => fetch(arg)),

    vscode.commands.registerCommand("oxygen.pull", (arg?: Repository | vscode.SourceControl) => pull(arg)),

    vscode.commands.registerCommand("oxygen.push", (arg?: Repository | vscode.SourceControl) => push(arg, false)),

    vscode.commands.registerCommand("oxygen.pushBookmark", (arg?: Repository | vscode.SourceControl) => push(arg, true)),

    vscode.commands.registerCommand("oxygen.sync", (arg?: Repository | vscode.SourceControl) => sync(arg)),

// ---------------------------------------------------------------- bookmarks

async function switchBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  let bookmarks;

  try {

    bookmarks = await repo.oxy.bookmarks(repo.root);

  } catch (e) {

    showError(e);

    return;

  }

  type Item = vscode.QuickPickItem & { action: "switch" | "create" | "merge" | "delete"; name?: string };

  const items: Item[] = bookmarks.map((b) => ({

    label: `${b.current ? "$(circle-filled)" : "$(bookmark)"} ${b.name}`,

    description: `${b.heads.length} head${b.heads.length === 1 ? "" : "s"}${b.ahead ? ` $(arrow-up)${b.ahead}` : ""}${b.behind ? ` $(arrow-down)${b.behind}` : ""}`,

    detail: b.current ? "current bookmark" : undefined,

    action: "switch",

    name: b.name,

  }));

  items.push(

    { label: "$(add) Create bookmark…", action: "create", alwaysShow: true },

    { label: "$(git-merge) Merge a bookmark into the current one…", action: "merge", alwaysShow: true },

    { label: "$(trash) Delete a bookmark…", action: "delete", alwaysShow: true },

  );

  const pick = await vscode.window.showQuickPick(items, { placeHolder: "Switch to a bookmark" });

  if (!pick) {

    return;

  }

  switch (pick.action) {

    case "create":

      return createBookmark(repo);

    case "merge":

      return mergeBookmark(repo);

    case "delete":

      return deleteBookmark(repo);

    case "switch":

      if (pick.name && !bookmarks.find((b) => b.name === pick.name)?.current) {

        await doSwitch(repo, pick.name);

      }

  }

}

async function doSwitch(repo: Repository, name: string): Promise<void> {

  try {

    await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Switching to ${name}` }, () => repo.oxy.bookmarkSwitch(repo.root, name));

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("has changes")) {

      const pick = await vscode.window.showWarningMessage(`The working copy has uncommitted changes. Switching to ${name} would discard them.`, { modal: true }, "Discard and switch");

      if (pick === "Discard and switch") {

        try {

          await repo.oxy.bookmarkSwitch(repo.root, name, true);

        } catch (e2) {

          showError(e2);

        }

      }

    } else {

      showError(e);

    }

  }

  await repo.refresh();

}

async function createBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  const name = await vscode.window.showInputBox({

    prompt: "New bookmark name (created at the working copy's base)",

    validateInput: (v) => (!v.trim() || v.startsWith("-") || v.includes("..") || v.includes("//") || /[\s@{]/.test(v) ? "Not a valid bookmark name" : undefined),

  });

  if (!name) {

    return;

  }

  try {

    await repo.oxy.bookmarkCreate(repo.root, name.trim());

    const pick = await vscode.window.showInformationMessage(`Oxygen: created bookmark ${name}.`, "Switch to it");

    if (pick) {

      await doSwitch(repo, name.trim());

    }

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

async function pickBookmark(repo: Repository, placeHolder: string, excludeCurrent: boolean): Promise<string | undefined> {

  const bookmarks = await repo.oxy.bookmarks(repo.root);

  const items = bookmarks.filter((b) => !excludeCurrent || !b.current).map((b) => ({ label: b.name, description: `${b.heads.length} head${b.heads.length === 1 ? "" : "s"}` }));

  if (items.length === 0) {

    void vscode.window.showInformationMessage("Oxygen: no other bookmarks.");

    return undefined;

  }

  return (await vscode.window.showQuickPick(items, { placeHolder }))?.label;

}

async function mergeBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const name = await pickBookmark(repo, `Merge into ${repo.currentBookmark?.name ?? "the current bookmark"}`, true);

    if (!name) {

      return;

    }

    const out = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Merging ${name}` }, () => repo.oxy.merge(repo.root, name));

    await repo.refresh();

    if (repo.status?.conflicted) {

      void vscode.window.showWarningMessage(`Oxygen: merged ${name}; the result has conflicts to resolve.`);

    } else {

      vscode.window.setStatusBarMessage(`$(git-merge) ${out.split("\n")[0]}`, 5000);

    }

  } catch (e) {

    showError(e);

  }

}

async function deleteBookmark(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const name = await pickBookmark(repo, "Delete which bookmark? Its changes stay.", true);

    if (!name) {

      return;

    }

    const pick = await vscode.window.showWarningMessage(`Delete bookmark ${name}?`, { modal: true }, "Delete");

    if (pick !== "Delete") {

      return;

    }

    await repo.oxy.bookmarkDelete(repo.root, name);

    await repo.refresh();

  } catch (e) {

    showError(e);

  }

}

// ---------------------------------------------------------------- sync

async function pickRemote(repo: Repository): Promise<string | undefined> {

  const remotes = await repo.oxy.remotes(repo.root);

  if (remotes.length === 0) {

    void vscode.window.showErrorMessage("Oxygen: this repository has no remotes. Add one with oxy remote add <name> <url>.");

    return undefined;

  }

  if (remotes.length === 1) {

    return remotes[0].name;

  }

  return (await vscode.window.showQuickPick(remotes.map((r) => ({ label: r.name, description: r.url })), { placeHolder: "Remote" }))?.label;

}

async function fetch(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    const info = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Fetching from ${remote}` }, () => repo.oxy.fetch(repo.root, remote));

    await repo.refresh();

    const fresh = info.refs.filter((r) => r.new > 0);

    const summary = fresh.length ? fresh.map((r) => `${r.name}: ${r.new} new`).join(", ") : "nothing new";

    vscode.window.setStatusBarMessage(`$(cloud-download) ${remote}: ${summary}`, 5000);

    if (info.unverified) {

      void vscode.window.showWarningMessage(`Oxygen: ${remote} has no trust policy; nothing fetched from it was verified.`);

    }

  } catch (e) {

    showError(e);

  }

}

async function pull(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    const info = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Pulling from ${remote}` }, () => repo.oxy.pull(repo.root, remote));

    await repo.refresh();

    if (!info.changed) {

      vscode.window.setStatusBarMessage("$(check) Already up to date", 4000);

    } else if (info.conflicted) {

      void vscode.window.showWarningMessage("Oxygen: pulled; the result has conflicts to resolve.");

    } else if (!info.checked_out) {

      void vscode.window.showInformationMessage("Oxygen: pulled; the working copy was not updated because it has changes. Check out when ready.");

    } else {

      vscode.window.setStatusBarMessage(`$(cloud-download) Pulled from ${remote}`, 4000);

    }

  } catch (e) {

    showError(e);

  }

}

async function push(arg: Repository | vscode.SourceControl | undefined, chooseBookmark: boolean): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  try {

    const remote = await pickRemote(repo);

    if (!remote) {

      return;

    }

    let bookmark: string | undefined;

    if (chooseBookmark) {

      bookmark = await pickBookmark(repo, "Push which bookmark?", false);

      if (!bookmark) {

        return;

      }

    }

    if (vscode.workspace.getConfiguration("oxygen").get<boolean>("confirmSync", true)) {

      const pick = await vscode.window.showInformationMessage(`Push ${bookmark ?? repo.currentBookmark?.name ?? "the current bookmark"} to ${remote}?`, { modal: false }, "Push", "Always push without asking");

      if (!pick) {

        return;

      }

      if (pick === "Always push without asking") {

        await vscode.workspace.getConfiguration("oxygen").update("confirmSync", false, vscode.ConfigurationTarget.Global);

      }

    }

    const results = await vscode.window.withProgress({ location: vscode.ProgressLocation.SourceControl, title: `Pushing to ${remote}` }, () => repo.oxy.push(repo.root, remote, bookmark));

    await repo.refresh();

    const rejected = results.filter((r) => !r.ok);

    if (rejected.length === 0) {

      vscode.window.setStatusBarMessage(`$(cloud-upload) Pushed to ${remote}`, 4000);

      return;

    }

    const reason = rejected.map((r) => `${r.name}: ${r.reason}`).join("; ");

    const pick = await vscode.window.showErrorMessage(`Oxygen: push rejected. ${reason}`, "Pull", "Show Output");

    if (pick === "Pull") {

      await pull(repo);

    } else if (pick === "Show Output") {

      output.show();

    }

  } catch (e) {

    if (e instanceof OxyError && e.message.includes("pull first")) {

      const pick = await vscode.window.showWarningMessage(`Oxygen: ${e.message}`, "Pull");

      if (pick === "Pull") {

        await pull(repo);

      }

      return;

    }

    showError(e);

  }

}

async function sync(arg: Repository | vscode.SourceControl | undefined): Promise<void> {

  const repo = repositoryFor(arg);

  if (!repo) {

    return;

  }

  await pull(repo);

  if (repo.status?.conflicted) {

    return;

  }

  if ((repo.currentBookmark?.ahead ?? 0) > 0) {

    await push(repo, false);

  }

}

  // ---------------------------------------------------------------- bookmarks

  bookmarkCreate(root: string, name: string, changes: string[] = []): Promise<void> {

    return this.check(root, ["bookmark", "create", name, ...changes]).then(() => undefined);

  }

  bookmarkSwitch(root: string, name: string, discard = false): Promise<void> {

    const args = ["bookmark", "switch", name];

    if (discard) {

      args.push("--discard");

    }

    return this.check(root, args).then(() => undefined);

  }

  bookmarkDelete(root: string, name: string): Promise<void> {

    return this.check(root, ["bookmark", "delete", name]).then(() => undefined);

  }

  merge(root: string, name: string): Promise<string> {

    return this.check(root, ["merge", name]).then((r) => r.stdout.toString("utf8").trim());

  }

  // ---------------------------------------------------------------- remotes and sync

  remotes(root: string): Promise<RemoteInfo[]> {

    return this.json<RemoteInfo[]>(root, ["remote", "list"]);

  }

  fetch(root: string, remote?: string): Promise<FetchInfo> {

    return this.json<FetchInfo>(root, ["fetch", ...(remote ? [remote] : [])]);

  }

  pull(root: string, remote?: string): Promise<PullInfo> {

    return this.json<PullInfo>(root, ["pull", ...(remote ? [remote] : [])]);

  }

  push(root: string, remote?: string, bookmark?: string, force = false): Promise<PushResult[]> {

    const args = ["push", ...(remote ? [remote] : [])];

    if (bookmark) {

      args.push("-b", bookmark);

    }

    if (force) {

      args.push("--force");

    }

    return this.json<PushResult[]>(root, args, [0, 1]);

  }

  clone(cwd: string, url: string, dest: string): Promise<void> {

    return this.check(cwd, ["clone", url, dest]).then(() => undefined);

  }

}

export interface RemoteInfo {

  name: string;

  url: string;

  bookmarks: { name: string; heads: string[] }[];

}

export interface FetchInfo {

  remote: string;

  refs: { name: string; heads: string[]; new: number }[];

  new_tags: number;

  unverified: boolean;

}

export interface PullInfo {

  remote: string;

  heads: string[];

  changed: boolean;

  checked_out: boolean;

  conflicted: boolean;

}

export interface PushResult {

  name: string;

  ok: boolean;

  reason: string;

import { BookmarkInfo, Oxy, PathStatus, StatusInfo } from "./oxy";

  private readonly syncBar: vscode.StatusBarItem;

  private bookmarksLatest: BookmarkInfo[] = [];

    this.statusBar.command = { command: "oxygen.switchBookmark", title: "Switch bookmark", arguments: [this] };

    this.syncBar = vscode.window.createStatusBarItem("oxygen.sync", vscode.StatusBarAlignment.Left, 99);

    this.syncBar.name = "Oxygen sync";

    this.syncBar.command = { command: "oxygen.sync", title: "Sync", arguments: [this] };

    this.disposables.push(this.sourceControl, this.conflictsGroup, this.changesGroup, this.statusBar, this.syncBar, this.onDidChangeStatusEmitter);

  get bookmarks(): BookmarkInfo[] {

    return this.bookmarksLatest;

  }

  get currentBookmark(): BookmarkInfo | undefined {

    return this.bookmarksLatest.find((b) => b.current);

  }

      const [status, prompt, bookmarks] = await Promise.all([this.oxy.status(this.root), this.oxy.prompt(this.root), this.oxy.bookmarks(this.root).catch(() => [] as BookmarkInfo[])]);

      this.bookmarksLatest = bookmarks;

    const current = this.currentBookmark;

    if (current && (current.ahead !== null || current.behind !== null)) {

      const ahead = current.ahead ?? 0;

      const behind = current.behind ?? 0;

      this.syncBar.text = `$(arrow-up)${ahead} $(arrow-down)${behind}`;

      this.syncBar.tooltip = `${ahead} change${ahead === 1 ? "" : "s"} to push, ${behind} to pull from origin. Click to sync.`;

      this.syncBar.show();

    } else {

      this.syncBar.hide();

    }

test("bookmarks, remotes and sync against a local origin", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-sync-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "origin"]);

  await oxy.clone(dir, join(dir, "origin"), join(dir, "work"));

  const root = join(dir, "work");

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "a");

  const remotes = await oxy.remotes(root);

  assert.equal(remotes[0].name, "origin");

  let push = await oxy.push(root);

  assert.equal(push[0].ok, true);

  let bookmarks = await oxy.bookmarks(root);

  assert.deepEqual(bookmarks.map((b) => [b.name, b.current, b.ahead, b.behind]), [["main", true, 0, 0]]);

  await oxy.bookmarkCreate(root, "feature");

  await oxy.bookmarkSwitch(root, "feature");

  writeFileSync(join(root, "a.txt"), "a\nfeature\n");

  await oxy.commit(root, "feature work");

  bookmarks = await oxy.bookmarks(root);

  assert.equal(bookmarks.find((b) => b.current)?.name, "feature");

  await oxy.bookmarkSwitch(root, "main");

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\n");

  writeFileSync(join(root, "b.txt"), "b\n");

  await assert.rejects(oxy.bookmarkSwitch(root, "feature"), /has changes/);

  await oxy.commit(root, "b on main");

  assert.match(await oxy.merge(root, "feature"), /Merged/);

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\nfeature\n");

  push = await oxy.push(root, "origin", "feature");

  assert.equal(push[0].ok, true);

  push = await oxy.push(root);

  assert.equal(push[0].ok, true);

  const fetch = await oxy.fetch(root);

  assert.equal(fetch.remote, "origin");

  const pull = await oxy.pull(root);

  assert.equal(pull.changed, false);

  await oxy.bookmarkDelete(root, "feature");

  bookmarks = await oxy.bookmarks(root);

  assert.deepEqual(bookmarks.map((b) => b.name), ["main"]);

});