mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
Four gaps found by the fourth Codex review of #451: - The check that refuses a target linked to another extra's source ran for import only, so a prepend or append target linked that way had its block written straight into that source. It now runs for every mode that edits the target in place. - Switching a target with a damaged block to symlink or copy recorded the damaged block as the user's restore point, so detaching later brought it back. Recording the restore point now fails on a damaged block. - Appending to a file that ends inside an open code fence put the begin marker inside that fence, so the next sync missed the block and appended another. Such an append is refused. Separately, a block body with an unclosed fence now ends at the end marker whose body matches the block's hash, even when the user's own code follows. - A second prepend block counted its sibling above it as misplacing it, so each sync moved one ahead of the other. Placement now ignores other managed blocks on the same side. Refs #436
371 lines
13 KiB
Go
371 lines
13 KiB
Go
package sync
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/sha256"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
// keepExtraBackups bounds the backups kept per replaced file.
|
|
const keepExtraBackups = 10
|
|
|
|
// extraBackupDir holds the backup history of one file, keyed by a digest of
|
|
// its absolute path: <state>/extras/backups/<digest>/<unix-nano>[.<reason>].bak
|
|
// (the fixed-width time prefix keeps name order time order), plus a
|
|
// "path" file naming the original. The state at attach time is recorded as a
|
|
// "created" marker (no file existed), a "restore" copy of the file that was
|
|
// replaced, or a "restore-link" naming the target of a replaced symlink;
|
|
// restore uses only that record, never a newer history backup.
|
|
func extraBackupDir(path string) string {
|
|
sum := sha256.Sum256([]byte(filepath.Clean(path)))
|
|
return filepath.Join(config.StateDir(), "extras", "backups", fmt.Sprintf("%x", sum[:8]))
|
|
}
|
|
|
|
// Why a history backup was taken; stored in its file name.
|
|
const (
|
|
BackupReasonConvert = "convert" // before a file is converted to or renamed as AGENTS.md
|
|
BackupReasonShim = "shim" // before @AGENTS.md is added to a project file
|
|
BackupReasonImport = "import" // before an @import line is added
|
|
BackupReasonEdit = "edit" // before a dashboard edit
|
|
BackupReasonDelete = "delete" // before a memory note is deleted
|
|
BackupReasonCollect = "collect" // before a target's edit is collected into the shared file
|
|
BackupReasonAttach = "attach" // the file replaced when a target was first attached
|
|
BackupReasonRestore = "restore" // before an older version is restored
|
|
BackupReasonMigrate = "migrate" // before a sync drops settings a release retired
|
|
)
|
|
|
|
// Why a drift backup (an edit skillshare replaced) was taken.
|
|
const (
|
|
DriftReasonOverwrite = "overwrite" // the edit was overwritten from the dashboard
|
|
DriftReasonMode = "mode" // the edit was replaced by a mode switch
|
|
DriftReasonRestore = "restore" // the edit was replaced by restoring the target
|
|
)
|
|
|
|
// extraBackupName returns a new backup file name recording reason.
|
|
func extraBackupName(reason string) string {
|
|
if reason == "" {
|
|
return fmt.Sprintf("%019d.bak", time.Now().UnixNano())
|
|
}
|
|
return fmt.Sprintf("%019d.%s.bak", time.Now().UnixNano(), reason)
|
|
}
|
|
|
|
// backupExtraFile saves the current content of path before skillshare replaces
|
|
// it. A copy identical to the latest backup is not stored again.
|
|
func backupExtraFile(path, reason string) error {
|
|
_, err := storeExtraBackup(path, reason)
|
|
return err
|
|
}
|
|
|
|
// storeExtraBackup is backupExtraFile returning the new backup's file name,
|
|
// or "" when the content matched the latest backup.
|
|
func storeExtraBackup(path, reason string) (string, error) {
|
|
data, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return "", fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
if latest, ok, _ := latestExtraBackup(path); ok && bytes.Equal(latest, data) {
|
|
return "", nil
|
|
}
|
|
dir := extraBackupDir(path)
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
return "", fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "path"), []byte(filepath.Clean(path)), 0644); err != nil {
|
|
return "", fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
name := extraBackupName(reason)
|
|
if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
|
|
return "", fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
pruneExtraBackups(dir)
|
|
return name, nil
|
|
}
|
|
|
|
// backupExtraDrift saves an edited target that skillshare is about to relink.
|
|
// It lives apart from the regular backups so restore never picks it.
|
|
func backupExtraDrift(path, reason string) error {
|
|
data, err := os.ReadFile(path)
|
|
// Preserve link identity even for a dangling link; never read its destination
|
|
// as if it were an edited regular file.
|
|
if dest, linkErr := os.Readlink(path); linkErr == nil {
|
|
kind := "symlink"
|
|
if info, statErr := os.Lstat(path); statErr == nil && info.Mode()&os.ModeSymlink == 0 && utils.IsLinkMode(path, info.Mode()) {
|
|
kind = "junction"
|
|
}
|
|
data, err = []byte(kind+": "+dest+"\n"), nil
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
dir := filepath.Join(extraBackupDir(path), "drift")
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
// The path file lets the file history find a target that has only drift backups.
|
|
if err := os.WriteFile(filepath.Join(extraBackupDir(path), "path"), []byte(filepath.Clean(path)), 0644); err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
name := extraBackupName(reason)
|
|
if err := os.WriteFile(filepath.Join(dir, name), data, 0600); err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
pruneExtraBackups(dir)
|
|
return nil
|
|
}
|
|
|
|
// extraBackupNames returns the backup file names of dir, oldest first.
|
|
func extraBackupNames(dir string) []string {
|
|
entries, _ := os.ReadDir(dir)
|
|
var names []string
|
|
for _, e := range entries {
|
|
if strings.HasSuffix(e.Name(), ".bak") {
|
|
names = append(names, e.Name())
|
|
}
|
|
}
|
|
sort.Strings(names) // zero-padded nanosecond prefixes sort by time
|
|
return names
|
|
}
|
|
|
|
func latestExtraBackup(path string) ([]byte, bool, error) {
|
|
dir := extraBackupDir(path)
|
|
names := extraBackupNames(dir)
|
|
if len(names) == 0 {
|
|
return nil, false, nil
|
|
}
|
|
data, err := os.ReadFile(filepath.Join(dir, names[len(names)-1]))
|
|
if err != nil {
|
|
return nil, false, err
|
|
}
|
|
return data, true, nil
|
|
}
|
|
|
|
// pruneExtraBackups is best effort: a backup that fails to delete only costs
|
|
// disk space.
|
|
func pruneExtraBackups(dir string) {
|
|
names := extraBackupNames(dir)
|
|
for len(names) > keepExtraBackups {
|
|
_ = os.Remove(filepath.Join(dir, names[0]))
|
|
names = names[1:]
|
|
}
|
|
}
|
|
|
|
// Attach-time records, one per target path. Exactly one is kept at a time.
|
|
const (
|
|
attachCreated = "created" // no file existed
|
|
attachRestore = "restore" // copy of the file that was replaced
|
|
attachRestoreJunction = "restore-junction" // original Windows junction
|
|
attachRestoreLink = "restore-link" // link target of a symlink that was replaced
|
|
)
|
|
|
|
func markExtraCreated(path string) error {
|
|
return recordExtraAttach(path, attachCreated, nil, 0644)
|
|
}
|
|
|
|
// recordExtraAttach writes the attach-time record name for path, replacing
|
|
// any other record.
|
|
func recordExtraAttach(path, name string, data []byte, perm os.FileMode) error {
|
|
dir := extraBackupDir(path)
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
return err
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "path"), []byte(filepath.Clean(path)), 0644); err != nil {
|
|
return err
|
|
}
|
|
clearExtraAttach(path)
|
|
return os.WriteFile(filepath.Join(dir, name), data, perm)
|
|
}
|
|
|
|
// recordExtraRestorePoint backs up the file at path when a target is attached
|
|
// over it and records that content as what restore puts back. importLine, left
|
|
// in the file by an earlier import mode, is not part of the user's file and is
|
|
// dropped from the record.
|
|
func recordExtraRestorePoint(f ExtraFile) error {
|
|
path := f.Target
|
|
if err := backupExtraFile(path, BackupReasonAttach); err != nil {
|
|
return err
|
|
}
|
|
data, err := os.ReadFile(path)
|
|
if err == nil {
|
|
// What this extra put there before the mode switch (an import line or
|
|
// a content block) is not the user's file; restoring must not bring it back.
|
|
if stripped, changed := removeImportLine(string(data), f.importLine()); changed {
|
|
data = []byte(stripped)
|
|
}
|
|
// A damaged block cannot be told apart from the user's lines; keeping it
|
|
// in the restore point would bring it back on detach.
|
|
if _, findErr := f.findContentBlock(strings.Split(string(data), "\n")); findErr != nil {
|
|
return findErr
|
|
}
|
|
if stripped, changed := f.removeContentBlock(string(data)); changed {
|
|
data = []byte(stripped)
|
|
}
|
|
err = recordExtraAttach(path, attachRestore, data, 0600)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// recordExtraRestoreLink records the symlink at path, which is not ours, as
|
|
// what restore puts back.
|
|
func recordExtraRestoreLink(path string) error {
|
|
dest, err := os.Readlink(path)
|
|
if err == nil {
|
|
kind := attachRestoreLink
|
|
if info, statErr := os.Lstat(path); statErr == nil && info.Mode()&os.ModeSymlink == 0 && utils.IsLinkMode(path, info.Mode()) {
|
|
kind = attachRestoreJunction
|
|
}
|
|
err = recordExtraAttach(path, kind, []byte(dest), 0644)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("back up %s: %w", path, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// extraAttached reports whether an attach-time state is recorded for path.
|
|
func extraAttached(path string) bool {
|
|
dir := extraBackupDir(path)
|
|
for _, name := range []string{attachCreated, attachRestore, attachRestoreLink, attachRestoreJunction} {
|
|
if _, err := os.Stat(filepath.Join(dir, name)); err == nil {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// putBackExtraRestorePoint recreates at path (which must not exist) the state
|
|
// recorded at attach time: the replaced file, the replaced symlink, or nothing
|
|
// when no file existed. Without a record it falls back to the latest backup.
|
|
// The record is dropped once restored.
|
|
func putBackExtraRestorePoint(path string) error {
|
|
dir := extraBackupDir(path)
|
|
switch {
|
|
case extraCreated(path):
|
|
case fileExists(filepath.Join(dir, attachRestoreJunction)):
|
|
dest, err := os.ReadFile(filepath.Join(dir, attachRestoreJunction))
|
|
if err == nil {
|
|
err = utils.CreateJunction(path, string(dest))
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("failed to restore %s: %w", path, err)
|
|
}
|
|
case fileExists(filepath.Join(dir, attachRestoreLink)):
|
|
dest, err := os.ReadFile(filepath.Join(dir, attachRestoreLink))
|
|
if err == nil {
|
|
err = os.Symlink(string(dest), path)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("failed to restore %s: %w", path, err)
|
|
}
|
|
default:
|
|
data, err := os.ReadFile(filepath.Join(dir, attachRestore))
|
|
ok := err == nil
|
|
if os.IsNotExist(err) {
|
|
data, ok, err = latestExtraBackup(path)
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("failed to read backup of %s: %w", path, err)
|
|
}
|
|
if ok {
|
|
if err := os.WriteFile(path, data, 0644); err != nil {
|
|
return fmt.Errorf("failed to restore %s: %w", path, err)
|
|
}
|
|
}
|
|
}
|
|
clearExtraAttach(path)
|
|
return nil
|
|
}
|
|
|
|
func fileExists(path string) bool {
|
|
_, err := os.Lstat(path)
|
|
return err == nil
|
|
}
|
|
|
|
// clearExtraAttach drops the attach-time record of path.
|
|
func clearExtraAttach(path string) {
|
|
dir := extraBackupDir(path)
|
|
for _, name := range []string{attachCreated, attachRestore, attachRestoreLink, attachRestoreJunction, extraWritten, extraImportBase} {
|
|
_ = os.Remove(filepath.Join(dir, name))
|
|
}
|
|
}
|
|
|
|
// extraWritten holds the hash of the copy skillshare last wrote at a target,
|
|
// so a later sync can tell its own unedited copy from a user edit.
|
|
const extraWritten = "written"
|
|
|
|
// recordExtraWritten remembers the file now at path as skillshare's copy.
|
|
func recordExtraWritten(path string) error {
|
|
h, err := utils.FileHash(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(filepath.Join(extraBackupDir(path), extraWritten), []byte(h), 0644)
|
|
}
|
|
|
|
func clearExtraWritten(path string) {
|
|
_ = os.Remove(filepath.Join(extraBackupDir(path), extraWritten))
|
|
}
|
|
|
|
// extraImportBase holds the target's own content (without this extra's
|
|
// import line) when it left import mode, so switching back rebuilds the file
|
|
// as it was then rather than as it was at attach time. Restore ignores it.
|
|
const extraImportBase = "import-base"
|
|
|
|
func recordExtraImportBase(path, content string) error {
|
|
dir := extraBackupDir(path)
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
return err
|
|
}
|
|
return os.WriteFile(filepath.Join(dir, extraImportBase), []byte(content), 0600)
|
|
}
|
|
|
|
func clearExtraImportBase(path string) {
|
|
_ = os.Remove(filepath.Join(extraBackupDir(path), extraImportBase))
|
|
}
|
|
|
|
func hasExtraWritten(path string) bool {
|
|
return fileExists(filepath.Join(extraBackupDir(path), extraWritten))
|
|
}
|
|
|
|
// extraRestoreBase returns the file content to rebuild when switching back to
|
|
// import: the content recorded when the target left import mode, else the one
|
|
// recorded at attach time, or "" when no file existed or a link was replaced
|
|
// (a link's content is not the user's to rebuild).
|
|
func extraRestoreBase(path string) string {
|
|
dir := extraBackupDir(path)
|
|
if data, err := os.ReadFile(filepath.Join(dir, extraImportBase)); err == nil {
|
|
return string(data)
|
|
}
|
|
data, err := os.ReadFile(filepath.Join(dir, attachRestore))
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
return string(data)
|
|
}
|
|
|
|
// isOurExtraCopy reports whether the file at path is still exactly the copy
|
|
// skillshare last wrote there.
|
|
func isOurExtraCopy(path string) bool {
|
|
want, err := os.ReadFile(filepath.Join(extraBackupDir(path), extraWritten))
|
|
if err != nil {
|
|
return false
|
|
}
|
|
h, err := utils.FileHash(path)
|
|
return err == nil && h == string(want)
|
|
}
|
|
|
|
func extraCreated(path string) bool {
|
|
_, err := os.Stat(filepath.Join(extraBackupDir(path), "created"))
|
|
return err == nil
|
|
}
|