SYNCPROOF 1.0.0 Verified Copy & Sync - Team variant =============================================================================== WHAT IT IS SyncProof pushes ONE source tree to MANY destinations in a single run and verifies every destination INDEPENDENTLY by SHA-256, then prints a per-destination pass/fail matrix. The team scenario it is built for: you push a build to three shares and one of them silently comes out bad. Tools that handle a single destination make you run them three times and correlate three reports by hand. SyncProof does the fan-out in one pass, isolates faults per destination, and tells you exactly which share is bad and which file on it is wrong. How it differs from the rest of the product line: CopySure - verified parallel copy + diff, ONE destination FolderSync - directory synchronisation, ONE destination MoveGuard - verified move, ONE destination TransferForge - transfer pipeline, ONE destination SyncProof - N destinations at once, independent per-destination verification, one pass/fail matrix, per-destination fault isolation ------------------------------------------------------------------------------- USAGE syncproof push --dest [--dest ...] [--workers N] [--apply] [--json] syncproof verify --dest [--dest ...] [--workers N] [--json] syncproof help | -h | --help syncproof version COMMANDS push Copy every file in to EVERY destination, then re-READ each written file from the destination and compare its SHA-256 against the source. DRY RUN unless --apply is given. verify No copying at all. For each destination, report which files match, which are corrupted (hash differs) and which are missing. FLAGS --dest PATH Destination root. Repeat the flag once per destination. At least one is required. --workers N Number of parallel workers across all destination/file pairs. Default: number of CPUs, capped at 8. --apply Actually write. Without it, push only reports what it would do. --json Machine-readable report on stdout instead of the table. Flags may appear before or after the positional source, and both -flag and --flag spellings are accepted. EXIT CODES 0 every destination verified OK (or a dry run completed) 1 usage error, unreadable source, bad arguments 2 at least one destination FAILED: it has corrupted files, missing files, or files that could not be written EXAMPLES # See what would happen - writes nothing syncproof push ./build --dest /mnt/share-a --dest /mnt/share-b --dest /mnt/share-c # Do it for real syncproof push ./build --dest /mnt/share-a --dest /mnt/share-b --dest /mnt/share-c --apply # Later: are all three shares still intact? syncproof verify ./build --dest /mnt/share-a --dest /mnt/share-b --dest /mnt/share-c # Wire it into a script syncproof verify ./build --dest /mnt/share-a --dest /mnt/share-b --json ------------------------------------------------------------------------------- WHAT IS IMPLEMENTED * Multi-destination fan-out. One source, any number of --dest roots, copied and verified in a single run. * Independent per-destination verification. Every destination is judged on its own: one bad share never masks or blocks the others. * Real read-back verification. After a file is written, SyncProof re-opens it from the destination and hashes what actually landed there. It does not trust the write call, and it does not compare size or timestamps only. * SHA-256 for every file, computed once on the source and once per destination copy. * Pass/fail matrix: destination, status, files, copied, skipped, verified, mismatch, missing, errors - plus the names of the offending files and the reason each destination failed. * Fault isolation. A destination that cannot be created, or a directory that cannot be made inside it, fails only that destination with a reason; the remaining destinations still complete and verify. * Dry run by default. push writes nothing at all without --apply: no files, no directories, not even the destination root. * Crash-safe writes. Each file is written to ".part" and renamed onto the real name only after the data is flushed and closed, so a real filename never holds a half-written file. A failed copy removes its own .part file. * Idempotent re-push. A destination file whose size and SHA-256 already match the source is reported as SKIPPED and is not rewritten. Re-running a push repairs only the files that are corrupted or missing. * Nested directory trees, including empty directories, are replicated. * Unix file permission bits are carried over from the source file. * Parallel execution with --workers across all destination/file pairs. * --json output for scripting: per-destination counters, per-file problems, summary and exit code. * Refuses obviously wrong invocations: a destination equal to or inside the source tree, the same destination given twice, a non-directory source, zero destinations. WHAT IS NOT IMPLEMENTED (ROADMAP) * Network / SMB destinations with credentials. Destinations must be local paths today, which includes an already-mounted network share; SyncProof cannot dial a UNC path or authenticate to a server itself. * Bandwidth throttling per destination. Copies run at full speed; there is no per-destination rate limit or global cap. * Delta / block-level transfer. A file that differs at all is copied whole. There is no rolling-checksum or block-diff transfer. * Scheduled runs. There is no built-in scheduler, daemon or watch mode; use cron, systemd timers or Task Scheduler. OTHER CURRENT LIMITS, STATED PLAINLY * Symlinks, devices, sockets and FIFOs are skipped, not recreated. They are counted and noted in the output. * Extra files that exist in a destination but not in the source are left alone. SyncProof never deletes anything; there is no --mirror or --delete. * Modification times are not preserved and are not part of verification. * Windows ACLs, alternate data streams and extended attributes are not copied. * The source is assumed not to change while a run is in progress. * Nothing is resumed: an interrupted run leaves whole files already written (verified) and no partial file at a real name. Re-run push --apply to finish; already-good files are skipped. ------------------------------------------------------------------------------- HOW A RUN READS DESTINATION STATUS FILES COPIED SKIPPED VERIFIED MISMATCH MISSING ERRORS /mnt/share-a OK 9 9 0 9 0 0 0 /mnt/share-b FAILED 9 0 0 0 0 0 9 /mnt/share-c OK 9 9 0 9 0 0 0 FILES files found in the source COPIED files written to this destination in this run (shown as TO-COPY in a dry run) SKIPPED files already byte-identical at this destination, left untouched VERIFIED files confirmed by SHA-256 to match the source right now MISMATCH files present but with the wrong contents (corrupted) MISSING files absent from this destination ERRORS files that could not be written or read A destination is OK only when MISMATCH, MISSING and ERRORS are all zero. Any FAILED destination sets the process exit code to 2. ------------------------------------------------------------------------------- BUILD go build -o syncproof . Go standard library only. No third-party dependencies, no network access required at build time or run time. Cross-compiled binaries in dist/: syncproof-linux-amd64 syncproof-darwin-amd64 syncproof-darwin-arm64 syncproof-windows-amd64.exe