apple-notes-mcp 2.0.1 → 2.1.1

package/build/services/appleNotesManager.js

@@ -664,24 +664,26 @@ export class AppleNotesManager {
             ? `
           if (count of resultList) >= ${safeLimit} then exit repeat`
             : "";
-        // Get names, IDs, and folder for each matching note
-        // We use a repeat loop to get all properties, separated by a delimiter
-        // Note: Some notes may have inaccessible containers, so we wrap in try/on error
+        // Get names, IDs, and folder for each matching note.
+        // Notes.app can return the same CoreData note more than once when asking
+        // an account for all notes, so dedupe on note ID before adding results.
         const searchCommand = `
       ${dateSetup}set matchingNotes to ${notesSource} where ${whereClause}
       set resultList to {}
-      repeat with n in matchingNotes${limitCheck}
+      set seenIds to {}
+      repeat with n in matchingNotes
         try
           set noteName to name of n
           set noteId to id of n
-          set noteFolder to name of container of n
-          set end of resultList to noteName & ${AS_FIELD_SEP} & noteId & ${AS_FIELD_SEP} & noteFolder
-        on error
-          try
-            set noteName to name of n
-            set noteId to id of n
-            set end of resultList to noteName & ${AS_FIELD_SEP} & noteId & ${AS_FIELD_SEP} & "Notes"
-          end try
+          if seenIds does not contain noteId then
+            set end of seenIds to noteId
+            try
+              set noteFolder to name of container of n
+            on error
+              set noteFolder to "Notes"
+            end try
+            set end of resultList to noteName & ${AS_FIELD_SEP} & noteId & ${AS_FIELD_SEP} & noteFolder${limitCheck}
+          end if
         end try
       end repeat
       set AppleScript's text item delimiters to ${AS_RECORD_SEP}
@@ -700,12 +702,17 @@ export class AppleNotesManager {
         // Parse the control-char-delimited output (#18): fields by FIELD_SEP, records by RECORD_SEP.
         const items = result.output.split(RECORD_SEP);
         const notes = [];
+        const seenIds = new Set();
         for (const item of items) {
             const [title, id, folder] = item.split(FIELD_SEP);
             if (!title?.trim())
                 continue;
+            const noteId = id?.trim() || generateFallbackId();
+            if (seenIds.has(noteId))
+                continue;
+            seenIds.add(noteId);
             notes.push({
-                id: id?.trim() || generateFallbackId(), // Use real ID, fallback to unique temp ID
+                id: noteId,
                 title: title.trim(),
                 content: "", // Not fetched in search
                 tags: [],
@@ -1032,15 +1039,24 @@ export class AppleNotesManager {
                     notesSource = `(${baseNotesSource} whose modification date >= thresholdDate)`;
                 }
             }
-            // Build the limit check
+            // Build the limit check. Check after appending so deduped results,
+            // rather than duplicate AppleScript references, determine the limit.
             const limitCheck = safeLimit !== undefined
                 ? `
             if (count of resultList) >= ${safeLimit} then exit repeat`
                 : "";
             const listCommand = `
         ${dateSetup}set resultList to {}
-        repeat with n in ${notesSource}${limitCheck}
-          set end of resultList to name of n
+        set seenIds to {}
+        repeat with n in ${notesSource}
+          try
+            set noteName to name of n
+            set noteId to id of n
+            if seenIds does not contain noteId then
+              set end of seenIds to noteId
+              set end of resultList to noteName & ${AS_FIELD_SEP} & noteId${limitCheck}
+            end if
+          end try
         end repeat
         set AppleScript's text item delimiters to ${AS_RECORD_SEP}
         return resultList as text
@@ -1053,16 +1069,36 @@ export class AppleNotesManager {
             if (!result.output.trim()) {
                 return [];
             }
-            return result.output
-                .split(RECORD_SEP)
-                .map((item) => item.trim())
-                .filter((item) => item.length > 0);
+            const seenIds = new Set();
+            const titles = [];
+            for (const item of result.output.split(RECORD_SEP)) {
+                const [title, id] = item.split(FIELD_SEP);
+                if (!title?.trim())
+                    continue;
+                const noteId = id?.trim() || generateFallbackId();
+                if (seenIds.has(noteId))
+                    continue;
+                seenIds.add(noteId);
+                titles.push(title.trim());
+            }
+            return titles;
         }
-        // Simple path: no date or limit filters. Coerce the name list to text with a
-        // control-char record separator so titles containing commas don't split (#18).
+        // Simple path: no date or limit filters. Use a repeat loop so duplicate
+        // CoreData note references can be deduped by ID before returning titles.
         const notesRef = folder ? `notes of ${buildFolderReference(folder)}` : `notes`;
         const listCommand = `
-      set resultList to name of ${notesRef}
+      set resultList to {}
+      set seenIds to {}
+      repeat with n in ${notesRef}
+        try
+          set noteName to name of n
+          set noteId to id of n
+          if seenIds does not contain noteId then
+            set end of seenIds to noteId
+            set end of resultList to noteName & ${AS_FIELD_SEP} & noteId
+          end if
+        end try
+      end repeat
       set AppleScript's text item delimiters to ${AS_RECORD_SEP}
       return resultList as text
     `;
@@ -1073,10 +1109,19 @@ export class AppleNotesManager {
         }
         if (!result.output.trim())
             return [];
-        return result.output
-            .split(RECORD_SEP)
-            .map((item) => item.trim())
-            .filter((item) => item.length > 0);
+        const seenIds = new Set();
+        const titles = [];
+        for (const item of result.output.split(RECORD_SEP)) {
+            const [title, id] = item.split(FIELD_SEP);
+            if (!title?.trim())
+                continue;
+            const noteId = id?.trim() || generateFallbackId();
+            if (seenIds.has(noteId))
+                continue;
+            seenIds.add(noteId);
+            titles.push(title.trim());
+        }
+        return titles;
     }
     /**
      * Lists all shared (collaborative) notes across all accounts.
@@ -1549,10 +1594,16 @@ export class AppleNotesManager {
     getNotesStats() {
         const accounts = this.listAccounts();
         const accountStats = [];
+        const warnings = [];
         let totalNotes = 0;
         // Collect stats per account with ONE bounded script per account (#20/#26):
         // count notes server-side per folder instead of fetching every note's name
         // (unbounded) via a listNotes call per folder (N+1 osascript spawns).
+        //
+        // Per-account failures degrade gracefully (#19): a single unreachable or
+        // locked account is recorded as a coverage warning and skipped, rather than
+        // discarding the stats for every healthy account. Only a total wipeout
+        // (no account readable) is escalated to a thrown error below.
         for (const account of accounts) {
             const countScript = buildAccountScopedScript({ account: account.name }, `
         set out to ""
@@ -1563,7 +1614,8 @@ export class AppleNotesManager {
         `);
             const res = executeAppleScript(countScript);
             if (!res.success) {
-                throw new Error(`Failed to read folder stats for "${account.name}": ${res.error ?? "unknown error"}`);
+                warnings.push({ scope: account.name, reason: res.error ?? "unknown error" });
+                continue;
             }
             const folderStats = [];
             let accountTotal = 0;
@@ -1583,12 +1635,33 @@ export class AppleNotesManager {
                 folders: folderStats,
             });
         }
-        // Get recently modified notes counts
-        const recentlyModified = this.getRecentlyModifiedCounts();
+        // If every account failed, there is no data to report — surface the error
+        // (#19) rather than returning a deceptively empty stats object.
+        if (accounts.length > 0 && accountStats.length === 0) {
+            throw new Error(`Failed to read folder stats for any of ${accounts.length} account(s): ${warnings
+                .map((w) => `${w.scope} (${w.reason})`)
+                .join("; ")}`);
+        }
+        // Get recently modified notes counts. A failure here is non-fatal — record a
+        // coverage warning and report zeros, flagged as not-covered (#19), instead of
+        // passing off fake zero activity as real.
+        const recent = this.getRecentlyModifiedCounts();
+        if (recent.error) {
+            warnings.push({ scope: "recent-activity", reason: recent.error });
+        }
+        // scopes = each account + the recent-activity scan
+        const scanned = accounts.length + 1;
+        const covered = scanned - warnings.length;
         return {
             totalNotes,
             accounts: accountStats,
-            recentlyModified,
+            recentlyModified: recent.counts,
+            coverage: {
+                complete: warnings.length === 0,
+                scanned,
+                covered,
+                warnings,
+            },
         };
     }
     /**
@@ -1621,15 +1694,22 @@ export class AppleNotesManager {
     `;
         const result = executeAppleScript(script);
         if (!result.success) {
-            // Surface the failure (#19) rather than reporting fake zero recent activity.
-            throw new Error(`Failed to read recent activity: ${result.error ?? "unknown error"}`);
+            // Non-fatal (#19): report the error to the caller so it becomes a coverage
+            // warning, with zeroed counts, instead of throwing away the whole stats
+            // result or passing off fake zero activity as real.
+            return {
+                counts: { last24h: 0, last7d: 0, last30d: 0 },
+                error: result.error ?? "unknown error",
+            };
         }
         const parts = result.output.trim().split(FIELD_SEP);
         const toInt = (s) => {
             const n = parseInt((s ?? "").trim(), 10);
             return Number.isFinite(n) ? n : 0;
         };
-        return { last24h: toInt(parts[0]), last7d: toInt(parts[1]), last30d: toInt(parts[2]) };
+        return {
+            counts: { last24h: toInt(parts[0]), last7d: toInt(parts[1]), last30d: toInt(parts[2]) },
+        };
     }
     // ===========================================================================
     // Attachments
@@ -1858,29 +1938,94 @@ export class AppleNotesManager {
      * ```
      */
     batchDeleteNotes(ids) {
-        const results = [];
-        for (const id of ids) {
-            // First verify the note exists and isn't password protected
-            const note = this.getNoteById(id);
-            if (!note) {
-                results.push(this.createBatchResult(id, false, "Note not found"));
-                continue;
+        if (ids.length === 0)
+            return [];
+        // Collapse the whole batch into ONE osascript spawn (#26): a single
+        // app-level script loops over every id, with a per-id `try` so one bad note
+        // can't abort the rest. The old path spawned 3 processes per note
+        // (getNoteById + isNotePasswordProtectedById + deleteNoteById) — i.e. 3N
+        // spawns for N notes. This is one spawn total, with the same per-item
+        // isolation and result semantics.
+        const results = new Array(ids.length);
+        const runnable = [];
+        ids.forEach((id, i) => {
+            try {
+                runnable.push({ index: i, safe: sanitizeId(id) });
             }
-            if (this.isNotePasswordProtectedById(id)) {
-                results.push(this.createBatchResult(id, false, "Note is password-protected"));
-                continue;
+            catch (e) {
+                results[i] = this.createBatchResult(id, false, e instanceof Error ? e.message : "Invalid note ID");
             }
-            // Attempt deletion
-            const success = this.deleteNoteById(id);
-            if (success) {
-                results.push(this.createBatchResult(id, true));
+        });
+        if (runnable.length > 0) {
+            const idList = runnable.map((r) => `"${r.safe}"`).join(", ");
+            const script = buildAppLevelScript(`
+        set out to ""
+        repeat with rawId in {${idList}}
+          set theId to (rawId as text)
+          set noteRef to missing value
+          try
+            set noteRef to note id theId
+          end try
+          if noteRef is missing value then
+            set out to out & "missing" & ${AS_RECORD_SEP}
+          else
+            set isPw to false
+            try
+              set isPw to (password protected of noteRef)
+            end try
+            if isPw then
+              set out to out & "pw" & ${AS_RECORD_SEP}
+            else
+              try
+                delete noteRef
+                set out to out & "ok" & ${AS_RECORD_SEP}
+              on error
+                set out to out & "fail" & ${AS_RECORD_SEP}
+              end try
+            end if
+          end if
+        end repeat
+        return out
+      `);
+            const res = executeAppleScript(script);
+            if (!res.success) {
+                // Whole-batch failure (e.g. Notes.app not responding): can't isolate,
+                // so mark every runnable note as failed with the underlying error.
+                for (const r of runnable) {
+                    results[r.index] = this.createBatchResult(ids[r.index], false, res.error ?? "Batch delete failed");
+                }
             }
             else {
-                results.push(this.createBatchResult(id, false, "Deletion failed"));
+                const statuses = res.output
+                    .split(RECORD_SEP)
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0);
+                runnable.forEach((r, k) => {
+                    results[r.index] = this.mapBatchStatus(ids[r.index], statuses[k], "delete");
+                });
             }
         }
         return results;
     }
+    /**
+     * Maps a per-item status token emitted by a batch AppleScript loop to a
+     * BatchResult, preserving the human-readable error messages of the original
+     * per-note implementation. See {@link batchDeleteNotes} / {@link batchMoveNotes}.
+     */
+    mapBatchStatus(id, status, op) {
+        switch (status) {
+            case "ok":
+                return this.createBatchResult(id, true);
+            case "pw":
+                return this.createBatchResult(id, false, "Note is password-protected");
+            case "missing":
+                return this.createBatchResult(id, false, "Note not found");
+            case "fail":
+                return this.createBatchResult(id, false, op === "delete" ? "Deletion failed" : "Move failed");
+            default:
+                return this.createBatchResult(id, false, "Unknown error");
+        }
+    }
     /**
      * Moves multiple notes to a folder by their IDs.
      *
@@ -1901,25 +2046,76 @@ export class AppleNotesManager {
      * ```
      */
     batchMoveNotes(ids, folder, account) {
-        const results = [];
-        for (const id of ids) {
-            // First verify the note exists
-            const note = this.getNoteById(id);
-            if (!note) {
-                results.push(this.createBatchResult(id, false, "Note not found"));
-                continue;
+        if (ids.length === 0)
+            return [];
+        // Collapse the whole batch into ONE osascript spawn (#26). The old path
+        // spawned 5+ processes per note (getNoteById + isNotePasswordProtectedById +
+        // moveNoteById's copy-then-delete fan-out). This uses the native `move`
+        // command — which preserves the note's identity and metadata rather than
+        // copy+delete — inside a single app-level loop with per-id `try` isolation.
+        const targetAccount = this.resolveAccount(account);
+        const safeAccount = sanitizeAccountName(targetAccount);
+        // buildFolderReference validates the (single, shared) destination path; a
+        // malformed folder is a precondition error for the whole call, so let it throw.
+        const destFolderRef = `${buildFolderReference(folder)} of account "${safeAccount}"`;
+        const results = new Array(ids.length);
+        const runnable = [];
+        ids.forEach((id, i) => {
+            try {
+                runnable.push({ index: i, safe: sanitizeId(id) });
             }
-            if (this.isNotePasswordProtectedById(id)) {
-                results.push(this.createBatchResult(id, false, "Note is password-protected"));
-                continue;
+            catch (e) {
+                results[i] = this.createBatchResult(id, false, e instanceof Error ? e.message : "Invalid note ID");
             }
-            // Attempt move using the ID-based method
-            const success = this.moveNoteById(id, folder, account);
-            if (success) {
-                results.push(this.createBatchResult(id, true));
+        });
+        if (runnable.length > 0) {
+            const idList = runnable.map((r) => `"${r.safe}"`).join(", ");
+            const script = buildAppLevelScript(`
+        set destFolder to ${destFolderRef}
+        set out to ""
+        repeat with rawId in {${idList}}
+          set theId to (rawId as text)
+          set noteRef to missing value
+          try
+            set noteRef to note id theId
+          end try
+          if noteRef is missing value then
+            set out to out & "missing" & ${AS_RECORD_SEP}
+          else
+            set isPw to false
+            try
+              set isPw to (password protected of noteRef)
+            end try
+            if isPw then
+              set out to out & "pw" & ${AS_RECORD_SEP}
+            else
+              try
+                move noteRef to destFolder
+                set out to out & "ok" & ${AS_RECORD_SEP}
+              on error
+                set out to out & "fail" & ${AS_RECORD_SEP}
+              end try
+            end if
+          end if
+        end repeat
+        return out
+      `);
+            const res = executeAppleScript(script);
+            if (!res.success) {
+                // Whole-batch failure (e.g. destination folder unresolved, Notes not
+                // responding): can't isolate, so fail every runnable note.
+                for (const r of runnable) {
+                    results[r.index] = this.createBatchResult(ids[r.index], false, res.error ?? "Batch move failed");
+                }
             }
             else {
-                results.push(this.createBatchResult(id, false, "Move failed"));
+                const statuses = res.output
+                    .split(RECORD_SEP)
+                    .map((s) => s.trim())
+                    .filter((s) => s.length > 0);
+                runnable.forEach((r, k) => {
+                    results[r.index] = this.mapBatchStatus(ids[r.index], statuses[k], "move");
+                });
             }
         }
         return results;