# Publish programs and apps to the NOVA app store

> Configure your app's manifest, install it with the NOVA CLI, and publish it to the Wandelbots NOVA app store catalog.

Once you've built and tested your programs and apps, e.g. a device integration, you can publish them to the NOVA app store with the [Wandelbots NOVA CLI](https://github.com/wandelbotsgmbh/nova-cli).

The NOVA CLI uses an application manifest closely linking to the Wandelbots NOVA API [Application endpoints](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/addApp).
This manifest is provided by default when you start an app with Typescript or Python templates.

### Step 1: Application manifest

```yaml
# The name of the app, how it will be displayed on the NOVA homescreen.
# Must be a valid RFC 1035 label name, e.g. lowercase letters, digits, and hyphens.
name: rerun
# URL path to an application icon, which will pop up on the NOVA homescreen.
# The path starts at the root level.
app_icon: app_icon.webp
container_image:
  # This is the image which will be running your service
  image: wandelbots.azurecr.io/nova-apps/rerun:0.0.30
  # The credentials required to pull images from private registries
  credentials:
    registry: wandelbots.azurecr.io
    user: your-username
    password: your-password
# The port where your app serves the OpenAPI interface, app_icon, and small UI. Defaults to 8080.
port: 3001
# Additional environment variables which will be available in the container.
environment:
  - name: ENV_VAR_NAME
    value: env_var_value
# The path and capacity of a volume that retains data across application restarts.
# The maximal requestable capacity is 300Mi. If you need more capacity consider using storeObject.
storage:
  mount_path: /data
  # The amount of local storage available for the application.
  # NOTE: The capacity can NEVER be reduced!
  capacity: 100Mi
# (Optional) Additional resources that the application requires.
resources:
  # Number of Intel GPUs the application requires (0 or 1).
  intel_gpu: 1
  # The maximum memory allocated to the application.
  memory_limit: 1000Mi
# (Optional) URL path suffix for the health check. Defaults to the app_icon path.
# If the health check fails, NOVA automatically restarts the application container.
health_path: /health
```

#### Environment variables

> **Warning:** When NOVA hosts your service in a cell called `cell` with the app name `robo-app`, the public base path becomes `http://host/cell/robo-app`.
> Respect the provided `BASE_PATH` so every link in your UI and OpenAPI stays valid.

- `BASE_PATH`: URL prefix used to mount your UI and API routes.
- `NOVA_API`: Internal endpoint that lets the container talk to NOVA.
- `CELL_NAME`: Name of the cell where the service is deployed.
- `NATS_BROKER`: The NATS broker endpoint accessible from within the application container.

### Step 2: Install and observe the service

Apply the manifest with the NOVA CLI:

```bash
nova app install your-app.yaml
```

> **Info:** All manifest parameters, runtime status, resource assignments, and usage metrics are exposed via the [List Apps API](https://portal.wandelbots.io/docs/api/v2/ui/#/operations/listApps).
> Use it to audit deployments or sync them with external tooling.

→ Once installed, the app tile launches your web UI, and robot programs can call the same endpoints through
`http://<your-instance>/cell/<app-name>` from inside the cell network.

### Step 3: Publish your app in the app store

After validating the integration, submit your app to the [Wandelbots NOVA catalog](https://github.com/wandelbotsgmbh/catalog).

A catalog entry has its own format: your deployment manifest moves under an `app` key (in camelCase, following the catalog's [schema.json](https://github.com/wandelbotsgmbh/catalog/blob/main/schema.json)),
and catalog metadata like `version`, `novaOsVersion`, and `description` is added around it.
Registry credentials are referenced as named secrets. The secrets must be available on the NOVA instance by default.

```yaml
version: 1.0.0
name: My App
novaOsVersion: ">= 25.3"
description: |
  What your app does.
homepage: https://github.com/your-org/your-app
app:
  name: my-app
  appIcon: app_icon.png
  port: 3000
  containerImage:
    image: docker.io/your-org/my-app:1.0.0
    secrets:
      - name: your-pull-secret
```

1. Add a folder `catalog/<your-app-name>/` containing `manifest.yaml` (following `schema.json`) and an `icon.png`.
2. Open a pull request so the entry can be reviewed. This ensures that the app meets the quality standards and is compatible with NOVA.\
   → Once merged, the app appears in the NOVA app store and can also be installed directly with the NOVA CLI:

```bash
nova catalog install <your-app-name>
```