Note Keeper (dsh-note-keeper)

Obsidian-compatible Markdown notes in the DSH sidebar, with search, graph, audio notes and agent tools.

Install from npm: dsh plugin --profile web add @lucagiftzek/dsh-note-keeper (the package carries a prebuilt Linux x64 daemon), or from GitHub: clone, build and link a checkout:

git clone https://github.com/lucagiftzek/dsh-note-keeper.git && cd dsh-note-keeper
npm ci && npm run build   # Go daemon + browser bundle (Go 1.22+, Node 22.5+)
dsh plugin --profile web add link:$PWD   # then restart dsh web

Screenshot from a demo DSH instance with sample data.

Note Keeper is a plugin for the DeepSeek Harness (DSH) web GUI: an
Obsidian-compatible, local-first notes app that lives in the left sidebar and
opens as a full-page panel. It stores notes as plain Markdown files in a
regular directory on disk, so any Obsidian-compatible sync method keeps it in
step with a phone or another desktop. It also exposes a set of notes_*
tools so an AI in the same DSH chat can read, search and write the user's
notes under a clear set of guardrails.

Author: Loukas "Luca" Tzekos. License: MIT.

Feature overview

• Left-sidebar "Notes" entry: a row in the sidebar panel list
  (sidebar.panellist slot) that opens Note Keeper as a full-page panel
  registered in the main-column keyed slot.
• Obsidian-compatible vault: plain Markdown files under a normal
  directory (default ~/NoteKeeper, configurable via vault). Wikilinks
  ([[Note]]), embeds (![[Note]]), #tags (including nested
  project/alpha), YAML frontmatter, callouts (> [!warning]), and a
  .trash folder for recoverable deletes, exactly the way Obsidian lays
  them out.
• Rename-safe wikilinks: moving or renaming a note rewrites every
  [[wikilink]]/![[embed]] that pointed at it, in every other note, the
  same way Obsidian does.
• Live sync from any writer: an fsnotify-backed watcher reindexes any
  change (this app's own writes, Obsidian on the same machine, a sync
  client landing a phone edit) and pushes a Server-Sent Events refresh to
  every open browser tab; a 5-minute full rescan repairs anything a dropped
  kernel event missed.
• Full-text search: accent-insensitive for both Greek and Latin script
  (Καλημέρα ≈ καλημερα ≈ ΚΑΛΗΜΕΡΑ), last-word prefix matching while typing,
  and "quoted phrase" matching. Filterable by tag (nested tags included)
  or folder.
• Tags, backlinks, outline, graph: a tag browser with counts, a
  backlinks panel per note, a heading outline, and an interactive local
  graph view (note/attachment/tag nodes, plus "ghost" nodes for unresolved
  links, just like Obsidian's graph).
• Quick capture & daily notes: one shortcut appends a timestamped
  bullet (or a - [ ] task) to Inbox.md; another opens or creates
  today's daily note at Daily/YYYY-MM-DD.md, expanding
  Templates/Daily.md when present.
• Templates: any note under the Templates/ folder can be used to
  start a new note, with {{title}}, {{date}} and {{time}} expanded.
• Audio notes: record with MediaRecorder, send the clip to the
  dsh-voice plugin's /api/voice/stt endpoint with the language pinned
  (Greek and English are first-class; several others are offered; "auto"
  lets the engine detect), optionally run a text-polish pass, and save the
  result as a Markdown note with nk-type: audio frontmatter
  (language, engine, duration) embedding the audio clip.
• Retro paint canvas: an MS-Paint-style drawing editor: pencil, brush,
  eraser, spray and more, over a raster canvas plus an editable vector shape
  layer. Saving writes a PNG, the vector JSON, and (optionally) OCR'd text
  from the drawing into a single "drawing" note.
• OCR: Tesseract (eng+ell by default) runs over pasted/attached
  images and over paint-canvas drawings to extract text (handwriting
  included, on a best-effort basis).
• Attachments: upload, paste, or drag-and-drop images, audio, video and
  PDF, with inline previews; risky file types (HTML, SVG, JS, …) are always
  forced to download so an uploaded file can never script the DSH origin.
  Large files: uploads above 64 MiB are sent as 64 MiB slices
  (begin / chunk… / finish), because an edge such as Cloudflare refuses
  any single request body over 100 MB. The server stages the slices in a hidden
  .nk-up-* file, renames it into place at finish, and removes it on any
  failure or abort. The assembled-file cap is 1 GiB (maxAttachBytes).
• Client-side zero-knowledge encryption: see the Security model
  section below. Encrypted notes/attachments/folders are opaque to the
  server, to sync tools and to AI tools; only the browser that knows the
  password can read them.
• Conflict detection: every save carries the mtime it was read at; a
  concurrent edit from another device, Obsidian, or an AI tool produces a
  conflict banner offering "load disk version", "keep both" or "overwrite
  with mine", instead of silently clobbering data.
• Autosave: edits are saved 1.2 s after the last keystroke, and flushed
  immediately when the tab is hidden or closed.
• Live preview editor: CodeMirror 6 with Obsidian-style live preview: links,
  wikilinks and tags are clickable while you type; source, split and reading modes too.
• Connect: the Note Keeper Sync plugin for Obsidian (desktop and mobile, two-way,
  paired with a one-time code, signed requests), WebDAV for other apps, and a
  two-way cloud mirror (Google Drive, OneDrive, Dropbox, iCloud Drive, S3) via rclone.
  See docs/SYNC-PROTOCOL.md.
• Import: Obsidian/Bear/Logseq/Joplin Markdown, HTML, Evernote .enex, Google Keep
  Takeout, Notion export zips.
• AI Enhance: proofread, format and interlink a note with the DSH default model
  (or any model chosen in its settings), previewed as a diff before anything changes.
• 12 AI tools (notes_*), see the AI tools table.

Screenshots

v0.2: live preview (links and tags clickable), AI Enhance diff review, Connect (Obsidian pairing):

Captured from the live DSH GUI with a custom theme (dark mode).

Install

Install from npm: dsh plugin --profile web add @lucagiftzek/dsh-note-keeper, or from GitHub: build a checkout and link it (steps below; dsh plugin add github:lucagiftzek/dsh-note-keeper alone does not build the daemon).

The npm package carries a prebuilt bin/notekeeperd for Linux x64, so on that platform the
one command above is the whole install (restart dsh web afterwards). From GitHub, or on any
other platform, Note Keeper needs its small Go daemon built on your machine, so install it from
a checkout:

1. Build it (Go ≥ 1.22 and Node ≥ 22.5):

git clone https://github.com/lucagiftzek/dsh-note-keeper.git
cd dsh-note-keeper
npm ci
npm run build      # bin/notekeeperd (Go daemon) + lib/client.js (browser bundle)

Optional: sudo apt install tesseract-ocr tesseract-ocr-ell for OCR.

2. Link it into the web profile, ~/.dsh/profiles/web/package.json: add
   "@lucagiftzek/dsh-note-keeper": "link:/path/to/dsh-note-keeper" to dependencies and
   "@lucagiftzek/dsh-note-keeper" to dsh.profile.bundles, then run pnpm install there.

3. Optional configuration goes on the plugin row in
   ~/.dsh/profiles/web/cordis.patch.yml:

- id: dsh-note-keeper
config:
vault: ~/NoteKeeper          # or point at an existing Obsidian vault
trustedHosts: [dsh.example.com]
aiWrite: true
aiDelete: true

4. Restart dsh-web. A Notes row appears in the left sidebar.

Kill switch: DSH_NOTE_KEEPER_DISABLE=1 in the dsh-web environment, or
- id: dsh-note-keeper / disabled: true in cordis.patch.yml.

Configuration

All keys are optional; defaults come from DEFAULTS in lib/index.js.

Keyboard shortcuts

Global (active while the Note Keeper page is mounted):

In the editor textarea:

Obsidian sync guide

Note Keeper's vault is a plain directory of Markdown files laid out the way
Obsidian expects, there is no proprietary database or format. This is
deliberate: it is what lets the vault be edited from more than one place at
once.

• Same machine: open the vault folder (default ~/NoteKeeper) directly
  as an Obsidian vault. Every change either app makes appears live in the
  other (Note Keeper watches the folder with fsnotify and refreshes over
  SSE within a fraction of a second; Obsidian watches it natively).
• Other desktops and mobile: use whatever you already rely on
  to sync a plain folder, Syncthing (Android and desktop), Obsidian
  Sync, iCloud or Möbius Sync on iOS, or git. Note Keeper does
  not care which one is used: it treats every external write to the vault
  the same way it treats its own, live.
• Encrypted notes and Obsidian: an encrypted note is still a syntactically
  valid Markdown file (YAML frontmatter with nk-encrypted: v1 plus a
  nk-cipher fenced block of base64 ciphertext), so Obsidian opens it
  without errors, it just shows the placeholder warning text and the opaque
  ciphertext block, never the plaintext. Encrypted attachments (.nkenc
  files) are opaque binary blobs to Obsidian. Only Note Keeper can decrypt
  and display encrypted content, Obsidian has no matching plugin. Open
  and unlock encrypted notes in Note Keeper.
• Unrecognisable attachments: a file uploaded into an encrypted folder is
  sealed in the browser (AES-256-GCM) before it leaves the page and stored under
  a random name (enc-<18 hex>.nkenc). Its real name, size and type live
  inside the ciphertext (an NKM1 header), so neither the connection (URLs,
  bodies, chunk boundaries aside) nor the vault, the cloud mirror or the
  daemon ever learns what the file was. Note Keeper shows the real name after
  you unlock it. Older NKE1 blobs without the header still open. The note
  embed inserted on upload references the opaque name, so type links by
  pasting from the upload, not by guessing the file name. Sealing happens in
  memory: budget about 4x the file size in browser RAM (roughly 1.2 GB for
  a 300 MB file).

AI tools

Registered on ctx.get('tools') when the tool registry is available (the
sidebar and daemon still work if it is not). Every call goes through the
same daemon API the browser uses, so path validation, conflict detection and
folder-lock rules apply identically.

notes_create/notes_update/notes_move/notes_mkdir/notes_capture/notes_daily
are disabled (return a clear error) when aiWrite: false; notes_delete is
also gated on aiDelete: false. Encrypted notes and folders are always
off-limits to models: notes_read refuses to return ciphertext, and any
write tool that would touch an encrypted .md file is refused by the daemon
with code: "locked": the model is told to ask the user to do it in Note
Keeper instead.

Security model (summary)

Two independent layers protect the vault; see docs/ARCHITECTURE.md for the
full threat model.

1. Server-side request gate (lib/security.js): every browser request
   to /note-keeper/api/* must pass four checks (R1 loopback peer, R2
   trusted Host/origin, R3 CSRF markers on mutations, R4 the DSH session
   cookie) before it is proxied to the Go daemon, which itself only listens
   on loopback and requires a fresh per-spawn secret (X-NK-Secret) that
   never appears in a browser-visible surface.
2. Client-side zero-knowledge encryption (src/client/crypto.js):
   passwords are stretched with PBKDF2-SHA-256 (600,000 iterations) into a
   non-extractable AES-256-GCM key that lives only in an in-memory key ring
   (auto-forgotten after 10 minutes idle, or on demand). Encryption can be
   applied per-note or per-folder; a folder carries a .nk-lock.json marker
   with a KDF salt and a key verifier, never a key or the plaintext. The
   server categorically refuses to store plaintext inside a locked folder,
   and the notes_* AI tools can never read or write encrypted content:
   "Warning: Loss of the password results in permanent, unrecoverable
   data loss." There is no recovery path by design.

Development / testing

npm run build          # build:server (Go) + build:client (esbuild bundle)
npm run build:server   # go build -> bin/notekeeperd
npm run build:client   # esbuild -> lib/client.js
npm run check          # node --check over every host-half .js file
npm test               # test:server + test:host
npm run test:server    # go vet ./... && go test -race -count=1 ./...   (server/)
npm run test:host      # node --test test/*.test.mjs                     (host + client logic)

Server tests live under server/internal/*/**_test.go (vault, index, api).
Host/browser-logic tests live under test/*.test.mjs (client logic,
graph-core, paint-core, a jsdom UI smoke test, and host.test.mjs for the
node host half).

Project layout

dsh-note-keeper/
├── lib/                  host half (Node/ESM, loaded by dsh-web)
│   ├── index.js          plugin entry: wires daemon + route + notes_* tools
│   ├── daemon.js         spawns/supervises notekeeperd, HTTP client to it
│   ├── proxy.js          /note-keeper/api/* route: gate + stream to daemon
│   ├── security.js       R1-R4 browser request gate
│   ├── tools.js          notes_* AI tool definitions
│   └── client.js         built browser bundle (esbuild output, checked in)
├── src/client/           browser half source (React, built by scripts/build.mjs)
│   ├── index.jsx         registers the sidebar row + main panel
│   ├── App.jsx           page shell: vault model, views, keyboard shortcuts
│   ├── Editor.jsx        Markdown editor (toolbar, preview, autocompletion)
│   ├── Recorder.jsx      audio note recording (MediaRecorder)
│   ├── Paint.jsx / paint-core.js   retro drawing canvas
│   ├── Graph.jsx / graph-core.js   force-directed graph view
│   ├── crypto.js         zero-knowledge encryption primitives
│   ├── upload.js         chunked upload transport + sealed uploads
│   ├── api.js            fetch client for /note-keeper/api
│   ├── markdown.js       Markdown rendering (marked + DOMPurify) + outline
│   ├── tree.js           vault-tree helpers
│   └── styles.js         CSS
├── server/               the Go daemon (notekeeperd)
│   ├── cmd/notekeeperd/  main: flags, wiring, HTTP listen
│   └── internal/
│       ├── vault/        filesystem operations, path safety, locks
│       ├── index/        in-memory search/link/tag index
│       ├── watch/        fsnotify watcher + SSE hub
│       ├── note/         Markdown/frontmatter/wikilink parsing
│       └── api/          the daemon's HTTP handlers
├── bin/notekeeperd       built Go binary (build:server output)
├── scripts/build.mjs     esbuild script for the client bundle
├── test/                 host + client-logic tests (node --test)
└── cordis.patch.yml      the one bundle row dsh-web loads

License

MIT, see LICENSE.

More plugins by the same author

All of them are open source and run on DeepSeek Harness 0.2.x (several on 0.1.5 too).

Built by Luca Tzekos, who also makes Job Opportunities API: employer-direct job data with per-field provenance you can verify yourself, free to read and available as an API. If this plugin is useful to you, a star on this repo or a look at jobopportunitiesapi.org is the best thanks.