Skip to content
Back to search

zennotes

Keyboard-first local Markdown notes with Vim motions, diagrams, and MCP integration.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/ZenNotes/zennotes with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/ZenNotes/zennotes'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zennotes--zennotes/badge.svg)](/listings/zennotes--zennotes)

HTML

<a href="/listings/zennotes--zennotes"><img src="/api/listings/zennotes--zennotes/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

All desktop installers are attached to each [GitHub Release](https://github.com/ZenNotes/zennotes/releases/latest). The app auto-updates, so you only download once. (Replace `<version>` with the current release, e.g. `2.2.0`.)

macOS

**Homebrew (recommended):**

brew install --cask zennotes/tap/zennotes

Or download the `.dmg` for your chip, open it, and drag **ZenNotes** to Applications. Builds are signed and notarized.

- Apple Silicon: `ZenNotes-<version>-mac-arm64.dmg` - Intel: `ZenNotes-<version>-mac-x64.dmg`

Windows

Download and run `ZenNotes-<version>-win-x64.exe`.

Linux

Pick whatever suits your distro:

- **Arch / CachyOS / Manjaro — AUR (recommended):**

  yay -S zennotes-bin     # or: paru -S zennotes-bin

Installs cleanly without `libfuse2`. - **Arch — native package:**

  sudo pacman -U ZenNotes-<version>-linux-x86_64.pacman

- **Debian / Ubuntu:**

  sudo apt install ./ZenNotes-<version>-linux-amd64.deb

- **Nix / NixOS:** Read [packaging/nix/README.md](packaging/nix/README.md) for installation instructions - **Any distro — AppImage:**

  chmod +x ZenNotes-<version>-linux-x86_64.AppImage
  ./ZenNotes-<version>-linux-x86_64.AppImage

AppImages need **FUSE 2**. On distros that ship only FUSE 3 (Arch, CachyOS, Fedora), either install it (`sudo pacman -S fuse2`, `sudo dnf install fuse`) or run without FUSE:

  ./ZenNotes-<version>-linux-x86_64.AppImage --appimage-extract-and-run

(Or just use the AUR / `.pacman` / `.deb` package, which sidestep this entirely.)

`zen` CLI

The desktop app installs a `zen` command-line companion from **Settings → CLI** — list, read, search, capture, edit, archive/trash notes, plus tasks, folders, and MCP. On macOS it can also install the Raycast extension locally.

Self-hosted web app

ZenNotes also runs as a self-hosted web app backed by a Go server. See [Local development](#local-development) to run the web client and server.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 616 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # ZenNotes
  2. <p align="center">
  3. <img src="apps/desktop/build/icon.png" alt="ZenNotes app icon" width="160">
  4. </p>
  5. > [!NOTE]
  6. > I build ZenNotes with a lot of help from AI tools like Claude and Codex. They let me move much faster, but I still go through some of the code before I ship it. The architecture, the technical decisions, and the trade-offs are things I still spend a lot of time thinking about. AI helps me write code faster, but it doesn't replace understanding how the system works.
  7. ZenNotes is a keyboard-first Markdown notes app with a shared product core and multiple runtimes:
  8. - a desktop app built with Electron
  9. - a self-hosted web app backed by a Go server
  10. - a future hosted deployment mode built on the same web/server stack
  11. ZenNotes keeps your notes as ordinary Markdown files on disk. It adds Vim-friendly editing, split and preview workflows, tasks, tags, archive/trash, diagrams, search, daily notes, CSV databases (Notion-style Table + Board views over plain `.csv` files), and MCP integration on top of the files you already own.
  12. On macOS, the first-party `zen` CLI also powers launcher workflows such as the Raycast extension.
  13. Grab the latest build from [GitHub Releases](https://github.com/ZenNotes/zennotes/releases/latest) — see [Install](#install) below.
  14. Website: [zennotes.org](https://zennotes.org)
  15. Support development: [GitHub Sponsors](https://github.com/sponsors/adibhanna)
  16. Detailed in-repo documentation lives under [docs/README.md](docs/README.md).
  17. ## Install
  18. All desktop installers are attached to each [GitHub Release](https://github.com/ZenNotes/zennotes/releases/latest). The app auto-updates, so you only download once. (Replace `<version>` with the current release, e.g. `2.2.0`.)
  19. ### macOS
  20. **Homebrew (recommended):**
  21. ```sh
  22. brew install --cask zennotes/tap/zennotes
  23. ```
  24. Or download the `.dmg` for your chip, open it, and drag **ZenNotes** to Applications. Builds are signed and notarized.
  25. - Apple Silicon: `ZenNotes-<version>-mac-arm64.dmg`
  26. - Intel: `ZenNotes-<version>-mac-x64.dmg`
  27. ### Windows
  28. Download and run the installer for your PC:
  29. - Intel and AMD: `ZenNotes-<version>-win-x64.exe`
  30. - ARM (Snapdragon and other Windows on ARM): `ZenNotes-<version>-win-arm64.exe`
  31. ### Linux
  32. Pick whatever suits your distro:
  33. - **Arch / CachyOS / Manjaro — AUR (recommended):**
  34. ```sh
  35. yay -S zennotes-bin # or: paru -S zennotes-bin
  36. ```
  37. Installs cleanly without `libfuse2`.
  38. - **Arch — native package:**
  39. ```sh
  40. sudo pacman -U ZenNotes-<version>-linux-x86_64.pacman
  41. ```
  42. - **Debian / Ubuntu:**
  43. ```sh
  44. sudo apt install ./ZenNotes-<version>-linux-amd64.deb
  45. ```
  46. - **Nix / NixOS:**
  47. Read [packaging/nix/README.md](packaging/nix/README.md) for installation instructions
  48. - **Any distro — AppImage:**
  49. ```sh
  50. chmod +x ZenNotes-<version>-linux-x86_64.AppImage
  51. ./ZenNotes-<version>-linux-x86_64.AppImage
  52. ```
  53. AppImages need **FUSE 2**. On distros that ship only FUSE 3 (Arch, CachyOS, Fedora), either install it (`sudo pacman -S fuse2`, `sudo dnf install fuse`) or run without FUSE:
  54. ```sh
  55. ./ZenNotes-<version>-linux-x86_64.AppImage --appimage-extract-and-run
  56. ```
  57. (Or just use the AUR / `.pacman` / `.deb` package, which sidestep this entirely.)
  58. ### `zen` CLI
  59. The desktop app installs a `zen` command-line companion from **Settings → CLI** — list, read, search, capture, edit, archive/trash notes, plus tasks, folders, and MCP. On macOS it can also install the Raycast extension locally.
  60. ### Self-hosted web app
  61. ZenNotes also runs as a self-hosted web app backed by a Go server. See [Local development](#local-development) to run the web client and server.
  62. ## What ZenNotes is for
  63. - writing and organizing plain-file Markdown notes without a database
  64. - moving quickly with keyboard-first navigation and Vim motions
  65. - working across edit, split, and preview modes without losing context
  66. - keeping tasks, tags, search, archive, trash, and quick capture inside the same vault
  67. - rendering math and diagrams directly from Markdown
  68. - exposing the vault to MCP-capable tools through a first-party server
  69. - searching and opening notes from terminal scripts or Raycast on macOS
  70. - self-hosting the app on your own machine or home server
  71. ## Product modes
  72. ZenNotes now ships from one monorepo with one shared app core.
  73. - `desktop`: Electron shell, native menus, updater, floating windows, desktop packaging
  74. - `self-hosted`: browser frontend plus Go server, suitable for home servers and LAN use
  75. - `hosted`: planned as the same web/server stack with auth and multi-user storage added later
  76. The source of truth for user-facing features is the shared UI in `packages/app-core`.
  77. ## Core ideas
  78. ### Plain files first
  79. Every note is a normal `.md` file inside a chosen vault. ZenNotes does not store note content in a hidden database.
  80. ### Keyboard-first by default
  81. ZenNotes assumes you want to move fast:
  82. - first-class Vim mode
  83. - leader-key flows
  84. - command palette
  85. - pane and tab motion
  86. - local ex commands
  87. - built-in help
  88. ### Preview is part of the workflow
  89. ZenNotes supports:
  90. - edit mode
  91. - preview mode
  92. - split mode
  93. - pinned reference panes
  94. - detached note windows on desktop
  95. ### Shared vault, shared tooling
  96. ZenNotes includes a first-party MCP server and desktop install flows for compatible clients, so tools can work on the same vault you do instead of a copy.
  97. ## Feature overview
  98. ### Notes, folders, and lifecycle
  99. ZenNotes can:
  100. - create, rename, duplicate, move, archive, unarchive, trash, restore, and reveal notes and folders
  101. - watch the vault for external changes
  102. - reopen your workspace layout with tabs and panes
  103. System folders still exist, but the vault model is more flexible now:
  104. - `quick`, `archive`, and `trash` remain built-in lifecycle areas
  105. - the main notes area can be either:
  106. - `inbox/`
  107. - the vault root directly, for Obsidian-style flat vaults
  108. The built-in folder labels are also customizable in the UI without changing the underlying internal ids.
  109. ### Daily and weekly notes
  110. Daily and weekly notes are optional and can be enabled from Settings.
  111. - when enabled, ZenNotes can open or create today's daily note and this week's weekly note automatically
  112. - the default daily title is a simple ISO date like `2026-04-21`
  113. - the default weekly title is an ISO week title like `2026-W24`
  114. - date notes live in dedicated directories under your primary notes area
  115. - the default directories are `Daily Notes` and `Weekly Notes`
  116. - the directory and title can use date patterns such as `yyyy/MM-MMM` and `yyyy-MM-dd-EEE`
  117. - weekly title patterns can use ISO week tokens such as `yyyy-'W'ww`
  118. - localized month and weekday names can follow `system`, `en-US`, `pt-BR`, or another BCP 47 locale
  119. Supported date note pattern tokens:
  120. - `yyyy` / `yy` for `2026` / `26`
  121. - `M` / `MM` / `MMM` / `MMMM` for `6` / `06` / `Jun` / `June`
  122. - `d` / `dd` for `9` / `09`
  123. - `EEE` / `EEEE` for `Tue` / `Tuesday`
  124. - `w` / `ww` for ISO week numbers like `24`
  125. - single-quoted literals, such as `'Daily Notes'/yyyy/MM-MMM`
  126. Weekly notes render date tokens from the ISO week's Monday, and `yyyy` is the ISO week-year for weekly patterns.
  127. ### Editor and preview
  128. The editor stack is CodeMirror 6 with a Markdown-oriented workflow:
  129. - live preview behavior in the editor
  130. - heading folding
  131. - outline extraction and jumps
  132. - configurable line numbers
  133. - configurable line-height and typography controls
  134. - syntax highlighting for fenced code blocks
  135. - desktop-installed TextMate grammars for custom fenced-code languages
  136. - wiki links, callouts, tables, footnotes, and local embeds
  137. - Vim block cursor and keyboard navigation
  138. Preview and split mode support:
  139. - GitHub-flavored Markdown
  140. - KaTeX math
  141. - Mermaid
  142. - TikZ
  143. - JSXGraph
  144. - function-plot
  145. - callouts
  146. - footnotes
  147. - wiki links and backlinks
  148. ### Search, tasks, tags, and built-in views
  149. ZenNotes includes:
  150. - note search by title and path
  151. - vault-wide text search
  152. - tags view
  153. - tasks view
  154. - archive view
  155. - trash view
  156. - quick notes view
  157. - built-in help/manual
  158. Vault text search can use the built-in engine, `ripgrep`, or `fzf`, with auto-detection and optional custom binary paths.
  159. The desktop app also ships a `zen` command-line companion for list, read, search, capture, edit, archive/trash, task, folder, and MCP workflows. On macOS, ZenNotes can install its Raycast extension locally from Settings -> CLI, avoiding the Raycast Store review path. The integration uses the CLI plus `zennotes://` deep links to search notes, open them in the main app, open them in floating windows, archive/unarchive, move notes to Trash, reveal files in Finder, and copy note paths or wikilinks.
  160. ### Obsidian-friendly vault support
  161. ZenNotes now works better with existing Obsidian-style vaults.
  162. - primary notes can live at the vault root instead of requiring `inbox/`
  163. - loose files anywhere in the vault are surfaced as files/assets
  164. - embedded files like `![[image.png]]` resolve more like Obsidian
  165. - new referenced files default to the vault root instead of a required attachments folder
  166. - legacy `attachements/` and `_assets/` folders are still recognized
  167. This means imported vaults with top-level notes, folders, and loose images/files behave much more naturally.
  168. ### Files and local assets
  169. ZenNotes supports local files in notes and in the sidebar/list views.
  170. - local images and files can appear directly in the vault tree
  171. - images, SVGs, videos, audio, PDFs, and other media open inside ZenNotes tabs or reference panes instead of being handed off to the OS by default
  172. - desktop context menus include reveal-in-file-manager actions
  173. - desktop uses Finder on macOS and the platform file manager on Windows/Linux
  174. - watcher updates now include non-Markdown file changes, so deleting files externally updates the UI without a manual refresh
  175. Sidebar multi-select supports platform modifiers: use Cmd/Ctrl-click to toggle individual notes or folders, Shift-click to select a visible range, then use the context menu to apply actions such as open in tabs, move, archive, trash, restore, delete folders, copy paths, or drag the selected group to a folder.
  176. ### Themes, fonts, and customization
  177. The settings surface includes:
  178. - theme families and light/dark/auto modes
  179. - interface, text, and monospace font selection
  180. - editor font size and line-height controls
  181. - preview and editor width controls
  182. - content alignment
  183. - keymap overrides
  184. - Vim toggles and leader hint behavior
  185. - search backend selection
  186. - vault layout settings
  187. - daily notes settings
  188. - system-folder display labels
  189. ## Desktop vs web
  190. Both runtimes share the same core app, but they do not expose identical platform features.
  191. Desktop-only features include:
  192. - native menus
  193. - app updater
  194. - floating note windows
  195. - `zen` CLI install/uninstall flow
  196. - local Raycast extension installation on macOS
  197. - MCP install/uninstall flows for supported clients
  198. - reveal in Finder / platform file manager
  199. - packaging and signed releases
  200. Web/self-hosted mode includes:
  201. - the same shared note UI and workflows
  202. - a Go backend for vault access and file watching
  203. - a server-side vault picker/browser
  204. - browser access on a LAN or home server
  205. ## Monorepo layout
  206. ZenNotes now uses a single monorepo.
  207. ```text
  208. apps/
  209. desktop/ Electron shell, preload, updater, packaging
  210. web/ Vite/PWA shell and HTTP bridge
  211. packages/
  212. app-core/ Shared React application and renderer logic
  213. bridge-contract/ Typed runtime contract between UI and host
  214. shared-domain/ Shared types and note/task/view models
  215. shared-ui/ Reusable UI primitives
  216. tooling/
  217. scripts/ Shared tooling hooks and migration scripts
  218. docs/
  219. ```
  220. Read [docs/monorepo-architecture.md](docs/monorepo-architecture.md) for the architectural boundary between the shared app core and the platform-specific shells.
  221. ## Quick start
  222. ### Requirements
  223. - Node.js 22.22 or newer
  224. - npm
  225. - Go 1.22+ for the server build path
  226. - Docker optional, for self-hosting
  227. ### Install dependencies
  228. ```bash
  229. npm ci
  230. ```
  231. ## Local development
  232. ### Desktop app
  233. ```bash
  234. npm run dev:desktop
  235. ```
  236. or:
  237. ```bash
  238. make desktop
  239. ```
  240. ### Web client
  241. ```bash
  242. npm run dev:web
  243. ```
  244. or:
  245. ```bash
  246. make web-dev
  247. ```
  248. ### Go server
  249. The server lives in its own repository,
  250. [ZenNotes/znserver](https://github.com/ZenNotes/znserver). For browser work
  251. you do not need it checked out: `npm run dev:server` downloads the release
  252. pinned in `tooling/server-release.json`, verifies its checksum, and runs it.
  253. To work on the server itself, point `ZENNOTES_SERVER_DIR` at a znserver
  254. checkout and the same command runs it with `go run`.
  255. ```bash
  256. npm run dev:server
  257. ```
  258. or:
  259. ```bash
  260. make server-dev
  261. ```
  262. ### Web + server together
  263. ```bash
  264. npm run dev:web-stack
  265. ```
  266. or:
  267. ```bash
  268. make web-stack
  269. ```
  270. Important dev note:
  271. - the browser app and the Go server are separate processes in dev mode
  272. - frontend-only changes usually need only the web dev server
  273. - backend changes happen in ZenNotes/znserver and need that server restarted
  274. - if the web client is newer than the running server, ZenNotes now shows a clearer error instead of raw 404 noise for newer API flows like the vault picker
  275. ## Root scripts
  276. From the repository root:
  277. | Script | Purpose |
  278. | ----------------------- | ----------------------------------------------- |
  279. | `npm run dev` | Alias for `npm run dev:desktop` |
  280. | `npm run dev:desktop` | Run the Electron desktop app in development |
  281. | `npm run dev:web` | Run the Vite web client |
  282. | `npm run dev:server` | Run the Go server |
  283. | `npm run dev:web-stack` | Run web + server development together |
  284. | `npm run start` | Start the built desktop app |
  285. | `npm run typecheck` | Run monorepo typechecks |
  286. | `npm run test` | Run monorepo tests |
  287. | `npm run test:run` | Run the full test suite |
  288. | `npm run build` | Build the monorepo and then build the Go server |
  289. | `npm run build:prod` | Typecheck + test + build |
  290. | `npm run pack` | Desktop packaged output |
  291. | `npm run dist:mac` | Build macOS desktop distributables |
  292. | `npm run dist:win` | Build Windows desktop distributables |
  293. | `npm run dist:linux` | Build Linux desktop distributables |
  294. ## Makefile commands
  295. The root `Makefile` provides a simpler interface:
  296. | Command | Purpose |
  297. | -------------------- | ------------------------------------------------------- |
  298. | `make install` | Install workspace dependencies |
  299. | `make desktop` | Run the Electron app in dev mode |
  300. | `make web-dev` | Run the web client |
  301. | `make server-dev` | Run the pinned Go server release (or a checkout) |
  302. | `make web-stack` | Run web + server together |
  303. | `make build` | Build the full monorepo |
  304. | `make desktop-build` | Build the Electron app |
  305. | `make web-build` | Build `apps/web` |
  306. | `make up` | Start the self-hosted Docker stack from the published image |
  307. | `make down` | Stop the Docker stack |
  308. | `make restart` | Restart the Docker stack |
  309. | `make logs` | Follow Docker logs |
  310. | `make status` | Show Docker status |
  311. | `make open` | Open the self-hosted app in a browser |
  312. | `make rebuild` | Pull the newest image and restart |
  313. | `make nuke` | Remove the Docker image, data, and build output |
  314. | `make clean` | Remove web build output and downloaded server binaries |
  315. Run `make help` to print the same summary.
  316. ## Self-hosting with Docker
  317. The image, `adibhanna/zennotes`, is built and published from the server's own
  318. repository, [ZenNotes/znserver](https://github.com/ZenNotes/znserver). This
  319. repository only ships the Compose file and Makefile that run it.
  320. ### Start the self-hosted app
  321. ```bash
  322. make up
  323. ```
  324. Then open:
  325. - [http://localhost:7878](http://localhost:7878)
  326. ### Default Docker mounts
  327. When you start Docker with `make up`, ZenNotes mounts:
  328. - host `./vault` -> container `./vault`'s absolute host path
  329. - host `./data` -> container `/data`
  330. In practice, that means the container sees the vault at the same absolute path you chose on the host, instead of rewriting it to `/workspace`.
  331. The server stores its config under `/data/server.json` by default.
  332. ### Default Docker security behavior
  333. The self-hosted Docker flow is now secure by default:
  334. - the published port binds to `127.0.0.1` unless you override it
  335. - ZenNotes generates a bootstrap auth token on first `make up` and stores it in `./data/auth-token`
  336. - the browser version signs in with that token once, then uses an `HttpOnly` session cookie
  337. - the container runs as your local UID/GID by default, with a read-only root filesystem, `no-new-privileges`, and dropped Linux capabilities
  338. Useful env vars:
  339. - `ALLOW_INSECURE_NOAUTH=1`: only use this if you intentionally want to disable auth
  340. - `ZENNOTES_ALLOWED_ORIGINS`: explicit browser origin allowlist
  341. - `ZENNOTES_BROWSE_ROOTS`: restricts which server-side directories the picker can browse
  342. Recommended deployment model:
  343. - keep ZenNotes behind a reverse proxy, VPN, or private network gate
  344. - do not expose the raw Go server directly to the public internet unless you understand the tradeoffs
  345. ### Choosing a different host folder
  346. You can mount a different host content root:
  347. ```bash
  348. CONTENT_ROOT="$HOME/Library/Mobile Documents/com~apple~CloudDocs" make up
  349. ```
  350. That works for paths with spaces too.
  351. Useful variables:
  352. - `CONTENT_ROOT`: host folder used as the live vault root
  353. - `DATA`: host directory used for persisted server config
  354. - `PORT`: published host port
  355. - `IMAGE`: Docker image to run (default `adibhanna/zennotes:latest`; pin with `IMAGE=adibhanna/zennotes:2.50.5`)
  356. - `ALLOW_INSECURE_NOAUTH`: disable the default auth requirement
  357. ### Docker browse model
  358. Important limitation:
  359. - the Docker container can only browse folders that are mounted into it
  360. - it cannot browse your entire host filesystem
  361. - by default, the picker is scoped to the mounted content root unless you explicitly relax it
  362. So if you want to browse an Obsidian vault, iCloud Drive, or another directory from the web picker, that directory needs to be mounted into the container first.
  363. ### Relevant container env vars
  364. The current compose/runtime flow supports:
  365. - `ZENNOTES_BIND`
  366. - `ZENNOTES_CONFIG_PATH`
  367. - `ZENNOTES_DEFAULT_VAULT_PATH`
  368. - `ZENNOTES_BROWSE_ROOTS`
  369. - `ZENNOTES_VAULT_PATH`
  370. Behavior notes:
  371. - `ZENNOTES_VAULT_PATH` hard-locks the server to a specific vault path
  372. - `ZENNOTES_DEFAULT_VAULT_PATH` sets the starting vault when no saved selection exists
  373. - `ZENNOTES_BROWSE_ROOTS` limits what the web picker can browse
  374. - `ZENNOTES_ALLOWED_ORIGINS` restricts which browser origins can connect
  375. - `ZENNOTES_ALLOW_UNSCOPED_BROWSE=1` removes browse-root enforcement
  376. - `ZENNOTES_ALLOW_INSECURE_NOAUTH=1` disables the default auth guardrail
  377. ## Web vault picker
  378. The self-hosted web build now includes a server-backed vault chooser.
  379. - it browses folders on the server, not the browser machine
  380. - it only browses configured allowed roots by default
  381. - it starts from sensible locations instead of requiring blind path typing
  382. - it supports a simpler folder-picker flow for choosing the active vault
  383. - on macOS-hosted servers, common shortcuts like iCloud Drive are supported when available
  384. If you start the server with `ZENNOTES_VAULT_PATH`, manual vault switching is intentionally disabled.
  385. If auth is enabled, the browser asks for the bootstrap token once and then switches to a secure session cookie. ZenNotes no longer relies on auth tokens in browser URLs or local storage.
  386. ## MCP integration
  387. ZenNotes ships a dedicated MCP server and desktop install flows for:
  388. - Claude Code
  389. - Claude Desktop
  390. - Codex
  391. The desktop app can:
  392. - detect whether the ZenNotes MCP entry is installed
  393. - install or uninstall it for each supported client
  394. - show the exact runtime used to launch the server
  395. - edit the server's default instructions from Settings
  396. The MCP server exposes vault operations such as:
  397. - reading notes
  398. - creating notes
  399. - moving notes
  400. - appending to notes
  401. - listing notes
  402. - searching vault text
  403. - listing files/assets
  404. - toggling tasks
  405. ## Building and packaging desktop releases
  406. ### Build everything
  407. ```bash
  408. npm run build:prod
  409. ```
  410. ### Desktop package scripts
  411. ```bash
  412. npm run pack
  413. npm run dist:mac
  414. npm run dist:win
  415. npm run dist:linux
  416. ```
  417. ### Signed macOS releases
  418. Public macOS releases are wired for hardened runtime signing and notarization.
  419. The GitHub Actions release workflow expects:
  420. - `MACOS_CERTIFICATE_P12`
  421. - `MACOS_CERTIFICATE_PASSWORD`
  422. - `APPLE_ID`
  423. - `APPLE_APP_SPECIFIC_PASSWORD`
  424. - `APPLE_TEAM_ID`
  425. Optional Windows signing can be supplied with:
  426. - `WINDOWS_CERTIFICATE_P12`
  427. - `WINDOWS_CERTIFICATE_PASSWORD`
  428. Tagged releases fail the macOS release job if the required Apple signing or notarization secrets are missing. That prevents accidentally shipping an unsigned public mac build.
  429. ## Current status
  430. ZenNotes is actively evolving. The desktop app is the more mature runtime today, while the self-hosted web/server path is being brought into parity through the shared monorepo core.
  431. That means:
  432. - many features are shared already
  433. - some platform-specific behavior still lives in the shell layers
  434. - the README will keep evolving as desktop, web, and self-hosted flows converge further
  435. ## License
  436. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.