Plugin Marketplace (part 2)
The second half of the Plugin Marketplace page: what a plugin may read from your session history and boards, what it can watch you doing, ratings and reviews, the errors you can hit, the developer and publisher surfaces, and the registry and install internals.
On this page
What it is
This is part 2 of the Plugin Marketplace page. That page covers what the Marketplace is, where to find it, and the opening of the numbered walkthrough: browsing the catalogue, installing and uninstalling, the gate on third-party plugin backends, and an agent’s install request. Part 3 covers keeping installed plugins current, version compatibility and package signing.
The numbered walkthrough continues from step 9 below.
Where to find it
The same two surfaces as the main page: the Marketplace virtual project in the sidebar for browsing and for switching plugins on and off, and Settings → Plugins for the settings of the plugins you have switched on. Settings → Plugins lists a plugin only while it is on and has something to manage there — its own settings, or access you can see and take back — plus any plugin that needs you to re-approve it; a plugin that is off, or one with nothing to set (Books, for example), is not listed. Built-in plugins the Marketplace does not list yet are switched on during first-run setup. Most of this half is reached from a single plugin’s own detail page or its Settings card, with the My Plugins tab in Marketplace for plugin authors.
An installed plugin's detail page in the Marketplace carries the same controls as its Settings card while the plugin is on: its own options, Open links in this plugin, and every access panel below (session history, folders and commands, files, scheduled emails, accounts), so what a plugin was given can be taken back from either place.
How it behaves
Your data a plugin can ask to read
Some plugins can ask to read your past Omniscio sessions and projects — for example, a plugin that turns your existing work into a summary or a deck. This is gated behind the sessions.readHistory permission and a strict, opt-in privacy model:
- Nothing by default. A plugin reads none of your history until you grant it. When a plugin needs access, a picker opens and you choose exactly which projects or sessions to hand over — it can only ever read those (a project you pick covers its sessions).
- Text only. The plugin receives the plain-text conversation, never the raw internals — tool output, file contents, and anything that could carry secrets are stripped out before it reaches the plugin.
- Logged and revocable. Every read is recorded in a log the plugin cannot touch, and your grant persists until you revoke it. Review what a plugin was granted, see its read log, and revoke access anytime under Settings → Plugins → "Session history access" (shown per plugin, only once a plugin has requested access).
Boards are a separate ask, on purpose. A plugin that wants to read your PM boards requests a
distinct boards.read permission rather than reusing the session-history one, because a board is
project-management data and not a conversation. Agreeing to share past sessions should never quietly
hand over something else. It follows the same model — nothing by default, you pick which boards, every
read logged, revocable — with two differences worth knowing: sharing one board shares only that
board (boards sit inside a workspace, and a workspace is far wider than the thing you pointed at),
and the plugin never receives the board's items, only a summary. Board grants appear in the same
per-plugin access panel as the others, each labelled for what it is.
A first-party built-in plugin shows no install-time consent dialog, so for those the picker and this access panel are the control surface. (Plugin authors: the developer side — the sessionHistory bridge namespace — is in Plugin Bridge Capabilities.)
Plugin authors: the marketplace publish validator keeps its OWN mirror of the declarable
permission set, because the cloud function cannot import host code. If the host gains a permission and
that mirror is not updated, an honest manifest declaring it is rejected at publish with
Unknown permissions: <name> — before a submission even exists, so no reviewer can wave it through.
What a plugin can see you doing
Separate from reading your past work, a plugin can ask to see your sessions as they happen. Two different things, with two different answers:
- A companion or status overlay — a plugin that reacts to your work (a pet, an activity HUD)
can ask for
sessions.observeStatus, shown in the consent dialog as Session Activity. It sees only when a session starts, finishes, or needs you. It never sees a single word of what you or the agent wrote. A plugin that has not asked for it receives nothing at all, even if it has an overlay on screen. - A plugin watching a session it started itself — if a plugin launched a session for you, it can follow that session's output live. That needs no extra permission, because it is the plugin's own work: it can only ever see sessions it launched, never yours or another plugin's. If you revoke that project's folder access, the stream stops.
Accounts a plugin can use (Google, GitHub)
Some plugins ask to use your Google or GitHub account. The first time, Omniscio shows a prompt naming the plugin and what it wants; nothing is shared until you click Allow.
- See it and take it back. Settings → Plugins → the plugin's card → "Accounts this plugin can use" lists each account, what the plugin may do, and when you allowed it (shown only while it holds access). Revoke asks to confirm, then stops the plugin's background process, so a sign-in it already held is gone too, and removes the access. The plugin stays stopped until it next starts (Omniscio reopens, or you turn it off and on), and then must ask you again.
- Saying no is respected. After a Deny, the plugin cannot ask again for five minutes.
- Only you can revoke. No plugin can list or revoke access, its own or another's. Over the CLI:
GET /plugins/:id/auth-grantslists it (never a token);POST /plugins/:id/auth-grants/revokewith{ "provider": "google" | "github" }revokes it.
Plugin authors: ctx.auth.getSession(provider, scopes, { reportDenial: true }) returns
{ denied: 'recently-denied', retryAfterMs } instead of null within five minutes of a Deny.
Without the flag, and for "no session", it returns null.
Text a plugin's publisher wrote
A plugin's README on its Marketplace page, and a skill a plugin ships, render in a restricted markdown mode because a publisher, not you or your agent, wrote them: web links open in your browser; other links (a local file, an Omniscio deep link, a relative path) show as plain words that do nothing; pictures load only from the web, and a withheld one shows a short note, not a gap. Your own AI chats are unaffected, and a build guard fails if a Marketplace render forgets the restricted mode (untrusted-markdown-render-contract.md).
Rating
Hidden for now:
MARKETPLACE_RATINGS_HIDDENhides every rating surface, this box included. See Rating in plugin-marketplace.md to bring it back. The steps below describe the box once it returns.
View ratings. Each detail page shows the average star rating, total review count, and a star-distribution histogram. The latest 20 reviews load below; the Load more button paginates 20 at a time. The star row under the plugin's name is that average, not your own rating — so when you are able to rate, the whole row becomes one control that jumps you down to the Ratings & Reviews form and puts the cursor in it. It stays a plain display when there is no form to reach (signed out, or the plugin is not installed), so it can never be a click that does nothing. It does not pre-pick a star: five stars that mean "the community said 4" in one place and "I say 4" in another would be two things wearing one face, and splitting the row into five buttons would turn a single spoken label into five for a screen reader.
Submit a rating (signed-in installers only). Submitting needs the marketplace GitHub sign-in —
MARKETPLACE_SUBMIT_RATINGrefuses unlessgetAdminStatus()isauthenticated— so the rating box (PluginRatingBox.tsx) re-checks that status every time the page opens and shows only what can actually work: It is not your Omniscio account: an earlier implementation sentauthService.getActiveAccountId()as anx-user-idheader, the endpoint ignored that header, and every submission failed — that code is gone.- Checking — nothing, until the status answers, so a stale value never flashes the form.
- Signed out (or the check failed) — builds with the in-app sign-in say to sign in with GitHub on the My Plugins tab; release builds, where that sign-in is compile-stripped, say reviews aren't available in this version yet. A release build holding a CLI sign-in (
omniscio-plugin login, or the sign-inomniscio-plugin publishperforms on first use) counts as signed in (marketplace-admin-auth-contract.md I11, I12). The Ratings & Reviews card itself still renders either way, so a build that cannot submit says why instead of leaving a silent gap. - Signed in, not installed — "Install this plugin to leave a review."
- Signed in and installed — the star form, with the green Installed verified badge on the ratings header. Pick 1–5 stars, optionally add a short review (no links), click Submit Rating.
The server keys the rating to the verified marketplace Firebase uid from that GitHub sign-in (never your Omniscio or Anthropic account) and refuses a plugin's own author (
403, "You cannot review your own plugin").Edit your rating. The backend keys each rating by your identity and upserts — you have exactly one rating per plugin, and re-submitting replaces it rather than stacking a new one. When you've already rated a plugin this session the form is honest about that: it pre-fills your stars + review and the button reads Update your rating instead of Submit. The public ratings feed pseudonymizes rater ids (a review can't be traced back to "you" from the list), so this pre-fill is driven by a session-tracked map of your own submissions (
myRatingsin the marketplace store), cleared on cloud logout so a different signed-in user never inherits it.
Errors
- Registry can't be fetched — the card shows a red banner with the error text and a Retry button.
- Single install fails (network glitch, checksum mismatch, oversized file) — red toast quotes the reason; your existing install, if any, is left untouched (see "atomic" below).
- Rating submit fails — toast with the reason; nothing persists locally, and your typed review is kept so a retry does not start from blank. (Hidden for now; see the note above.)
- A rating the server REFUSES says which rule you hit. Reviewing a plugin you published (403
FORBIDDEN), the per-user rate limit, a link in the review text, an out-of-range star value — each comes back as a 4xx carrying the marketplace's own sentence, and that sentence is what you read: "You cannot review your own plugin", not a guess. It is carried as its own error type (MarketplaceRefusedError, thrown by marketplace-ratings.ts and passed through by TYPE in marketplace-user-errors.ts), the same way an upgrade-required refusal already was — because left to the classifier it arrives as the stringHTTP 403: {…}, matches the transport bucket's/\bhttp\s+\d{3}\b/, and becomes "Couldn't reach the plugin marketplace. Check your internet connection and try again." The marketplace had answered perfectly; the advice was wrong, retrying could never clear it, and the explanation was thrown away. Only a 4xx carrying a server sentence is passed through — a 5xx is a genuine upstream fault and keeps the transport copy, and a non-JSON, blank or over-long body falls back to it too. The raw status and body still reach the log.
A failure that retrying cannot fix says so. Raw causes are classified into plain sentences by toMarketplaceUserError (marketplace-user-errors.ts), and a deterministic failure never gets the generic "Please try again" — that advice sends the user round a loop that fails identically every time. A full disk asks them to free space; a directory another process holds open (EPERM/EBUSY, and safeSwapInstalledDir's own "currently in use" refusal) asks them to close what's using the plugin; and a plugins folder Omniscio cannot write to (EXDEV/EROFS) states plainly that retrying won't help and asks them to report it. These fs checks run before the corrupt-package check on purpose: an fs error quotes the path it failed on, so a locked …/manifest.json matches the corruption heuristic and would otherwise blame a package that was never damaged.
That last bucket also decides what reaches Sentry: a full disk, a locked file or an upstream reply that never arrived as usable JSON logs WARN and is marked expected, like a network blip, but failing to write our own plugins folder, a package that genuinely failed its integrity check (a checksum mismatch, a checksum file the package doesn't carry, or no manifest), and an over-cap reply are defects and stay unmarked at ERROR — the EXDEV cross-device install bug produced no crash signal precisely because it hid in that unmarked bucket.
A reply bigger than Omniscio accepts says exactly that — never "corrupted". When the catalog, a plugin's details or ratings, or a package download is over its size cap (see "Fetch hardening" below), the user reads "The plugin marketplace sent more data than Omniscio can accept, so this couldn't be loaded. The plugin isn't damaged, and trying again won't help until we fix it on our end." — translated, and with no retry advice, because the same reply fails the same way until the server changes. This check runs before the corrupt-package check and matches only the size-cap errors themselves (Response too large / Registry response too large / Package too large), so an unrelated "too large" such as an HTTP 413 keeps its old bucket. It stays unmarked at ERROR: an oversized reply is our defect, and its Sentry report is how the 2026-09-23 incident was found — GitHub Integration's details had grown to 299,361 bytes and every user opening its page was told the plugin looked corrupted.
Developer dashboard
The Marketplace's My Plugins tab is where plugin authors track their own submissions to the marketplace. It shows:
- Sign-in button — OAuth flow against the marketplace Firebase project. Internal/dev builds only: the in-app GitHub sign-in handler is compile-stripped from the packaged app, so a release build shows a notice pointing at the CLI instead.
- Submissions list — each submission is an expandable status card (
SubmissionStatusCard). Collapsed, it shows plugin id + version, a statusPill(Pending review / Published / Changes requested), and the relative submission time. Expanded, it reveals a three-step status timeline (Submitted → In review → Decision, each marker coloured by state and stamped with a relative time), the full What's new changelog, Reviewer notes (shown for an approved submission with feedback as well as a rejection), and a what-happens-next hint tailored to the status.
In a release build, the tab signs in with your CLI login. A packaged app has no marketplace sign-in of its own, so it borrows the credential omniscio-plugin login writes to ~/.amc/marketplace-token — the same account that ran omniscio-plugin publish, which has signed authors in on first use since before login existed, so everyone who has a submission to show already has this file. Nothing new to sign into: the My Plugins tab lists your submissions as soon as the CLI is logged in, omniscio-plugin logout signs the tab out too (a refreshed token is written back to the CLI's file, never copied into the app), and a borrowed login is always treated as a developer, never an admin — it can list your own submissions but cannot open any review surface. The app's own token, when one exists (internal builds), still wins (marketplace-cli-token.ts; the borrowed-CLI-credential rule in marketplace-admin-auth-contract.md).
The view exists separately from the Marketplace Review view used by Omniscio admins to triage incoming submissions.
Related
Plugin Marketplace is the first half of this page — what the Marketplace is, how to browse it, and how installing and the security gate work — and part 3 covers updates, version compatibility and package signing. The contracts and key files listed above hold the invariants behind what this half describes.
Last verified 2026-11-05