Skip to content

v0.2.0-beta.1

Pre-release
Pre-release

Choose a tag to compare

@github-actions github-actions released this 14 Aug 17:49
· 1728 commits to main since this release

Added

  • Cassini now makes the Talk signaling internal secret — the one input required for invisible HPB-internal recording that cannot be auto-provisioned — easy to know and set. When CASSINI_TALK_SIGNALING_INTERNAL_SECRET is missing, the operator logs an actionable WARNING at startup and GET /operator/status returns a signaling_internal_secret_hint, instead of only failing when a recording is attempted. The External Apps deploy-option description and docs/exapp-install.md now explain where to find it (e.g. docker exec nextcloud-aio-talk printenv INTERNAL_SECRET on Nextcloud All-in-One, or the signaling server's [clients] internalsecret on a standalone HPB) and how to set it.
  • Zero-config Talk recording secret: CASSINI_TALK_RECORDING_SECRET is now optional. When it is not supplied, the operator generates a secret on first start and persists it on the AppAPI volume (surviving restart and app update), so installing Cassini from the App Store no longer requires inventing or copying a shared secret. An explicitly supplied secret still wins and is treated as externally managed.
  • New ADMIN-only provisioning endpoint operator/talk/provisioning returns the ready-to-apply spreed recording_servers value (backend URL + secret), so an admin can register Cassini as Talk's recording backend in one step without ever handling the secret by hand.
  • The operator now delivers published recordings into Nextcloud Files. Each published meeting's portable .opus is uploaded before its entry is added to the catalog.json index under the canonical Cassini/Recordings/ folder. The in-Nextcloud viewer then serves its catalog and per-meeting audio authoritatively from Files (with its CSP and routes unchanged), while standalone development keeps its local source. Mutable catalog responses bypass browser caches, and the embedded viewer refreshes its meeting list on focus and every 15 seconds. Delivery failures are visible rather than silently masked by local fallback. Recordings are delivered as .opus only; Talk's recording /store endpoint (which rejects .opus) is not used. This first pass is public and writes as the Nextcloud admin; per-user/per-group access and a dedicated service account follow.
  • Recordings now belong to a dedicated cassini account, created automatically when the app is enabled. Previously they were owned by the Nextcloud administrator, which tied every recording to a human account that may be renamed, handed over or removed, and gave the identity holding all the recordings full administrative rights over the instance. Setup work — creating the recordings folder, its groups and the service account itself — is still performed as an administrator; storing and reading recordings is not. The account owns and serves the recordings; there is no other mode.
  • Per-participant access control for recordings. The operator freezes each recording's audience to the Talk room's participants at publish time — it grants read-only Nextcloud advanced-ACL (nc:acl-list) to each local participant (users, groups, circles) on the meeting's .opus; guests, email and federated participants are skipped. The in-Nextcloud viewer is then served per caller: the meeting list is built directly from catalog.json, filtered to the .opus files visible in the caller's own Nextcloud scan, and each recording is fetched as the caller so Nextcloud enforces access — a recording a user is not granted never appears and cannot be played. The read path fails closed (an empty list, never the full archive) on any error. Access is editable afterwards through Nextcloud's own sharing/ACL tools. Recordings are owned by a dedicated cassini service account, which also manages their ACLs; privileged setup is performed separately as a Nextcloud administrator. Two native prerequisites must be enabled first — the Team folders (groupfolders) and Everyone Group (group_everyone) apps — after which Cassini provisions the recordings folder and ACL topology itself. See docs/exapp-nextcloud-recordings-permissions.md.
  • Automatic setup of the recordings directory and its permissions. Enabling the Cassini ExApp now provisions everything the model needs by itself, over Nextcloud's HTTP APIs — no manual occ Team-folder setup. On the enabled edge the operator creates the Cassini Team folder with its default-deny advanced-ACL floor, gives Nextcloud's virtual everyone group read and the narrow cassini owner group full permissions, delegates cassini as ACL manager, migrates any per-recording permissions left by earlier versions, applies the root container ACL (so the owner can write and every account can traverse), and creates the canonical Cassini/Recordings/meetings collections. Because the audience group is virtual, every account has the mount from the moment it is created — there is no membership sweep and no convergence delay. Two native prerequisites remain, neither of which an external app can install for itself: the Group folders ("Team folders") app and the Everyone Group (group_everyone) app. The local harness enables both automatically.
  • The recordings setup now reports its own health. Setting up the recordings folder used to fail into a log line, leaving an app that looked healthy while showing nobody their recordings. GET /operator/status now reports whether the Team folder, its permissions and the universal everyone mount are actually in place, names the step that failed and the likely cause, and returns 503 when the app cannot serve recordings — so a missing Group folders or Everyone Group app is visible instead of silent.
  • The production deploy is now a committed, parameterised script
    (ops/deploy/deploy-exapp.sh) driven by an inventory file, instead of a
    one-off on a maintainer's laptop. It is dry-run by default, reads the live
    rollback target before touching anything, and refuses to deploy a moving tag
    (latest, latest-cuda, …) or an image whose child manifests are missing
    from the registry. CPU and GPU deployments differ by one inventory value, the
    daemon's compute device — there is no separate GPU path.
  • docs/exapp-update-constraints.md states what the Nextcloud admin UI's
    Install and Update buttons can and cannot deliver — most importantly that
    deploy environment is applied at container creation only, so a release adding
    a required environment variable is a breaking change the Update button
    cannot deliver.
  • A retention policy for per-run working files, --artifact-retention / CASSINI_ARTIFACT_RETENTION. Disk use grew with every recording and every rerun and nothing ever reclaimed it. The default (sealed) removes a completed run's working copies — all of which are duplicated in the operator's canonical library or were temporary staging — and keeps its sealed meeting file and every log. superseded only removes runs that a rerun has replaced; all keeps everything, as before — except a delivered run's staging copy, which is always removed once the recording reaches its destination so that no full copy of it is left outside the access model. Nothing removes the last copy of anything, and published recordings are never touched.
  • Installing Cassini now tells you whether recordings will actually work. Setting up the recordings folder used to fail into a log line, so an app whose setup had not completed still enabled, answered every request, and showed nobody their recordings. GET /operator/status now reports that setup under recordings_access as provisioned, unavailable (a named thing is missing — it says which app to install, or which setting to fill in), degraded (a setup call failed), or unknown (the app was restarted without being re-enabled), and returns 503 for anything that is not working. The two Nextcloud apps Cassini cannot install for itself — Team folders and Everyone Group — are now checked by name before setup starts, and reported individually.
  • GET /operator/setup — a USER-level route reporting whether recordings can be served (ok and state) and nothing else. It is what lets a non-admin be told that an install was never finished; the diagnosis (which step, which administrator, which paths) stays on the admin-only /operator/status. It answers 200 in every state, including the broken ones, so a browser can tell "Cassini is not set up" apart from "the app is down" — /operator/status remains the endpoint that answers 503 for monitoring. Existing installs pick the route up when the app is next registered or updated.
  • A one-shot migration for recordings published by an older version. Recordings made before Cassini stored them in Nextcloud Files live only on the app's own storage, and nothing publishes them again. ./scripts/backfill-nc-files.sh moves them across, run once by hand after updating; --dry-run reports what it would move without changing anything. Migrated recordings are readable only by the Cassini service account, because the audience a recording had when it was published cannot be recovered afterwards — grant access from the Files app, or use --public to make them readable by every signed-in account as they were before Cassini had access control. The migration changes nothing when Nextcloud Files already holds recordings, or when there is no older archive to move, so it is safe to run when you are unsure whether it is needed — and skipping it entirely is a supported choice: the old recordings simply stay where they are and everything published from now on works normally.
  • Read your meetings from outside Nextcloud: cassini meetings. An agent or script on a laptop or container can now list the recordings a Nextcloud account is allowed to read (cassini meetings list), download one as its single portable .opus (cassini meetings fetch <id>), or print one as readable context — transcript plus generated summary, as markdown or JSON (cassini meetings context <id>). It authenticates as a Nextcloud user with a Nextcloud app password, so no interactive browser login is needed and no new server route was added: the commands drive the app's existing per-recording read surface, which fetches from Nextcloud Files as the calling user. Nextcloud therefore enforces exactly the same permissions the in-Nextcloud viewer obeys — a recording you may not read is reported as not found, never as forbidden, so it never reveals that it exists. The surface is read-only; starting, stopping and deleting recordings remain administrator actions. context labels its transcript derived-from-words: a published meeting carries word-level timings, so paragraph breaks are inferred from pauses and speaker changes rather than editorially cleaned up. Requires ffprobe for context. Downloaded recordings are written readable by their owner only, since they hold a private meeting's audio and transcript. The CLI refuses to send your credentials anywhere other than the Nextcloud you named — it does not follow redirects, and it rejects a catalog entry pointing at another host. See docs/agent-meeting-access.md.
  • Working-file retention is now configurable on an installed app. CASSINI_ARTIFACT_RETENTION is declared as a deploy option, so administrators can choose to keep every per-run working file (all) when diagnosing a problem. The default is unchanged.
  • cassini meetings warns when --insecure is used with an app password, since disabling certificate verification exposes that password to anything able to intercept the connection.
  • Added explicit LAN media, signaling, and Talk callback configuration for running the full installed-ExApp harness on Docker Desktop for Mac, with fail-fast validation and a setup runbook.

Changed

  • Image publishing now verifies that every keep-forever tag — :latest, :latest-cuda, :latest-rocm, :cuda, and each :X.Y.Z[-cuda|-rocm] release pin — is actually pullable, failing the run instead of leaving a tag that resolves but points at a deleted manifest.
  • The operator/status talk block now reports secret_source (env | generated | unset) and the derived recording_backend_url (never the secret value), so admins can see at a glance how the recording secret was provisioned and what to register in Talk.
  • The operator now selects where published meetings are delivered with --sink / CASSINI_PUBLISH_SINK. The only sink today is local — the operator's own site root, which is what publishing has always done — and it is the default, so existing deployments need no change. An unrecognised name is rejected at startup with the valid names listed, rather than quietly publishing somewhere unintended.
  • The faithful installed-ExApp CI gate refuses its negative-test env hooks
    (D453_EXPECT_CONFIG_FAILURE, D453_FAIL_AT) unless D453_ALLOW_TEST_HOOKS=1
    is also set, so a stray hook variable in a CI job fails loudly instead of
    quietly weakening the gate.
  • The demo sandbox now runs on Nextcloud All-in-One (AIO) instead of a hand-rolled docker-compose stack that reused the CI/dev harness. AIO provides Nextcloud, Postgres, the Talk HPB, and the reverse proxy — mirroring a real deployment. The sandbox no longer references anything under harness/. Cassini is installed/updated on top of AIO with a single idempotent sandbox/wire-cassini.sh (App Store release by default); one-time AIO + reverse-proxy + firewall setup is documented in sandbox/README.md.
  • Cassini's in-Nextcloud control-panel and viewer now render entirely through AppAPI's native embedded-UI mechanism, under Nextcloud's normal Content-Security-Policy. A stock Nextcloud + AppAPI install shows the admin control-panel and viewer with no modifications to AppAPI and no app_api integrity warning — the development-only CSP patch that edited AppAPI's signed proxy controller is gone.
  • Publishing a recording is now lightweight: cassini publish updates the meeting catalog and recordings only and no longer rebuilds or embeds the viewer on every publish. The viewer is served from the app image, so publishing is faster and no longer depends on the viewer build. Pass --rebuild-viewer (or set CASSINI_PUBLISH_REBUILD_VIEWER=1) to produce a self-contained static site with the viewer embedded, as before.
  • Upgrading needs no data migration and no manual step: recordings are stored in a group folder, which is shared storage rather than a personal one, so existing recordings stay where they are and remain accessible to the same people. Cassini installs the dedicated owner group's write mapping and then removes the legacy administrator-group mount and ACL-manager delegation after the service account has successfully managed the migrated root.
  • A recording that does not reach Nextcloud Files no longer counts as published. Delivery used to run after the publish was already marked successful, and its failures were only logged — so a job could report success with the recording nowhere in Nextcloud and the viewer showing nothing. Delivery is now part of publishing: if the upload, the catalog update or the per-meeting access grant fails, the publish fails, says which step failed, and a rerun re-attempts it.
  • An installed app now stores recordings in Nextcloud Files by default. CASSINI_PUBLISH_SINK selects the destination explicitly (nextcloud-files or local), and an installed app whose value is missing defaults to Nextcloud Files rather than quietly keeping recordings on the app's own volume. Selecting nextcloud-files without a usable Nextcloud connection now stops the app at startup with an actionable message instead of failing later, one recording at a time.
  • An installed app no longer keeps its own copy of published recordings. Recordings are stored in Nextcloud Files, but the app also retained a full copy of every meeting it had ever published on its own volume, outside the permissions that govern the originals. That copy is no longer produced: the working directory a publish builds is removed once Nextcloud has accepted the recording, and the app serves meetings only from Nextcloud. A recording the app cannot fetch is reported as missing rather than quietly answered from local disk.
  • Talk still receives recording status (started, stopped, failed) exactly as before, so the Record button, the room's recording indicator and failure reporting are unchanged. CASSINI_TALK_BACKEND_URL now covers status callbacks and OCS calls only.
  • Recording access now uses Nextcloud's virtual everyone group, giving new accounts the recordings Team-folder mount immediately without periodic membership reconciliation. Installers must enable both the Team folders (groupfolders) and Everyone Group (group_everyone) apps — they are the only two manual prerequisites; existing recording-viewers ACLs are migrated without changing whether a recording is private or public.
  • Whether a conversation is public is recorded at the time of the recording and stays with it. Making a conversation public later does not retrospectively widen recordings made while it was private, and making it private does not withdraw recordings people were already told they could see. If Cassini cannot determine the conversation's type, the recording stays restricted to its participants.
  • The recording-permissions runbook now states the access rule accurately: a recording is visible to everyone who had access to the conversation, including people invited who never joined, not only those present during the call.
  • Recordings are now access-controlled for everyone, with no way to turn it off. Per-participant access used to be an opt-in deploy option that defaulted to off, so a stock install shipped an archive where any logged-in Nextcloud user could browse and play every recording. That is gone: an installed Cassini app serves each person only the recordings Nextcloud says they may read, and there is no public-archive mode to fall back to. Nothing to configure — the app sets up the recordings folder and its permissions itself when you enable it. The two things an administrator still does are enable Nextcloud's Group folders ("Team folders") app and the Everyone Group app, neither of which an external app can install on its own.
  • The admin deploy option CASSINI_NC_ACCESS_CONTROL and the local harness's --nc-access-control switch were removed along with it. If you set either, drop it; nothing replaces it.
  • The AppAPI register logic is now one implementation
    (ops/deploy/lib/exapp-register.sh) shared by the sandbox, the harness
    install phase and the production deploy, so the rules that protect the
    recording archive hold everywhere: unregister before re-register, never pass
    --rm-data, and force PUT /enabled so the navigation entries come back.
  • The ExApp install guide now documents the /exapps/* reverse-proxy route to
    HaRP. It is required for every HaRP daemon and is what actually blocks an
    install when missing — the symptom is an app that reports [enabled] with no
    navigation icon, which points nowhere near the reverse proxy. It must use
    Caddy's handle, not handle_path, so the prefix survives.
  • The operator's job pipeline has a fourth stage, seal, between build and publish, with its own timestamps, log and progress step in the control panel. Publishing is now reached only through a completed seal.
  • A recording is no longer published when the recordings folder is not set up. Without it, recordings were written into a private folder belonging to Cassini's own service account: the upload succeeded, the job reported success, and nobody could ever open the result. Publishing now fails with the reason and points at GET /operator/status; a rerun works once the cause is fixed. This also applies after a container restart until the app is re-enabled, because setup runs when the app is enabled and nothing has verified where recordings would land until it does. To keep recordings on the app's own volume deliberately, set CASSINI_PUBLISH_SINK=local.
  • The install guide now lists both required Nextcloud apps under Prerequisites, documents every deploy option, and explains how to read the setup report.
  • An unfinished install now explains itself in Cassini, instead of failing with HTTP 502. When the recordings folder is not set up, opening Cassini no longer shows a failed meeting list — it shows what is wrong, and it says something different depending on who is looking. An administrator gets the step that stopped: the missing Nextcloud app named by name and id with the occ app:install line for it, or CASSINI_NC_ADMIN_USER when no administrator could be resolved, or the container log to read when a setup call simply failed and there is nothing to install — plus the disable/enable pair that re-runs setup, and the same sentence the container log carries. Everyone else is told that Cassini is not set up, that it is not their account, and is given a link to this Cassini page to send to an administrator — who, opening it, sees the instructions. Which message you get is decided by the same boundary that decides whether you see the Operator tab at all.
  • Where the message goes depends on whether recordings can still be read, which is not the same question as whether setup finished. When nothing is mounted, it replaces the meeting list, because the list would otherwise be an error or an empty lie. After a plain container restart — where setup has not re-run, so publishing is refused, but every recording already published still opens — it is a strip above the list and the list stays.
  • Enabling or updating the app no longer re-uploads your whole recording archive. It used to copy every recording it had ever published into Nextcloud Files again on each enable, install and update, under a fixed time budget for the entire batch. Past a certain archive size that ran out of time before it could update the recording list — and because the list is written last, it stayed frozen at its previous contents permanently, with new recordings delivered but invisible and nothing said about it. Recordings have gone straight into Nextcloud Files as part of publishing for some time now, so nothing depended on this any more.
  • All three Go modules now declare the same minimum Go version (1.24), matching the toolchain the release images have always built them with. Previously two modules declared 1.22 and one declared 1.24, so the version a module was checked and formatted under depended on which module it was.

Removed

  • sandbox/compose.sandbox.yml, sandbox/deploy.sh, and sandbox/destroy.sh — the harness-coupled compose sandbox they implemented is superseded by the AIO-based sandbox.
  • Cassini no longer uploads recordings to Nextcloud Talk. Every Talk-button recording used to file a raw .mkv into the room owner's /Talk/Recording/<token>/ through Talk's recording-store endpoint, in addition to publishing the meeting as a portable .opus. That second copy sat outside Cassini's canonical recordings root and outside its per-file access controls, so a meeting could be readable there by people it was never shared with. The upload is gone — including the rerun path that re-attempted it — and a meeting now reaches Nextcloud exactly once, as the published .opus.

Fixed

  • CUDA image tags (:X.Y.Z-cuda, :latest-cuda, :cuda) can be pulled again. Image pruning had deleted the manifests those tags pointed at, so docker pull failed and a CUDA deploy daemon silently fell back to the CPU image — running transcription without GPU acceleration and reporting no error. Tags published before this fix stay unpullable until republished; :latest-cuda and :cuda repair themselves on the next push to main.
  • cassini dev stack up --resume now recreates containers and mounts the existing Compose and ExApp data volumes after a normal stack down, instead of requiring the removed containers to still exist.
  • Publishing a recording no longer re-exports the whole library. Every publish used to rebuild and rewrite every meeting in the archive, so the time it took grew with the archive — on a production instance with 67 meetings that was roughly seven and a half minutes per recording, during which the job sits at publish / running and looks stuck. A publish now exports only the meeting being published and merges it into the live site, leaving every other recording's files untouched. Re-publishing a meeting (for example via a rerun) updates its entry in place rather than adding a second one.
  • The three-songs harness sync check now fails loudly when the recorder report
    is missing or contains fewer than 2 composed sessions, instead of silently
    skipping; the recorder run now writes the report the check needs.
  • The recorder now rejects --request-offer-interval 0 at startup instead of
    silently disabling every capture-recovery path, which could leave an empty
    recording for the whole call after a single dropped requestoffer.
  • Setup no longer assumes the administrator is called admin. Cassini probes for one — the configured account, then admin, then the instance's own account list — so instances that name theirs differently can complete setup. If none of them is an administrator it says so and stops, rather than continuing as an account that may not exist; CASSINI_NC_ADMIN_USER names one directly.
  • Publishing a recording no longer rewrites the whole Nextcloud Files archive. Each publish uploads its own recording and adds it to the shared catalog, so a delivery that fails can no longer remove other meetings from the list.
  • A recording you are not allowed to see now reads as "not found" rather than "forbidden". Reporting a denial told you the recording existed, which is exactly what the access model is meant to prevent. Genuine outages are still reported as errors, and denials are still distinguishable in the operator's logs.
  • The internal site manifest (cassini.json), which lists meeting counts and job ids, is no longer readable by any signed-in user of an installed app.
  • The viewer no longer treats an unreachable meeting list as an empty one. A Nextcloud outage now surfaces as an error instead of an empty archive.
  • Recordings of public conversations are now readable by everyone, as you would expect. A conversation anyone with the link can join was treated exactly like a private one, so its recording was restricted to whoever happened to be on the attendee list. That was worst for the most public meetings: participants who joined by link rather than by invitation cannot be granted access individually, so a public meeting full of link guests produced a recording only its owner could open. Recordings of public conversations are now visible to any account on the Nextcloud.
  • A newly created user can now see public recordings straight away. The recordings Team folder now uses Nextcloud's virtual everyone group, so every account has its mount from creation instead of waiting for a periodic membership sweep. A new account sees everything it is entitled to on its first Cassini visit.
  • A public recording no longer loses its broad access when the app restarts. A periodic integrity sweep re-applies the restrictive permissions to any recording that is missing them, and it mistook a public recording's deliberately broad grant for a missing restriction — quietly turning every public recording back into a participant-only one. The sweep now leaves a recording's own permissions alone, whichever way they were set, and only repairs recordings that carry none at all.
  • A momentary Nextcloud Talk hiccup no longer costs a recording. Working out who a meeting belongs to happens once, at publish time, and now gates publishing — so a single failed request used to fail the recording outright, recoverable only by re-running the job by hand. The lookup now retries, and then falls back to asking as the recordings owner, which is the case retrying alone cannot fix: the person who started the recording may have left the conversation, been removed or been disabled between the meeting and its publication. A meeting whose participants are all guests or federated users still publishes successfully and stays visible to its owner only.
  • The recordings list no longer gets stuck on "Meeting not found". Opening the viewer before its first recording exists — or during any brief Nextcloud hiccup — could leave the right-hand pane showing an error that stayed there even after the list loaded, until you clicked a meeting or reloaded. A link to a specific meeting opened in that window was also dropped instead of opening once the list arrived.
  • bin/cassini no longer leaks a ~17 MB temp directory on every invocation (about 3.7 GB/day on a dev VM running the harness). The wrapper now builds the CLI to a stable path under ${XDG_CACHE_HOME:-$HOME/.cache}/cassini/bin and reuses it, so there is nothing to clean up; concurrent invocations stay safe via an atomic rename, on macOS too.
  • A recording is no longer published before its downloadable meeting file exists. The portable .opus — the single-file meeting you download, share and archive — used to be produced in the background after the recording had already been handed off for publishing. If that step failed, was interrupted by a restart, or was overtaken by a second run of the same recording, the recording could still be reported as finished while its meeting file was missing, stale, or belonged to a different run. Packing that file is now a stage the recording has to pass: it is written once, checked, and fingerprinted before publishing starts, and the file that reaches the viewer is verified to be that exact file. A failure now fails the recording, with the reason recorded and a rerun available, instead of disappearing into the log.
  • Re-running a recording can no longer overwrite the previous run's meeting file. Each run now writes its own, so the two cannot race.
  • A failed publish can no longer leave the recordings page without its viewer. Refreshing the site's viewer files used to delete them before copying the new ones in; an interrupted copy left the page listing recordings it could no longer play. The new files are now staged beside the old ones and swapped in, so a failure leaves the previous, working page exactly as it was.
  • An interrupted replacement can no longer destroy a meeting file. cassini pack removed the previous .opus before moving the new one into place; it now replaces it in a single atomic step.
  • Setup no longer assumes the administrator is called admin. Cassini used to look up the administrator with a request made as the administrator it had not found yet, so on an instance whose administrator is named anything else the lookup failed, it carried on as admin regardless, and every subsequent step was rejected with nothing explaining why. It now asks Nextcloud who the accounts are and finds an administrator among them; if it cannot, it stops and says so, naming CASSINI_NC_ADMIN_USER as the way to point it at one.
  • A recording whose permissions could not be applied is no longer reported as published. Nextcloud accepts a permission change on a file outside a Team folder with a success code that hides a per-property rejection, so the recording could be stored with no restrictions at all while everything looked fine.
  • An administrator whose install was broken no longer loses the Operator surface. Cassini decides whether to show the operator by asking the admin-only status endpoint, and that endpoint answers 503 when recordings cannot be served — which was being read as "not an administrator". The one person who could fix the install saw the same browse-only app, and the same unexplained error, as everyone else.
  • Catalog meeting dates now come from the pack's recorded createdAtUtc (rendered in UTC), so meetings whose file name carries no timestamp — e.g. backfilled dailies — show a real date and sort correctly instead of echoing the raw id. Already-published archives pick this up on their next export.
  • docs/portable-meeting-format.md no longer tells consumers to reject every file Cassini writes. The file-identification and required-tag sections still demanded CASSINI_FORMAT=org.cassini.portable-meeting/1 even though the producer has emitted /2 since the multi-transcription format landed. Both sections now state that consumers must accept /1 and /2.
  • A recording delivered to Nextcloud Files is now verified to be the file the recording actually produced. Cassini fingerprints each meeting when it is packed and re-checks that fingerprint before publishing; the check was applied when recordings were stored on the app's own volume, but not on the Nextcloud Files path an installed app uses. A recording whose file does not match what was packed is now refused before anything is uploaded, so a half-delivered recording can no longer appear in the archive.
  • The standalone operator container no longer risks clearing more than its own site directory when started with an unusual CASSINI_OPERATOR_SITE_ROOT.
  • The recordings migration script (backfill-nc-files.sh) now runs on macOS's system bash, where invoking it with no options previously aborted.
  • The local test harness now stops with a clear message when Nextcloud Talk fails to install, instead of continuing and failing much later with an unexplained error.
  • Fixed harness startup under the macOS system Bash when optional Compose or Nextcloud command arguments are empty.