@noteplanco/noteplan-mcp 1.1.23 → 1.1.25

package/dist/tools/attachments.test.js

@@ -1,17 +1,62 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as path from 'path';
 // ── Mocks ──
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    mkdirSync: vi.fn(),
-    writeFileSync: vi.fn(),
-    readFileSync: vi.fn(),
-    readdirSync: vi.fn(),
-    statSync: vi.fn(),
-    renameSync: vi.fn(),
-    copyFileSync: vi.fn(),
-    unlinkSync: vi.fn(),
-    rmdirSync: vi.fn(),
+vi.mock('fs', () => {
+    const sync = {
+        existsSync: vi.fn(),
+        mkdirSync: vi.fn(),
+        writeFileSync: vi.fn(),
+        readFileSync: vi.fn(),
+        readdirSync: vi.fn(),
+        statSync: vi.fn(),
+        renameSync: vi.fn(),
+        copyFileSync: vi.fn(),
+        unlinkSync: vi.fn(),
+        rmdirSync: vi.fn(),
+        rmSync: vi.fn(),
+    };
+    // bridge-fs / attachments use fs.promises after the async cascade. Each
+    // promise variant forwards to the sync mock so existing assertions on
+    // fs.*Sync still pass.
+    const promises = {
+        mkdir: vi.fn(async (p, opts) => sync.mkdirSync(p, opts)),
+        writeFile: vi.fn(async (p, content, opts) => sync.writeFileSync(p, content, opts)),
+        readFile: vi.fn(async (p, opts) => {
+            if (!sync.existsSync(p)) {
+                throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+            }
+            return sync.readFileSync(p, opts);
+        }),
+        readdir: vi.fn(async (p, opts) => sync.readdirSync(p, opts)),
+        stat: vi.fn(async (p) => {
+            if (!sync.existsSync(p))
+                throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' });
+            const explicit = sync.statSync(p) ?? {};
+            // bridge-fs.statPath calls stats.isDirectory(); ensure it exists even
+            // when a test only mocked size/mtime.
+            return {
+                isDirectory: typeof explicit.isDirectory === 'function' ? explicit.isDirectory : () => false,
+                isFile: typeof explicit.isFile === 'function' ? explicit.isFile : () => true,
+                size: explicit.size ?? 0,
+                mtime: explicit.mtime ?? new Date(0),
+                birthtime: explicit.birthtime ?? new Date(0),
+            };
+        }),
+        rename: vi.fn(async (a, b) => sync.renameSync(a, b)),
+        copyFile: vi.fn(async (a, b) => sync.copyFileSync(a, b)),
+        unlink: vi.fn(async (p) => sync.unlinkSync(p)),
+        rm: vi.fn(async (p) => {
+            if (sync.rmSync)
+                sync.rmSync(p, { recursive: true });
+            else
+                sync.unlinkSync(p);
+        }),
+    };
+    return { ...sync, promises };
+});
+vi.mock('../transport/bridge-availability.js', () => ({
+    getBridgeClient: vi.fn(async () => null),
+    invalidateBridgeClient: vi.fn(),
 }));
 vi.mock('../noteplan/unified-store.js', () => ({
     getNote: vi.fn(),
@@ -44,7 +89,7 @@ beforeEach(() => {
 });
 // ── Schema ──
 describe('attachmentsSchema', () => {
-    it('accepts valid input with all fields', () => {
+    it('accepts valid input with all fields', async () => {
         const result = attachmentsSchema.safeParse({
             action: 'add',
             id: '1',
@@ -53,7 +98,7 @@ describe('attachmentsSchema', () => {
         });
         expect(result.success).toBe(true);
     });
-    it('rejects invalid action', () => {
+    it('rejects invalid action', async () => {
         const result = attachmentsSchema.safeParse({ action: 'delete' });
         expect(result.success).toBe(false);
     });
@@ -68,49 +113,49 @@ describe('addAttachment', () => {
         insertLink: false,
         includeData: false,
     };
-    it('returns error when data is missing', () => {
-        const result = addAttachment({ ...baseParams, data: undefined });
+    it('returns error when data is missing', async () => {
+        const result = await addAttachment({ ...baseParams, data: undefined });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/data.*required/i);
     });
-    it('returns error when attachmentFilename is missing', () => {
-        const result = addAttachment({ ...baseParams, attachmentFilename: undefined });
+    it('returns error when attachmentFilename is missing', async () => {
+        const result = await addAttachment({ ...baseParams, attachmentFilename: undefined });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/attachmentFilename.*required/i);
     });
-    it('returns error when note not found', () => {
-        vi.mocked(getNote).mockReturnValue(null);
-        const result = addAttachment(baseParams);
+    it('returns error when note not found', async () => {
+        vi.mocked(getNote).mockResolvedValue(null);
+        const result = await addAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns error for space notes', () => {
-        vi.mocked(getNote).mockReturnValue(mockNote({ source: 'space' }));
-        const result = addAttachment(baseParams);
+    it('returns error for space notes', async () => {
+        vi.mocked(getNote).mockResolvedValue(mockNote({ source: 'space' }));
+        const result = await addAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/space/i);
     });
-    it('returns error when filename sanitizes to empty', () => {
-        vi.mocked(getNote).mockReturnValue(mockNote());
-        const result = addAttachment({ ...baseParams, attachmentFilename: '()[]!' });
+    it('returns error when filename sanitizes to empty', async () => {
+        vi.mocked(getNote).mockResolvedValue(mockNote());
+        const result = await addAttachment({ ...baseParams, attachmentFilename: '()[]!' });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/invalid.*filename/i);
     });
-    it('returns error for empty base64 (zero-length buffer)', () => {
-        vi.mocked(getNote).mockReturnValue(mockNote());
+    it('returns error for empty base64 (zero-length buffer)', async () => {
+        vi.mocked(getNote).mockResolvedValue(mockNote());
         vi.mocked(fs.existsSync).mockReturnValue(true);
         // Use padding-only base64 that decodes to zero bytes
         // Note: An empty string '' is falsy and caught by the !data check first,
         // so we use a whitespace-only string that passes truthiness but decodes to empty
-        const result = addAttachment({ ...baseParams, data: '  ' });
+        const result = await addAttachment({ ...baseParams, data: '  ' });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/empty/i);
     });
-    it('successfully writes attachment and returns correct markdownLink', () => {
+    it('successfully writes attachment and returns correct markdownLink', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
-        const result = addAttachment(baseParams);
+        const result = await addAttachment(baseParams);
         expect(result.success).toBe(true);
         expect(result).toHaveProperty('markdownLink');
         expect(result.markdownLink).toBe('![image](Test%20Note_attachments/photo.png)');
@@ -119,56 +164,52 @@ describe('addAttachment', () => {
         expect(result.noteFilename).toBe('Notes/Test Note.md');
         expect(fs.writeFileSync).toHaveBeenCalled();
     });
-    it('creates the _attachments folder if it does not exist', () => {
+    it('ensures the _attachments parent folder exists when writing', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(false);
-        addAttachment(baseParams);
+        await addAttachment(baseParams);
+        // bridge-fs.writeFileBinary always mkdirs the parent (idempotent with
+        // `recursive: true`) before the write, so the explicit existsSync gate
+        // we used to have is no longer needed.
         expect(fs.mkdirSync).toHaveBeenCalledWith(path.join(NP_PATH, 'Notes', 'Test Note_attachments'), { recursive: true });
     });
-    it('does NOT create folder when it already exists', () => {
+    it('generates correct image markdown link for png/jpg', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
-        vi.mocked(fs.existsSync).mockReturnValue(true);
-        addAttachment(baseParams);
-        expect(fs.mkdirSync).not.toHaveBeenCalled();
-    });
-    it('generates correct image markdown link for png/jpg', () => {
-        const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         for (const ext of ['png', 'jpg', 'jpeg', 'gif', 'webp', 'heic']) {
-            const result = addAttachment({ ...baseParams, attachmentFilename: `photo.${ext}` });
+            const result = await addAttachment({ ...baseParams, attachmentFilename: `photo.${ext}` });
             expect(result.markdownLink).toMatch(/^!\[image\]/);
             expect(result.isImage).toBe(true);
         }
     });
-    it('generates correct file markdown link for pdf/txt', () => {
+    it('generates correct file markdown link for pdf/txt', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         for (const ext of ['pdf', 'txt', 'csv', 'mp3']) {
-            const result = addAttachment({ ...baseParams, attachmentFilename: `doc.${ext}` });
+            const result = await addAttachment({ ...baseParams, attachmentFilename: `doc.${ext}` });
             expect(result.markdownLink).toMatch(/^!\[file\]/);
             expect(result.isImage).toBe(false);
         }
     });
-    it('insertLink=false (default) does NOT modify note content', () => {
+    it('insertLink=false (default) does NOT modify note content', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
-        const result = addAttachment({ ...baseParams, insertLink: false });
+        const result = await addAttachment({ ...baseParams, insertLink: false });
         expect(result.success).toBe(true);
         expect(result.linkInserted).toBe(false);
         // writeFileSync should be called once (for the attachment), not for the note
         expect(vi.mocked(fs.writeFileSync).mock.calls.length).toBe(1);
     });
-    it('insertLink=true appends link to note', () => {
+    it('insertLink=true appends link to note', async () => {
         const note = mockNote({ content: '# Test\n' });
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.readFileSync).mockReturnValue('# Test\n');
-        const result = addAttachment({ ...baseParams, insertLink: true });
+        const result = await addAttachment({ ...baseParams, insertLink: true });
         expect(result.success).toBe(true);
         expect(result.linkInserted).toBe(true);
         // writeFileSync should be called twice: once for attachment, once for note
@@ -177,11 +218,11 @@ describe('addAttachment', () => {
         const writtenContent = noteWriteCall[1];
         expect(writtenContent).toContain('![image](Test%20Note_attachments/photo.png)');
     });
-    it('cleans markdown-conflicting characters from filename', () => {
+    it('cleans markdown-conflicting characters from filename', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
-        const result = addAttachment({
+        const result = await addAttachment({
             ...baseParams,
             attachmentFilename: 'photo (1) [copy]!.png',
         });
@@ -190,11 +231,11 @@ describe('addAttachment', () => {
         expect(result.markdownLink).toBe('![image](Test%20Note_attachments/photo%201%20copy.png)');
         expect(result.attachmentPath).toBe('Test Note_attachments/photo 1 copy.png');
     });
-    it('percent-encodes special characters in the markdown link path', () => {
+    it('percent-encodes special characters in the markdown link path', async () => {
         const note = mockNote({ filename: 'Notes/My (Special) Note.md' });
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
-        const result = addAttachment({ ...baseParams, attachmentFilename: 'file name.png' });
+        const result = await addAttachment({ ...baseParams, attachmentFilename: 'file name.png' });
         expect(result.success).toBe(true);
         // Note name has special chars that get encoded in the path
         // "My (Special) Note_attachments/file name.png"
@@ -210,34 +251,34 @@ describe('listAttachments', () => {
         insertLink: false,
         includeData: false,
     };
-    it('returns error when note not found', () => {
-        vi.mocked(getNote).mockReturnValue(null);
-        const result = listAttachments(baseParams);
+    it('returns error when note not found', async () => {
+        vi.mocked(getNote).mockResolvedValue(null);
+        const result = await listAttachments(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns empty list when _attachments folder does not exist', () => {
-        vi.mocked(getNote).mockReturnValue(mockNote());
+    it('returns empty list when _attachments folder does not exist', async () => {
+        vi.mocked(getNote).mockResolvedValue(mockNote());
         vi.mocked(fs.existsSync).mockReturnValue(false);
-        const result = listAttachments(baseParams);
+        const result = await listAttachments(baseParams);
         expect(result.success).toBe(true);
         expect(result.count).toBe(0);
         expect(result.attachments).toEqual([]);
     });
-    it('lists attachments with correct metadata', () => {
+    it('lists attachments with correct metadata', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         const mockDate = new Date('2024-01-15T10:30:00Z');
         vi.mocked(fs.readdirSync).mockReturnValue([
-            { name: 'photo.png', isFile: () => true },
-            { name: 'doc.pdf', isFile: () => true },
+            { name: 'photo.png', isFile: () => true, isDirectory: () => false },
+            { name: 'doc.pdf', isFile: () => true, isDirectory: () => false },
         ]);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 1024,
             mtime: mockDate,
         });
-        const result = listAttachments(baseParams);
+        const result = await listAttachments(baseParams);
         expect(result.success).toBe(true);
         expect(result.count).toBe(2);
         expect(result.noteFilename).toBe('Notes/Test Note.md');
@@ -253,37 +294,37 @@ describe('listAttachments', () => {
         expect(attachments[1].isImage).toBe(true);
         expect(attachments[1].markdownLink).toBe('![image](Test%20Note_attachments/photo.png)');
     });
-    it('skips hidden files (starting with .)', () => {
+    it('skips hidden files (starting with .)', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.readdirSync).mockReturnValue([
-            { name: '.DS_Store', isFile: () => true },
-            { name: '.hidden', isFile: () => true },
-            { name: 'visible.png', isFile: () => true },
+            { name: '.DS_Store', isFile: () => true, isDirectory: () => false },
+            { name: '.hidden', isFile: () => true, isDirectory: () => false },
+            { name: 'visible.png', isFile: () => true, isDirectory: () => false },
         ]);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 100,
             mtime: new Date(),
         });
-        const result = listAttachments(baseParams);
+        const result = await listAttachments(baseParams);
         expect(result.success).toBe(true);
         expect(result.count).toBe(1);
         expect(result.attachments[0].filename).toBe('visible.png');
     });
-    it('skips directories', () => {
+    it('skips directories', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.readdirSync).mockReturnValue([
-            { name: 'subfolder', isFile: () => false },
-            { name: 'photo.png', isFile: () => true },
+            { name: 'subfolder', isFile: () => false, isDirectory: () => true },
+            { name: 'photo.png', isFile: () => true, isDirectory: () => false },
         ]);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 100,
             mtime: new Date(),
         });
-        const result = listAttachments(baseParams);
+        const result = await listAttachments(baseParams);
         expect(result.success).toBe(true);
         expect(result.count).toBe(1);
     });
@@ -297,33 +338,33 @@ describe('getAttachment', () => {
         insertLink: false,
         includeData: false,
     };
-    it('returns error when attachmentFilename is missing', () => {
-        const result = getAttachment({ ...baseParams, attachmentFilename: undefined });
+    it('returns error when attachmentFilename is missing', async () => {
+        const result = await getAttachment({ ...baseParams, attachmentFilename: undefined });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/attachmentFilename.*required/i);
     });
-    it('returns error when note not found', () => {
-        vi.mocked(getNote).mockReturnValue(null);
-        const result = getAttachment(baseParams);
+    it('returns error when note not found', async () => {
+        vi.mocked(getNote).mockResolvedValue(null);
+        const result = await getAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns error when attachment file does not exist', () => {
-        vi.mocked(getNote).mockReturnValue(mockNote());
+    it('returns error when attachment file does not exist', async () => {
+        vi.mocked(getNote).mockResolvedValue(mockNote());
         vi.mocked(fs.existsSync).mockReturnValue(false);
-        const result = getAttachment(baseParams);
+        const result = await getAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns metadata without data when includeData is false', () => {
+    it('returns metadata without data when includeData is false', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 2048,
             mtime: new Date('2024-06-01T12:00:00Z'),
         });
-        const result = getAttachment({ ...baseParams, includeData: false });
+        const result = await getAttachment({ ...baseParams, includeData: false });
         expect(result.success).toBe(true);
         expect(result.filename).toBe('photo.png');
         expect(result.isImage).toBe(true);
@@ -332,9 +373,9 @@ describe('getAttachment', () => {
         expect(result.markdownLink).toBe('![image](Test%20Note_attachments/photo.png)');
         expect(result).not.toHaveProperty('data');
     });
-    it('returns base64 data when includeData is true', () => {
+    it('returns base64 data when includeData is true', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 100,
@@ -342,13 +383,13 @@ describe('getAttachment', () => {
         });
         const fileBuffer = Buffer.from('file content');
         vi.mocked(fs.readFileSync).mockReturnValue(fileBuffer);
-        const result = getAttachment({ ...baseParams, includeData: true });
+        const result = await getAttachment({ ...baseParams, includeData: true });
         expect(result.success).toBe(true);
         expect(result.data).toBe(fileBuffer.toString('base64'));
     });
-    it('respects maxDataSize - returns dataTruncated=true for large images', () => {
+    it('respects maxDataSize - returns dataTruncated=true for large images', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 5000,
@@ -357,7 +398,7 @@ describe('getAttachment', () => {
         // Create a buffer larger than maxDataSize
         const largeBuffer = Buffer.alloc(5000, 'x');
         vi.mocked(fs.readFileSync).mockReturnValue(largeBuffer);
-        const result = getAttachment({
+        const result = await getAttachment({
             ...baseParams,
             includeData: true,
             maxDataSize: 1000,
@@ -368,9 +409,9 @@ describe('getAttachment', () => {
         expect(result.originalSize).toBe(5000);
         expect(result.hint).toBeDefined();
     });
-    it('does NOT truncate non-image files even if over maxDataSize', () => {
+    it('does NOT truncate non-image files even if over maxDataSize', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 5000,
@@ -378,7 +419,7 @@ describe('getAttachment', () => {
         });
         const largeBuffer = Buffer.alloc(5000, 'x');
         vi.mocked(fs.readFileSync).mockReturnValue(largeBuffer);
-        const result = getAttachment({
+        const result = await getAttachment({
             ...baseParams,
             attachmentFilename: 'doc.pdf',
             includeData: true,
@@ -388,9 +429,9 @@ describe('getAttachment', () => {
         expect(result.data).toBe(largeBuffer.toString('base64'));
         expect(result.dataTruncated).toBeUndefined();
     });
-    it('returns correct MIME type mapping', () => {
+    it('returns correct MIME type mapping', async () => {
         const note = mockNote();
-        vi.mocked(getNote).mockReturnValue(note);
+        vi.mocked(getNote).mockResolvedValue(note);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.statSync).mockReturnValue({
             size: 100,
@@ -412,7 +453,7 @@ describe('getAttachment', () => {
             ['unknown.xyz', 'application/octet-stream'],
         ];
         for (const [filename, expectedMime] of mimeTests) {
-            const result = getAttachment({
+            const result = await getAttachment({
                 ...baseParams,
                 attachmentFilename: filename,
                 includeData: false,
@@ -443,57 +484,57 @@ describe('moveAttachment', () => {
         insertLink: false,
         includeData: false,
     };
-    it('returns error when attachmentFilename is missing', () => {
-        const result = moveAttachment({ ...baseParams, attachmentFilename: undefined });
+    it('returns error when attachmentFilename is missing', async () => {
+        const result = await moveAttachment({ ...baseParams, attachmentFilename: undefined });
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/attachmentFilename.*required/i);
     });
-    it('returns error when source note not found', () => {
-        vi.mocked(getNote).mockReturnValue(null);
-        const result = moveAttachment(baseParams);
+    it('returns error when source note not found', async () => {
+        vi.mocked(getNote).mockResolvedValue(null);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns error when destination note not found', () => {
+    it('returns error when destination note not found', async () => {
         // First call for source returns note, second call for destination returns null
         vi.mocked(getNote)
-            .mockReturnValueOnce(sourceNote)
-            .mockReturnValueOnce(null);
-        const result = moveAttachment(baseParams);
+            .mockResolvedValueOnce(sourceNote)
+            .mockResolvedValueOnce(null);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found/i);
     });
-    it('returns error when attachment file does not exist at source', () => {
+    it('returns error when attachment file does not exist at source', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
         vi.mocked(fs.existsSync).mockReturnValue(false);
-        const result = moveAttachment(baseParams);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(false);
         expect(result.error).toMatch(/not found.*source/i);
     });
-    it('successfully moves file and returns new markdownLink', () => {
+    it('successfully moves file and returns new markdownLink', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.readFileSync).mockReturnValue('# Source\n![image](Source%20Note_attachments/photo.png)\n');
         vi.mocked(fs.readdirSync).mockReturnValue([]);
-        const result = moveAttachment(baseParams);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(true);
         expect(result.markdownLink).toBe('![image](Dest%20Note_attachments/photo.png)');
         expect(result).toHaveProperty('movedFrom', 'Source Note_attachments/photo.png');
         expect(result).toHaveProperty('movedTo', 'Dest Note_attachments/photo.png');
         expect(fs.renameSync).toHaveBeenCalled();
     });
-    it('removes old markdown link from source note content', () => {
+    it('removes old markdown link from source note content', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
         vi.mocked(fs.existsSync).mockReturnValue(true);
         vi.mocked(fs.readFileSync).mockReturnValue('# Source\n![image](Source%20Note_attachments/photo.png)\nMore text\n');
         vi.mocked(fs.readdirSync).mockReturnValue([]);
-        const result = moveAttachment(baseParams);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(true);
         expect(result.oldLinkRemoved).toBe(true);
         // Check that writeFileSync was called for the source note with link removed
@@ -503,7 +544,7 @@ describe('moveAttachment', () => {
         expect(writtenContent).not.toContain('![image](Source%20Note_attachments/photo.png)');
         expect(writtenContent).toContain('More text');
     });
-    it('creates destination folder if needed', () => {
+    it('creates destination folder if needed', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
@@ -516,10 +557,10 @@ describe('moveAttachment', () => {
         });
         vi.mocked(fs.readFileSync).mockReturnValue('# Source\n');
         vi.mocked(fs.readdirSync).mockReturnValue([]);
-        moveAttachment(baseParams);
+        await moveAttachment(baseParams);
         expect(fs.mkdirSync).toHaveBeenCalledWith(path.join(NP_PATH, 'Notes', 'Dest Note_attachments'), { recursive: true });
     });
-    it('cleans up empty source folder after move', () => {
+    it('cleans up empty source folder after move', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
@@ -527,10 +568,10 @@ describe('moveAttachment', () => {
         vi.mocked(fs.readFileSync).mockReturnValue('# Source\n');
         // Empty remaining files after move
         vi.mocked(fs.readdirSync).mockReturnValue([]);
-        moveAttachment(baseParams);
-        expect(fs.rmdirSync).toHaveBeenCalledWith(path.join(NP_PATH, 'Notes', 'Source Note_attachments'));
+        await moveAttachment(baseParams);
+        expect(fs.rmSync).toHaveBeenCalledWith(path.join(NP_PATH, 'Notes', 'Source Note_attachments'), { recursive: true });
     });
-    it('does NOT remove source folder when other files remain', () => {
+    it('does NOT remove source folder when other files remain', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
@@ -538,10 +579,10 @@ describe('moveAttachment', () => {
         vi.mocked(fs.readFileSync).mockReturnValue('# Source\n');
         // Other files remain
         vi.mocked(fs.readdirSync).mockReturnValue(['other.png']);
-        moveAttachment(baseParams);
+        await moveAttachment(baseParams);
         expect(fs.rmdirSync).not.toHaveBeenCalled();
     });
-    it('falls back to copy+unlink when renameSync throws EXDEV', () => {
+    it('falls back to copy+unlink when renameSync throws EXDEV', async () => {
         vi.mocked(getNote)
             .mockReturnValueOnce(sourceNote)
             .mockReturnValueOnce(destNote);
@@ -552,7 +593,7 @@ describe('moveAttachment', () => {
         vi.mocked(fs.renameSync).mockImplementation(() => {
             throw exdevError;
         });
-        const result = moveAttachment(baseParams);
+        const result = await moveAttachment(baseParams);
         expect(result.success).toBe(true);
         expect(fs.copyFileSync).toHaveBeenCalled();
         expect(fs.unlinkSync).toHaveBeenCalled();