apple-notes-mcp 2.11.0 → 2.13.0

package/build/index.js

@@ -24477,14 +24477,14 @@ var require_turndown_cjs = __commonJS({
         } else if (node.nodeType === 1) {
           replacement = replacementForNode.call(self, node);
         }
-        return join31(output, replacement);
+        return join32(output, replacement);
       }, "");
     }
     function postProcess(output) {
       var self = this;
       this.rules.forEach(function(rule) {
         if (typeof rule.append === "function") {
-          output = join31(output, rule.append(self.options));
+          output = join32(output, rule.append(self.options));
         }
       });
       return output.replace(/^[\t\r\n]+/, "").replace(/[\t\r\n\s]+$/, "");
@@ -24496,7 +24496,7 @@ var require_turndown_cjs = __commonJS({
       if (whitespace.leading || whitespace.trailing) content = content.trim();
       return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
     }
-    function join31(output, replacement) {
+    function join32(output, replacement) {
       var s1 = trimTrailingNewlines(output);
       var s2 = trimLeadingNewlines(replacement);
       var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
@@ -51023,13 +51023,13 @@ var SidecarWriter = class {
         }
         this.created = true;
       }
-      const safe = safeAssetName(name, mime);
-      const ext = extname3(safe);
-      const stem = safe.slice(0, safe.length - ext.length);
+      const safe2 = safeAssetName(name, mime);
+      const ext = extname3(safe2);
+      const stem = safe2.slice(0, safe2.length - ext.length);
       let target;
       let out;
       for (let n = 1; n <= 1e3 && out === void 0; n++) {
-        target = join19(this.dir, n === 1 ? safe : `${stem}-${n}${ext}`);
+        target = join19(this.dir, n === 1 ? safe2 : `${stem}-${n}${ext}`);
         try {
           out = openSync4(target, CREATE_FLAGS, 420);
         } catch (error2) {
@@ -51714,7 +51714,8 @@ var PUBLIC_HELPER_SETUP_COMMAND = "apple-notes-mcp setup --public-helper";
 var PUBLIC_HELPER_ACTIONS = /* @__PURE__ */ new Set([
   "hello",
   "decode_drawing",
-  "transcribe"
+  "transcribe",
+  "speech_status"
 ]);
 var DEFAULT_TIMEOUT_MS2 = 3e4;
 var MAX_OUTPUT_BYTES2 = 256 * 1024 * 1024;
@@ -52888,16 +52889,16 @@ var NOTE_PLACEHOLDERS = [
   "exportStem"
 ];
 var PLACEHOLDER_MODIFIERS = ["raw", "yaml"];
-var wrap2 = (before, after = "", join31) => ({
+var wrap2 = (before, after = "", join32) => ({
   mode: "wrap",
   before,
   after,
-  ...join31 ? { join: join31 } : {}
+  ...join32 ? { join: join32 } : {}
 });
-var pattern = (value, join31) => ({
+var pattern = (value, join32) => ({
   mode: "pattern",
   value,
-  ...join31 ? { join: join31 } : {}
+  ...join32 ? { join: join32 } : {}
 });
 var STANDARD = {
   schemaVersion: 1,
@@ -53969,12 +53970,12 @@ function pathComponent(value) {
   return clean || "untitled";
 }
 function templateAssetsDir(directory, outputDir, values) {
-  const safe = {};
+  const safe2 = {};
   for (const [key, value] of Object.entries(values)) {
     const raw = typeof value === "string" ? value : value?.raw;
-    if (raw !== void 0) safe[key] = pathComponent(raw);
+    if (raw !== void 0) safe2[key] = pathComponent(raw);
   }
-  const filled = fillPlaceholders(directory, safe);
+  const filled = fillPlaceholders(directory, safe2);
   const base = resolve5(outputDir);
   const dir = resolve5(base, filled);
   if (isAbsolute3(filled) || filled.split("/").includes("..") || !dir.startsWith(base + sep4))
@@ -59405,6 +59406,710 @@ function formatHelperBuild(report) {
   return lines.join("\n");
 }
 
+// src/services/permissions.ts
+import { spawnSync as spawnSync6 } from "node:child_process";
+import { createInterface } from "node:readline";
+var PRIVACY = "System Settings > Privacy & Security";
+var PANE_ANCHORS = {
+  fullDiskAccess: { anchor: "Privacy_AllFiles", label: "Full Disk Access" },
+  automation: { anchor: "Privacy_Automation", label: "Automation" },
+  speechRecognition: { anchor: "Privacy_SpeechRecognition", label: "Speech Recognition" }
+};
+function settingsUrl(pane, macOSVersion) {
+  const legacy = macOSVersion !== null && compareVersions(macOSVersion, "13.0") < 0;
+  const base = legacy ? "x-apple.systempreferences:com.apple.preference.security" : "x-apple.systempreferences:com.apple.settings.PrivacySecurity.extension";
+  return `${base}?${PANE_ANCHORS[pane].anchor}`;
+}
+function paneFields(pane, macOSVersion) {
+  return {
+    settingsPane: `${PRIVACY} > ${PANE_ANCHORS[pane].label}`,
+    settingsUrl: settingsUrl(pane, macOSVersion)
+  };
+}
+function defaultCheckOptions() {
+  return { probeAutomation: false, check: false, env: process.env };
+}
+function automationSkipReason(options) {
+  if (!options.probeAutomation)
+    return "this check sends no Apple event to Notes.app unless you pass --probe-automation";
+  if (options.env.SSH_CONNECTION)
+    return "this is an SSH session, where macOS cannot show its permission prompt, so no Apple event was sent";
+  if (options.check)
+    return "--check reports state only and never sends an Apple event to Notes.app";
+  return null;
+}
+function checkPermissions(probes = defaultPermissionProbes(), options = defaultCheckOptions()) {
+  const macOSVersion = safe(probes.macOSVersion, null);
+  const launchingApp = safe(probes.launchingApp, null);
+  const who = launchingApp ?? "the app that launches the server";
+  const items = [
+    fullDiskAccessItem(probes, macOSVersion),
+    automationItem(probes, macOSVersion, who, automationSkipReason(options)),
+    shortcutsItem(probes),
+    speechItem(probes, macOSVersion, who)
+  ];
+  return {
+    ready: items.every((item) => !item.required || item.status === "granted" || item.notProbed),
+    launchingApp,
+    execPath: probes.execPath,
+    macOSVersion,
+    items
+  };
+}
+function safe(fn, fallback) {
+  try {
+    return fn();
+  } catch {
+    return fallback;
+  }
+}
+function errorText(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
+}
+function fullDiskAccessItem(probes, macOSVersion) {
+  const base = {
+    id: "fullDiskAccess",
+    title: "Full Disk Access",
+    required: true,
+    ...paneFields("fullDiskAccess", macOSVersion)
+  };
+  let granted;
+  try {
+    granted = probes.fullDiskAccess();
+  } catch (error2) {
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not probe the Notes database: ${errorText(error2)}`,
+      fix: fdaRemediation(probes.execPath)
+    };
+  }
+  return granted ? {
+    ...base,
+    status: "granted",
+    detail: "the Notes database (NoteStore.sqlite) is readable",
+    fix: null
+  } : {
+    ...base,
+    status: "missing",
+    detail: "the Notes database is not readable, so query-notes, checklist state, note metadata, note links, native objects, exports and the bridges' readback do not work",
+    fix: fdaRemediation(probes.execPath)
+  };
+}
+var PROBE_AUTOMATION_COMMAND = "apple-notes-mcp setup --permissions --probe-automation";
+function automationItem(probes, macOSVersion, who, skipReason) {
+  const base = {
+    id: "notesAutomation",
+    title: "Automation of Notes.app",
+    required: true,
+    ...paneFields("automation", macOSVersion)
+  };
+  if (skipReason !== null)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `not probed: ${skipReason}`,
+      fix: `On this Mac, in a terminal, run \`${PROBE_AUTOMATION_COMMAND}\`. It sends one read-only Apple event to Notes.app, and macOS may ask whether this app may control Notes; choose Allow.`,
+      notProbed: true
+    };
+  let result;
+  try {
+    result = probes.notesAutomation();
+  } catch (error2) {
+    result = { success: false, error: errorText(error2) };
+  }
+  if (result.success)
+    return {
+      ...base,
+      status: "granted",
+      detail: "Notes.app answered a read-only Apple event",
+      fix: null
+    };
+  if (isPermissionDenied(result.error))
+    return {
+      ...base,
+      status: "missing",
+      detail: "macOS refused the Apple event to Notes.app (Automation denied)",
+      fix: `In ${PRIVACY} > Automation, expand ${who} and turn on Notes. Then fully quit (Cmd+Q) and relaunch that app. If Notes is not listed, run this check again and choose Allow when macOS asks to control Notes.`
+    };
+  return {
+    ...base,
+    status: "unknown",
+    detail: `Notes.app did not answer: ${result.error || "no response"}`,
+    fix: "Open Notes.app once, then run this check again. If macOS asks whether this app may control Notes, choose Allow."
+  };
+}
+function shortcutsItem(probes) {
+  const base = {
+    id: "shortcutBridges",
+    title: "Shortcut bridges",
+    required: false,
+    settingsPane: null,
+    settingsUrl: null
+  };
+  let report;
+  try {
+    report = probes.shortcuts();
+  } catch (error2) {
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not run the shortcuts command: ${errorText(error2)}`,
+      fix: "Run `apple-notes-mcp setup --check`."
+    };
+  }
+  const required2 = report.items.filter((item) => !item.optional);
+  const failed = required2.filter((item) => item.error && !item.installed);
+  const missing = required2.filter((item) => !item.installed);
+  const consent = "After install or upgrade, run each bridge once in Shortcuts.app and choose Always Allow.";
+  if (missing.length === 0)
+    return {
+      ...base,
+      status: "granted",
+      detail: `both required bridges are installed (${required2.map((item) => item.name).join(", ")}). ${consent}`,
+      fix: null
+    };
+  if (failed.length === missing.length && failed.length > 0)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `could not inspect: ${failed.map((item) => `${item.name}: ${item.error}`).join("; ")}`,
+      fix: "Run `apple-notes-mcp setup --check`."
+    };
+  return {
+    ...base,
+    status: "missing",
+    detail: `not installed: ${missing.map((item) => item.name).join(", ")}. The native-write tools (append-native, checklists, tables, native tags, pinning, note links) need them; everything else works without them`,
+    fix: `Run \`apple-notes-mcp setup\` and approve Add Shortcut in macOS. ${consent}`
+  };
+}
+function speechItem(probes, macOSVersion, who) {
+  const base = {
+    id: "speechRecognition",
+    title: "Speech Recognition",
+    required: false,
+    ...paneFields("speechRecognition", macOSVersion)
+  };
+  let answer;
+  try {
+    answer = probes.speech();
+  } catch (error2) {
+    answer = { ok: false, reason: errorText(error2) };
+  }
+  if (!answer.ok)
+    return {
+      ...base,
+      status: "unknown",
+      detail: `only transcribe-note-audio needs this; could not read the status: ${answer.reason}`,
+      fix: `Build the public native helper with \`${PUBLIC_HELPER_SETUP_COMMAND}\`, then run this check again.`
+    };
+  const state = answer.speechAuthorization;
+  if (state === "authorized")
+    return {
+      ...base,
+      status: "granted",
+      detail: "transcribe-note-audio can use on-device speech recognition",
+      fix: null
+    };
+  if (state === "restricted")
+    return {
+      ...base,
+      status: "missing",
+      detail: "Speech Recognition is restricted on this Mac (for example by a management profile)",
+      fix: "Ask the Mac's administrator; the restriction cannot be lifted in System Settings."
+    };
+  if (state === "denied")
+    return {
+      ...base,
+      status: "missing",
+      detail: "Speech Recognition was denied, so transcribe-note-audio stops with permission_required",
+      fix: `In ${PRIVACY} > Speech Recognition, turn on ${who}, then relaunch it.`
+    };
+  if (!answer.requiresGrant)
+    return {
+      ...base,
+      status: "not_needed",
+      detail: "not granted, and not needed: on macOS 26 and later transcription runs on-device without a Speech Recognition grant",
+      fix: null
+    };
+  return {
+    ...base,
+    status: "missing",
+    detail: `status ${state}. Before macOS 26, transcription needs this grant, and the server never shows the permission prompt`,
+    fix: `In ${PRIVACY} > Speech Recognition, turn on ${who} if it is listed, then relaunch it.`
+  };
+}
+function findLaunchingApp(startPid = process.ppid, readProcess = readProcessEntry) {
+  let pid = startPid;
+  for (let depth = 0; depth < 32 && pid > 1; depth++) {
+    const entry = readProcess(pid);
+    if (!entry) return null;
+    const match = /^(.*?\.app)\//.exec(entry.command);
+    if (match) return match[1];
+    pid = entry.ppid;
+  }
+  return null;
+}
+function readProcessEntry(pid) {
+  const result = spawnSync6("/bin/ps", ["-o", "ppid=", "-o", "comm=", "-p", String(pid)], {
+    encoding: "utf8",
+    timeout: 3e3
+  });
+  const match = /^\s*(\d+)\s+(.+)$/.exec(String(result.stdout ?? "").trim());
+  return match ? { ppid: Number(match[1]), command: match[2] } : null;
+}
+var AUTOMATION_TIMEOUT_MS = 6e4;
+function defaultPermissionProbes() {
+  return {
+    fullDiskAccess: hasFullDiskAccess,
+    notesAutomation: () => {
+      const result = executeAppleScript('tell application "Notes" to get name of account 1', {
+        timeoutMs: AUTOMATION_TIMEOUT_MS,
+        maxRetries: 1
+      });
+      return { success: result.success, error: result.error };
+    },
+    shortcuts: () => setupShortcuts(true),
+    speech: () => {
+      const install = inspectPublicHelper();
+      if (!install.ready)
+        return { ok: false, reason: install.detail ?? "the public native helper is not built" };
+      const answer = callPublicHelper("speech_status");
+      return {
+        ok: true,
+        speechAuthorization: String(answer.speechAuthorization ?? "unknown"),
+        requiresGrant: answer.requiresGrant !== false
+      };
+    },
+    macOSVersion: readMacOSVersion,
+    launchingApp: () => findLaunchingApp(),
+    execPath: process.execPath
+  };
+}
+function openSettingsPane(item, open = openUrl) {
+  if (!item.settingsUrl || !item.settingsUrl.startsWith("x-apple.systempreferences:"))
+    return { ok: false, error: `${item.title} has no System Settings pane` };
+  return open(item.settingsUrl);
+}
+function openUrl(url) {
+  const result = spawnSync6("/usr/bin/open", [url], { encoding: "utf8" });
+  return result.status === 0 ? { ok: true } : { ok: false, error: result.stderr || result.error?.message || "open failed" };
+}
+function pendingItems(report) {
+  return report.items.filter(
+    (item) => !item.notProbed && (item.status === "missing" || item.status === "unknown")
+  );
+}
+var ICONS = {
+  granted: "\u2713",
+  not_needed: "\u2713",
+  missing: "\u2717",
+  unknown: "?"
+};
+function formatPermissionsReport(report) {
+  const lines = ["Apple Notes MCP permissions", ""];
+  lines.push(
+    report.launchingApp ? `macOS attributes these grants to ${report.launchingApp}, the app that launched this check.` : `No launching app was found above this process, so macOS attributes these grants to ${report.execPath}.`
+  );
+  lines.push(
+    "An MCP host (Claude Desktop, an editor) can hold different grants: run this check from the same app, or use the doctor tool there.",
+    ""
+  );
+  for (const item of report.items) {
+    const tag = item.required ? "" : " (optional)";
+    lines.push(`${ICONS[item.status]} ${item.title}${tag}: ${item.detail}`);
+    if (item.notProbed) {
+      if (item.fix) lines.push(`    To check: ${item.fix}`);
+    } else if (item.status === "missing" || item.status === "unknown") {
+      if (item.settingsPane) lines.push(`    Pane: ${item.settingsPane}`);
+      if (item.settingsUrl) lines.push(`    URL:  ${item.settingsUrl}`);
+      if (item.fix) lines.push(`    Fix:  ${item.fix}`);
+    }
+  }
+  lines.push("");
+  const unchecked = report.items.some((item) => item.notProbed);
+  lines.push(
+    !report.ready ? "Required permissions are missing; the server works only partly until they are granted." : unchecked ? "Every required permission that was checked is granted. Automation of Notes.app was not checked." : "Every required permission is granted."
+  );
+  return lines.join("\n");
+}
+function parsePermissionsArgs(args) {
+  return {
+    open: args.includes("--open"),
+    once: args.includes("--once") || args.includes("--check"),
+    json: args.includes("--json"),
+    probeAutomation: args.includes("--probe-automation"),
+    check: args.includes("--check")
+  };
+}
+async function runPermissionsCli(options, deps) {
+  const opened = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const report = deps.check();
+    deps.write(
+      options.json ? JSON.stringify(report, null, 2) + "\n" : formatPermissionsReport(report) + "\n"
+    );
+    const pending = pendingItems(report);
+    if (options.open) {
+      for (const item of pending) {
+        if (!item.settingsUrl || opened.has(item.id)) continue;
+        opened.add(item.id);
+        const result = deps.open(item);
+        if (!options.json)
+          deps.write(
+            result.ok ? `Opened ${item.settingsPane}.
+` : `Could not open ${item.settingsPane}: ${result.error}
+`
+          );
+      }
+    }
+    if (pending.length === 0 || options.once || !deps.interactive) return report.ready ? 0 : 1;
+    deps.write("\nPress Enter to check again, or type q and press Enter to quit. ");
+    const line = await deps.waitForEnter();
+    if (line === null || line.trim().toLowerCase() === "q") return report.ready ? 0 : 1;
+    deps.write("\n");
+  }
+}
+function defaultPermissionsCliDeps(options) {
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const rl = interactive ? createInterface({ input: process.stdin }) : null;
+  const lines = [];
+  const waiters = [];
+  let closed = false;
+  rl?.on("line", (line) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(line);
+    else lines.push(line);
+  });
+  rl?.on("close", () => {
+    closed = true;
+    for (const waiter of waiters.splice(0)) waiter(null);
+  });
+  return {
+    check: () => checkPermissions(defaultPermissionProbes(), {
+      probeAutomation: options.probeAutomation,
+      check: options.check,
+      env: process.env
+    }),
+    open: (item) => openSettingsPane(item),
+    write: (text2) => process.stdout.write(text2),
+    waitForEnter: () => new Promise((resolveLine) => {
+      if (lines.length) resolveLine(lines.shift());
+      else if (closed || !rl) resolveLine(null);
+      else waiters.push(resolveLine);
+    }),
+    interactive,
+    close: () => rl?.close()
+  };
+}
+
+// src/services/permissionsWindow.ts
+import { spawn as spawn2, spawnSync as spawnSync7 } from "node:child_process";
+import {
+  chmodSync as chmodSync3,
+  existsSync as existsSync17,
+  mkdirSync as mkdirSync10,
+  mkdtempSync as mkdtempSync9,
+  readFileSync as readFileSync6,
+  renameSync as renameSync4,
+  rmSync as rmSync9,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { homedir as homedir22 } from "node:os";
+import { join as join31 } from "node:path";
+import { createInterface as createInterface2 } from "node:readline";
+var PERMISSIONS_WINDOW_PROTOCOL = 1;
+var PERMISSIONS_WINDOW_DIR_ENV = "APPLE_NOTES_MCP_PERMISSIONS_WINDOW_DIR";
+var PERMISSIONS_WINDOW_BINARY = "apple-notes-permissions-window";
+var PERMISSIONS_WINDOW_SOURCE = "native/permissions-window/apple-notes-permissions-window.swift";
+var PERMISSIONS_WINDOW_MANIFEST = "manifest.json";
+var PERMISSIONS_WINDOW_SETUP_COMMAND = "apple-notes-mcp setup --permissions-window";
+var PERMISSIONS_WINDOW_BUNDLE_ID = "apple-notes-mcp.permissions-window";
+var windowManifestSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  protocolVersion: external_exports.number().int(),
+  sourceSha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  binarySha256: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  builtAt: external_exports.string(),
+  compiler: external_exports.string()
+});
+function defaultPermissionsWindowDeps(overrides = {}) {
+  return {
+    env: process.env,
+    platform: process.platform,
+    sourcePath: join31(packageRoot(), PERMISSIONS_WINDOW_SOURCE),
+    exists: existsSync17,
+    readFile: (path10) => readFileSync6(path10),
+    spawn: spawnSync7,
+    now: () => /* @__PURE__ */ new Date(),
+    ...overrides
+  };
+}
+function permissionsWindowInstallDir(env = process.env) {
+  const override = env[PERMISSIONS_WINDOW_DIR_ENV]?.trim();
+  if (override) return override;
+  return join31(homedir22(), "Library", "Application Support", "apple-notes-mcp", "permissions-window");
+}
+function inspectPermissionsWindow(deps = defaultPermissionsWindowDeps()) {
+  const installDir = permissionsWindowInstallDir(deps.env);
+  const binaryPath = join31(installDir, PERMISSIONS_WINDOW_BINARY);
+  const fail = (reason, detail) => ({ ready: false, reason, detail, installDir, binaryPath });
+  if (deps.platform !== "darwin") return fail("unsupported_platform", "macOS only");
+  const rebuild = `Run \`${PERMISSIONS_WINDOW_SETUP_COMMAND}\`.`;
+  if (!deps.exists(deps.sourcePath))
+    return fail("window_not_installed", `Packaged window source is missing: ${deps.sourcePath}`);
+  const manifestPath = join31(installDir, PERMISSIONS_WINDOW_MANIFEST);
+  if (!deps.exists(binaryPath) || !deps.exists(manifestPath))
+    return fail("window_not_installed", `The permissions window is not built. ${rebuild}`);
+  let manifest;
+  try {
+    manifest = windowManifestSchema.parse(JSON.parse(deps.readFile(manifestPath).toString("utf8")));
+  } catch {
+    return fail("window_manifest_invalid", `The window manifest is unreadable. ${rebuild}`);
+  }
+  if (manifest.sourceSha256 !== sha256Hex(deps.readFile(deps.sourcePath)) || manifest.protocolVersion !== PERMISSIONS_WINDOW_PROTOCOL)
+    return fail(
+      "window_stale",
+      `The installed window was built from a different source than this version ships. ${rebuild}`
+    );
+  if (sha256Hex(deps.readFile(binaryPath)) !== manifest.binarySha256)
+    return fail(
+      "window_modified",
+      `The window binary no longer matches the checksum recorded when it was built. ${rebuild}`
+    );
+  return { ready: true, reason: null, detail: null, installDir, binaryPath };
+}
+function permissionsWindowInfoPlist() {
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
+    '<plist version="1.0">',
+    "<dict>",
+    "  <key>CFBundleIdentifier</key>",
+    `  <string>${PERMISSIONS_WINDOW_BUNDLE_ID}</string>`,
+    "  <key>CFBundleName</key>",
+    "  <string>Apple Notes MCP Permissions</string>",
+    "  <key>CFBundleInfoDictionaryVersion</key>",
+    "  <string>6.0</string>",
+    "</dict>",
+    "</plist>",
+    ""
+  ].join("\n");
+}
+function permissionsWindowCompileArguments(sourcePath, digestPath, plistPath, outputPath) {
+  return [
+    "swiftc",
+    "-O",
+    "-parse-as-library",
+    "-framework",
+    "AppKit",
+    "-framework",
+    "SwiftUI",
+    "-Xlinker",
+    "-sectcreate",
+    "-Xlinker",
+    "__TEXT",
+    "-Xlinker",
+    "__info_plist",
+    "-Xlinker",
+    plistPath,
+    sourcePath,
+    digestPath,
+    "-o",
+    outputPath
+  ];
+}
+var helloSchema2 = external_exports.object({
+  type: external_exports.literal("hello"),
+  protocolVersion: external_exports.number().int(),
+  sourceSha256: external_exports.string()
+});
+function buildPermissionsWindow(checkOnly, deps = defaultPermissionsWindowDeps()) {
+  const steps = [];
+  const finish = () => {
+    const installation2 = inspectPermissionsWindow(deps);
+    return {
+      ok: installation2.ready && steps.every((s) => s.ok),
+      checkOnly,
+      steps,
+      installation: installation2
+    };
+  };
+  if (checkOnly) {
+    const installation2 = inspectPermissionsWindow(deps);
+    steps.push({
+      step: "inspect installed window",
+      ok: installation2.ready,
+      detail: installation2.ready ? installation2.binaryPath : installation2.detail ?? void 0
+    });
+    return finish();
+  }
+  if (deps.platform !== "darwin") {
+    steps.push({ step: "platform", ok: false, detail: "macOS only" });
+    return finish();
+  }
+  if (!deps.exists(deps.sourcePath)) {
+    steps.push({ step: "locate source", ok: false, detail: deps.sourcePath });
+    return finish();
+  }
+  const sourceSha = sha256Hex(deps.readFile(deps.sourcePath));
+  steps.push({ step: "locate source", ok: true, detail: `sha256 ${sourceSha}` });
+  const version3 = deps.spawn("/usr/bin/xcrun", ["swiftc", "--version"], { encoding: "utf8" });
+  if (version3.status !== 0) {
+    steps.push({
+      step: "find compiler",
+      ok: false,
+      detail: "No Swift compiler found. Install the Command Line Tools with `xcode-select --install`."
+    });
+    return finish();
+  }
+  const compiler = String(version3.stdout || version3.stderr || "").split("\n").find((line) => line.includes("Swift version"))?.trim() || "swiftc";
+  steps.push({ step: "find compiler", ok: true, detail: compiler });
+  const installDir = permissionsWindowInstallDir(deps.env);
+  mkdirSync10(installDir, { recursive: true, mode: 448 });
+  const staging = mkdtempSync9(join31(installDir, ".staging-"));
+  try {
+    const stagedBinary = join31(staging, PERMISSIONS_WINDOW_BINARY);
+    const digestPath = join31(staging, "source-digest.swift");
+    const plistPath = join31(staging, "Info.plist");
+    writeFileSync8(digestPath, sourceDigestSwift(sourceSha), { mode: 384 });
+    writeFileSync8(plistPath, permissionsWindowInfoPlist(), { mode: 384 });
+    const compile = deps.spawn(
+      "/usr/bin/xcrun",
+      permissionsWindowCompileArguments(deps.sourcePath, digestPath, plistPath, stagedBinary),
+      { encoding: "utf8", timeout: 3e5 }
+    );
+    if (compile.status !== 0) {
+      steps.push({
+        step: "compile",
+        ok: false,
+        detail: String(compile.stderr || compile.error?.message || "swiftc failed").slice(0, 4e3)
+      });
+      return finish();
+    }
+    steps.push({ step: "compile", ok: true });
+    const sign = deps.spawn(
+      "/usr/bin/codesign",
+      ["--force", "--sign", "-", "--identifier", PERMISSIONS_WINDOW_BUNDLE_ID, stagedBinary],
+      { encoding: "utf8" }
+    );
+    if (sign.status !== 0) {
+      steps.push({ step: "ad-hoc sign", ok: false, detail: String(sign.stderr || "failed") });
+      return finish();
+    }
+    steps.push({ step: "ad-hoc sign", ok: true });
+    const hello = deps.spawn(stagedBinary, [], {
+      input: JSON.stringify({ type: "hello" }) + "\n",
+      encoding: "utf8",
+      timeout: 1e4,
+      killSignal: "SIGKILL"
+    });
+    let parsed = null;
+    try {
+      parsed = helloSchema2.parse(JSON.parse(String(hello.stdout ?? "").trim()));
+    } catch {
+      parsed = null;
+    }
+    if (!parsed || parsed.protocolVersion !== PERMISSIONS_WINDOW_PROTOCOL || parsed.sourceSha256 !== sourceSha) {
+      steps.push({
+        step: "handshake",
+        ok: false,
+        detail: parsed ? `window reported protocol ${parsed.protocolVersion}, source ${parsed.sourceSha256}` : `no valid hello (exit ${hello.status})`
+      });
+      return finish();
+    }
+    steps.push({ step: "handshake", ok: true });
+    const manifest = {
+      schemaVersion: 1,
+      protocolVersion: parsed.protocolVersion,
+      sourceSha256: sourceSha,
+      binarySha256: sha256Hex(deps.readFile(stagedBinary)),
+      builtAt: deps.now().toISOString(),
+      compiler
+    };
+    chmodSync3(stagedBinary, 448);
+    renameSync4(stagedBinary, join31(installDir, PERMISSIONS_WINDOW_BINARY));
+    writeFileSync8(
+      join31(installDir, PERMISSIONS_WINDOW_MANIFEST),
+      JSON.stringify(manifest, null, 2) + "\n",
+      { mode: 384 }
+    );
+    steps.push({ step: "install", ok: true, detail: installDir });
+  } finally {
+    rmSync9(staging, { recursive: true, force: true });
+  }
+  const installation = inspectPermissionsWindow(deps);
+  steps.push({
+    step: "verify installation",
+    ok: installation.ready,
+    detail: installation.ready ? void 0 : installation.detail ?? void 0
+  });
+  return finish();
+}
+function formatPermissionsWindowBuild(report) {
+  const lines = ["Apple Notes MCP permissions window", ""];
+  for (const step of report.steps)
+    lines.push(`${step.ok ? "\u2713" : "\u2717"} ${step.step}${step.detail ? `: ${step.detail}` : ""}`);
+  lines.push("");
+  if (report.ok)
+    lines.push(
+      `Installed at ${report.installation.binaryPath}. Open it with \`apple-notes-mcp setup --permissions --window\`.`
+    );
+  else if (report.checkOnly) lines.push(`Run \`${PERMISSIONS_WINDOW_SETUP_COMMAND}\` to build it.`);
+  else lines.push("The window was not installed. Fix the failed step above and run setup again.");
+  return lines.join("\n");
+}
+var windowMessageSchema = external_exports.discriminatedUnion("type", [
+  external_exports.object({ type: external_exports.literal("open"), id: external_exports.string().max(64) }),
+  external_exports.object({ type: external_exports.literal("recheck") })
+]);
+function runPermissionsWindow(binaryPath, session) {
+  const launch = session.launch ?? ((path10) => spawn2(path10, [], { stdio: ["pipe", "pipe", "inherit"] }));
+  const log = session.log ?? (() => {
+  });
+  let report = session.check();
+  const child2 = launch(binaryPath);
+  const sendReport = () => {
+    if (child2.stdin && !child2.stdin.destroyed)
+      child2.stdin.write(JSON.stringify({ type: "report", report }) + "\n");
+  };
+  child2.stdin?.on("error", () => {
+  });
+  sendReport();
+  if (child2.stdout) {
+    const lines = createInterface2({ input: child2.stdout });
+    lines.on("line", (line) => {
+      let message;
+      try {
+        message = windowMessageSchema.parse(JSON.parse(line));
+      } catch {
+        return;
+      }
+      if (message.type === "recheck") {
+        report = session.check();
+        sendReport();
+        return;
+      }
+      const item = report.items.find((candidate) => candidate.id === message.id);
+      if (!item || item.notProbed) return;
+      const result = session.open(item);
+      log(
+        result.ok ? `Opened ${item.settingsPane}.
+` : `Could not open ${item.settingsPane ?? item.title}: ${result.error}
+`
+      );
+    });
+  }
+  return new Promise((resolveExit) => {
+    child2.on("error", (error2) => {
+      log(`Could not run the permissions window: ${error2.message}
+`);
+      resolveExit(report.ready ? 0 : 1);
+    });
+    child2.on("close", () => resolveExit(report.ready ? 0 : 1));
+  });
+}
+
 // src/tools/privateHelperTools.ts
 var coreDataId2 = external_exports.string().regex(/^x-coredata:\/\/[0-9A-F-]+\/ICNote\/p\d+$/i);
 var notesUuid = external_exports.string().regex(UUID_PATTERN);
@@ -59514,6 +60219,733 @@ function registerPrivateHelperTools(server2, manager, depsFactory = () => defaul
   );
 }
 
+// src/utils/localServer.ts
+import { randomBytes as randomBytes3, timingSafeEqual } from "node:crypto";
+import { networkInterfaces } from "node:os";
+function isTailnetIPv4(address) {
+  const match = /^100\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(address);
+  if (!match) return false;
+  const [second, third, fourth] = match.slice(1).map(Number);
+  return second >= 64 && second <= 127 && third <= 255 && fourth <= 255;
+}
+function findTailnetAddress(interfaces = networkInterfaces()) {
+  const candidates = [];
+  for (const [name, infos] of Object.entries(interfaces)) {
+    for (const info of infos ?? []) {
+      if (info.family === "IPv4" && !info.internal && isTailnetIPv4(info.address))
+        candidates.push({ address: info.address, interface: name });
+    }
+  }
+  return candidates.find((c) => c.interface.startsWith("utun")) ?? candidates[0];
+}
+function newServerToken() {
+  return randomBytes3(32).toString("hex");
+}
+function bearerToken(req) {
+  const auth = req.headers.authorization;
+  return auth?.startsWith("Bearer ") ? auth.slice(7) : void 0;
+}
+function tokenMatches(given, token) {
+  if (!given) return false;
+  const a = Buffer.from(given, "utf8");
+  const b = Buffer.from(token, "utf8");
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function hostAuthority(host, port) {
+  return host.includes(":") ? `[${host}]:${port}` : `${host}:${port}`;
+}
+function crossOriginRefusal(req, origin, requireOrigin = false) {
+  const site = req.headers["sec-fetch-site"];
+  if (site && site !== "same-origin" && site !== "none") return "cross-site";
+  const requestOrigin = req.headers.origin;
+  if (requestOrigin !== void 0 && requestOrigin !== origin) return "foreign-origin";
+  if (requireOrigin && requestOrigin !== origin) return "missing-origin";
+  return void 0;
+}
+
+// src/services/templateEditor.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { createServer } from "node:http";
+
+// src/utils/templateSamples.ts
+function sampleBlock(text2, style = "body", extra = {}, runs = [{ text: text2 }]) {
+  return {
+    index: 0,
+    start: 0,
+    length: runs.reduce((sum, run) => sum + run.text.length, 0),
+    text: runs.map((run) => run.text).join(""),
+    style,
+    styleType: null,
+    indent: 0,
+    alignment: "left",
+    blockQuote: false,
+    ...extra,
+    runs: runs.map((run) => ({ start: 0, length: run.text.length, ...run })),
+    attachments: []
+  };
+}
+var sampleAttachmentRun = (id2, uti) => ({
+  text: "\uFFFC",
+  attachment: { id: id2, uti }
+});
+function sampleAttachment(id2, uti, extra = {}) {
+  return { id: id2, pk: 0, uti, kind: classifyUti(uti), children: [], ...extra };
+}
+function sampleNote(pk, blocks, attachments = []) {
+  let offset = 0;
+  const indexed = blocks.map((b, index) => {
+    const start = offset;
+    offset += b.length + 1;
+    let at = start;
+    const runs = b.runs.map((run) => {
+      const shifted = { ...run, start: at };
+      at += run.length;
+      return shifted;
+    });
+    const markers2 = runs.flatMap(
+      (run) => run.attachment ? [{ ...run.attachment, start: run.start, blockIndex: index }] : []
+    );
+    return { ...b, index, start, runs, attachments: markers2 };
+  });
+  const markers = indexed.flatMap((b) => b.attachments);
+  return {
+    id: `x-coredata://SAMPLE/ICNote/p${pk}`,
+    title: indexed[0]?.text ?? "",
+    doc: {
+      text: indexed.map((b) => b.text).join("\n"),
+      textLength: offset,
+      blocks: indexed,
+      attachments: markers,
+      undecodedFields: { attributeRun: {}, paragraphStyle: {} },
+      summary: summarize(indexed, markers)
+    },
+    attachments: new Map(attachments.map((a) => [a.id, a])),
+    ordered: attachments.map((a, i) => ({ ...a, pk: i + 1 }))
+  };
+}
+function sampleMeta(uuid2) {
+  return {
+    uuid: uuid2,
+    created: "2026-01-05T14:30:00.000Z",
+    modified: "2026-02-10T09:15:00.000Z",
+    folder: "Sample Folder",
+    account: "iCloud"
+  };
+}
+function templateSamples() {
+  return [
+    {
+      id: "structure",
+      label: "Headings, lists and checklists",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000001"),
+      note: sampleNote(1, [
+        sampleBlock("Weekly Plan", "title"),
+        sampleBlock("Goals", "heading"),
+        sampleBlock("Details", "subheading"),
+        sampleBlock("A plain paragraph with *characters* that need escaping."),
+        sampleBlock("First step", "numbered"),
+        sampleBlock("Second step", "numbered"),
+        sampleBlock("Nested step", "numbered", { indent: 1 }),
+        sampleBlock("A bullet", "bulleted"),
+        sampleBlock("A dash", "dashed"),
+        sampleBlock("Nested bullet", "bulleted", { indent: 1 }),
+        sampleBlock("Done task", "checklist", { checklist: { id: "sample-a", done: true } }),
+        sampleBlock("Open task", "checklist", { checklist: { id: "sample-b", done: false } }),
+        sampleBlock("A quoted line", "body", { blockQuote: true }),
+        sampleBlock("const answer = 42;", "monospaced"),
+        sampleBlock('console.log("sample");', "monospaced")
+      ])
+    },
+    {
+      id: "inline",
+      label: "Inline formatting and links",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000002"),
+      note: sampleNote(2, [
+        sampleBlock("Formatting Sample", "title"),
+        sampleBlock("", "body", {}, [
+          { text: "Bold", bold: true },
+          { text: ", " },
+          { text: "italic", italic: true },
+          { text: ", " },
+          { text: "both", bold: true, italic: true },
+          { text: ", " },
+          { text: "struck", strikethrough: true },
+          { text: ", " },
+          { text: "underlined", underline: true },
+          { text: "." }
+        ]),
+        sampleBlock("", "body", {}, [
+          { text: "Highlighted", highlight: "purple" },
+          { text: ", x" },
+          { text: "2", superscript: true },
+          { text: ", H" },
+          { text: "2", subscript: true },
+          { text: "O, and " },
+          { text: "red text", color: "#FF3B30" },
+          { text: "." }
+        ]),
+        sampleBlock("", "body", {}, [
+          { text: "A " },
+          { text: "web link", link: "https://example.com/page", linkSafe: true },
+          { text: " and a " },
+          { text: "bold link", link: "https://example.com/bold", linkSafe: true, bold: true },
+          { text: "." }
+        ])
+      ])
+    },
+    {
+      id: "attachments",
+      label: "Attachments and tags",
+      meta: sampleMeta("00000000-0000-4000-8000-000000000003"),
+      note: sampleNote(
+        3,
+        [
+          sampleBlock("Trip Notes", "title"),
+          sampleBlock("", "body", {}, [
+            { text: "Tagged " },
+            sampleAttachmentRun("SAMPLE-TAG", "com.apple.notes.inlinetextattachment.hashtag"),
+            { text: " for later." }
+          ]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-IMG", "public.jpeg")]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-PDF", "com.adobe.pdf")]),
+          sampleBlock("", "body", {}, [
+            sampleAttachmentRun("SAMPLE-DIV", "com.apple.notes.inlinetextattachment.dividerline")
+          ]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-URL", "public.url")]),
+          sampleBlock("", "body", {}, [sampleAttachmentRun("SAMPLE-IMGURL", "public.url")])
+        ],
+        [
+          sampleAttachment("SAMPLE-TAG", "com.apple.notes.inlinetextattachment.hashtag", {
+            altText: "#travel"
+          }),
+          sampleAttachment("SAMPLE-IMG", "public.jpeg", { title: "harbor.jpg" }),
+          sampleAttachment("SAMPLE-PDF", "com.adobe.pdf", { title: "itinerary.pdf" }),
+          sampleAttachment("SAMPLE-DIV", "com.apple.notes.inlinetextattachment.dividerline"),
+          sampleAttachment("SAMPLE-URL", "public.url", {
+            title: "Example Domain",
+            url: "https://example.com/"
+          }),
+          sampleAttachment("SAMPLE-IMGURL", "public.url", {
+            title: "Harbor at dusk",
+            url: "https://example.com/photos/harbor.jpg"
+          })
+        ]
+      )
+    }
+  ];
+}
+
+// src/services/templateEditorPage.ts
+var EDITOR_STYLE = `
+:root { color-scheme: light dark; --bg: #fafafa; --fg: #1d1d1f; --muted: #6e6e73;
+  --panel: #ffffff; --border: #d2d2d7; --accent: #0a66d8; --bad: #c1272d; --ok: #1f7a3a; }
+@media (prefers-color-scheme: dark) { :root { --bg: #1c1c1e; --fg: #f2f2f7; --muted: #a1a1a6;
+  --panel: #2c2c2e; --border: #3a3a3c; --accent: #4c9bff; --bad: #ff6b6b; --ok: #4cd07d; } }
+* { box-sizing: border-box; }
+body { margin: 0; font: 14px/1.4 -apple-system, BlinkMacSystemFont, "Helvetica Neue", sans-serif;
+  background: var(--bg); color: var(--fg); }
+header { display: flex; flex-wrap: wrap; gap: 8px 16px; align-items: center; padding: 10px 16px;
+  border-bottom: 1px solid var(--border); background: var(--panel); }
+header h1 { font-size: 15px; margin: 0 12px 0 0; }
+label { display: inline-flex; gap: 6px; align-items: center; color: var(--muted); }
+select, input, button, textarea { font: inherit; color: var(--fg); background: var(--bg);
+  border: 1px solid var(--border); border-radius: 6px; padding: 4px 8px; }
+button { background: var(--accent); color: #fff; border-color: var(--accent); cursor: pointer; }
+main { display: grid; grid-template-columns: 1fr 1fr; gap: 12px; padding: 12px 16px;
+  height: calc(100vh - 110px); min-height: 360px; }
+@media (max-width: 800px) { main { grid-template-columns: 1fr; height: auto; } }
+section { display: flex; flex-direction: column; min-height: 0; min-width: 0; }
+h2 { font-size: 13px; margin: 0 0 6px; color: var(--muted); font-weight: 600; }
+textarea { flex: 1; min-height: 300px; width: 100%; resize: none;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; }
+pre { flex: 1; margin: 0; overflow: auto; padding: 8px; background: var(--panel);
+  border: 1px solid var(--border); border-radius: 6px; min-height: 300px;
+  font: 12px/1.45 ui-monospace, SFMono-Regular, Menlo, monospace; white-space: pre-wrap; }
+ul { margin: 6px 0 0; padding-left: 18px; max-height: 120px; overflow: auto; }
+.bad { color: var(--bad); } .ok { color: var(--ok); } .muted { color: var(--muted); }
+footer { padding: 0 16px 12px; }
+`;
+var EDITOR_SCRIPT = `
+"use strict";
+const token = new URLSearchParams(location.search).get("token") || "";
+const $ = (id) => document.getElementById(id);
+const api = async (path, body) => {
+  const res = await fetch(path, body === undefined
+    ? { headers: { Authorization: "Bearer " + token } }
+    : { method: "POST", headers: { Authorization: "Bearer " + token,
+        "Content-Type": "application/json" }, body: JSON.stringify(body) });
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) { const e = new Error((data.error && data.error.message) || res.statusText);
+    e.detail = data.error; throw e; }
+  return data;
+};
+const setText = (id, text, cls) => { const el = $(id); el.textContent = text;
+  el.className = cls || ""; };
+const list = (id, items) => { const ul = $(id); ul.replaceChildren();
+  for (const item of items) { const li = document.createElement("li");
+    li.textContent = item; ul.append(li); } };
+let timer;
+async function refresh() {
+  try {
+    const out = await api("/api/preview", { template: $("json").value, sample: $("sample").value });
+    if (out.valid) setText("status", "Valid template.", "ok");
+    else setText("status", out.errors.length + " problem(s):", "bad");
+    list("errors", out.errors.map((e) => e.path + ": " + e.message));
+    list("warnings", out.warnings.map((w) => w.code + (w.attachmentId ? " (" + w.attachmentId + ")" : "")));
+    $("preview").textContent = out.valid ? out.markdown : "";
+  } catch (e) { setText("status", "Preview failed: " + e.message, "bad"); }
+}
+const schedule = () => { clearTimeout(timer); timer = setTimeout(refresh, 250); };
+async function load(name) {
+  try {
+    const out = await api("/api/template?name=" + encodeURIComponent(name));
+    $("json").value = JSON.stringify(out.template, null, 2) + "\\n";
+    $("name").value = out.source === "saved" ? out.name : "";
+    refresh();
+  } catch (e) { setText("status", "Could not open " + name + ": " + e.message, "bad"); }
+}
+async function save() {
+  try {
+    const out = await api("/api/save", { name: $("name").value.trim(),
+      template: $("json").value, force: $("force").checked });
+    setText("saved", (out.replaced ? "Replaced " : "Saved ") + out.name + " at " + out.path, "ok");
+    $("force").checked = false;
+    await fillPicker(out.name);
+  } catch (e) {
+    const errors = (e.detail && e.detail.errors) || [];
+    setText("saved", e.message + (errors.length ? " " + errors.map((x) => x.path + ": " + x.message).join("; ") : ""), "bad");
+  }
+}
+async function fillPicker(selected) {
+  const state = await api("/api/state");
+  const picker = $("picker"); picker.replaceChildren();
+  const group = (label, names) => { const g = document.createElement("optgroup");
+    g.label = label; for (const n of names) { const o = document.createElement("option");
+      o.value = n; o.textContent = n; g.append(o); } picker.append(g); };
+  group("Built-in", state.builtins);
+  if (state.saved.length) group("Saved", state.saved);
+  picker.value = selected;
+  setText("dir", "Library: " + state.dir, "muted");
+  return state;
+}
+(async () => {
+  try {
+    const state = await fillPicker("");
+    const sample = $("sample");
+    for (const s of state.samples) { const o = document.createElement("option");
+      o.value = s.id; o.textContent = s.label; sample.append(o); }
+    $("picker").value = state.initial.name;
+    $("json").value = JSON.stringify(state.initial.template, null, 2) + "\\n";
+    $("name").value = state.initial.source === "saved" ? state.initial.name : "";
+    $("json").addEventListener("input", schedule);
+    sample.addEventListener("change", refresh);
+    $("picker").addEventListener("change", () => load($("picker").value));
+    $("save").addEventListener("click", save);
+    refresh();
+  } catch (e) { setText("status", "Could not start: " + e.message, "bad"); }
+})();
+`;
+var EDITOR_BODY = `
+<header>
+  <h1>Markdown template editor</h1>
+  <label>Open <select id="picker"></select></label>
+  <label>Preview <select id="sample"></select></label>
+  <span id="dir" class="muted"></span>
+</header>
+<main>
+  <section>
+    <h2>Template JSON</h2>
+    <textarea id="json" spellcheck="false" aria-label="Template JSON"></textarea>
+    <div id="status" role="status"></div>
+    <ul id="errors" class="bad"></ul>
+  </section>
+  <section>
+    <h2>Markdown preview</h2>
+    <pre id="preview" aria-label="Markdown preview"></pre>
+    <ul id="warnings" class="muted" aria-label="Warnings"></ul>
+  </section>
+</main>
+<footer>
+  <label>Save as <input id="name" placeholder="my-template" maxlength="64" autocomplete="off"></label>
+  <label><input id="force" type="checkbox"> Replace an existing template</label>
+  <button id="save" type="button">Save</button>
+  <span id="saved" role="status"></span>
+</footer>
+`;
+function templateEditorPage(nonce) {
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="referrer" content="no-referrer"><title>Template Editor</title><style nonce="${nonce}">${EDITOR_STYLE}</style></head><body>${EDITOR_BODY}<script nonce="${nonce}">${EDITOR_SCRIPT}</script></body></html>`;
+}
+
+// src/services/templateEditor.ts
+var DEFAULT_EDITOR_IDLE_MS = 30 * 60 * 1e3;
+var MAX_EDITOR_BODY_BYTES = MAX_TEMPLATE_BYTES * 2 + 4096;
+var EditorHttpError = class extends Error {
+  constructor(status, code, message, errors) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.errors = errors;
+  }
+  status;
+  code;
+  errors;
+};
+function editorPresentedToken(req, url) {
+  return bearerToken(req)?.trim() ?? url.searchParams.get("token") ?? void 0;
+}
+var CROSS_ORIGIN_MESSAGE = {
+  "cross-site": "Cross-site requests are refused.",
+  "foreign-origin": "Cross-origin requests are refused.",
+  "missing-origin": "POST requires the editor's own Origin."
+};
+async function readEditorJson(req) {
+  const type = req.headers["content-type"] ?? "";
+  if (!/^application\/json(?:\s*;|$)/i.test(type))
+    throw new EditorHttpError(415, "unsupported-media-type", "Send JSON (application/json).");
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > MAX_EDITOR_BODY_BYTES)
+      throw new EditorHttpError(413, "too-large", "Request body too large.");
+    chunks.push(chunk);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new EditorHttpError(400, "bad-request", "Request body is not valid JSON.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new EditorHttpError(400, "bad-request", "Request body must be a JSON object.");
+  return parsed;
+}
+var editorStringField = (body, key) => {
+  const value = body[key];
+  if (typeof value !== "string")
+    throw new EditorHttpError(400, "bad-request", `"${key}" must be a string.`);
+  return value;
+};
+async function startTemplateEditor(options = {}) {
+  const host = options.host ?? "127.0.0.1";
+  const idleMs = options.idleMs ?? DEFAULT_EDITOR_IDLE_MS;
+  const store = options.store ?? new TemplateStore();
+  const token = options.token ?? newServerToken();
+  const samples = templateSamples();
+  const initialName = options.name ?? "standard-markdown";
+  const initial = isBuiltinTemplate(initialName) ? builtinTemplate(initialName) : store.get(initialName);
+  const initialSource = isBuiltinTemplate(initialName) ? "builtin" : "saved";
+  let origin = "";
+  let hostHeader = "";
+  let idleTimer;
+  let closeReason = "closed";
+  const sockets = /* @__PURE__ */ new Set();
+  const loadTemplate = (name) => {
+    if (isBuiltinTemplate(name))
+      return { name, source: "builtin", template: builtinTemplate(name) };
+    return { name, source: "saved", template: store.get(name) };
+  };
+  const state = () => {
+    const listing = store.list();
+    return {
+      builtins: BUILTIN_TEMPLATE_NAMES,
+      saved: listing.templates.map((t) => t.name),
+      dir: listing.dir,
+      samples: [
+        ...samples.map((s) => ({ id: s.id, label: s.label })),
+        ...options.note ? [{ id: "note", label: `Note: ${options.note.note.title}` }] : []
+      ],
+      initial: { name: initialName, source: initialSource, template: initial }
+    };
+  };
+  const preview = (body) => {
+    const text2 = editorStringField(body, "template");
+    const sampleId = typeof body.sample === "string" ? body.sample : samples[0].id;
+    const source = sampleId === "note" && options.note ? options.note : samples.find((s) => s.id === sampleId);
+    if (!source) throw new EditorHttpError(400, "bad-request", `Unknown sample "${sampleId}".`);
+    let portable;
+    try {
+      portable = parseTemplate(text2);
+    } catch (error2) {
+      if (error2 instanceof TemplateValidationError)
+        return { valid: false, errors: error2.errors, markdown: "", warnings: [] };
+      throw error2;
+    }
+    const result = renderNotesWithTemplate(
+      [source.note],
+      { stats: emptyStats() },
+      {
+        template: resolveTemplate(portable),
+        exportStem: "preview",
+        metaFor: () => source.meta
+      }
+    );
+    return { valid: true, errors: [], markdown: result.markdown, warnings: result.warnings };
+  };
+  const save = (body) => {
+    const name = editorStringField(body, "name");
+    const text2 = editorStringField(body, "template");
+    const force = body.force === true;
+    try {
+      const saved = store.save(name, text2, { force });
+      return { name, path: saved.path, bytes: saved.bytes, replaced: saved.replaced };
+    } catch (error2) {
+      if (error2 instanceof TemplateValidationError)
+        throw new EditorHttpError(
+          422,
+          "invalid-template",
+          "The template is invalid.",
+          error2.errors
+        );
+      if (error2 instanceof TemplateStoreError && error2.code === "template-exists")
+        throw new EditorHttpError(
+          409,
+          error2.code,
+          `A template named "${name}" already exists. Tick "Replace an existing template" to replace it.`
+        );
+      if (error2 instanceof TemplateStoreError)
+        throw new EditorHttpError(400, error2.code, error2.message);
+      throw error2;
+    }
+  };
+  const send = (res, status, type, body, extra = {}) => {
+    res.writeHead(status, {
+      "Content-Type": type,
+      "Cache-Control": "no-store",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff",
+      "X-Frame-Options": "DENY",
+      "Cross-Origin-Resource-Policy": "same-origin",
+      "Cross-Origin-Opener-Policy": "same-origin",
+      ...extra
+    });
+    res.end(body);
+  };
+  const sendJson = (res, status, value) => send(res, status, "application/json; charset=utf-8", JSON.stringify(value));
+  const touch = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (idleMs > 0)
+      idleTimer = setTimeout(() => {
+        closeReason = "idle";
+        void close();
+      }, idleMs);
+  };
+  const handle = async (req, res) => {
+    if (req.headers.host !== hostHeader)
+      throw new EditorHttpError(421, "wrong-host", "Unexpected Host header.");
+    const url = new URL(req.url ?? "/", origin);
+    if (!tokenMatches(editorPresentedToken(req, url), token))
+      throw new EditorHttpError(401, "unauthorized", "Missing or wrong token.");
+    const refusal = crossOriginRefusal(req, origin, req.method === "POST");
+    if (refusal) throw new EditorHttpError(403, "cross-origin", CROSS_ORIGIN_MESSAGE[refusal]);
+    touch();
+    const route = `${req.method} ${url.pathname}`;
+    switch (route) {
+      case "GET /": {
+        const nonce = randomBytes4(16).toString("base64");
+        return send(res, 200, "text/html; charset=utf-8", templateEditorPage(nonce), {
+          "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; img-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'`
+        });
+      }
+      case "GET /api/state":
+        return sendJson(res, 200, state());
+      case "GET /api/template": {
+        const name = url.searchParams.get("name") ?? "";
+        try {
+          return sendJson(res, 200, loadTemplate(name));
+        } catch (error2) {
+          if (error2 instanceof TemplateStoreError)
+            throw new EditorHttpError(404, error2.code, error2.message);
+          if (error2 instanceof TemplateValidationError)
+            throw new EditorHttpError(
+              422,
+              "invalid-template",
+              "The saved template is invalid.",
+              error2.errors
+            );
+          throw error2;
+        }
+      }
+      case "POST /api/preview":
+        return sendJson(res, 200, preview(await readEditorJson(req)));
+      case "POST /api/save":
+        return sendJson(res, 200, save(await readEditorJson(req)));
+      default:
+        throw new EditorHttpError(404, "not-found", "Not found.");
+    }
+  };
+  const server2 = createServer((req, res) => {
+    handle(req, res).catch((error2) => {
+      const http = error2 instanceof EditorHttpError ? error2 : new EditorHttpError(
+        500,
+        "internal-error",
+        "The editor could not complete the request."
+      );
+      if (!res.headersSent)
+        sendJson(res, http.status, {
+          error: {
+            code: http.code,
+            message: http.message,
+            ...http.errors ? { errors: http.errors } : {}
+          }
+        });
+      else res.end();
+    });
+  });
+  server2.on("connection", (socket) => {
+    sockets.add(socket);
+    socket.on("close", () => sockets.delete(socket));
+  });
+  let resolveClosed;
+  const closed = new Promise((resolve9) => resolveClosed = resolve9);
+  let closing;
+  const close = () => {
+    closing ??= new Promise((resolve9) => {
+      if (idleTimer) clearTimeout(idleTimer);
+      server2.close(() => {
+        resolveClosed(closeReason);
+        resolve9();
+      });
+      for (const socket of sockets) socket.destroy();
+    });
+    return closing;
+  };
+  await new Promise((resolve9, reject) => {
+    server2.once("error", reject);
+    server2.listen({ host, port: options.port ?? 0, exclusive: true }, () => {
+      server2.off("error", reject);
+      resolve9();
+    });
+  });
+  const port = server2.address().port;
+  const authority = hostAuthority(host, port);
+  origin = `http://${authority}`;
+  hostHeader = authority;
+  touch();
+  return { url: `${origin}/?token=${token}`, host, port, token, closed, close };
+}
+
+// src/services/templateEditorCli.ts
+var TEMPLATES_USAGE = `Usage: apple-notes-mcp templates edit [name] [options]
+
+Open a local web editor for Markdown export templates. The editor validates
+and previews as you type, against built-in sample notes, and saves into the
+template library (create-only unless you tick "replace").
+
+  name                 Template to open: standard-markdown, obsidian, or a saved name
+  --port N             Port to listen on (default: a free port)
+  --idle-minutes N     Stop after N minutes without a request (default 30; 0: never)
+  --note ID            Also preview one real note (x-coredata://.../ICNote/pN), read-only
+  --tailnet            Listen on this Mac's Tailscale address instead of 127.0.0.1,
+                       so other devices on your tailnet can open the editor.
+                       Anyone on the tailnet who has the printed URL can read and save
+                       templates, and with --note can read the full body of that note.
+
+Every request needs the per-run token in the printed URL. Press Ctrl-C to stop.
+`;
+function parseTemplatesArgs(argv) {
+  if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) return "help";
+  const [command, ...rest] = argv;
+  if (command !== "edit") throw new Error(`Unknown templates command "${command}".`);
+  const args = {
+    idleMinutes: DEFAULT_EDITOR_IDLE_MS / 6e4,
+    tailnet: false
+  };
+  const number3 = (flag3, value, max) => {
+    if (value === void 0 || !/^\d+$/.test(value) || Number(value) > max)
+      throw new Error(`${flag3} needs a whole number from 0 to ${max}.`);
+    return Number(value);
+  };
+  for (let i = 0; i < rest.length; i++) {
+    const arg = rest[i];
+    if (arg === "--port") args.port = number3(arg, rest[++i], 65535);
+    else if (arg === "--idle-minutes") args.idleMinutes = number3(arg, rest[++i], 24 * 60);
+    else if (arg === "--note") {
+      const id2 = rest[++i];
+      if (!id2 || !/^x-coredata:\/\/[^/\s]+\/ICNote\/p[0-9]{1,18}$/.test(id2))
+        throw new Error("--note needs a note id such as x-coredata://\u2026/ICNote/p123.");
+      args.noteId = id2;
+    } else if (arg === "--tailnet") args.tailnet = true;
+    else if (arg.startsWith("-")) throw new Error(`Unknown option ${arg}.`);
+    else if (args.name === void 0) args.name = arg;
+    else throw new Error(`Unexpected argument "${arg}".`);
+  }
+  return args;
+}
+var editorSignals = (stop) => {
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  return () => {
+    process.off("SIGINT", stop);
+    process.off("SIGTERM", stop);
+  };
+};
+function tailnetWarning(host, withNote) {
+  const lines = [
+    `Listening on the tailnet address ${host}. Any device on your tailnet that has this URL can read and save templates. Keep the URL private.`,
+    withNote ? "--note is set: the full body of that note is shown in the preview, so anyone with this URL can read the entire note. Stop the editor when you are done." : "--note exposes the full note body to anyone with this URL, so do not combine it with --tailnet unless you want that."
+  ];
+  return `${lines.join("\n")}
+`;
+}
+async function runTemplatesCommand(argv, deps = {}) {
+  const out = deps.out ?? ((text2) => process.stdout.write(text2));
+  const err = deps.err ?? ((text2) => process.stderr.write(text2));
+  let args;
+  try {
+    args = parseTemplatesArgs(argv);
+  } catch (error2) {
+    err(`${error2.message}
+
+${TEMPLATES_USAGE}`);
+    return 2;
+  }
+  if (args === "help") {
+    out(TEMPLATES_USAGE);
+    return 0;
+  }
+  let host = "127.0.0.1";
+  if (args.tailnet) {
+    const found = (deps.tailnetAddress ?? findTailnetAddress)();
+    if (!found) {
+      err(
+        "No Tailscale address found (no 100.64.0.0/10 IPv4 address on this Mac). Connect Tailscale first, or run without --tailnet.\n"
+      );
+      return 1;
+    }
+    host = found.address;
+  }
+  let handle;
+  try {
+    const note = args.noteId ? (deps.readNote ?? ((id2) => ({ note: readExportNote(id2), meta: readExportNoteMeta(id2) })))(args.noteId) : void 0;
+    handle = await (deps.start ?? startTemplateEditor)({
+      host,
+      port: args.port,
+      idleMs: args.idleMinutes * 6e4,
+      name: args.name,
+      note
+    });
+  } catch (error2) {
+    err(`Could not start the template editor: ${error2.message}
+`);
+    return 1;
+  }
+  out(`Template editor: ${handle.url}
+`);
+  if (args.tailnet) err(tailnetWarning(handle.host, args.noteId !== void 0));
+  err(
+    args.idleMinutes > 0 ? `Press Ctrl-C to stop. Stops by itself after ${args.idleMinutes} idle minute(s).
+` : "Press Ctrl-C to stop.\n"
+  );
+  const unregister = (deps.onSignal ?? editorSignals)(() => void handle.close());
+  const reason = await handle.closed;
+  unregister();
+  err(
+    reason === "idle" ? "Template editor stopped after the idle timeout.\n" : "Template editor stopped.\n"
+  );
+  return 0;
+}
+
 // src/index.ts
 loadFileConfig();
 var require2 = createRequire(import.meta.url);
@@ -59528,11 +60960,40 @@ if (process.argv[2] === "setup" && process.argv.slice(3).includes("--native-help
   process.stdout.write(formatHelperBuild(report) + "\n");
   process.exit(report.ok ? 0 : 1);
 }
+if (process.argv[2] === "setup" && process.argv.slice(3).includes("--permissions-window")) {
+  const report = buildPermissionsWindow(process.argv.slice(3).includes("--check"));
+  process.stdout.write(formatPermissionsWindowBuild(report) + "\n");
+  process.exit(report.ok ? 0 : 1);
+}
+if (process.argv[2] === "setup" && process.argv.slice(3).includes("--permissions")) {
+  const args = process.argv.slice(3);
+  const options = parsePermissionsArgs(args);
+  const cli = defaultPermissionsCliDeps(options);
+  let code;
+  const window2 = args.includes("--window") ? inspectPermissionsWindow() : null;
+  if (window2?.ready) {
+    code = await runPermissionsWindow(window2.binaryPath, {
+      check: cli.check,
+      open: (item) => openSettingsPane(item),
+      log: cli.write
+    });
+  } else {
+    if (window2) cli.write(`${window2.detail} Showing the checklist here instead.
+
+`);
+    code = await runPermissionsCli(options, cli);
+  }
+  cli.close();
+  process.exit(code);
+}
 if (process.argv[2] === "setup") {
   const report = setupShortcuts(process.argv.slice(3).includes("--check"));
   process.stdout.write(formatShortcutSetup(report) + "\n");
   process.exit(report.ready || !report.checkOnly ? 0 : 1);
 }
+if (process.argv[2] === "templates") {
+  process.exit(await runTemplatesCommand(process.argv.slice(3)));
+}
 var server = new McpServer({
   name: "apple-notes",
   version: version2,