apple-notes-mcp 1.4.0 → 1.4.1

package/README.md

@@ -812,7 +812,7 @@ The `\\\\` in JSON becomes `\\` in the actual string, which represents a single
 ```bash
 npm install      # Install dependencies
 npm run build    # Compile TypeScript
-npm test         # Run test suite (310 tests)
+npm test         # Run test suite (313 tests)
 npm run lint     # Check code style
 npm run format   # Format code
 ```

package/build/index.js

@@ -454,10 +454,16 @@ server.tool("list-folders", {
     return successResponse(`Found ${folders.length} folders${acct}:\n${folderList}${syncNote}`);
 }, "Error listing folders"));
 // --- create-folder ---
-server.tool("create-folder", folderNameSchema, withErrorHandling(({ name, account }) => {
+server.tool("create-folder", {
+    name: z
+        .string()
+        .min(1, "Folder name is required")
+        .describe('Folder name or nested path separated by "/". E.g., "Retro Tech/PC/CPUs" creates all intermediate folders. Existing segments are skipped.'),
+    account: z.string().optional().describe("Account name (defaults to iCloud)"),
+}, withErrorHandling(({ name, account }) => {
     const folder = notesManager.createFolder(name, account);
     if (!folder) {
-        return errorResponse(`Failed to create folder "${name}". It may already exist.`);
+        return errorResponse(`Failed to create folder "${name}".`);
     }
     return successResponse(`Folder created: "${folder.name}"`);
 }, "Error creating folder"));

package/build/services/appleNotesManager.js

@@ -539,11 +539,11 @@ export class AppleNotesManager {
         let createCommand;
         if (folder) {
             // Create note in specific folder (supports nested paths like "Work/Clients")
+            // Note: We avoid `set newNote` + `return id of newNote` because AppleScript
+            // fails to resolve the note reference in deeply nested folder contexts (-1728).
+            // The implicit return from `make new note` includes the ID which we parse.
             const folderRef = buildFolderReference(folder);
-            createCommand = `
-        set newNote to make new note at ${folderRef} with properties {body:"${safeBody}"}
-        return id of newNote
-      `;
+            createCommand = `make new note at ${folderRef} with properties {body:"${safeBody}"}`;
         }
         else {
             // Create note in default location
@@ -1194,16 +1194,52 @@ export class AppleNotesManager {
      */
     createFolder(name, account) {
         const targetAccount = this.resolveAccount(account);
-        const safeName = escapeForAppleScript(name);
-        const createCommand = `make new folder with properties {name:"${safeName}"}`;
-        const script = buildAccountScopedScript({ account: targetAccount }, createCommand);
-        const result = executeAppleScript(script);
-        if (!result.success) {
-            console.error(`Failed to create folder "${name}":`, result.error);
+        const parts = splitFolderPath(name);
+        if (parts.length === 0) {
+            console.error(`Invalid folder name: "${name}"`);
             return null;
         }
-        // Extract the folder ID from the response
-        const folderId = extractCoreDataId(result.output, "folder");
+        // Create each segment of the path, checking existence first to avoid duplicates.
+        // For "A/B/C": ensure "A" exists, then "A/B", then "A/B/C".
+        for (let i = 0; i < parts.length; i++) {
+            const currentPath = parts
+                .slice(0, i + 1)
+                .map((p) => escapeFolderName(p))
+                .join("/");
+            const currentRef = buildFolderReference(currentPath);
+            // Check if this folder already exists
+            const checkScript = buildAccountScopedScript({ account: targetAccount }, `return id of ${currentRef}`);
+            const checkResult = executeAppleScript(checkScript);
+            if (checkResult.success) {
+                // Folder exists, move to next segment
+                continue;
+            }
+            // Folder doesn't exist — create it
+            const segmentName = escapeForAppleScript(parts[i]);
+            let createCommand;
+            if (i === 0) {
+                createCommand = `make new folder with properties {name:"${segmentName}"}`;
+            }
+            else {
+                const parentPath = parts
+                    .slice(0, i)
+                    .map((p) => escapeFolderName(p))
+                    .join("/");
+                const parentRef = buildFolderReference(parentPath);
+                createCommand = `make new folder at ${parentRef} with properties {name:"${segmentName}"}`;
+            }
+            const script = buildAccountScopedScript({ account: targetAccount }, createCommand);
+            const result = executeAppleScript(script);
+            if (!result.success) {
+                console.error(`Failed to create folder "${name}":`, result.error);
+                return null;
+            }
+        }
+        // Get the ID of the final (deepest) folder
+        const fullRef = buildFolderReference(name);
+        const idScript = buildAccountScopedScript({ account: targetAccount }, `return id of ${fullRef}`);
+        const idResult = executeAppleScript(idScript);
+        const folderId = idResult.success ? extractCoreDataId(idResult.output, "folder") : "";
         return {
             id: folderId,
             name,

package/build/services/appleNotesManager.test.js

@@ -1047,7 +1047,16 @@ describe("AppleNotesManager", () => {
     });
     describe("createFolder", () => {
         it("returns Folder object on success", () => {
-            mockExecuteAppleScript.mockReturnValue({
+            mockExecuteAppleScript
+                // Check existence — folder doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create the folder
+                .mockReturnValueOnce({
+                success: true,
+                output: "folder id x-coredata://ABC123/ICFolder/p456",
+            })
+                // Get ID of created folder
+                .mockReturnValueOnce({
                 success: true,
                 output: "folder id x-coredata://ABC123/ICFolder/p456",
             });
@@ -1056,15 +1065,82 @@ describe("AppleNotesManager", () => {
             expect(result?.name).toBe("New Project");
             expect(result?.id).toBe("x-coredata://ABC123/ICFolder/p456");
         });
-        it("returns null on failure", () => {
-            mockExecuteAppleScript.mockReturnValue({
+        it("returns existing folder without creating duplicate", () => {
+            mockExecuteAppleScript
+                // Check existence — folder already exists
+                .mockReturnValueOnce({
+                success: true,
+                output: "x-coredata://ABC123/ICFolder/p789",
+            })
+                // Get ID of existing folder
+                .mockReturnValueOnce({
+                success: true,
+                output: "folder id x-coredata://ABC123/ICFolder/p789",
+            });
+            const result = manager.createFolder("Existing Folder");
+            expect(result).not.toBeNull();
+            expect(result?.name).toBe("Existing Folder");
+            expect(result?.id).toBe("x-coredata://ABC123/ICFolder/p789");
+            // Should only have 2 calls (check + get ID), no create call
+            expect(mockExecuteAppleScript).toHaveBeenCalledTimes(2);
+        });
+        it("returns null on genuine failure", () => {
+            mockExecuteAppleScript
+                // Check existence — doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create fails
+                .mockReturnValueOnce({
                 success: false,
                 output: "",
-                error: "Folder already exists",
+                error: "Permission denied",
             });
-            const result = manager.createFolder("Existing Folder");
+            const result = manager.createFolder("Restricted Folder");
             expect(result).toBeNull();
         });
+        it("creates nested folder path", () => {
+            mockExecuteAppleScript
+                // Check "Retro Tech" — doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create "Retro Tech"
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p1" })
+                // Check "Retro Tech/PC" — doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create "PC" inside "Retro Tech"
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p2" })
+                // Check "Retro Tech/PC/CPUs" — doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create "CPUs" inside "Retro Tech/PC"
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p3" })
+                // Get ID of final folder
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p3" });
+            const result = manager.createFolder("Retro Tech/PC/CPUs");
+            expect(result).not.toBeNull();
+            expect(result?.name).toBe("Retro Tech/PC/CPUs");
+            expect(result?.id).toBe("x-coredata://A/ICFolder/p3");
+            // Verify the create commands (calls at index 1, 3, 5)
+            const calls = mockExecuteAppleScript.mock.calls;
+            expect(calls[1][0]).toContain('make new folder with properties {name:"Retro Tech"}');
+            expect(calls[3][0]).toContain('make new folder at folder "Retro Tech" with properties {name:"PC"}');
+            expect(calls[5][0]).toContain('make new folder at folder "PC" of folder "Retro Tech" with properties {name:"CPUs"}');
+        });
+        it("skips existing intermediate folders in nested path", () => {
+            mockExecuteAppleScript
+                // Check "Retro Tech" — exists
+                .mockReturnValueOnce({ success: true, output: "x-coredata://A/ICFolder/p1" })
+                // Check "Retro Tech/PC" — doesn't exist
+                .mockReturnValueOnce({ success: false, output: "", error: "Can't get folder" })
+                // Create "PC" inside "Retro Tech"
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p2" })
+                // Get ID of final folder
+                .mockReturnValueOnce({ success: true, output: "folder id x-coredata://A/ICFolder/p2" });
+            const result = manager.createFolder("Retro Tech/PC");
+            expect(result).not.toBeNull();
+            expect(result?.name).toBe("Retro Tech/PC");
+            // No create call for "Retro Tech" — only for "PC"
+            const createCalls = mockExecuteAppleScript.mock.calls.filter((c) => c[0].includes("make new folder"));
+            expect(createCalls).toHaveLength(1);
+            expect(createCalls[0][0]).toContain('name:"PC"');
+        });
     });
     describe("deleteFolder", () => {
         it("returns true on successful deletion", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apple-notes-mcp",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "MCP server for Apple Notes - create, search, update, and manage notes via Claude",
   "type": "module",
   "main": "build/index.js",