App Store
The App Store is where you discover and manage the Apps available on your Operaide instance. It shows every App that has been published to the built-in registry — both the Core Apps that ship with the platform and any custom Apps that developers have added.
You access the App Store from App-Store in the sidebar.
What You See
The App Store has two panes. The left pane lists every available App, grouped by origin (see How Apps Are Grouped). Search by name or use the filter next to the search box to narrow the list. Select an App to open its detail panel on the right.
The detail panel shows:
| Element | Description |
|---|---|
| Name and description | The App's display name, icon, and a short summary |
| Version picker | Top right - switch between available versions (dev, stable, and built-in channels) |
| Deploy New Instance | Primary action - opens the deploy wizard to create an App Instance |
| Actions menu | Dropdown next to Deploy New Instance: Create New App from Template, Export App as Archive (.tgz), Install to Library (Legacy) |
| Tabs | Details, Dependencies, and More Info. A Migration tab also appears when the selected App version ships a migration guide |
The organization name displayed in the header confirms which organization's App Store you are viewing.
How Apps Are Grouped
The App Store groups Apps into sections by origin: where each App came from and how far to trust it. Empty sections are hidden.
| Section | What it contains |
|---|---|
| Local Custom | Apps added on this instance by a developer, via npm publish, direct deploy, or import |
| Remote Custom | Copies cached from a trusted upstream Operaide instance |
| Official | Core Apps shipped with the platform image, maintained by the Operaide team |
| Public NPM | Apps resolved from public npm.org, not verified by Operaide |
Sections appear in that order. The Apps unique to your instance (Local Custom, Remote Custom) come first, then the Official Apps that ship with every instance, then anything from public npm.
The Public NPM section carries an Untrusted badge. These packages come from public npm and are not checked by Operaide. Install them only if you trust the source.
Click a section header to collapse or expand it; folding a section you rarely use keeps the others in view. Each section header carries a help icon that explains that origin's trust level.
Core Apps
Every Operaide installation ships with a set of Core Apps (op-core-*). These are reference implementations maintained by the Operaide team and automatically published to the built-in registry when the instance starts. They are available in the App Store immediately after provisioning.
Core Apps available out of the box include:
| App | Purpose |
|---|---|
operaide-app-core-operaide-chat | Full-featured chat with streaming, file handling, web search, and assistant management |
operaide-app-core-basic-chat | Simpler chat with a configurable system prompt |
operaide-app-op-core-knowledge-chat-ng | Chat with knowledge base integration |
operaide-app-op-core-websearch | Web search functionality |
operaide-app-core-blank-app | Empty scaffold for developers starting a new App |
How New Apps Reach the Store
Publishing is handled by developers. There are two paths, and both result in the App appearing in your App Store:
Path 1: npm publish (standard)
A developer publishes a packaged App to the instance's built-in npm registry:
npm publish
The developer's .npmrc file points to your instance's registry endpoint (https://<your-instance>/api/v1/registry) and includes an API key for authentication. The user behind the API key must hold NPM Registry Publisher (or a role that implies it, such as App Developer, App Manager, or System Administrator); otherwise the registry returns 403 Forbidden. Once published, the App appears in the App Store for all organizations on that instance.
If a requested package is not in the local registry, Operaide forwards the request to an upstream registry. The default upstream is https://registry.npmjs.org. To configure a private upstream (Verdaccio, GitHub Packages, npm Enterprise, or another Operaide instance), see Upstream NPM Registry.
Path 2: Direct deploy (development)
During active development, a developer can upload source files directly:
npm run deploy
This sends files to the /api/v1/deploy-reaktor endpoint. The App appears in the App Store immediately. Existing App Instances of this App in the developer's organization are synced: new Reaktors are added, removed Reaktors are deleted. To run a freshly uploaded App for the first time, create an App Instance via the UI. This path is typically used on development instances, not production.
Path 3: Export and Import via UI
You can transfer an App between two Operaide instances that do not share a registry. No npm CLI, tooling, or API key is required.
Export on the source instance:
- Open the App Store and select the App.
- Open the Actions menu next to Deploy New Instance and click Export App as Archive (.tgz).
- The browser downloads
<packageName>-<version>.tgz.
Import on the target instance:
- Open the App Store.
- Click Import App in the store header.
- Select the
.tgzfile from the export step.
A success notification confirms the import and the App appears in the store.
The file format is the standard npm tarball with all files under a package/ root. Files produced by Create New App from Template > Develop locally (named <app>@<version>.tgz, flat layout) are local-development artifacts and are rejected by the import with a clear error.
Version collisions: the import rejects a version that already exists on the target instance. Bump the version on the source, re-publish, and re-export to bring in an updated build.
Required permissions:
| Action | Permission |
|---|---|
| Export | Read from NPM Registry |
| Import | Publish to NPM Registry |
On a production instance, the typical workflow is: a developer publishes the App to the registry (Path 1), and you install it from the App Store. The developer does not need direct access to the production instance beyond their API key.
Getting Updated App Versions
When a developer publishes a new version of an existing App, the updated version appears in the App Store automatically. The App Store always shows the highest version that is compatible with your platform version.
Compatibility is determined by the @operaide/aktor peer dependency declared in the App's package.json. If a new version requires a newer platform version than what you are running, it will not appear in the store until the platform is upgraded.
Permissions
Access to the App Store is controlled by the following permissions:
| Permission | Description | Default roles |
|---|---|---|
| Access App Store | View available Apps in the store | App Developer, App Manager |
| Install Apps | Install Apps from the store into the organization | App Manager |
| Download App Code | Download App source code as a .tgz archive | App Developer |
| Read from NPM Registry | Read package metadata and tarballs via the registry (npm install) | NPM Registry Reader, NPM Registry Publisher, App Developer (by implication) |
| Publish to NPM Registry | Publish new package versions via the registry (npm publish) | NPM Registry Publisher, App Developer (by implication) |
Only users with the App Manager role can install Apps. If you need to install an App, ensure your account has this role assigned.