BullseyeSync
Ask your AI "is the fleet in sync?" and it answers from the real state of every machine. BullseyeSync keeps your editor and tool configuration identical across machines through a private GitHub repo you own, and hands your AI (Claude Code, Codex or Copilot) a read-only syncState tool so one sentence tells you which machines are alive, what is blocked and what is waiting.
There is nothing to learn first: you install it, sign in with GitHub once, and from then on you watch the panel and ask your AI. The AI reads the fleet; the changes themselves (download, upload, restore) are the panel's buttons, because they overwrite files and stay in your hands.
🎯 Better together: BullseyeUber
BullseyeSync works on its own, and it gains the most inside BullseyeUber β one install puts it with FleetView, BullseyeBacklog, DeepAgent, BullseyeSync and BullseyeNotify in a single Bullseye Control tab. Installing BullseyeUber pulls in any member you are missing, and each keeps its own listing and updates.
- Sync status one tab away from everything else. BullseyeSync's status tab is a member of Bullseye Control, and the Dashboard card shows its version, whether it is open and its own status hover next to the other four.
- A slow start holds nobody. Sync can take most of a minute to be ready; in Bullseye Control each member's tab opens the moment its own extension is ready, so the others never wait on "Opening its page hereβ¦".
- Safe reload, same dialog. It joins the shared reload that parks every member's work, and its alerts use the one Bullseye dialog drawn over whichever tab you are on.
👉 Get BullseyeUber on the Marketplace
β¨ Most impactful first
| # |
What it does for you |
Why it matters |
| 1 |
🔐 A login never travels; an identity's key does β Any apiKey, secretKey, usageKey, licenseKey, authToken or credential value in settings.json is stripped on the way out and on the way in, and the live file's own value always wins, empty included. The one exception is a DeepAgent identity's own key and usageKey: they ride with their record, so the key HP holds is the key every machine holds once it delivers editor files (takeover mode). |
A login you delete on one machine stays deleted on every machine; it is never written to the repo. An identity key is ordinary synced data: the last edit from any machine wins, a key deleted on the machine that owns the choice is deleted everywhere, and a record from an older copy that has no key member never wipes the key a machine holds. The keys sit in the sync repo and its history, so a rollback to an older commit brings an older key back. A credential follows the identity that owns it by id, never its position in a list. |
| 2 |
🧭 A conflict never waits for you β the source-of-truth machine keeps its side, every other machine takes it, and the file it replaces is set aside first under ~/.bullseye/sync-conflicts/<day>/. |
No more "choose which settings win" ritual; nothing is lost invisibly. Set local-wins or remote-wins in manifest.yml to override the rule fleet-wide. |
| 3 |
🤖 Your AI reads the fleet β ask "is the fleet in sync?" and the read-only syncState tool answers from every machine's real state. One resident server on 127.0.0.1:7474 serves every chat session and window. |
Five chats mean one server, not five. Only the panel's buttons ever change anything. |
| 4 |
🔄 Syncs your whole setup β VS Code per profile (settings, keybindings, tasks, snippets, MCP servers, extensions, UI state) plus Claude, Copilot, Cursor, Windsurf, Zed, Continue, Aider and your shell and git dotfiles. |
The configuration outside VS Code is the part Settings Sync never covers. |
| 5 |
🕰οΈ Point-in-time restore β roll back to any of the last 60 commits; the state you leave is pinned under a backup ref first. |
A wrong pick is still recoverable. |
| 6 |
🩹 It heals itself β a push an earlier cycle stranded goes up on the next sync; when VS Code's GitHub session dies, it falls back to the credential your own git already uses. |
A dead sign-in no longer stalls the fleet silently. |
| 7 |
🤝 Coexist or take over β it takes your editor files over only once VS Code Settings Sync is proved off; a mode it cannot read stays coexisting and says so. |
Two syncers never fight over one file. |
| 8 |
β³ Every button answers β each press disables itself, ticks live seconds and ends on its outcome or the reason it failed; the panel stops its background checks while hidden. |
Broken and healthy never look the same, and a hidden panel costs nothing. |
| 9 |
📋 One manifest.yml β change what syncs on any machine and every machine adopts it. |
The fleet has one definition of itself. |
Ask your AI
Copy any of these into your AI chat. Each is answered by the syncState tool, which reads disk and never starts, refuses or changes a sync.
1. "Is the fleet in sync, and is anything stuck?" The reply lists every machine with when it was last heard from, whether its push is blocked, and whether this machine's last commit is the state it last fetched. A machine it could not read is reported as unreadable, never as healthy.

The reply to prompt 1: three machines, each with its last heartbeat. travel-laptop has pushBlocked true and an old version. Machine names are invented.
2. "When did each of my machines last sync?" Same call; the roster is the answer. The panel shows the same roster with Last verified push per machine.

Prompt 2 on screen: the Machines table, one row per machine with its last push, commit count and health. This is also the screen you land on after install.
3. "Why is my push failing?" The reply carries the blocked flag and the reason the push was refused; the panel draws the same state in red, along with any peer that stopped syncing.

Prompt 3: a rejected push ("the remote moved ahead") and a machine that has gone quiet for days. Fix it with Download or Sync now.
4. "Do I have any sync conflicts waiting?" The reply says whether the push is blocked and why. A same-key clash is settled on its own by the source-of-truth rule (the replaced file is set aside under ~/.bullseye/sync-conflicts/), so no conflict ever waits for you.
5. "Did my last push actually land?" The reply compares this machine's commit with the state it last fetched and says whether anything is unpushed.
After the first screen: what to do
| You want to |
Do this |
| See the fleet at a glance |
Click the BullseyeSync chip in the status bar, or the Activity Bar icon |
| Push or pull right now |
Sync now in the panel |
| Roll your config back |
βΊ History in the panel (or BullseyeSync: Restore from history): pick any of the last 60 commits. The state you leave is first pinned under a backup/<machine>/<timestamp> ref, and BullseyeSync: Open backup branch names it |
| Make this machine match the remote, or the reverse |
Overwrite local / Overwrite remote (palette: Download / Upload) |
| Choose how a conflict resolves |
β‘ Conflicts in the panel: source of truth wins (the default), keep this machine's version, or take the remote's β for the whole fleet. |
| Retire a machine |
remove on its row in the roster |
| Change what is synced |
Components / Profiles, or edit manifest.yml; every machine adopts it |
What it does
It covers what VS Code's built-in Settings Sync covers (settings, keybindings, extensions list, snippets, tasks, MCP servers, UI state, per profile) and the configuration that lives outside VS Code: Claude, Copilot Chat, Cursor, Windsurf, Zed, Continue, Aider, plus shell, git, prompt and package-manager dotfiles.
It does not fight VS Code Settings Sync
BullseyeSync runs in one of two relationships with Settings Sync, chosen by GitHub Sync mode (auto by default, forceable to coexist or takeover):
- Coexist β Settings Sync is on and keeps ownership of VS Code's own resources. BullseyeSync observes those files, commits each burst of writes to git for history and point-in-time restore, and actively syncs everything outside VS Code. It never writes editor resources back on pull, so the two never overwrite each other.
- Takeover β Settings Sync is off. BullseyeSync becomes the sole sync and delivers editor resources to the live config on every pull, on top of the external files.
In auto, the mode follows Settings Sync's own cache: no sync activity for 14 days is read as off. The window is deliberately generous β an idle-but-enabled machine must not be flipped into takeover and start overwriting.
A cache that cannot be read is never read as off. If BullseyeSync cannot read whether Settings Sync is running here, it stays in coexist, says so on the panel and in the log, and leaves your editor files alone. Only a proved "off" hands it the editor files β a lookup that failed says nothing about the machine, and guessing would put two syncers on one file.
What it syncs
VS Code, per profile β settings.json, keybindings.json, tasks.json, mcp.json, user snippets, the installed-extensions list, and UI state (globalState.json). You pick which profiles participate.
AI and editor tools β Claude CLI (~/.claude: CLAUDE.md, keybindings.json, skills/, agents/, rules/, and only the env block of settings.json β the provider address, key and model choices; its hooks, status line and permission list name one machine's absolute paths and stay on that machine), Codex CLI (~/.codex: AGENTS.md, agents/, skills/, and only the model, model_reasoning_effort, service_tier and model_provider keys of config.toml; every other key and table stays on its machine), the Claude key failover choice (~/.bullseye/auto-switch/settings.json), Claude Desktop, GitHub Copilot Chat agent files, Continue, Aider, Cursor and Windsurf rules and settings, Zed settings.
Dotfiles β .gitconfig, global gitignore, lazygit, .bashrc, .bash_profile, .zshrc, .zprofile, fish, nushell, PowerShell profile, starship, WezTerm, Ghostty, Alacritty, .tmux.conf, .vimrc, Neovim init.lua, ~/.ssh/config (config only, never keys), .npmrc, pnpm, pip, Poetry.
Anything else β add your own files or folders from the wizard or BullseyeSync: Edit custom items.
Every built-in preset is an allowlist: it names the specific files to sync and nothing else. Pointing a preset at ~/.claude does not drag along caches, transcripts or credentials β only the listed files travel. The directory serializer additionally refuses credential-shaped files and *.backup* variants.
Setup
- Install the extension and click BullseyeSync in the Activity Bar.
- Sign in with GitHub β the same OS-native consent dialog Copilot uses. No token to paste. A private
vscode-bullseye-sync repo is created for you if it does not exist.
- Pick what to sync β VS Code resources plus every tool config the extension actually found on this machine. The step also offers to turn Settings Sync off; BullseyeSync delivers the editor files itself from the moment it can prove Settings Sync is off.
- Done β the first push runs immediately.
On a second machine, install and sign in with the same account; the wizard finds the existing repo and pulls. If you already ran setup in another VS Code variant or profile on the same box, this one adopts that setup silently rather than asking again.
Configuration lives in the repo, not in settings.json
The synced set is one fleet-global file, manifest.yml, at the root of your sync repo. Change what is synced on any machine and every other machine adopts it on its next pull. The VS Code Settings UI therefore shows a single read-only pointer rather than a wall of knobs.
manifest.yml carries the synced profiles, the synced resources, your custom directories, and two fleet settings: GitHub Sync mode and the default conflict action (prompt / local-wins / remote-wins). Edit it by hand with BullseyeSync: Edit manifest, or through the panel buttons.
How syncing works
Push β chokidar watches every synced path. A change debounces for 5 seconds, then the affected paths are re-serialized, diffed against HEAD, and pushed. A snapshot that produces no git-level change never becomes a commit. If more than 200 events arrive within 10 seconds, an anti-thrash brake trips instead of hammering the remote. When the native watcher cannot work β network drives, some containers β the path falls back to 5-second polling and the panel says so.
Pull β the remote is checked every 60 seconds, and on boot and on demand. A watchdog sweep every 2 minutes restarts a dead watcher or a stalled remote-check loop. Three consecutive failures trip a circuit breaker; a hard misconfiguration (no repo URL, 404) stops the daemon rather than retrying forever.
Merge β three-way, against the commit this machine last synced (tracked per machine at refs/bullseye-sync/machines/<id>/last-synced, so a merge base is never guessed). JSON and JSONC files merge per key with comments preserved; everything else merges by line with diff3. Same key with the same value is a no-op; different keys union. A genuine same-key divergence resolves by the source-of-truth rule (or your fleet-wide local-wins / remote-wins), and the side it replaces is set aside under ~/.bullseye/sync-conflicts/<day>/. extensions.yml resolves by capture time β the newest capture wins, so an uninstall on one machine is never resurrected by an older peer that still has it.
Extension sync asks first
A pulled extension list is turned into a plan β install these, uninstall those β and shown to you before anything is installed or removed, because applying it forces a window reload that kills whatever that window was running. Every entry is independently deniable. A refusal is remembered, and forgotten again the moment the repo stops asking, so a later flip re-asks. An empty captured list means "extensions were never captured", never "uninstall everything". BullseyeSync never proposes uninstalling itself.
Fleet operations
The panel keeps a roster of every machine that has pushed, with its last sync time. From there:
- Overwrite local (palette: Download) β replace this machine's config with the remote's. Overwrite remote (palette: Upload) β overwrite every other machine with this one.
- Restore from history β point-in-time rollback: pick any of the last 60 commits and put your config back to that point. Before anything on disk is overwritten, the state you are leaving is pinned under a backup ref (
refs/heads/backup/<machine>/<timestamp>), so a wrong pick is still recoverable. BullseyeSync: Open backup branch names that ref for you.
- Reconfigure all machines β change the synced set once and propagate it.
- Leave on this machine β forget membership here, keep the editor files.
- Factory reset everywhere β wipe BullseyeSync state on every machine, optionally deleting the remote repo. Deleting the repo asks for the extra GitHub scope only at that moment. The panel's
Dev group draws this button on every machine: where a checkout of this extension was found it is live, and anywhere else it is greyed with the reason and names this command for the palette.
- Remove machine β tombstone a retired machine from its row in the roster so it stops appearing.
- Reload β reload the window with the live work saved first, so a reload does not throw away what this window was doing.
Fleet commands travel as a control file in the repo (.bullseye-control/control.json) and are honoured on the next pull, plus a marker on disk so every VS Code variant and profile on the same box reacts too, not just the window you clicked in.
Every press answers
Sync now, Pause / Resume, Overwrite local, Overwrite remote, Download, Refresh, Re-authenticate GitHub, Factory reset and the DEV pulldown all behave the same way: the button disables itself, shows β³ <verb>β¦ Ns with live seconds, and ends on β
with the outcome or β οΈ with the reason it failed. A full repaint of the panel mid-press redraws the busy state rather than dropping it.
Light on handles
A folder the preset excludes is never watched at all, so large excluded trees (for example ~/.claude/skills/synced and skills/.trash) hold no file-watcher handles on your machine. Heavy modules load on first use rather than at VS Code startup.
Works with BullseyeUber
The syncState and propagationState tools are registered as an MCP server by this extension: one resident HTTP process on 127.0.0.1:7474 per machine, started by the first window that activates, with every chat session and window a client of it. propagationState says what the closed-window tick last did on each clone β published, applied the fleet's settings, found nothing new, deferred to an open window, paused, refused with its reason, failed, or could not reach the fleet. That tick is what keeps a machine whose VS Code is closed in step: the same server pushes this machine's changes and pulls the fleet's settings every minute while no window is open, and stands down while one is. If BullseyeUber is installed in the same window, BullseyeSync stands aside and BullseyeUber hosts the tools, so you get one copy rather than two.
Where things are
- Activity Bar β the BullseyeSync dashboard: status, sync state, watcher list, machine roster, and every action.
BullseyeSync: Open status as a tab is the fallback if the view ever fails to paint.
- Status bar β one chip on the right; clicking it opens the dashboard.
- Output panel β
BullseyeSync for the plain-English activity log, BullseyeSync (Debug) for raw library errors.
- On disk β a rotated log at
<globalStorage>/logs/bullseye-sync.log, 1 MB per file, 3 generations, opened by BullseyeSync: Open log file.
Repo layout
manifest.yml
editor/profiles/<profile>/settings.json
editor/profiles/<profile>/keybindings.json
editor/profiles/<profile>/tasks.json
editor/profiles/<profile>/mcp.json
editor/profiles/<profile>/globalState.json
editor/profiles/<profile>/snippets/
editor/profiles/<profile>/extensions.yml
dirs/<id>/...
.bullseye-control/control.json
.bullseye-machines/<machineId>.json
.machines/<machineId>.removed
.bullseye-machines/ is how the roster knows a peer is still alive: one small file per machine, rewritten on every push, so a machine that has stopped syncing shows as stale instead of silently staying on the list.
Commands
| Command |
What it does |
Set up |
Run the wizard. Re-runnable any time to change what syncs. |
Clone setup from repo |
Restore a machine from an existing sync repo. |
Sync now |
Pull, then push. |
🔄 Reload |
Save the live work first, then reload the window. |
Open remote repo / Open local repo folder |
Jump to either copy. |
Status / Open status as a tab |
Focus the dashboard, or open it as an editor tab if the sidebar view ever fails to paint. |
Add path to sync / Remove path from sync |
Single-path shortcuts. |
Pause / Resume |
Halt auto-sync on this machine. |
Restore from history |
Point-in-time rollback β pick one of the last 60 commits. |
Restore from commit |
The same act as Restore from history under a second palette entry. |
Open backup branch |
Name the backup ref a restore pinned before it overwrote anything. |
Edit manifest |
Open manifest.yml directly. |
Show output log / Show debug log |
The plain-English activity log, and the raw library errors. |
Open log file |
The rotated log on disk. |
Reconfigure all machines |
Change the synced set fleet-wide. |
Factory reset everywhere |
Wipe every machine, optionally delete the remote. |
Leave on this machine |
Forget membership here, keep the files. |
Download / Upload |
One-way overwrite (the panel's Overwrite local / Overwrite remote): this machine from the remote, or the remote from this machine. |
Remove machine from sync repo |
Tombstone a retired machine. |
Clear reset marker |
Debug: forget the marker that tells the other VS Code windows on this box a reset happened. |
Open settings |
Jump to BullseyeSync's settings page. |
Edit synced components |
Everything that syncs β the known catalog plus your own items. |
Edit known components |
Toggle the built-in catalog entries. |
Edit custom items |
Add or remove your own files and directories. |
Edit synced profiles |
Choose which VS Code profiles participate. |
BullseyeSync DEV |
The DEV pulldown below. |
BullseyeSync DEV opens a pulldown with four entries: β¬οΈ Reinstall latest, 🔢 Bump version only, 🚀 Publish to Marketplace and 🔄 Reload (saves your work first). The first three need a BullseyeSync checkout to exist on this machine β it does not have to be open in this window. The pulldown is drawn only when one is found, and an entry refuses by name if it went away between the draw and the click. Clear reset marker is the other maintainer command.
Auth and privacy
Authentication goes through VS Code's built-in GitHub provider β the same one Copilot uses. The token is fetched fresh for each git operation and is never written to settings or to the repo. The repo is private and yours; there is no BullseyeSync server and nothing is sent anywhere else. That private repo is the whole security boundary: its contents are not encrypted, so do not add paths that hold secrets.
License
MIT.