Your code folder, current on every machine.
Synchronize complete Git worktrees through a hub you control. No account, hosted control plane, or silent conflict overwrite.
~/Codecleanseq 1842durableseq 1842src/v2/engine.ts3 chunks transferred967 msGit carries history. Code Folder Sync carries work in progress.
Commits are excellent durable checkpoints. They are awkward as a handoff for half-finished code, an unstaged refactor, a changed index, or the exact context an agent needs right now.
Code Folder Sync keeps that live state aligned across a trusted fleet while Git continues doing the job it was built for.
Complete working state, moved deliberately.
Six narrow guarantees make the whole folder dependable across a trusted fleet.
Mirrors the working tree
Repositories, uncommitted work, branches, refs, indexes, symlinks, executable files, and local project state travel together.
Moves only changed content
Content-defined chunks reuse accepted bytes. A small edit does not resend a large file or the rest of the folder.
Keeps both versions
Concurrent ordinary edits become deterministic CODEFOLDERSYNC-CONFLICT siblings. No line merge and no last-writer guess.
Treats Git as a transaction
The .git directory transfers incrementally, then stages, validates, and swaps as one recoverable state.
Works through your SSH access
A persistent framed SSH process reaches a hub directory on a machine you operate. There is no account or hosted control plane.
Queues work while offline
Objects and causal events remain in a durable local outbox. Reconnect retries the same identity instead of inventing a winner.
Build once. Create a hub. Join every other machine.
Install the same version on peers and the hub host, then let the setup wizard validate filesystem behavior before it writes any configuration.
corepack pnpm install
pnpm check
pnpm build
node dist/product-cli.js install
~/.local/bin/codefoldersync --versionCreate the folder
Point setup at the parent containing your direct-child Git repositories and choose a local path or SSH hub.
Join an empty peer
Use the folder ID on another machine. An empty destination receives the exact accepted worktree and Git state.
Keep the daemon running
A per-folder user service watches stable saves, publishes deltas, and reconciles metadata periodically.
One current tree for humans, remotes, and coding agents.
Move between machines without converting every context switch into a temporary commit or a hand-written file transfer.
Laptop to build machine
Continue an uncommitted change on a faster remote host with the same branches, refs, index, and local project files.
- Direct SSH transport
- Chunk reuse after first join
- Durable offline queue
Human to coding agent
Give an agent host the exact workspace you see, then receive its saved changes through the same causal conflict rules.
- No special agent integration
- Normal files stay normal files
- Competing edits remain visible
Machine replacement
Join a fresh empty destination from retained hub state instead of reconstructing each repository and uncommitted change.
- Exact symlink target text
- Transactional Git validation
- Full verification command
The safety boundary is explicit.
This is infrastructure for a small trusted fleet. It fails closed when it cannot prove that a path, object, Git state, or causal transition is safe.
Questions, answered directly.
Does Code Folder Sync replace Git?
No. Git remains your history and collaboration system. Code Folder Sync mirrors the live filesystem state around it, including the complete .git directory, so another trusted machine can continue from the same working state.
Is there an account or hosted service?
No. Peers use a local directory or your existing SSH access to a hub directory on a machine you control. There is no signup, browser flow, billing system, or hosted control plane.
Can the hub read my files?
Yes. Hub content is plaintext and inherits that machine’s filesystem permissions, disk encryption, and backup policy. SSH authenticates the machine and encrypts transport, but Code Folder Sync does not add end-to-end encryption.
What happens when two machines edit the same file?
The first causally valid event keeps the original path. Every stale competing version is preserved beside it with a deterministic CODEFOLDERSYNC-CONFLICT name that you resolve with normal tools.
Can I sync any arbitrary folder?
Version 2 intentionally supports one parent folder containing explicitly enrolled direct-child Git repositories with in-tree .git directories. That narrow boundary makes membership, Git handling, path safety, and recovery provable.
Which systems are supported?
The current installation contract supports Linux x86-64 and macOS arm64 with Node.js 22 or newer, Git, and SSH access when the hub is remote.
Put every trusted machine on the same working tree.
Start with a local hub, understand the safety boundary, then join the machines where you actually work.