Skip to content

Releases & module packs ​

A Replora release is a zip of the application plus a small signed manifest that installations read to offer one-click updates. Most modules travel separately, in a signed module pack that the installer downloads from the license server after a valid purchase code. Both are signed with Ed25519 keys that only the release machine holds; installations refuse anything whose signature doesn't match.

15 minutesMaintainers, developersSingle user · SaaS

Overview ​

ArtifactBuilt bySigned withChecked against
replora-<edition>-<version>.zippnpm release— (its SHA-256 is signed in the manifest)The manifest's sha256
replora-<edition>.json (update manifest)pnpm releaseRelease key (~/.replora/release-key.pem)REPLORA_UPDATE_KEY of each installation
replora-core-<version>.zip (module pack)pnpm release (or pnpm release:core)Core-pack key (~/.replora/core-pack-key.pem)license.public_key in config/replora.php

1. Create the keys (once) ​

sh
pnpm release:keygen        # release key → ~/.replora/release-key.pem (or REPLORA_RELEASE_KEY)
pnpm release:core-keygen   # core-pack key → ~/.replora/core-pack-key.pem (or REPLORA_CORE_KEY)

Each command writes a private key (PKCS#8 PEM, readable by you only, folder mode 700) and prints the public key as base64 of its 32 raw bytes:

KeyPut the public key into
Release keyREPLORA_UPDATE_KEY of every installation. Releases write it into the shipped .env.example themselves, so new installations trust it out of the box.
Core-pack keylicense.public_key in apps/standalone/config/replora.php (then every release trusts packs it signed).

Both refuse to overwrite an existing key. Keep the private keys out of the repository and backed up: without the release key, installations can't verify future releases; without the core-pack key, new packs can't be signed for existing installations. REPLORA_RELEASE_KEY (a path) puts the release key elsewhere, for both the key generator and pnpm release; REPLORA_CORE_KEY does the same for the core-pack key.

2. Build a release ​

Set the version in apps/standalone/VERSION, then:

sh
pnpm release --url=https://releases.example.com                    # Single user edition
pnpm release --edition=saas --url=https://releases.example.com     # SaaS edition
pnpm release --bundle --url=https://releases.example.com           # Single user, every module inside
pnpm release --url=https://releases.example.com --notes=notes.txt  # with "what changed" text
OptionDefaultWhat it does
--url=https://…— (required)Where you will publish the zip and the manifest. Must start with https://. The manifest's download URL and the feed address written into .env.example are built from it.
--edition=single|saassinglesingle leaves out the saas/ folder and builds the dashboard without SaaS pages; saas includes them.
--bundleoffSingle user only: puts every module into the zip and lets the installer go on without a purchase code (REPLORA_LICENSE_REQUIRED=false), e.g. for a marketplace review.
--notes=pathemptyA text file shown as "what changed" on the System page.

What it does, in order:

  1. Checks translations (tools/check-i18n.mjs) and runs pnpm build (with REPLORA_EDITION=single for the Single user edition).
  2. Stages apps/standalone without development files: node_modules, vendor (installed fresh with composer install --no-dev --optimize-autoloader), tests, tools, .env, editor and agent files, runtime data in storage/ (the folders stay); without --bundle also the module folders listed in resources/core-pack.json.
  3. With --bundle, stamps each bundled module with a core-pack.json of this version, so a later update without them fetches the matching modules.
  4. Rewrites .env.example with production defaults (APP_ENV=production, APP_DEBUG=false, empty database settings, database queue, cache and sessions, local recording storage) plus REPLORA_MODE, REPLORA_UPDATE_FEED, REPLORA_UPDATE_KEY (and REPLORA_LICENSE_REQUIRED=false with --bundle).
  5. Adds INSTALLATION.txt (requirements, install and update steps).
  6. Zips it with one top folder, writes the .sha256, and checks the contents: required files present (artisan, vendor/autoload.php, public/build/manifest.json, the installer…), nothing forbidden (tests, dev packages, source maps, node_modules, logs, .env, saas/ in Single user builds, pack modules in unbundled builds), and no local secrets in .env.example. A broken or leaky package fails the build.
  7. Writes and signs the update manifest.
  8. Without --bundle, builds the module pack (below).

Output in dist/:

text
dist/
├── replora-single-1.0.0.zip
├── replora-single-1.0.0.zip.sha256
├── replora-single.json                 the update manifest
├── replora-core-1.0.0.zip                    the module pack (+ .sig and .json)
└── license-packs/replora/1.0.0.zip(.sig)     the pack, laid out for the license server

3. Publish the update feed ​

Upload the zip and the manifest to the --url folder. Installations read REPLORA_UPDATE_FEED (<url>/replora-<edition>.json) twice a day (replora:update --check), remember the answer for 12 hours, and show Update now on the System page when a newer version is there.

json
{
  "version": "1.0.1",
  "released_at": "2026-12-01",
  "notes": "Faster session list. Fixed heatmaps on RTL pages.",
  "url": "https://releases.example.com/replora-single-1.0.1.zip",
  "sha256": "9f2c…",
  "signature": "Base64 Ed25519 signature of the sha256 text",
  "requires": { "php": "8.3.0" }
}
FieldMeaning
versionThe release's version (from VERSION).
released_atRelease date (YYYY-MM-DD).
notesText from --notes.
urlThe zip's download address.
sha256SHA-256 of the zip (hex).
signatureEd25519 signature of the sha256 hex string, base64.
requires.phpLowest PHP version the release runs on.

An installation installs the release only when the signature matches its REPLORA_UPDATE_KEY and the download matches sha256 (at most 300 MB). It keeps the current files as a backup (replora:update --rollback puts them back), then runs replora:upgrade (migrations, upgrade steps, caches) behind the maintenance page. Without a feed and a key, updates are installed by uploading the files and running php artisan replora:upgrade. See Updating & rolling back.

4. The module pack ​

Every module except Installer (the list in apps/standalone/resources/core-pack.json) travels in a signed pack. Release zips built without --bundle leave those folders out; a buyer's installer downloads the pack from the license server after a valid purchase code, checks its signature against license.public_key and unpacks it into place. Later updates refresh it with the purchase code saved at installation.

sh
pnpm build          # the pack carries the built tracker and offline player
pnpm release:core   # tools/release-core.mjs on its own

The build:

  • refuses to run when the signing key doesn't match license.public_key (installations would refuse the pack), when a module in modules/ is missing from core-pack.json, or when modules/Installer is in it;
  • needs modules/Recordings/Resources/tracker/t.js and modules/Recordings/Resources/offline/player.js (run pnpm build first);
  • writes replora-core.json (product, version, series, paths) at the top and a core-pack.json version stamp into each module folder, leaves out Tests/ folders;
  • signs the zip bytes (Ed25519) into .sig, writes {version, sha256, size, signature} into replora-core-<version>.json;
  • checks the result like an installation would (only the listed folders, a stamp in each, the needed files, at most 64 MB).

New modules

Add every new bundled module to apps/standalone/resources/core-pack.json (paths). The release fails until you do, so a module can't silently miss the buyers' installations.

Upload the pack to the license server ​

Copy dist/license-packs/replora/<version>.zip and <version>.zip.sig into the license server's resources/core-packs/replora/ folder (commit them there: a git pull on the server delivers them).

Installations check purchase codes with REPLORA_LICENSE_URL (default https://altara.digital/api/verify-purchase): GET <url>?purchase_code=…&product=replora&version=…&domain=…. The server answers {"success": true|false, "plan": "single"|"saas", "supported_until": …, "download": {url, version, sha256, size, signature}}, where download is a one-time link to the pack of that version. The SaaS edition accepts only codes of the SaaS plan.

Checklist for a release ​

  1. pnpm typecheck && pnpm test:coverage && pnpm i18n at the root, composer check in apps/standalone.
  2. Raise apps/standalone/VERSION; write the notes.
  3. pnpm release --url=… for each edition you ship (and --bundle for a review build).
  4. Upload zips and manifests to the release URL.
  5. Upload dist/license-packs/replora/* to the license server.
  6. Update an existing test installation from its System page and check the version.

Replora: see what your visitors see.