fix(ui): name the plugin whose UI module raised a browser error (#22487)

## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - The browser UI loads plugin UI modules. The host fetches each
module, rewrites its imports, and imports it from a random `blob:` URL
> - Browser errors go to Sentry. A stack frame from a plugin module
names only that random blob URL
> - So a Sentry report cannot tell which plugin raised an error. For
example, a plugin can abort its own request during an unmount, and the
report shows only `blob:https://<host>/<uuid>`
> - This pull request records each blob URL with its plugin key, and
tags the Sentry event with that plugin key
> - The benefit is that a plugin error can go to the correct plugin
owner, and the blob URL is never sent

## Linked Issues or Issue Description

Refs #22380, which marks the announcement card's own aborts as
intentional. Some events in the same Sentry group come from a plugin
module instead, and #22380 cannot cover them.

**What happened?**
Hosted browsers report `AbortError: signal is aborted without reason` as
an unhandled rejection. The innermost frame is a React effect cleanup in
a `blob:` module at line 5590. Only plugin UI modules run from `blob:`
URLs in the main thread. The event has no data that names the plugin.

**Expected behavior**
A Sentry event from a plugin module names the plugin, so the plugin
owner can fix the plugin.

**Steps to reproduce**
1. Install a plugin with a UI slot whose effect cleanup calls
`controller.abort()` on a pending `fetch` and does not catch the
rejection.
2. Open a page with that slot. Then go to a page without it.
3. Sentry records an unhandled `AbortError` whose frame is a `blob:` URL
and no plugin key.

## What Changed

- `ui/src/lib/plugin-module-origins.ts`: a new, bounded registry (100
recent modules). `rememberPluginModuleUrl` records a blob URL with its
plugin key. `readPluginModuleOrigin` finds the innermost `blob:` frame
of an event and returns its plugin key, `unmapped`, or nothing. It never
throws.
- `ui/src/plugins/slots.tsx`: `importPluginModule` records the blob URL
with the plugin key before the import.
- `ui/src/lib/sentry.ts`: `beforeSend` sets the `browser_plugin_module`
tag when an event has a `blob:` frame. The tag holds the plugin key (at
most 200 characters) or `unmapped`. It never holds the URL.
- Tests for the registry, the loader, and the Sentry hook.

## Verification

- `cd ui && npx vitest run src/lib/plugin-module-origins.test.ts
src/lib/sentry.test.ts src/plugins/slots-loading.test.tsx
src/plugins/slots.test.ts src/hooks/useAnnouncement.test.tsx`: 69/69
pass.
- Red first: with the source changes removed and the new tests kept, the
Sentry test and the loader test fail (`expected 'unmapped' to be
'fixture.navigation'`).
- `cd ui && npx vitest run src/lib src/plugins`: 279 files, 3231 tests
pass.
- `npx tsc --noEmit -p ui/tsconfig.json`: no errors in the changed
files.

## Risks

- Low risk. The change adds one tag. It does not drop, group, or change
any event.
- The tag holds a plugin key, which is a manifest identifier. It holds
no URL, path, or user data.
- The registry keeps at most 100 entries, so memory stays bounded when
modules reload.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), with tool use and code execution,
in Claude Code.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [ ] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: paperclipbugbot <356415228+paperclipbugbot@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
authored and GitHub committed 2026-11-21 03:26:38 -08:00
1 parent 4631d3b41a
commit 683d7ae120
6 files changed
+182 -2

No files matched your search

+52
View File
@@ -0,0 +1,52 @@
import { afterEach, describe, expect, it } from "vitest";
import {
__resetPluginModuleOrigins,
readPluginModuleOrigin,
rememberPluginModuleUrl,
} from "./plugin-module-origins";
const hostFrame = { filename: "/assets/index.js", abs_path: "https://app.example/assets/index.js" };
afterEach(() => __resetPluginModuleOrigins());
describe("readPluginModuleOrigin", () => {
it("names the plugin of the innermost blob frame", () => {
rememberPluginModuleUrl("blob:https://app.example/outer", "acme.outer");
rememberPluginModuleUrl("blob:https://app.example/inner", "acme.inner");
expect(readPluginModuleOrigin([{
stacktrace: { frames: [
{ filename: "blob:https://app.example/outer" },
hostFrame,
{ abs_path: "blob:https://app.example/inner", filename: "blob:https://app.example/inner" },
] },
}])).toBe("acme.inner");
});
it("reports an unrecorded blob module as unmapped", () => {
expect(readPluginModuleOrigin([{
stacktrace: { frames: [hostFrame, { filename: "blob:https://app.example/unknown" }] },
}])).toBe("unmapped");
});
it("adds nothing when no frame ran from a blob module", () => {
rememberPluginModuleUrl("blob:https://app.example/module", "acme.plugin");
expect(readPluginModuleOrigin([{ stacktrace: { frames: [hostFrame] } }])).toBeUndefined();
expect(readPluginModuleOrigin([{}])).toBeUndefined();
expect(readPluginModuleOrigin(undefined)).toBeUndefined();
});
it("keeps only the most recent modules", () => {
for (let index = 0; index <= 100; index += 1) {
rememberPluginModuleUrl(`blob:https://app.example/${index}`, `acme.plugin-${index}`);
}
const frameFor = (index: number) => [{ stacktrace: { frames: [{ filename: `blob:https://app.example/${index}` }] } }];
expect(readPluginModuleOrigin(frameFor(0))).toBe("unmapped");
expect(readPluginModuleOrigin(frameFor(100))).toBe("acme.plugin-100");
});
it("bounds the tag to Sentry's value length", () => {
rememberPluginModuleUrl("blob:https://app.example/long", "a".repeat(300));
expect(readPluginModuleOrigin([{ stacktrace: { frames: [{ filename: "blob:https://app.example/long" }] } }]))
.toHaveLength(200);
});
});
+71
View File
@@ -0,0 +1,71 @@
// Attribute a browser error to the plugin UI module that raised it.
//
// The host imports each plugin's UI module from a `blob:` URL (see
// `importPluginModule` in `plugins/slots.tsx`). A stack frame from that
// module names only the random blob URL, so a Sentry event cannot tell which
// plugin threw, or which plugin aborted a request during an unmount.
//
// The loader records each blob URL with its plugin key here. Sentry's
// `beforeSend` reads the innermost blob frame of an event back and tags the
// event with that plugin key. Blob URLs stay in this module and are never sent.
/** At most this many recent plugin module URLs are remembered. */
const MAX_REMEMBERED_MODULES = 100;
/** Sentry tag values are limited to 200 characters. */
const MAX_TAG_LENGTH = 200;
const pluginKeysByModuleUrl = new Map<string, string>();
/** Record that `url` holds the UI module of plugin `pluginKey`. Never throws. */
export function rememberPluginModuleUrl(url: string, pluginKey: string): void {
try {
pluginKeysByModuleUrl.delete(url);
pluginKeysByModuleUrl.set(url, pluginKey);
while (pluginKeysByModuleUrl.size > MAX_REMEMBERED_MODULES) {
const oldest = pluginKeysByModuleUrl.keys().next().value;
if (oldest === undefined) break;
pluginKeysByModuleUrl.delete(oldest);
}
} catch { /* diagnostic unavailable */ }
}
interface StackFrameLike {
filename?: string;
abs_path?: string;
}
interface ExceptionLike {
stacktrace?: { frames?: readonly StackFrameLike[] };
}
/**
* The plugin key of the innermost frame that ran from a `blob:` module, or
* `unmapped` when that blob module is not a recorded plugin module.
* `undefined` when no frame ran from a blob module. Sentry lists frames from
* outermost to innermost.
*/
export function readPluginModuleOrigin(
exceptions: readonly ExceptionLike[] | undefined,
): string | undefined {
try {
if (!exceptions) return undefined;
for (const exception of exceptions) {
const frames = exception.stacktrace?.frames ?? [];
for (let index = frames.length - 1; index >= 0; index -= 1) {
const frame = frames[index];
const url = [frame.abs_path, frame.filename].find(
(value): value is string => typeof value === "string" && value.startsWith("blob:"),
);
if (!url) continue;
const pluginKey = pluginKeysByModuleUrl.get(url);
return pluginKey ? pluginKey.slice(0, MAX_TAG_LENGTH) : "unmapped";
}
}
} catch { /* diagnostic unavailable */ }
return undefined;
}
/** Test-only: forget every recorded module URL. */
export function __resetPluginModuleOrigins(): void {
pluginKeysByModuleUrl.clear();
}
+26
View File
@@ -542,6 +542,32 @@ describe("buildBrowserSentryInitOptions", () => {
expect(buildBrowserSentryInitOptions(DSN).ignoreErrors).toEqual(["__firefox__"]);
});
it("names the plugin whose blob module raised an error, without its URL", async () => {
const { buildBrowserSentryInitOptions } = await importFreshSentry();
const origins = await import("./plugin-module-origins");
const blobUrl = "blob:https://tenant.example/0b5f1f4e-module";
origins.rememberPluginModuleUrl(blobUrl, "acme.dashboard");
const beforeSend = buildBrowserSentryInitOptions(DSN).beforeSend!;
const eventFor = (filename: string) => ({
exception: { values: [{
type: "AbortError",
mechanism: { type: "auto.browser.global_handlers.onunhandledrejection", handled: false },
stacktrace: { frames: [{ filename: "/assets/index.js" }, { filename, abs_path: filename }] },
}] },
});
const reason = new DOMException("signal is aborted without reason", "AbortError");
const plugin = await beforeSend(eventFor(blobUrl) as never, { originalException: reason });
expect(plugin?.tags).toMatchObject({ browser_plugin_module: "acme.dashboard" });
expect(JSON.stringify(plugin?.tags)).not.toContain("blob:");
const unmapped = await beforeSend(eventFor("blob:https://tenant.example/other") as never, { originalException: reason });
expect(unmapped?.tags).toMatchObject({ browser_plugin_module: "unmapped" });
const host = await beforeSend(eventFor("/assets/other.js") as never, { originalException: reason });
expect(host?.tags).not.toHaveProperty("browser_plugin_module");
});
it("adds diagnostics without a transaction filter", async () => {
const { buildBrowserSentryInitOptions } = await importFreshSentry();
+8
View File
@@ -43,6 +43,9 @@
// starts monitoring, `fetch-rejection-origin.ts` wraps `fetch` itself and
// tags an unhandled rejection with an enum for who started the request. It
// sends no URL, path, or stack text.
//
// Plugin UI modules run from random `blob:` URLs. `plugin-module-origins.ts`
// maps such a frame back to its plugin key and tags the event with it.
import {
buildBrowserErrorContext,
@@ -60,6 +63,7 @@ import {
startFetchRejectionDiagnostics,
} from "./fetch-rejection-origin";
import { isIntentionalAbortReason } from "./intentional-abort";
import { readPluginModuleOrigin } from "./plugin-module-origins";
let queue: Promise<void> = Promise.resolve();
@@ -263,6 +267,10 @@ export function buildBrowserSentryInitOptions(
...event.tags,
browser_build_mode: import.meta.env.DEV ? "development" : "production",
};
// A plugin UI module runs from a random `blob:` URL. Name the plugin
// whose module holds the innermost such frame, never the URL.
const pluginModule = readPluginModuleOrigin(event.exception?.values);
if (pluginModule) event.tags.browser_plugin_module = pluginModule;
if (isUnhandledRejection) {
// The SDK supplies the rejected value directly. Classify without
// reading object properties, coercing strings, or copying its value.
+18
View File
@@ -67,3 +67,21 @@ it("does not load agent tabs that have not opted into task side panels", async (
expect(container.textContent).toBe("0");
expect(fetch).not.toHaveBeenCalled();
});
it("records each plugin module's blob URL with its plugin key for error attribution", async () => {
const { readPluginModuleOrigin, __resetPluginModuleOrigins } = await import("@/lib/plugin-module-origins");
__resetPluginModuleOrigins();
vi.stubGlobal("fetch", vi.fn(async () => new Response("export const Switcher = () => null;")));
vi.spyOn(URL, "createObjectURL").mockReturnValue("blob:http://localhost/plugin-module");
vi.spyOn(URL, "revokeObjectURL").mockImplementation(() => {});
vi.spyOn(console, "error").mockImplementation(() => {});
try {
// jsdom cannot import the blob URL; the loader logs that failure and settles.
await ensurePluginContributionLoaded(contribution);
expect(readPluginModuleOrigin([
{ stacktrace: { frames: [{ filename: "blob:http://localhost/plugin-module" }] } },
])).toBe("fixture.navigation");
} finally {
__resetPluginModuleOrigins();
}
});
+7 -2
View File
@@ -43,6 +43,7 @@ import { authApi } from "@/api/auth";
import { describeError, isTransientError } from "@/api/errors";
import { queryViewKind } from "@/components/QueryView";
import { queryKeys } from "@/lib/queryKeys";
import { rememberPluginModuleUrl } from "@/lib/plugin-module-origins";
import { cn } from "@/lib/utils";
import {
PluginBridgeContext,
@@ -425,9 +426,10 @@ function rewriteBareSpecifiers(source: string): string {
* Fetch, rewrite, and import a plugin UI module.
*
* @param url - The URL to the plugin's UI entry module
* @param pluginKey - The plugin's key, recorded for error attribution
* @returns The module's exports
*/
async function importPluginModule(url: string): Promise<Record<string, unknown>> {
async function importPluginModule(url: string, pluginKey: string): Promise<Record<string, unknown>> {
// Check if the bridge registry is available. If not, fall back to direct
// import (which will fail on bare specifiers but won't crash the loader).
if (!globalThis.__paperclipPluginBridge__) {
@@ -449,6 +451,9 @@ async function importPluginModule(url: string): Promise<Record<string, unknown>>
// Create a blob URL from the rewritten source and import it
const blob = new Blob([rewritten], { type: "application/javascript" });
const blobUrl = URL.createObjectURL(blob);
// Stack frames from this module name only the blob URL. Keep its plugin
// key so an error report from the module can say which plugin raised it.
rememberPluginModuleUrl(blobUrl, pluginKey);
try {
const mod = await import(/* @vite-ignore */ blobUrl);
@@ -508,7 +513,7 @@ async function loadPluginModule(contribution: PluginUiContribution): Promise<voi
try {
// Dynamic ESM import of the plugin's UI entry module with
// bare-specifier rewriting for host-provided dependencies.
const mod: Record<string, unknown> = await importPluginModule(url);
const mod: Record<string, unknown> = await importPluginModule(url, pluginKey);
// Collect the set of export names declared across all UI contributions so
// we only register what the manifest advertises (ignore extra exports).