Agent skill

JS Cpp Protocol

Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel.

GPL-3.0Auto-check passedDevelopment

Install JS Cpp Protocol

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .claude/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Paste into Claude Code

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .claude/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

$skill-installer

$skill-installer install https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol

Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a codex

Project install goes to .agents/skills/; add -g for ~/.codex/skills/.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol --agent codex

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .agents/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .agents/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.agents/skills/ instead of .agents/skills for a personal install.

Codex skills documentation · loads skills from .agents/skills/

Paste into Codex

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .agents/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a cursor

Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol --agent cursor

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .cursor/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.cursor/skills/ instead of .cursor/skills for a personal install.

Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/

Paste into Cursor

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .cursor/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

gemini skills install

$ gemini skills install https://github.com/notepadqq/notepadqq.git --path .agents/skills/js-cpp-protocol

--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a gemini-cli

Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol --agent gemini-cli

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .gemini/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.

Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/

Paste into Gemini CLI

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .gemini/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol

Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a github-copilot

Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .github/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .github/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.

GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/

Paste into GitHub Copilot

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .github/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

skills CLI

$ npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a opencode

OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.

GitHub CLI

$ gh skill install notepadqq/notepadqq js-cpp-protocol --agent opencode

Project scope by default (.agents/skills/); add --scope user for a personal install.

Manual copy

$ git clone --depth 1 https://github.com/notepadqq/notepadqq.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/.agents/skills/js-cpp-protocol .opencode/skills/js-cpp-protocol && rm -rf skills-src

Use ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.

OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/

Paste into OpenCode

Install the "js-cpp-protocol" agent skill from https://github.com/notepadqq/notepadqq/tree/master/.agents/skills/js-cpp-protocol into .opencode/skills/js-cpp-protocol/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "js-cpp-protocol", then confirm the skill loads.

OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.

Facts

Skill name: js-cpp-protocol
GitHub stars: 2.3k
Token cost: ~3.2k tokens
SKILL.md length: 1,093 words
Files: 1
Skills in repo: 2
Repo updated: Oct 5, 2026
First seen: Oct 7, 2026
Licence: GPL-3.0

At a glance

Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel.

Works in 3 steps: C++ (editor.cpp:47-70): Creates a… → JS (index.html:7 / index_monaco.html:7):… → JS (UiDriver.js:8-26): On…
Implementing new editor features
SKILL.md covers Overview, Architecture, Key Files and Communication Mechanism, plus 8 more sections
Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

JS Cpp Protocol is an agent skill from notepadqq/notepadqq. Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel. Use when implementing new editor features, adding messages to the bridge, debugging JS/C++ communication, or understanding how editor commands flow between layers.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development. It works with C++, JavaScript, Linux and macOS. The repository describes itself as: A simple, general-purpose editor for Linux and MacOS. The licence is GPL-3.0.

When your agent uses it

Implementing new editor features
Adding messages to the bridge
Debugging JS/C++ communication
Understanding how editor commands flow between layers

Example prompts

“/js-cpp-protocol”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

C++ (editor.cpp:47-70): Creates a JsToCppProxy QObject (registered as "cpp_ui_driver"), creates a QWebChannel, sets it on the WebEngine…
JS (index.html:7 / index_monaco.html:7): Includes (Qt's built-in WebChannel JS library).
JS (UiDriver.js:8-26): On DOMContentLoaded, creates new QWebChannel(qt.webChannelTransport, callback), obtains cpp_ui_driver =…

What it can do on your machine

Read from SKILL.md and the folder at commit 37652c5. It shows what the files ask for, not the result of running them.

Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are javascript and cpp).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

JS Cpp Protocol loads about 3.2k tokens when it runs. Until then it costs about 79 tokens; SKILL.md has 1,093 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it: ~79
When it runs · the whole SKILL.md, loaded when a task matches: ~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from notepadqq/notepadqq at commit 37652c5, republished under its GPL-3.0 licence (© notepadqq). 1,093 words, ~3,247 tokens.

Download SKILL.mdSave it as .claude/skills/js-cpp-protocol/SKILL.md (or your agent's skills folder).

name: js-cpp-protocol
description: Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel. Use when implementing new editor features, adding messages to the bridge, debugging JS/C++ communication, or understanding how editor commands flow between layers.

JS Editor / C++ UI Communication Protocol

Overview

Notepadqq's editor uses Qt WebEngine (QWebEngineView) with Qt WebChannel (QWebChannel) for bi-directional communication between the native C++ UI and the JavaScript editor engine (either CodeMirror or Monaco). The C++ side is unaware of which engine is running — both engines implement the identical message protocol.

Architecture

┌───────────────────────────┐          QWebChannel           ┌──────────────────────────┐
│        C++ / Qt           │  ◄─────────────────────────►   │   JavaScript Editor      │
│                           │                                │                          │
│  Editor (editor.cpp)      │  signal: messageReceivedByJs   │  UiDriver.js             │
│    ├─ JsToCppProxy (QObject)│  ──────────────────────────►  │    ├─ QWebChannel bridge │
│    └─ CustomQWebView      │  ◄──────────────────────────  │    └─ messageReceived()   │
│                           │  slot: receiveMessage()        │                          │
│  EditorTabWidget          │                                │  app.js / app_monaco.js  │
│  MainWindow               │                                │    └─ event handlers     │
└───────────────────────────┘                                └──────────────────────────┘

Key Files

Side	File	Role
JS	`src/editor/classes/UiDriver.js`	Core bridge: QWebChannel setup, `sendMessage()`, `registerEventHandler()`, `messageReceived()` dispatcher
JS	`src/editor/app.js`	CodeMirror implementation: registers handlers for all `C_CMD_` / `C_FUN_` messages
JS	`src/editor/app_monaco.js`	Monaco implementation: registers handlers for all `C_CMD_` / `C_FUN_` messages
JS	`src/editor/index.html`	CodeMirror HTML entry point
JS	`src/editor/index_monaco.html`	Monaco HTML entry point
C++	`src/ui/EditorNS/editor.cpp`	Creates QWebChannel, sends messages, receives replies, manages async callbacks
C++	`src/ui/include/EditorNS/editor.h`	Declares `JsToCppProxy`, `Editor`, `AsyncReply`
C++	`src/ui/EditorNS/customqwebview.cpp`	QWebEngineView subclass: event handling, drag-drop, context menu

Communication Mechanism

Setup

C++ (editor.cpp:47-70): Creates a JsToCppProxy QObject (registered as "cpp_ui_driver"), creates a QWebChannel, sets it on the WebEngine page, and registers the proxy: channel->registerObject("cpp_ui_driver", m_jsToCppProxy).
JS (index.html:7 / index_monaco.html:7): Includes <script src="qrc:///qtwebchannel/qwebchannel.js"></script> (Qt's built-in WebChannel JS library).
JS (UiDriver.js:8-26): On DOMContentLoaded, creates new QWebChannel(qt.webChannelTransport, callback), obtains cpp_ui_driver = channel.objects.cpp_ui_driver, and connects to the messageReceivedByJs signal.

C++ → JS (Commands and Function Calls)

Two modes exist:

Synchronous (legacy/deprecated): sendMessage(msg, data)

editor.cpp:374-382: Emits messageReceivedByJs signal, which Qt WebChannel delivers to JS.
JS receives it via cpp_ui_driver.messageReceivedByJs.connect(...) and processes it immediately.

Asynchronous (preferred): asyncSendMessageWithResultP(msg, data)

editor.cpp:389-430: Generates a unique message ID, wraps the message in [ASYNC_REQUEST] prefix + [ID=N] suffix.
JS receives it, dispatches to registered handlers, then sends back [ASYNC_REPLY] with the same ID.
C++ resolves the QtPromise::QPromise<QVariant> on receipt.

Message format for async:

C++ sends:  [ASYNC_REQUEST]C_CMD_GET_VALUE[ID=42]
JS replies: [ASYNC_REPLY]C_CMD_GET_VALUE[ID=42]

JS → C++ (Events)

JS calls UiDriver.sendMessage("J_EVT_*", data) which invokes cpp_ui_driver.receiveMessage(msg, data) (UiDriver.js:36).

C++ receives it in JsToCppProxy::receiveMessage() (editor.h:44), which emits messageReceived signal → Editor::on_proxyMessageReceived() (editor.cpp:143).

Message Naming Convention

Prefix	Direction	Semantics
`C_CMD_*`	C++ → JS	Fire-and-forget command (no return value expected)
`C_FUN_*`	C++ → JS	Function call (return value expected via async reply)
`J_EVT_*`	JS → C++	Event notification (no return value)

Complete Message Reference

C_CMD_* — Commands (C++ → JS, no return value)

Message	Data	Description
`C_CMD_SET_VALUE`	`QString`	Set full editor text content
`C_CMD_MARK_CLEAN`	none	Mark document as clean (no unsaved changes)
`C_CMD_MARK_DIRTY`	none	Mark document as dirty (unsaved changes)
`C_CMD_SET_LANGUAGE`	language MIME string	Set syntax highlighting language
`C_CMD_SET_INDENTATION_MODE`	`{useTabs: bool, size: int}`	Set tab/space indentation
`C_CMD_SET_SELECTIONS_TEXT`	`{text: string[], select: "after"\|"before"\|"selected"}`	Replace selected text
`C_CMD_SET_SELECTION`	`[fromLine, fromCol, toLine, toCol]`	Set selection range
`C_CMD_SET_CURSOR`	`[line, col]`	Set cursor position
`C_CMD_SET_RTL`	none	Set text direction to RTL
`C_CMD_SET_LTR`	none	Set text direction to LTR
`C_CMD_SET_SCROLL_POS`	`[left, top]`	Set scroll position
`C_CMD_SELECT_ALL`	none	Select entire document
`C_CMD_UNDO`	none	Undo last change
`C_CMD_REDO`	none	Redo last undone change
`C_CMD_CLEAR_HISTORY`	none	Clear undo history
`C_CMD_SET_LINE_WRAP`	`bool`	Toggle line wrapping
`C_CMD_SHOW_END_OF_LINE`	`bool`	Show/hide end-of-line characters
`C_CMD_SHOW_WHITESPACE`	`bool`	Show/hide whitespace characters
`C_CMD_SET_TABS_VISIBLE`	`bool`	Show/hide tab characters
`C_CMD_SET_THEME`	`{name: string, path: string}`	Apply editor theme
`C_CMD_SET_FONT`	`{family: string, size: int, lineHeight: double}`	Set editor font
`C_CMD_SET_LINE_NUMBERS_VISIBLE`	`bool`	Show/hide line numbers
`C_CMD_SET_OVERWRITE`	`bool`	Toggle overwrite mode
`C_CMD_SET_SMART_INDENT`	`bool`	Toggle smart indent
`C_CMD_SET_FOCUS`	none	Focus the editor
`C_CMD_BLUR`	none	Blur the editor
`C_CMD_DISPLAY_PRINT_STYLE`	none	Switch to print-friendly CSS
`C_CMD_DISPLAY_NORMAL_STYLE`	none	Switch back to normal CSS
`C_CMD_DUPLICATE_LINE`	none	Duplicate current line
`C_CMD_MOVE_LINE_UP`	none	Move current line up
`C_CMD_MOVE_LINE_DOWN`	none	Move current line down
`C_CMD_TRANSPOSE_LINE`	none	Transpose with previous line
`C_CMD_DELETE_LINE`	none	Delete current line
`C_CMD_TRIM_LEADING_TRAILING_SPACE`	none	Trim leading and trailing whitespace
`C_CMD_TRIM_TRAILING_SPACE`	none	Trim only trailing whitespace
`C_CMD_TRIM_LEADING_SPACE`	none	Trim only leading whitespace
`C_CMD_ENABLE_MATH`	`bool`	Enable/disable LaTeX math rendering
`C_CMD_TAB_TO_SPACE`	none	Convert tabs to spaces
`C_CMD_SPACE_TO_TAB_ALL`	none	Convert all spaces to tabs
`C_CMD_SPACE_TO_TAB_LEADING`	none	Convert leading spaces to tabs
`C_CMD_EOL_TO_SPACE`	none	Replace line endings with spaces
`C_CMD_GET_DOCUMENT_INFO`	none	Request document info (replied via J_EVT_DOCUMENT_INFO)

C_FUN_* — Function Calls (C++ → JS, return value via async reply)

Message	Data	Return Type
`C_FUN_IS_CLEAN`	none	`bool`
`C_FUN_GET_HISTORY_GENERATION`	none	`int`
`C_FUN_GET_VALUE`	none	`QString`
`C_FUN_GET_INDENTATION_MODE`	none	`{useTabs: bool, size: int}`
`C_FUN_GET_SELECTIONS_TEXT`	none	`QStringList`
`C_FUN_GET_SELECTIONS`	none	`[{anchor: {line, col}, head: {line, col}}]`
`C_FUN_GET_TEXT_LENGTH`	none	`int`
`C_FUN_GET_LINE_COUNT`	none	`int`
`C_FUN_GET_CURSOR`	none	`[line, col]`
`C_FUN_GET_SCROLL_POS`	none	`[left, top]`
`C_FUN_SEARCH`	`[regex: string, modifiers: string, forward: bool]`	`bool` (found or not)
`C_FUN_REPLACE`	`[regex, modifiers, forward, replacement, searchMode]`	`bool`
`C_FUN_REPLACE_ALL`	`[regex, modifiers, replacement, searchMode]`	`int` (count)
`C_FUN_SEARCH_SELECT_ALL`	`[regex, modifiers]`	`int` (count)
`C_FUN_GET_LANGUAGES`	none	`array` of `{name, mime, mode, ext}`
`C_FUN_DETECT_INDENTATION_MODE`	none	`{found: bool, useTabs: bool, size: int}`
`C_FUN_GET_CURRENT_WORD`	none	`QString`
`C_FUN_IS_MATH_ENABLED`	none	`bool`

Show full SKILL.md (389 more words)Show less

J_EVT_* — Events (JS → C++, no return value)

Message	Data	When Sent
`J_EVT_READY`	none	Editor initialization complete
`J_EVT_CONTENT_CHANGED`	none	Document content changes (throttled ~50ms)
`J_EVT_CLEAN_CHANGED`	`bool`	Clean/dirty state changes
`J_EVT_CURSOR_ACTIVITY`	`{cursor: {...}, selections: [...], content: {...}}`	Cursor/selection changes (throttled ~50ms)
`J_EVT_DOCUMENT_INFO`	`{cursor, selections, content}`	Reply to `C_CMD_GET_DOCUMENT_INFO`
`J_EVT_GOT_FOCUS`	none	Editor receives focus

Handler Registration Pattern (JS)

Handlers are registered in app.js or app_monaco.js:

javascript

UiDriver.registerEventHandler("C_CMD_SET_VALUE", function(msg, data, prevReturn) {
    editor.setValue(data);
});

Multiple handlers can be registered for the same message. They are called in registration order; each handler receives the previous handler's return value as prevReturn.

Async Flow in Detail

C++ generates a unique ID (messageIdentifier counter, editor.cpp:387).
C++ creates a promise and stores an AsyncReply{id, message, value, callback} in the asyncReplies list (editor.cpp:407-412).
C++ sends [ASYNC_REQUEST]C_FUN_GET_CURSOR[ID=42] via messageReceivedByJs signal (editor.cpp:414-418).
JS receives in UiDriver.messageReceived() (UiDriver.js:52-75), parses the real message and ID via regex /^\[ASYNC_REQUEST\](.*)\[ID=(\d+)\]$/, dispatches to handler(s), then sends back [ASYNC_REPLY]C_FUN_GET_CURSOR[ID=42] with the return value.
C++ receives in Editor::on_proxyMessageReceived() (editor.cpp:148-176), parses the ID via regex \\[ID=(\\d+)\\]$, looks up the matching AsyncReply, resolves the promise and/or calls the callback, then emits asyncReplyReceived.

C++ API for Sending Messages

cpp

// Legacy synchronous (deprecated — blocks event loop)
void sendMessage(const QString msg, const QVariant data);

// Modern async with QtPromise (preferred)
QtPromise::QPromise<QVariant> asyncSendMessageWithResultP(const QString msg, const QVariant data);

// Legacy future-based (deprecated — spins event loop in while())
std::shared_future<QVariant> asyncSendMessageWithResult(
    const QString msg, const QVariant data,
    std::function<void(QVariant)> callback = nullptr);

Adding a New Message

Choose the prefix: C_CMD_* if no return value, C_FUN_* if a return value is needed, J_EVT_* for JS-initiated notifications.
JS side: Register a handler via UiDriver.registerEventHandler("C_CMD_YOUR_MSG", handler) in both app.js and app_monaco.js.
C++ side: Call asyncSendMessageWithResultP("C_FUN_YOUR_MSG", data) (or the legacy API) from editor.cpp or a higher-level wrapper method in editor.h.
Handle the reply: If async, .then() on the returned promise or connect to asyncReplyReceived signal.
JS→C++ events: Just call UiDriver.sendMessage("J_EVT_YOUR_MSG", data) from JS and handle the parsed message in Editor::on_proxyMessageReceived().

Dual Editor Engine

Notepadqq ships two editor engines:

CodeMirror (default): index.html + app.js
Monaco (VS Code's editor): index_monaco.html + app_monaco.js

Both implement the identical message protocol. The C++ side selects the engine via Editor::useMonaco() (editor.cpp:33). Any new message must be implemented in both app.js and app_monaco.js.

Key Architecture Notes

QWebChannel serialises all values as QVariant (C++) ↔ plain JS values (JSON-compatible types).
JS-to-C++ messages use a callback parameter function(ret) {} even when the return value is unused — the QWebChannel bridge requires this for the method call to work.
The UiDriver maintains a msgQueue for messages sent before the WebChannel is ready; they are flushed once QWebChannel initialises.
C++ messages sent before the editor fires J_EVT_READY are queued and delivered once editorReady signal fires (editor.cpp:419-426).

Files

Just SKILL.md in .agents/skills/js-cpp-protocol of notepadqq/notepadqq.

Open the folder on GitHubat commit 37652c5

Compare with similar skills

JS Cpp Protocol next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

JS Cpp Protocol compared with similar skills
Skill	Stars	Used in	Tokens	Auto-check	Licence	Repo updated
JS Cpp Protocol this skillnotepadqq/notepadqq	2.3k	—	~3.2k	Automated safety check: Pass	GPL-3.0	2 days ago
Bump LibdatadogDataDog/dd-trace-dotnet	573	—	~1.7k	Automated safety check: Pass	Apache-2.0	today
Debug CIweb-infra-dev/rslint	460	—	~2.8k	Automated safety check: Pass	MIT	today
Releasing Blancbnfy/blanc	105	—	~2.9k	Automated safety check: Notes	MIT	today
Subspace Buildsdallison/subspace	104	—	~990	Automated safety check: Pass	Apache-2.0	yesterday
Gui Testlibnativeapi/nativeapi	157	—	~3.5k	Automated safety check: Pass	MIT	today

Similar skills

Bump Libdatadog
DataDog/dd-trace-dotnet
Official
Update/bump the libdatadog native library version in dd-trace-dotnet.
573 GitHub stars~1.7k tokensUpdated today
DevelopmentAuto-check passed
Debug CI
web-infra-dev/rslint
Reproduce Linux CI failures locally using Docker when the same tests pass on the host, especially Go platform differences and VS Code extension tests requiring xvfb.
460 GitHub stars~2.8k tokensUpdated today
DevelopmentAuto-check passed
Releasing Blanc
bnfy/blanc
Full runbook for cutting a Blanc desktop release — scripts/release.sh mechanics and its required BLANCRELEASE env vars, macOS notarization via 1Password, the Touch ID provisioning profile and…
105 GitHub stars~2.9k tokensUpdated today
DevOps & CloudAuto-check: notes
Subspace Builds
dallison/subspace
Build and test Subspace across supported platforms and build systems.
104 GitHub stars~990 tokensUpdated yesterday
Backend & APIsAuto-check passed
Gui Test
libnativeapi/nativeapi
End-to-end test a desktop app (Flutter desktop apps and plain native executables such as C++ examples) by launching the real app, driving it with guarded synthetic mouse input — eased moves, clicks…
157 GitHub stars~3.5k tokensUpdated today
MobileAuto-check passed
Build Northstar
nordstjernen-web/northstar-browser
Configure, compile, and smoke-test a Meson-based C or C++ desktop browser on Linux, macOS, or Windows, and diagnose dependency, compiler, linker, runtime-library, build-directory, or…
112 GitHub stars~1.3k tokensUpdated yesterday
Testing & QAAuto-check passed

Questions about JS Cpp Protocol

What does JS Cpp Protocol do?

Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel. JS Cpp Protocol is an agent skill from notepadqq/notepadqq. Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel.

When should I use JS Cpp Protocol?

JS Cpp Protocol fits situations like: implementing new editor features; adding messages to the bridge; debugging JS/C++ communication; understanding how editor commands flow between layers.

How do I install JS Cpp Protocol in Claude Code?

Run `npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a claude-code`. Or copy the skill folder (.agents/skills/js-cpp-protocol in notepadqq/notepadqq) into .claude/skills/js-cpp-protocol in your project. Claude Code loads it when a task matches its description.

How do I install JS Cpp Protocol in Codex?

Run `npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a codex`. Or copy the skill folder (.agents/skills/js-cpp-protocol in notepadqq/notepadqq) into .agents/skills/js-cpp-protocol in your project. Codex loads it when a task matches its description.

Can I use JS Cpp Protocol in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add notepadqq/notepadqq --skill js-cpp-protocol -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/js-cpp-protocol, .gemini/skills/js-cpp-protocol, .github/skills/js-cpp-protocol and .opencode/skills/js-cpp-protocol in your project.

What does JS Cpp Protocol need to run?

SKILL.md names no scripts, command-line tools or credentials: JS Cpp Protocol is instructions for the agent only.

Does JS Cpp Protocol access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is JS Cpp Protocol safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does JS Cpp Protocol use?

JS Cpp Protocol is published under the GPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does JS Cpp Protocol use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to JS Cpp Protocol?

Skills that share tags, products or a category with JS Cpp Protocol: Bump Libdatadog (DataDog/dd-trace-dotnet, 573 stars), Debug CI (web-infra-dev/rslint, 460 stars), Releasing Blanc (bnfy/blanc, 105 stars) and Subspace Builds (dallison/subspace, 104 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains JS Cpp Protocol?

notepadqq (a GitHub organization) maintains it in notepadqq/notepadqq, which has 2,332 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 5, 2026.

Source: notepadqq/notepadqq on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.

Install JS Cpp Protocol

Facts

At a glance

What it does

When your agent uses it

Example prompts

Workflow steps

What it can do on your machine

Tool permissions

Runs code

Network

Credentials

Context cost

Safety

SKILL.md

JS Editor / C++ UI Communication Protocol

Overview

Architecture

Key Files

Communication Mechanism

Setup

C++ → JS (Commands and Function Calls)

JS → C++ (Events)

Message Naming Convention

Complete Message Reference

C_CMD_* — Commands (C++ → JS, no return value)

C_FUN_* — Function Calls (C++ → JS, return value via async reply)

J_EVT_* — Events (JS → C++, no return value)

Handler Registration Pattern (JS)

Async Flow in Detail

C++ API for Sending Messages

Adding a New Message

Dual Editor Engine

Key Architecture Notes

Files

Compare with similar skills

Similar skills

Bump Libdatadog

Debug CI

Releasing Blanc

Subspace Builds

Gui Test

Build Northstar

More from notepadqq/notepadqq

Release

Related

Questions about JS Cpp Protocol