apple-notes-mcp 2.5.7 → 2.5.8

package/build/utils/applescript.test.js

@@ -1,342 +0,0 @@
-/**
- * Tests for AppleScript execution utilities
- *
- * These tests mock the child_process.execSync function to avoid
- * requiring actual AppleScript execution during testing.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { execSync } from "child_process";
-import { executeAppleScript } from "./applescript.js";
-// Mock the child_process module
-vi.mock("child_process", () => ({
-    execSync: vi.fn(),
-    spawnSync: vi.fn(() => ({ error: null })), // Mock sleep to return immediately
-}));
-const mockExecSync = vi.mocked(execSync);
-describe("executeAppleScript", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe("successful execution", () => {
-        it("returns success result with trimmed output", () => {
-            // Arrange: Mock a successful AppleScript execution
-            mockExecSync.mockReturnValue("  Note Title  \n");
-            // Act: Execute a simple script
-            const result = executeAppleScript('tell app "Notes" to get name of note 1');
-            // Assert: Output should be trimmed
-            expect(result.success).toBe(true);
-            expect(result.output).toBe("Note Title");
-            expect(result.error).toBeUndefined();
-        });
-        it("preserves newlines within the script for AppleScript syntax", () => {
-            mockExecSync.mockReturnValue("success");
-            // Multi-line AppleScript with tell blocks
-            const script = `
-        tell application "Notes"
-          tell account "iCloud"
-            get notes
-          end tell
-        end tell
-      `;
-            executeAppleScript(script);
-            // Verify the script was passed with newlines preserved
-            const calledCommand = mockExecSync.mock.calls[0][0];
-            expect(calledCommand).toContain("tell application");
-            expect(calledCommand).toContain("end tell");
-        });
-        it("escapes single quotes in the script for shell safety", () => {
-            mockExecSync.mockReturnValue("content");
-            // Script containing a single quote (e.g., in a note title)
-            executeAppleScript('get note "Rob\'s Notes"');
-            // Verify the quote was escaped for shell
-            const calledCommand = mockExecSync.mock.calls[0][0];
-            expect(calledCommand).toContain("Rob'\\''s");
-        });
-    });
-    describe("hardened executor (#16/#17)", () => {
-        afterEach(() => {
-            delete process.env.APPLE_NOTES_MCP_MAX_BUFFER;
-        });
-        it("wraps the script in `with timeout` so Notes.app aborts cleanly", () => {
-            mockExecSync.mockReturnValue("ok");
-            executeAppleScript("get name of notes", { timeoutMs: 30000 });
-            const cmd = mockExecSync.mock.calls[0][0];
-            expect(cmd).toContain("with timeout of");
-            expect(cmd).toContain("end timeout");
-            // 30s process timeout − 5s headroom = 25s script timeout
-            expect(cmd).toContain("with timeout of 25 seconds");
-        });
-        it("passes SIGKILL and a large maxBuffer to execSync", () => {
-            mockExecSync.mockReturnValue("ok");
-            executeAppleScript("get name of notes");
-            const opts = mockExecSync.mock.calls[0][1];
-            expect(opts.killSignal).toBe("SIGKILL");
-            expect(opts.maxBuffer).toBe(64 * 1024 * 1024);
-        });
-        it("honors APPLE_NOTES_MCP_MAX_BUFFER override", () => {
-            process.env.APPLE_NOTES_MCP_MAX_BUFFER = "1048576";
-            mockExecSync.mockReturnValue("ok");
-            executeAppleScript("get name of notes");
-            const opts = mockExecSync.mock.calls[0][1];
-            expect(opts.maxBuffer).toBe(1048576);
-        });
-    });
-    describe("error handling", () => {
-        it("returns error result when execution fails", () => {
-            // Arrange: Mock an AppleScript execution failure
-            mockExecSync.mockImplementation(() => {
-                throw new Error("execution error: Can't get note. (-1728)");
-            });
-            // Act: Try to execute a script that will fail
-            const result = executeAppleScript('get note "Nonexistent"');
-            // Assert: Should return structured error
-            expect(result.success).toBe(false);
-            expect(result.output).toBe("");
-            expect(result.error).toBeDefined();
-        });
-        it("parses execution error messages cleanly", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error("execution error: Note not found (-1728)");
-            });
-            const result = executeAppleScript("get note 1");
-            // Should extract the meaningful part of the error
-            expect(result.error).toBe("Note not found");
-        });
-        it("handles 'not found' error patterns with user-friendly message", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('Can\'t get note "Missing".');
-            });
-            const result = executeAppleScript('get note "Missing"');
-            expect(result.error).toContain("not found");
-            expect(result.error).toContain("Missing");
-            expect(result.error).toContain("case-sensitive"); // Includes helpful hint
-        });
-        it("provides helpful message for permission errors", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error("execution error: Not authorized to send Apple events (-1743)");
-            });
-            const result = executeAppleScript("test");
-            expect(result.error).toContain("Permission denied");
-            expect(result.error).toContain("System Preferences");
-        });
-        it("provides helpful message for folder not found", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('Can\'t get folder "Work".');
-            });
-            const result = executeAppleScript("test");
-            expect(result.error).toContain("Work");
-            expect(result.error).toContain("not found");
-            expect(result.error).toContain("list-folders");
-        });
-        it("provides helpful message for account not found", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('Can\'t get account "Gmail".');
-            });
-            const result = executeAppleScript("test");
-            expect(result.error).toContain("Gmail");
-            expect(result.error).toContain("not found");
-            expect(result.error).toContain("list-accounts");
-        });
-        it("handles non-Error exceptions gracefully", () => {
-            mockExecSync.mockImplementation(() => {
-                throw "string error"; // Some code throws strings
-            });
-            const result = executeAppleScript("some script");
-            expect(result.success).toBe(false);
-            expect(result.error).toBe("string error");
-        });
-        it("handles unknown error types", () => {
-            mockExecSync.mockImplementation(() => {
-                throw { weird: "object" }; // Unusual but possible
-            });
-            const result = executeAppleScript("some script");
-            expect(result.success).toBe(false);
-            expect(result.error).toBe("AppleScript execution failed with unknown error");
-        });
-    });
-    describe("input validation", () => {
-        it("returns error for empty script", () => {
-            const result = executeAppleScript("");
-            expect(result.success).toBe(false);
-            expect(result.error).toBe("Cannot execute empty AppleScript");
-            expect(mockExecSync).not.toHaveBeenCalled();
-        });
-        it("returns error for whitespace-only script", () => {
-            const result = executeAppleScript("   \n\t  ");
-            expect(result.success).toBe(false);
-            expect(result.error).toBe("Cannot execute empty AppleScript");
-            expect(mockExecSync).not.toHaveBeenCalled();
-        });
-    });
-    describe("execution options", () => {
-        it("uses default 30 second timeout", () => {
-            mockExecSync.mockReturnValue("ok");
-            executeAppleScript("test");
-            const options = mockExecSync.mock.calls[0][1];
-            expect(options.timeout).toBe(30000); // 30 second default timeout
-        });
-        it("allows custom timeout via options", () => {
-            mockExecSync.mockReturnValue("ok");
-            executeAppleScript("test", { timeoutMs: 60000 });
-            const options = mockExecSync.mock.calls[0][1];
-            expect(options.timeout).toBe(60000); // Custom timeout
-        });
-        it("uses UTF-8 encoding for output", () => {
-            mockExecSync.mockReturnValue("日本語テスト");
-            const result = executeAppleScript("test");
-            expect(result.output).toBe("日本語テスト");
-            const options = mockExecSync.mock.calls[0][1];
-            expect(options.encoding).toBe("utf8");
-        });
-    });
-    describe("timeout handling", () => {
-        it("returns specific error message on timeout", () => {
-            // Simulate a timeout error (Node.js sets killed=true and signal=SIGTERM)
-            const timeoutError = new Error("Command failed: SIGTERM");
-            timeoutError.killed = true;
-            timeoutError.signal = "SIGTERM";
-            mockExecSync.mockImplementation(() => {
-                throw timeoutError;
-            });
-            const result = executeAppleScript("test");
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("timed out after 30 seconds");
-            expect(result.error).toContain("Notes.app may be unresponsive");
-        });
-        it("includes custom timeout value in error message", () => {
-            const timeoutError = new Error("Command failed: SIGTERM");
-            timeoutError.killed = true;
-            timeoutError.signal = "SIGTERM";
-            mockExecSync.mockImplementation(() => {
-                throw timeoutError;
-            });
-            const result = executeAppleScript("test", { timeoutMs: 60000 });
-            expect(result.error).toContain("timed out after 60 seconds");
-        });
-    });
-    describe("retry logic", () => {
-        it("does not retry by default (maxRetries=1)", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error("Notes.app is not responding");
-            });
-            executeAppleScript("test");
-            // Only one attempt with default settings
-            expect(mockExecSync).toHaveBeenCalledTimes(1);
-        });
-        it("retries on transient errors when maxRetries > 1", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 3) {
-                    throw new Error("Notes.app is not responding");
-                }
-                return "success";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(result.output).toBe("success");
-            expect(mockExecSync).toHaveBeenCalledTimes(3);
-        });
-        it("does not retry on non-transient errors", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error('Can\'t get note "Missing"');
-            });
-            executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            // Should not retry for "note not found" errors
-            expect(mockExecSync).toHaveBeenCalledTimes(1);
-        });
-        it("retries on timeout errors", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 2) {
-                    const timeoutError = new Error("SIGTERM");
-                    timeoutError.killed = true;
-                    timeoutError.signal = "SIGTERM";
-                    throw timeoutError;
-                }
-                return "success after retry";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(result.output).toBe("success after retry");
-            expect(mockExecSync).toHaveBeenCalledTimes(2);
-        });
-        it("retries on 'connection invalid' errors", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 2) {
-                    throw new Error("connection is invalid");
-                }
-                return "recovered";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(mockExecSync).toHaveBeenCalledTimes(2);
-        });
-        it("returns last error after all retries exhausted", () => {
-            mockExecSync.mockImplementation(() => {
-                throw new Error("Notes.app is not responding");
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(false);
-            expect(result.error).toContain("not responding");
-            expect(mockExecSync).toHaveBeenCalledTimes(3);
-        });
-        it("retries on 'timed out' errors", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 2) {
-                    throw new Error("operation timed out");
-                }
-                return "recovered";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(mockExecSync).toHaveBeenCalledTimes(2);
-        });
-        it("retries on 'lost connection' errors", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 2) {
-                    throw new Error("lost connection to Notes.app");
-                }
-                return "recovered";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(mockExecSync).toHaveBeenCalledTimes(2);
-        });
-        it("retries on 'busy' errors", () => {
-            let callCount = 0;
-            mockExecSync.mockImplementation(() => {
-                callCount++;
-                if (callCount < 2) {
-                    throw new Error("Notes.app is busy");
-                }
-                return "recovered";
-            });
-            const result = executeAppleScript("test", { maxRetries: 3, retryDelayMs: 1 });
-            expect(result.success).toBe(true);
-            expect(mockExecSync).toHaveBeenCalledTimes(2);
-        });
-        it("uses exponential backoff between retries", () => {
-            let execCallCount = 0;
-            // Fails first 3 times, succeeds on 4th attempt
-            mockExecSync.mockImplementation(() => {
-                execCallCount++;
-                if (execCallCount <= 3) {
-                    throw new Error("Notes.app is not responding");
-                }
-                return "success";
-            });
-            // With retryDelayMs=100, delays should be: 100ms, 200ms, 400ms
-            const result = executeAppleScript("test", { maxRetries: 4, retryDelayMs: 100 });
-            expect(result.success).toBe(true);
-            expect(mockExecSync).toHaveBeenCalledTimes(4);
-        });
-    });
-});

package/build/utils/attachmentFs.js

@@ -1,97 +0,0 @@
-/**
- * Filesystem helpers for saving / fetching note attachments (#27).
- *
- * Notes.app exports an attachment to a path via AppleScript `save`. These helpers
- * keep that safe (no writing outside sensible roots, no path traversal) and
- * provide a base64 read for the fetch-attachment tool.
- *
- * @module utils/attachmentFs
- */
-import { existsSync, mkdtempSync, readFileSync, rmSync, statSync } from "fs";
-import { isAbsolute, resolve, sep } from "path";
-import { homedir, tmpdir } from "os";
-/** Roots an attachment may be written to. */
-export function allowedSaveRoots() {
-    return [resolve(homedir()), resolve(tmpdir()), "/Volumes", "/private/var/folders", "/tmp"];
-}
-/**
- * Validate a user-supplied destination path. Returns the resolved absolute path,
- * or throws if it is relative or escapes the allowed roots.
- */
-export function assertSafeSavePath(p, roots = allowedSaveRoots()) {
-    if (!p || !p.trim())
-        throw new Error("A destination path is required.");
-    if (!isAbsolute(p))
-        throw new Error(`Destination path must be absolute: "${p}"`);
-    const abs = resolve(p);
-    const ok = roots.some((r) => abs === r || abs.startsWith(r.endsWith(sep) ? r : r + sep));
-    if (!ok) {
-        throw new Error(`Refusing to write outside allowed locations (home, temp, /Volumes): "${abs}"`);
-    }
-    return abs;
-}
-/**
- * Default upper bound on an attachment that `fetch-attachment` will base64-encode
- * into a single MCP response. `readFileSync` loads the whole file into memory and
- * base64 grows it ~33%, so an unbounded read of a multi-GB attachment (video,
- * disk image) could exhaust memory. 25 MB is generous for the inline-fetch use
- * case (docs, images, PDFs); larger attachments should be exported to disk with
- * `save-attachment` instead. Overridable via APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES.
- */
-const DEFAULT_MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
-/** Resolve the configured max attachment size (bytes) for inline base64 fetch. */
-export function maxAttachmentBytes(env = process.env) {
-    const raw = env.APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES;
-    if (raw !== undefined) {
-        const n = Number(raw);
-        if (Number.isFinite(n) && n > 0)
-            return n;
-    }
-    return DEFAULT_MAX_ATTACHMENT_BYTES;
-}
-/** Read a file as base64. */
-export function readFileBase64(p) {
-    return readFileSync(p).toString("base64");
-}
-/**
- * Read a file as base64, refusing files larger than `maxBytes`.
- *
- * Guards `fetch-attachment` against unbounded in-memory reads: the size is
- * checked from filesystem metadata BEFORE the file is read, so an oversized
- * attachment is rejected with a clear error instead of loading it (and its
- * ~33%-larger base64) into memory. (`APPLE_NOTES_MCP_MAX_BUFFER` does not apply
- * to `readFileSync`.)
- *
- * @throws if the file exceeds `maxBytes`
- */
-export function readFileBase64Capped(p, maxBytes = maxAttachmentBytes()) {
-    const size = fileSize(p);
-    if (size > maxBytes) {
-        throw new Error(`Attachment is ${size} bytes, exceeding the ${maxBytes}-byte fetch limit ` +
-            `(APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES). Use save-attachment to export it to disk instead.`);
-    }
-    return readFileBase64(p);
-}
-/** Byte size of a file (0 if missing). */
-export function fileSize(p) {
-    try {
-        return statSync(p).size;
-    }
-    catch {
-        return 0;
-    }
-}
-/** Make a private temp dir for a one-shot attachment export; caller cleans up. */
-export function makeTempDir() {
-    return mkdtempSync(resolve(tmpdir(), "apple-notes-att-"));
-}
-/** Remove a temp dir tree, ignoring errors. */
-export function cleanupTempDir(dir) {
-    try {
-        if (existsSync(dir))
-            rmSync(dir, { recursive: true, force: true });
-    }
-    catch {
-        /* best-effort */
-    }
-}

package/build/utils/attachmentFs.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect, afterEach } from "vitest";
-import { writeFileSync, existsSync, mkdtempSync } from "fs";
-import { homedir, tmpdir } from "os";
-import { join } from "path";
-import { assertSafeSavePath, readFileBase64, readFileBase64Capped, maxAttachmentBytes, fileSize, makeTempDir, cleanupTempDir, allowedSaveRoots, } from "../utils/attachmentFs.js";
-const dirs = [];
-afterEach(() => dirs.splice(0).forEach(cleanupTempDir));
-describe("assertSafeSavePath (#27)", () => {
-    it("accepts absolute paths under the temp dir and home dir", () => {
-        const p = join(tmpdir(), "x.png");
-        expect(assertSafeSavePath(p)).toBe(p);
-        const h = join(homedir(), "Downloads", "x.png");
-        expect(assertSafeSavePath(h)).toBe(h);
-    });
-    it("rejects empty, relative, and out-of-root paths", () => {
-        expect(() => assertSafeSavePath("")).toThrow(/required/);
-        expect(() => assertSafeSavePath("relative/x.png")).toThrow(/absolute/);
-        expect(() => assertSafeSavePath("/etc/passwd")).toThrow(/outside allowed/);
-    });
-    it("blocks traversal that escapes an allowed root", () => {
-        expect(() => assertSafeSavePath(join(tmpdir(), "..", "..", "etc", "x"))).toThrow(/outside allowed/);
-    });
-    it("exposes the allowed roots", () => {
-        expect(allowedSaveRoots()).toEqual(expect.arrayContaining(["/Volumes"]));
-    });
-});
-describe("base64 / size / temp helpers (#27)", () => {
-    it("reads a file as base64 and reports its size", () => {
-        const dir = mkdtempSync(join(tmpdir(), "anatt-"));
-        dirs.push(dir);
-        const f = join(dir, "f.bin");
-        writeFileSync(f, Buffer.from("hello"));
-        expect(readFileBase64(f)).toBe(Buffer.from("hello").toString("base64"));
-        expect(fileSize(f)).toBe(5);
-    });
-    it("fileSize returns 0 for a missing file", () => {
-        expect(fileSize(join(tmpdir(), "definitely-missing-xyz.bin"))).toBe(0);
-    });
-    it("makeTempDir creates a dir and cleanupTempDir removes it (idempotent)", () => {
-        const dir = makeTempDir();
-        expect(existsSync(dir)).toBe(true);
-        cleanupTempDir(dir);
-        expect(existsSync(dir)).toBe(false);
-        expect(() => cleanupTempDir(dir)).not.toThrow();
-    });
-});
-describe("readFileBase64Capped / maxAttachmentBytes (size guard)", () => {
-    it("reads files at or under the cap", () => {
-        const dir = mkdtempSync(join(tmpdir(), "anatt-"));
-        dirs.push(dir);
-        const f = join(dir, "ok.bin");
-        writeFileSync(f, Buffer.from("hello"));
-        expect(readFileBase64Capped(f, 1024)).toBe(Buffer.from("hello").toString("base64"));
-    });
-    it("throws (without reading) when the file exceeds the cap", () => {
-        const dir = mkdtempSync(join(tmpdir(), "anatt-"));
-        dirs.push(dir);
-        const f = join(dir, "big.bin");
-        writeFileSync(f, Buffer.alloc(2048));
-        expect(() => readFileBase64Capped(f, 1024)).toThrow(/exceeding the 1024-byte fetch limit/);
-    });
-    it("maxAttachmentBytes honors APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES and falls back to a sane default", () => {
-        expect(maxAttachmentBytes({ APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES: "12345" })).toBe(12345);
-        // Invalid / non-positive values fall back to the default (25 MB).
-        expect(maxAttachmentBytes({ APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES: "0" })).toBe(25 * 1024 * 1024);
-        expect(maxAttachmentBytes({ APPLE_NOTES_MCP_MAX_ATTACHMENT_BYTES: "nope" })).toBe(25 * 1024 * 1024);
-        expect(maxAttachmentBytes({})).toBe(25 * 1024 * 1024);
-    });
-});