> ## Documentation Index
> Fetch the complete documentation index at: https://docs.rigbox.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# Catalog Apps

> Install pre-packaged apps like VS Code, Jupyter, and Streamlit in one call.

The Rigbox app catalog provides curated, pre-packaged applications that you can install into any workspace with a single CLI command. Each catalog app is configured with the correct port, subdomain, and systemd service — no manual setup required.

## How It Works

When you install a catalog app:

1. Rigbox downloads and configures the app inside your workspace
2. For **Service-shape** apps: a systemd service is created, an app route maps the port to a `*.rigbox.dev` subdomain, and a readiness probe waits for the service to come up
3. For **CLI-shape** apps: the binary is dropped into `$PATH` (and any routing/profile.d shims are written), then the install returns — no systemd unit, no port, no route, no probe
4. The app row is registered either way, so the workspace UI shows the app as installed

You manage installed Service-shape apps with the same endpoints you use for any other app — start, stop, restart, delete, and change visibility. CLI-shape apps don't expose those endpoints; you invoke them interactively over SSH.

## App shapes

| Shape       | What you get                                       | What's missing                         | Typical use                               |
| ----------- | -------------------------------------------------- | -------------------------------------- | ----------------------------------------- |
| **Service** | systemd unit, Caddy route, subdomain, health probe | —                                      | VS Code, Jupyter, Streamlit, PGWeb, …     |
| **CLI**     | Binary on `$PATH`, optional profile.d routing shim | systemd, route, subdomain, port, probe | `claude`, `codex`, `opencode`, `kilocode` |

For CLI-shape apps the `install-app` job is finished as soon as `install.sh` exits — there is no service readiness to wait on. Once the job status is `completed`, SSH into the workspace and run the agent directly. See [AI Coding Tools](/guides/ai-coding-tools) for usage patterns once a recipe is installed, and [Managed AI Proxy](/guides/managed-proxy) for how credits are metered for the requests each agent makes.

<Note>
  User-created apps (those you `POST` to [`/apps`](/api-reference/apps/create) directly, instead of installing a catalog recipe) accept the same `app_kind: "service" | "cli"` field. CLI-shape apps must have `port: 0` and omit `protocol`; Service-shape apps default to port `3000` and require a protocol.
</Note>

## Available Apps

Catalog apps are official **app recipes**, addressed as `@rigbox/<id>@builtin`. The Service-shape and CLI-shape reference tables below list every available app and its catalog ID. Preview any one before installing:

```bash theme={null}
rig recipe app info @rigbox/vscode@builtin
```

See [List Catalog Apps](/api-reference/app-catalog/list) for the underlying HTTP shape.

### Service-shape Catalog Reference

| App            | Catalog ID    | Port | Subdomain    | Description                                       |
| -------------- | ------------- | ---- | ------------ | ------------------------------------------------- |
| VS Code Server | `vscode`      | 8443 | `vscode`     | Browser-based VS Code with full extension support |
| Jupyter Lab    | `jupyter`     | 8888 | `jupyter`    | Interactive notebooks for Python, Julia, R        |
| Marimo         | `marimo`      | 8000 | `marimo`     | Reactive Python notebooks                         |
| Streamlit      | `streamlit`   | 8501 | `streamlit`  | Python data app framework for dashboards          |
| File Browser   | `filebrowser` | 8080 | `files`      | Web-based file manager with upload/download       |
| Excalidraw     | `excalidraw`  | 3000 | `excalidraw` | Collaborative whiteboard and diagramming          |
| PGWeb          | `pgweb`       | 8081 | `pgweb`      | PostgreSQL web client with query builder          |

<Note>
  Subdomains are prefixed with the workspace name. For example, if your workspace is named `my-workspace` and you install the VS Code catalog app, the resulting app name is `my-workspace-vscode` and the full URL is `https://my-workspace-vscode.rigbox.dev`. Replace `my-workspace` with whatever name you gave your workspace.
</Note>

### CLI-shape Catalog Reference

These recipes install an interactive AI coding agent into the workspace's `$PATH`. They route through the managed AI proxy (Rigbox's OpenRouter gateway), so no provider API key is required when the workspace is in managed AI mode.

| Agent       | Catalog ID | Invoke as  | Routing notes                                                                      |
| ----------- | ---------- | ---------- | ---------------------------------------------------------------------------------- |
| Claude Code | `claude`   | `claude`   | `OPENROUTER_*` injected; `profile.d` shim adds Anthropic-compatible env            |
| Codex CLI   | `codex`    | `codex`    | `OPENROUTER_*` → translated to `OPENAI_BASE_URL` / `OPENAI_API_KEY` by `profile.d` |
| OpenCode    | `opencode` | `opencode` | Reads `OPENROUTER_API_KEY` natively — no env translation needed                    |
| Kilo Code   | `kilocode` | `kilocode` | `OPENROUTER_*` → `KILO_OPEN_ROUTER_API_KEY` by `profile.d`                         |

Install one of them the same way as a Service-shape app:

```bash theme={null}
rig recipe app install -r @rigbox/claude@builtin -w <WORKSPACE_NAME>
```

Inside a workspace VM, drop the `--workspace` flag — `rig` infers it from the ambient identity. Then SSH in and run the agent — `rig ssh-info <workspace>` will print the right `ssh` command.

<Note>
  CLI-shape recipes don't appear in the [Start App](/api-reference/apps/start) / [Stop App](/api-reference/apps/stop) / visibility endpoints — there's no daemon to control. To uninstall, delete the app row; the catalog's cleanup paths (e.g. `/etc/profile.d/codex-routing.sh`) are removed automatically.
</Note>

## Installing a Catalog App

Install an app by its catalog ID:

```bash theme={null}
rig recipe app install -r @rigbox/vscode@builtin -w <WORKSPACE_NAME>
```

`rig recipe app install` blocks until the install job completes and returns the app's name and URL when it's done. From inside a workspace VM, omit `-w`/`--workspace`.

For programmatic installs that need to fire-and-forget or track the job ID separately, use [Install Catalog App](/api-reference/app-catalog/install) and [Get Job Status](/api-reference/app-catalog/job-status) directly.

### Access the installed app

Once installed, a Service-shape app is running and accessible at its subdomain URL. CLI-shape apps are invoked over SSH (see [App shapes](#app-shapes) above).

## Managing Installed Apps

After installation, catalog apps behave like any other app. Use the standard app endpoints to manage them.

### Start and Stop

```bash theme={null}
rig app start <APP_NAME>
rig app stop <APP_NAME>
rig app restart <APP_NAME>
```

See [Start App](/api-reference/apps/start), [Stop App](/api-reference/apps/stop), and [Restart App](/api-reference/apps/restart) for the API form.

### Change Visibility

Catalog apps are private by default. Use `rig app share` to change visibility — pick exactly one mode:

```bash theme={null}
rig app share --app $APP_NAME --public                # visible to everyone
rig app share --app $APP_NAME --private               # visible only to you
rig app share --app $APP_NAME --emails a@x.com,b@y.com # allowlist specific emails
```

See [App Visibility](/guides/visibility) for the full set of options and [Update App Visibility](/api-reference/apps/update-visibility) for the API reference.

### Delete

Deleting an installed app removes both the route and the systemd service inside the workspace:

```bash theme={null}
rig app rm <APP_NAME>
```

See [Delete App](/api-reference/apps/delete) for the API form.

## App Details

Each app installs with the same one-liner — swap in the catalog ID from the table above:

```bash theme={null}
rig recipe app install -r @rigbox/vscode@builtin -w <WORKSPACE_NAME>
```

### VS Code Server

A full browser-based VS Code instance with extension support, integrated terminal, and file editing. Runs [code-server](https://github.com/coder/code-server).

<Tip>
  VS Code Server supports installing extensions from the Open VSX registry. Search and install extensions directly from the browser UI.
</Tip>

### Jupyter Lab

Interactive notebooks for Python, Julia, R, and more. Supports inline visualizations, markdown cells, and kernel management.

### Marimo

Reactive Python notebooks where cells automatically re-execute when dependencies change. An alternative to Jupyter with a focus on reproducibility.

### Streamlit

Build interactive data dashboards and web apps in Python. Write a Python script and Streamlit renders it as a web application.

### File Browser

A web-based file manager with drag-and-drop upload, download, and file editing. Useful for managing files inside the workspace without SSH.

### Excalidraw

A collaborative whiteboard for sketching diagrams, wireframes, and architecture drawings. Runs locally inside the workspace — no external dependencies.

### PGWeb

A web-based PostgreSQL client with a query editor, table browser, and export functionality. Useful for inspecting databases running inside the workspace.

## Image Compatibility

Every catalog app works on both the `base` and `dev` images — both ship Python 3.12 and Node.js 22.

<Tip>
  The `base` image has pre-warmed npm caches for Jupyter, Marimo, Streamlit, and Excalidraw. Installation on `base` is significantly faster because those dependencies are already downloaded.
</Tip>

## Complete Example: Install VS Code and Jupyter

Install both into the same workspace:

```bash theme={null}
rig recipe app install -r @rigbox/vscode@builtin -w my-project
rig recipe app install -r @rigbox/jupyter@builtin -w my-project
```

Each command blocks until the install completes and prints the app's URL. After both finish, the apps are accessible at `https://my-project-vscode.rigbox.dev` and `https://my-project-jupyter.rigbox.dev`.

## Next Steps

* [Expose Ports & Route Apps](/guides/expose-and-route) - understand how app routing works
* [App Visibility](/guides/visibility) - control who can access installed apps
* [Workspaces](/guides/workspaces) - manage the workspace where your apps run
* [Images & Templates](/guides/images-and-templates) - choose the right base image for your catalog apps