Files
paseo/docs/markdown-renderer.md
T
Mohamed Boudra ef146bc62d Browse, install and manage plugins from a built-in gallery (#9752)
* feat(app): browse, install and manage plugins from a built-in gallery

Settings → Host → Plugins becomes a gallery with two tabs. Installed lists
the host's plugins with on/off switches and pending updates. Browse lists the
plugin directory with featured cards, categories, sorting and search. Each
plugin has its own page with its screenshots, overview, details, install or
on/off controls, and its own settings screens inline.

Every install asks first, in a sheet naming the source and version, because
installing runs the plugin's code on the host. Uninstalling also asks first;
its confirm says what is deleted.

The daemon fetches the directory from its configured registry
(plugin.registry.list/get, gated by server_info.features.pluginRegistry). The
app never fetches from the registry itself, so a host with a private registry
shows that registry.

README overviews render with the registry's overview contract (the same one
the website uses): only https links and images work, and nothing is read as a
workspace file. Before this, a word like "Node.js" became a broken relative
link.

* fix(app): refresh plugin failures and leave Settings cleanly from a plugin page

The Installed row read the app-side evaluation error without subscribing to the
registry, so a plugin fixed by Reload kept its "failed" badge. Rows and the
plugin page now subscribe through usePluginEvaluationError.

Leaving Settings with no remembered workspace replaced only the top stack entry;
with a plugin page pushed on top, the Plugins list stayed mounted underneath and
reopening Settings stacked a second copy. Dismiss the Settings entries first.

* fix(app): keep Browse working as the registry grows, and test it end to end

Registry listings now reach apps through an open wire schema
(plugin.registry.list/get carry PluginListing*), and the daemon drops a listing
it cannot read instead of failing the whole index. A registry that adds an
artifact kind or bumps schemaVersion no longer breaks Browse on older apps.

The gallery picks its opening tab once, so installing the first plugin keeps
the user on Browse. README links open only https: the parser still autolinks
bare http, www and email text, so a press checks the URL again.

Adds a Browse e2e test against a local registry and Git repository: install
from a row through the confirm sheet, stay on Browse, open the listing page,
uninstall from it.

* test(server): give the oversized-sibling diff refresh the same time budget as its siblings

expect.poll defaults to one second, which a Windows git diff refresh can exceed.

* test(server): wait as long as the other observer tests for native watcher events

expect.poll defaults to one second; macOS FSEvents can deliver later than that on CI.

* fix(app): keep a listed plugin's page usable after uninstalling it, and fetch the directory less

An installed plugin's page finds its listing through the plugin, so uninstalling
a directory plugin from the Installed tab left "not installed or listed" with no
way back. The page now becomes the listing's page, offering Install again.

Updates are re-checked when the host's plugins change and after a failed update,
whose proposal named a revision that no longer exists. The directory, listing
and update queries refetch on mount only once stale, so opening a plugin's page
no longer refetches the whole directory and every update check.

* test(app): install the plugin before opening Plugins in the busy-queue reload test

Plugins opens on Browse when the host has no plugins and stays there after the first install, so a plugin installed through the daemon after the page opened never showed on Installed.

* test(website): wait for hydration before scrolling to the hero in a short window

The router resets the scroll position when the page hydrates. Scrolling to the mockup before that left it below the window, so its start line never came on screen and the opening scene never played. It failed 7 of 10 runs on webkit.

* fix(server): show the registry setup error on Browse instead of asking to retry

The registry's request headers were built inside the try around fetch, so a setup error such as credentials over plain HTTP came back as "Could not reach plugin registry. Retry later." Install already built them first.

* fix(app): show plugin errors without the request details meant for logs

A daemon RPC error's message ends with requestType=… code=…; the daemon's own text is in userMessage. Gallery alerts and toasts now show that text.

* fix(app): show why an update failed on the plugin's page

The update operation's failure was recorded under the plugin ID, but the page only read it to show the spinner, so a failed update looked as if nothing happened. The page now shows the error in its own alert, without the plugin's Failed badge, because the installed version keeps running. While an update is still available the button reads Retry.

* fix(app): show a plugin page's update error only while the update is offered

The failed update stayed in the operations store after the plugin was updated elsewhere or uninstalled, so the page kept saying the update failed. The page now shows it with the Update button it belongs to, as the Installed tab's Updates row does, and uninstalling forgets it.
2026-11-15 20:34:13 +07:00

8.6 KiB
Raw Blame History

Markdown rendering

Use MarkdownRenderer for chat replies, file previews, plans, pull requests and changelog content. It uses react-native-enriched-markdown on iOS, Android and web. Keep source adaptation and renderer configuration in components/markdown; consumers supply Markdown and, when needed, its file location.

Native selection belongs to the library's text view. Keep an assistant message in one row so selection can cross paragraphs, headings and lists. Code blocks and tables use the library's native views and their selection behavior. Web uses browser selection over semantic HTML. Once its WASM parser is initialized, the library parses synchronously for the first commit of each mounted row; an empty interim row would corrupt virtualized measurements and move the reader. Chat owns paced reveal, the web render cap, message identity and list measurement. Native renders completed messages together. While streaming, it keeps closed blocks in one head view and updates a separate tail, then reunites the text on completion. See native parsing cost for the boundary and pacing constraints.

Block spacing

Every block is separated by one gap, density.blockGap: 12 on compact layouts, 16 wider. Inside the library's text, every element style ends with that gap and the library drops it after the last block. Views stacked outside the library (Mermaid segments, streaming head and tail) use the same gap through MarkdownBlockStack. Do not give a block type its own margins; change the gap.

Workspace file links use the shared file-link resolver. The workspace supplies its client, root and open-file action once; chat can supply the agent's more specific context. URLs use the same link press path. Recognized inline-code paths stay tappable. The library callback carries the tapped occurrence’s syntax context. Preserve it when opening files: explicit Markdown links decode URL escapes, while recognized inline-code paths preserve literal percent characters and use suffix lookup. Identical URL strings in different occurrences must stay distinct. Explicit absolute workspace links receive a relative hover title; existing authored titles remain intact. Inside a workspace, forge references such as #12 and owner/repo#12 are recognized in prose (not code) and open the workspace forge; the reference pattern comes before path recognition so group/project#12 is not read as a path. See forge providers.

Pass external for author-controlled Markdown from outside the host, such as a plugin README. It follows the registry's overview contract in packages/protocol/src/plugin-overview.ts, which the website also uses: only absolute https links and images work, and any other destination renders as its label or alt text. The parser still autolinks bare http://, www. and email text, so a link press checks the URL again and opens only https. None of the workspace recognition above applies, so Node.js is prose, not a file. The lines of a paragraph join, as they do on the README's forge.

Resolve workspace image paths over the existing session RPC, then give the library a cached native file URL or web blob URL. HTTP(S) images pass through unchanged. This preserves relay, SSH and local socket connections, which do not expose a daemon HTTP endpoint. Each mounted renderer owns its image acquisition identity, so a later reply reads a rewritten path again while the earlier mounted reply retains its snapshot. Image taps open the attachment lightbox. File previews resolve relative images against the Markdown file's directory. An image alone on its line becomes its own paragraph before the library sees it, so it renders as a block on every platform; the library only treats sole-child paragraph images as blocks, and with hard soft breaks every newline is a break node, which left own-line images inline on iOS and web. Images that share a line with text stay inline at line height and keep their aspect ratio. A linked image counts as an image, so review-bot badges such as [![Retrigger](badge.svg)](url) Confidence stay inline on web; the library's web renderer only checked direct paragraph children, so it rendered them as full-width block images (local patch in patches/react-native-enriched-markdown+*.patch).

Engine constraints

The pinned nightly has the same React Native package and core source trees as upstream commit 73ac5085eb1fdc743973b3473d4dba65abad5261. Compatibility was checked with React Native 0.81.5. Native dependencies must be rebuilt when changing the highlighting configuration; JavaScript refresh cannot enable compiled grammars.

Math and video are disabled. Task lists and admonitions are enabled; task checkboxes are read-only. Source adaptation spaces adjacent empty GFM table delimiters before escaping prose spoiler delimiters and decodes entity text before the engine can discard it. Code spans and fences keep their literal source. Comment HTML is normalized to Markdown before parsing; details show their summary and body expanded.

Mermaid fences use the existing isolated diagram runtime and fullscreen viewer. Web dispatches them through the library’s code-block override. Native has no block-renderer hook, so the renderer extracts only Mermaid fences and places the existing WebView host between library-rendered segments. This is the only block exception; see native selection limitations for diagram grouping and leading inline images. Streaming keeps the last valid diagram visible while the next revision renders.

Native code blocks use the library's copy control and compiled grammars. Web code blocks use HighlightedCodeBlock through the library's renderers.codeBlock override. The patch also keeps the library's block spacing around the web code block override, preserves web list numbering and link titles, marks pending parses with aria-busy so Find waits for rendered text, and carries link syntax through native and web tap events. Web inline code inside a link inherits only the link colour; its code font, size and background stay intact. Keep link variants colour-only: native pills replace text runs and prevent paths from wrapping; Android pills also use the surrounding block’s font size. The package patch is tracked by upstream PR #997; remove the patch when the pinned release includes it.

The package patch also keeps overflowing native horizontal blocks in control of their drags: Android claims parent interception at touch-down and releases it for vertical drags so the chat list can scroll; iOS keeps its scroll recognizer active for outward drags at the leading edge. This prevents compact sidebar pans from taking block scrolling without changing sidebar swipes on prose or non-overflowing blocks. Native changes require a client rebuild.

On iOS a newly mounted Markdown view paints empty for a frame or more after it is laid out at its measured height: the library parses even a view's first content on a background queue and applies it in a later main-queue turn. Expanding a turn in chat therefore shows its rows in place with the text arriving a frame later (165 ms when the mount keeps the main thread busy). Android paints the text in the first frame. Rendering a view's first content synchronously fixes the frame but costs frame time when a fling mounts history rows, so the app keeps the library's behavior until enriched-markdown #1131 is resolved.

Android measurements use a size-only, 512-entry LRU across view unmounts, matching the library’s existing iOS cache. Scrolling back through history can reuse layout sizes without parsing those rows again. Content, layout props and width identify each entry; font-scale changes and native layout invalidation discard affected sizes. The cache retains no views or spans.

The library determines how incomplete Markdown appears during streaming. Completed text uses the same component and engine as history. Find and scroll-to-message address source message ids; selection-copy understands semantic HTML and the web code component's copy metadata.

Verification

Follow QA and mobile testing. Exercise chat, file preview, plan and PR content on all three platforms. Include cross-paragraph selection, progressive streaming, a file-link tap, code copy/highlighting, a table and a workspace image. On iPad, repeat preview selection after opening and closing Explorer and after rotation. Check web find, selection-copy and source-message navigation after DOM changes.