Fix(assets): every device links an attached file the same way

Attaching or dropping a file wrote a different link depending on which
surface you did it from. Paste, and an existing asset dragged in from the
sidebar, embedded a vault-relative wikilink; a drop wrote a markdown link
with a path relative to the note, `![pic](<../assets/pic.png>)`, and the
self-hosted server produced that same note-relative form for the web
client. The mobile apps had a third answer again. Same file, same folder,
three different links.

The note-relative form was also wrong, not merely different: nothing
rewrites relative asset paths when a note moves, so `../assets/pic.png`
broke the moment the note changed depth.

So there is now one rule, everywhere: the file lands in `assets/` and is
linked by VAULT-relative path, an image as `![[assets/pic.png]]` and
anything else as `[name](<assets/report.pdf>)`. That is what paste and
the sidebar drag already wrote, so this moves the odd routes onto the
form the app already used most.

Existing notes are unaffected: resolveAssetVaultRelativePath tries
note-relative, then vault-root, then a unique basename, so both the old
and the new form keep resolving on both rendering surfaces.

`ImportAsset` no longer reads notePath, since where the note lives can no
longer change what is written; it stays in the signature because the
handler and clients still send it. The matching mobile fixes ship in the
zennotesandroid and zennotesios repos.

Claude-Session: https://claude.ai/code/session_01AYTRixg5TJmxn2j6FCqfUD

Author: adibhanna

apps/desktop/src/main/vault.test.ts

@@ -442,7 +442,7 @@ describe('importFiles', () => {
     await expect(readFile(path.join(root, 'Diagram.png'))).rejects.toThrow()
   })
 
-  it('stores in assets/ for an inbox-mode note too, linked relative to the note', async () => {
+  it('stores in assets/ for an inbox-mode note too, linked by vault-relative wikilink', async () => {
     const root = await makeTempDir('zennotes-import-files-inbox-')
     await ensureVaultLayout(root)
     const srcDir = await makeTempDir('zennotes-import-src-inbox-')
@@ -452,8 +452,9 @@ describe('importFiles', () => {
     const imported = await importFiles(root, 'inbox/Note.md', [src])
 
     expect(imported[0]?.path).toBe('assets/Photo.png')
-    // Note in inbox/, asset in assets/, so the link steps up a level.
-    expect(imported[0]?.markdown).toContain('../assets/Photo.png')
+    // A dropped image embeds by vault-relative wikilink, the same form paste
+    // and the mobile apps write, so the link survives the note being moved.
+    expect(imported[0]?.markdown).toBe('![[assets/Photo.png]]')
     await expect(readFile(path.join(root, 'assets/Photo.png'))).resolves.toEqual(
       Buffer.from([1, 2, 3])
     )

apps/desktop/src/main/vault.ts

@@ -3405,16 +3405,27 @@ function cleanDeletedAssetToken(token: string): string {
   return token
 }
 
+/**
+ * The link written for a file dragged or attached into a note, by VAULT-relative
+ * path: an image as a wikilink, anything else as a markdown link.
+ *
+ * This is the one rule every route now follows, on every platform: paste here,
+ * an existing asset dragged in from the sidebar
+ * (`importedAssetForExistingVaultAsset`), the server's own import, and both
+ * mobile apps. A drop used to be the odd one out, writing a path relative to
+ * the note, so the same file looked different depending on how it entered the
+ * note and the link broke as soon as the note moved to another depth, because
+ * nothing rewrites relative asset paths on move. Both forms resolve
+ * (`resolveAssetVaultRelativePath` tries note-relative, then vault-root, then a
+ * unique basename), so this is safe for links already in existing notes.
+ */
 function markdownForImportedAsset(
-  relativeFromNote: string,
+  vaultRelPath: string,
   filename: string,
   kind: ImportedAssetKind
 ): string {
-  const destination = markdownDestination(relativeFromNote)
-  if (kind === 'image') {
-    return `![${path.basename(filename, path.extname(filename))}](${destination})`
-  }
-  return `[${filename}](${destination})`
+  if (kind === 'image') return `![[${vaultRelPath}]]`
+  return `[${filename}](${markdownDestination(vaultRelPath)})`
 }
 
 // The naming lives in @shared/pasted-image so the web client produces the
@@ -4261,7 +4272,6 @@ export async function importFiles(
 ): Promise<ImportedAsset[]> {
   await fs.mkdir(root, { recursive: true })
 
-  const noteDir = path.posix.dirname(toPosix(noteRelPath))
   const imported: ImportedAsset[] = []
   // Dropped files land in the unified `assets/` folder, matching pasted images
   // (`importPastedImage`). They used to be copied to the vault root, which in
@@ -4280,15 +4290,11 @@ export async function importFiles(
     await fs.copyFile(sourceAbs, destAbs)
 
     const vaultRelPath = toPosix(path.relative(root, destAbs))
-    const relativeFromNote = path.posix.relative(
-      noteDir === '.' ? '' : noteDir,
-      vaultRelPath
-    )
     const kind = classifyImportedAsset(finalName)
     imported.push({
       name: finalName,
       path: vaultRelPath,
-      markdown: markdownForImportedAsset(relativeFromNote, finalName, kind),
+      markdown: markdownForImportedAsset(vaultRelPath, finalName, kind),
       kind
     })
   }

apps/server/internal/vault/vault.go

@@ -2521,7 +2521,11 @@ func (v *Vault) SearchText(query string) ([]TextSearchMatch, error) {
 // mirrors the desktop importFiles/importPastedImage (#377): uploads used to
 // land at the vault root, which in Vault Root mode dumped them right next to
 // the notes.
+// notePath is no longer read: the link is vault-relative now, so where the note
+// lives does not change what gets written. It stays in the signature because
+// the HTTP handler and clients still send it.
 func (v *Vault) ImportAsset(notePath, filename string, body io.Reader) (ImportedAsset, error) {
+	_ = notePath
 	v.mu.Lock()
 	defer v.mu.Unlock()
 	assetsAbs := filepath.Join(v.root, AssetsDir)
@@ -2562,18 +2566,8 @@ func (v *Vault) ImportAsset(notePath, filename string, body io.Reader) (Imported
 		return ImportedAsset{}, err
 	}
 	rel := filepath.ToSlash(relFromRoot)
-	noteDir := filepath.Dir(filepath.FromSlash(notePath))
-	if noteDir == "." {
-		noteDir = ""
-	}
-	markdownPath := rel
-	if noteDir != "" {
-		if relative, err := filepath.Rel(noteDir, rel); err == nil {
-			markdownPath = filepath.ToSlash(relative)
-		}
-	}
 	kind := kindForExt(strings.ToLower(filepath.Ext(abs)))
-	markdown := makeAssetMarkdown(markdownPath, kind, filepath.Base(abs))
+	markdown := makeAssetMarkdown(rel, kind, filepath.Base(abs))
 	return ImportedAsset{
 		Name:     filepath.Base(abs),
 		Path:     rel,
@@ -2740,14 +2734,17 @@ func cleanAssetFilename(name string) (string, error) {
 	return trimmed, nil
 }
 
-func makeAssetMarkdown(relPath, kind, name string) string {
-	dest := "<" + strings.ReplaceAll(relPath, ">", "%3E") + ">"
-	switch kind {
-	case "image":
-		return "![" + name + "](" + dest + ")"
-	default:
-		return "[" + name + "](" + dest + ")"
+// makeAssetMarkdown mirrors the desktop markdownForImportedAsset: everything is
+// linked by VAULT-relative path, an image as a wikilink and anything else as a
+// markdown link, which is the single form every client now writes. The link
+// used to be relative to the note, so it broke as soon as the note moved to
+// another depth (nothing rewrites relative asset paths on move).
+func makeAssetMarkdown(vaultRelPath, kind, name string) string {
+	if kind == "image" {
+		return "![[" + vaultRelPath + "]]"
 	}
+	dest := "<" + strings.ReplaceAll(vaultRelPath, ">", "%3E") + ">"
+	return "[" + name + "](" + dest + ")"
 }
 
 // --- Misc helpers ---

apps/server/internal/vault/vault_test.go

@@ -111,13 +111,38 @@ func TestImportAssetWithinLimit(t *testing.T) {
 	if !bytes.Equal(got, body) {
 		t.Fatalf("written bytes differ from input")
 	}
-	// The embed markdown is relative to the note's directory: a root-level
-	// note links straight into assets/.
+	// A non-image keeps the note-relative markdown link: a root-level note
+	// links straight into assets/.
 	if asset.Markdown == "" || !strings.Contains(asset.Markdown, "assets/x.bin") {
 		t.Fatalf("markdown = %q, want a link into assets/", asset.Markdown)
 	}
 }
 
+// An image embeds by vault-relative wikilink whatever folder the note is in,
+// matching the desktop and both mobile apps, so moving the note cannot break
+// the link (nothing rewrites relative asset paths on move).
+func TestImportAssetEmbedsImagesByVaultRelativeWikilink(t *testing.T) {
+	root := t.TempDir()
+	v, err := New(root, Options{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	png := []byte{0x89, 'P', 'N', 'G'}
+	for _, notePath := range []string{"Note.md", "inbox/Note.md", "inbox/deep/Note.md"} {
+		asset, err := v.ImportAsset(notePath, "Photo.png", bytes.NewReader(png))
+		if err != nil {
+			t.Fatalf("%s: %v", notePath, err)
+		}
+		want := "![[" + asset.Path + "]]"
+		if asset.Markdown != want {
+			t.Fatalf("%s: markdown = %q, want %q", notePath, asset.Markdown, want)
+		}
+		if strings.Contains(asset.Markdown, "../") {
+			t.Fatalf("%s: markdown = %q, must not be note-relative", notePath, asset.Markdown)
+		}
+	}
+}
+
 func TestImportAssetReportsAtBoundary(t *testing.T) {
 	root := t.TempDir()
 	v, err := New(root, Options{MaxAssetBytes: 8})