From 8b0582a524603a543f244f210225fbb6f06d6deb Mon Sep 17 00:00:00 2001 From: Adib Hanna Date: Fri, 20 Nov 2026 12:03:10 -0600 Subject: [PATCH] Fix(vault): a note made again under a deleted note's name gets its own date on Windows NTFS hands a file created or renamed into a name deleted in the last 15 seconds the old file's birthtime (file system tunneling). zn cleared a new note's creation record and left its date to that birthtime, so a note deleted and made again under the same name showed the old note's date, and its next save wrote that date into the record for good. The desktop app had the same gap and closes it in the same change. writeNoteFileAtomic, which every note write goes through (CreateNote, WriteNote, the MCP tools), now records now as the creation date when the note does not exist yet, replacing any record an earlier note of the name left. A note that exists keeps the date it had, as before. A note made outside zn still falls back to the file's times. TestNewNoteRecordsItsOwnCreationDate fails without the fix: the record is missing right after CreateNote and after a first WriteNote. --- internal/vault/note_metadata.go | 23 +++++++++---- internal/vault/note_metadata_test.go | 50 ++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 7 deletions(-) diff --git a/internal/vault/note_metadata.go b/internal/vault/note_metadata.go index 9c4faa0..1db70ce 100644 --- a/internal/vault/note_metadata.go +++ b/internal/vault/note_metadata.go @@ -7,6 +7,7 @@ import ( "os" "path/filepath" "strings" + "time" ) const noteMetadataDir = "note-metadata" @@ -64,7 +65,12 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { // before replacing the note, so a new inode cannot seed a newer date here. info, err := os.Stat(abs) if errors.Is(err, os.ErrNotExist) { - if err := os.Remove(metadataPath); err != nil && !errors.Is(err, os.ErrNotExist) { + // A new note records now rather than leaving its date to the file's + // birthtime. On NTFS a file made under a name deleted in the last 15 + // seconds gets the deleted file's birthtime back (file system + // tunneling), and the next save would write that date down for good. + // This replaces any record an earlier note of the name left behind. + if err := v.writeCreationMetadata(metadataPath, time.Now().UnixMilli()); err != nil { return err } } else if err != nil { @@ -76,12 +82,7 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { return err } if created == 0 { - created = originalCreatedAt - raw, err := json.Marshal(noteCreationMetadata{Version: 1, CreatedAt: created}) - if err != nil { - return err - } - if err := writeFileAtomic(metadataPath, append(raw, '\n'), v.fileMode, v.dirMode); err != nil { + if err := v.writeCreationMetadata(metadataPath, originalCreatedAt); err != nil { return err } } @@ -89,6 +90,14 @@ func (v *Vault) writeNoteFileAtomic(abs string, data []byte) error { return writeFileAtomic(abs, data, v.fileMode, v.dirMode) } +func (v *Vault) writeCreationMetadata(metadataPath string, createdAt int64) error { + raw, err := json.Marshal(noteCreationMetadata{Version: 1, CreatedAt: createdAt}) + if err != nil { + return err + } + return writeFileAtomic(metadataPath, append(raw, '\n'), v.fileMode, v.dirMode) +} + // Move the sidecar in the same transaction as its note or folder. If metadata // cannot move, keep the content at its original path rather than losing its date. func (v *Vault) relocateWithMetadata(from, to string, directory bool) error { diff --git a/internal/vault/note_metadata_test.go b/internal/vault/note_metadata_test.go index 31d5ef7..29cf518 100644 --- a/internal/vault/note_metadata_test.go +++ b/internal/vault/note_metadata_test.go @@ -4,6 +4,7 @@ import ( "os" "path/filepath" "testing" + "time" ) const originalCreatedAt int64 = 1600000000123 @@ -82,6 +83,55 @@ func TestNoteCreationMetadataSurvivesWritesAndLifecycle(t *testing.T) { } } +// On NTFS a file made under a name deleted in the last 15 seconds gets the +// deleted file's birthtime back (file system tunneling), so a new note's date +// cannot come from the file. Each way of making one records it in the sidecar +// at once, and the first save keeps that record. +func TestNewNoteRecordsItsOwnCreationDate(t *testing.T) { + create := map[string]func(v *Vault) (NoteMeta, error){ + "CreateNote": func(v *Vault) (NoteMeta, error) { return v.CreateNote(FolderInbox, "Original", "", nil) }, + "WriteNote": func(v *Vault) (NoteMeta, error) { return v.WriteNote("inbox/Original.md", "# Original\n") }, + } + for name, make := range create { + t.Run(name, func(t *testing.T) { + v := newTestVault(t) + rel := "inbox/Original.md" + writeFile(t, filepath.Join(v.root, rel), "# Original\n") + seedNoteMetadata(t, v, rel) + if err := v.DeleteNote(rel); err != nil { + t.Fatal(err) + } + before := time.Now().UnixMilli() + meta, err := make(v) + after := time.Now().UnixMilli() + if err != nil { + t.Fatal(err) + } + if meta.Path != rel { + t.Fatalf("path = %s, want %s", meta.Path, rel) + } + sidecar := filepath.Join(v.root, ".zennotes", "note-metadata", rel+".metadata.json") + recorded, err := readCreationMetadata(sidecar) + if err != nil { + t.Fatal(err) + } + if recorded < before || recorded > after { + t.Fatalf("recorded createdAt = %d, want between %d and %d", recorded, before, after) + } + if meta.CreatedAt != recorded { + t.Fatalf("createdAt = %d, want the recorded %d", meta.CreatedAt, recorded) + } + saved, err := v.WriteNote(rel, "# Original\n\nEdited.\n") + if err != nil { + t.Fatal(err) + } + if saved.CreatedAt != recorded { + t.Fatalf("after a save createdAt = %d, want %d", saved.CreatedAt, recorded) + } + }) + } +} + func TestNoteMetadataCorruptionDoesNotMutateNote(t *testing.T) { v := newTestVault(t) rel := "inbox/Original.md"