Compare commits

..

No commits in common. "1a0a5ffbee38c74480a8620e6e2f97297913a1d1" and "a3c05e9062b93682e338f098e7d46c5c098cca13" have entirely different histories.

42 changed files with 240 additions and 1210 deletions

View file

@ -1,8 +1,8 @@
name: Build Kaleido Desktop installers
# Started by hand (Actions, then this workflow, then Run). Each platform needs a runner
# with its label; without one the job would wait indefinitely, so this never runs on
# push. Releases can instead be built with scripts/build.ps1 (Windows) or
# scripts/build.sh (macOS) and published with scripts/publish-release.mjs.
# push. Releases can instead be built with scripts/build.ps1 and published with
# scripts/publish-release.mjs.
on:
workflow_dispatch:
@ -29,14 +29,11 @@ jobs:
TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
run: ./scripts/build.ps1
- name: Build (macOS)
if: matrix.os == 'macos'
- name: Build (macOS / Linux)
if: matrix.os != 'windows'
env:
TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
run: sh scripts/build.sh
- name: Build (Linux)
if: matrix.os == 'linux'
run: |
sh scripts/fetch-libmpv.sh
npm ci

1
.gitignore vendored
View file

@ -10,6 +10,5 @@ vendor/mpv/*/
.env
.env.*
evidence/
.DS_Store
*.log
.claude/

View file

@ -11,7 +11,7 @@
- Keep the interface restrained: no redundant buttons or navigation.
- `.env` (`PLEX_SERVER_URL`, `PLEX_TOKEN`) is for local testing only. Never print,
commit or embed credentials. `.tools/updater.key` signs updates; never commit or
replace it. `.tools/macos-signing.*` backs up the macOS signing certificate; same rules.
replace it.
- Shared code goes in `src/` and `src-tauri/src/`; anything OS-specific goes in
`src-tauri/src/platform/<os>.rs` or `tauri.<os>.conf.json`.
@ -19,20 +19,19 @@
- `npm run typecheck`, `npm test`, `cargo check --manifest-path src-tauri/Cargo.toml`.
- UI: `npm run dev` and a browser at http://localhost:1420 (signs in from `.env`).
- Native: `npm run tauri dev` (on Windows with `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9333`);
`window.__kaleido` exposes the stores in development. On macOS the Rust toolchain is
Homebrew's keg-only `rustup` (`export PATH=/opt/homebrew/opt/rustup/bin:$PATH`).
- Native: `npm run tauri dev` with `WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=9333`;
`window.__kaleido` exposes the stores in development.
- Mute before playback tests (`__kaleido.useSettings.getState().set('volume', 0)`).
Playback changes real Plex progress and track selections; restore them.
## Releases
Built and published locally, Windows and macOS each on their own machine, into one
release (CI only validates). In short: bump the version in `package.json`,
`src-tauri/Cargo.toml`, `src-tauri/tauri.conf.json` (+ lockfile), add a `CHANGELOG.md`
section, commit + tag `vX.Y.Z` + push; on each OS build (`.\scripts\build.ps1` /
`sh scripts/build.sh`) and `node scripts/publish-release.mjs X.Y.Z [--prerelease]`; then
`node scripts/update-manifest.mjs X.Y.Z` and commit/push `updates/latest.json`. Full checklist: `docs/development.md` → Releases. Only push or
Built and published locally (CI only validates). In short: bump the version in
`package.json`, `src-tauri/Cargo.toml`, `src-tauri/tauri.conf.json` (+ lockfile), add a
`CHANGELOG.md` section, `.\scripts\build.ps1`, commit + tag `vX.Y.Z` + push,
`node scripts/publish-release.mjs X.Y.Z [--prerelease]`, then
`node scripts/update-manifest.mjs X.Y.Z <release download URL>` and commit/push
`updates/latest.json`. Full checklist: `docs/development.md` → Releases. Only push or
publish when the user asks. `FORGEJO_TOKEN` lives in the ignored `.env`.
See `docs/architecture.md` and `docs/development.md`.

View file

@ -1,14 +1,5 @@
# Changelog
## 0.1.0-beta.8
Kaleido for Mac.
- Kaleido now runs on Macs with Apple silicon (macOS 26 or later), with the same interface and features as on Windows: browsing, playback with hardware decoding, the miniplayer, downloads, server management and in-app updates. The window uses the Mac's own close, minimize and zoom buttons, which fade with the player's controls, and shortcuts use ⌘ (⌘K to search, ⌘[ to go back, ⌃⌘F for full screen).
- HDR passthrough works on Mac too: HDR titles play in the display's extended dynamic range instead of being converted to SDR.
- Each release now includes both the Windows and Mac versions.
- Updates are signed with a new key, so the Windows version needs to be reinstalled once from this release; later updates install in the app as before.
## 0.1.0-beta.7
A new startup animation and a bolder app icon.

View file

@ -4,10 +4,9 @@ A cinematic Plex client for the desktop, built in the same artwork-led style as
[Kaleido for Android TV](https://git.elijahkuntz.com/Elijah/Kaleido), and designed for
mouse and keyboard.
Kaleido runs on Windows and macOS (Apple silicon) with the same interface and features;
each release carries both, and installed copies update themselves. The interface and
nearly all of the native core are shared, and each platform's differences live in one
place (see [Architecture](docs/architecture.md)). Linux builds browse but don't play yet.
Windows is supported today. The repository is structured for Windows, macOS and Linux:
the interface and nearly all of the native core are shared, and each platform's
differences live in one place (see [Architecture](docs/architecture.md)).
## What's in the app
@ -62,20 +61,18 @@ place (see [Architecture](docs/architecture.md)). Linux builds browse but don't
| Browsing | | Player | |
| --- | --- | --- | --- |
| Ctrl+K (⌘K) | Search | Space / K | Play/pause |
| Ctrl+K | Search | Space / K | Play/pause |
| Arrow keys | Move between titles | ← / → | Seek (Shift: 1 min) |
| Enter / Space | Open / play | ↑ / ↓, wheel | Volume |
| Menu or Shift+F10 | Title actions | F, double-click | Full screen |
| Alt+← (⌘[) / mouse back | Back | C | Next subtitle |
| Alt+← / mouse back | Back | C | Next subtitle |
| / | Focus search | Shift+N | Next episode |
| F11 (⌃⌘F) | Full screen | Esc | Exit full screen, then player |
Keys in brackets are the macOS equivalents.
| F11 | Full screen | Esc | Exit full screen, then player |
## Build from source
Requirements: Node 22+, Rust (stable); on Windows the Visual Studio C++ build tools and
7-Zip, on macOS the Xcode command line tools and Homebrew.
Requirements: Node 22+, Rust (stable), and on Windows the Visual Studio C++ build tools
and 7-Zip.
```powershell
npm ci
@ -84,13 +81,6 @@ npm run tauri dev # development app
.\scripts\build.ps1 # signed release installer (NSIS)
```
```bash
npm ci
sh scripts/fetch-libmpv.sh # libmpv and its libraries into vendor/mpv/macos
npm run tauri dev # development app
sh scripts/build.sh # .app, .dmg and the signed update archive
```
During development the app signs in automatically from an ignored `.env` in the
repository root (`PLEX_SERVER_URL`, `PLEX_TOKEN`). Release builds never read it.
`npm run dev` serves the interface alone in a browser for UI work (no playback or

View file

@ -35,34 +35,21 @@ updates/latest.json Signed update feed for every platform
`src-tauri/src/platform/mod.rs` selects one of `windows.rs`, `macos.rs` or `linux.rs`.
Each exposes the same items:
| Item | Windows | macOS |
| --- | --- | --- |
| `VideoSurface` | mpv renders with `d3d11-output-mode=composition`; its swapchain (`display-swapchain`) is set as the content of a DirectComposition visual targeted at the window with `topmost = false`, i.e. behind the web view's child windows. For the miniplayer the visual is offset and mpv's composition size shrunk to a corner rectangle (`player_rect`). | mpv's render API (`vo=libmpv`, OpenGL) draws into a `CAOpenGLLayer` hosted by a view inserted beneath the WKWebView, whose background is turned off (`drawsBackground`). `start` creates the render context once mpv is initialized; a render thread redraws the layer whenever mpv reports a new frame. For the miniplayer the view is moved to the corner rectangle. |
| `MPV_LIBRARIES` | `libmpv-2.dll` | `libmpv.2.dylib` (in `Contents/Frameworks` with the libraries it links) |
| `hold_awake` | `SetThreadExecutionState` | an IOKit `PreventUserIdleDisplaySleep` assertion |
| Window buttons | drawn by the page (`WindowControls`) | the native traffic lights (`titleBarStyle: Overlay`, placed on the top bar's centre line); `set_window_buttons` hides them with the player's controls |
| `device_name` | `COMPUTERNAME` | the computer name from Sharing settings |
| Item | Windows implementation |
| --- | --- |
| `VideoSurface` | mpv renders with `d3d11-output-mode=composition`; its swapchain (`display-swapchain`) is set as the content of a DirectComposition visual targeted at the window with `topmost = false`, i.e. behind the web view's child windows. For the miniplayer the visual is offset and mpv's composition size shrunk to a corner rectangle (`player_rect`). |
| `MPV_LIBRARIES` | `libmpv-2.dll` |
| `hold_awake` | `SetThreadExecutionState` while video plays |
Linux provides stubs for `VideoSurface` (browsing, downloads, settings and updates
work; playback reports that it is unavailable); the macOS approach (render API beneath
the web view) applies there with an OpenGL surface under WebKitGTK. Per-OS bundling
(libmpv, targets, window style) lives in `tauri.<os>.conf.json`. Credentials use the
platform's keychain through the `keyring` crate with per-OS features in `Cargo.toml`;
macOS debug builds keep them in a private file instead, because each unsigned rebuild
would make the Keychain ask again.
macOS and Linux currently provide stubs for `VideoSurface` (browsing, downloads,
settings and updates work; playback reports that it is unavailable). To add playback
there, render through mpv's render API into a layer beneath the web view and implement
the same methods (`set_rect` places the video in part of the window for the miniplayer). Per-OS bundling (libmpv, targets, dependencies) lives in
`tauri.macos.conf.json` and `tauri.linux.conf.json`. Credentials use the platform's
keychain through the `keyring` crate with per-OS features in `Cargo.toml`.
The page background turns transparent only while video is visible
(`html.video-active`), so browsing is opaque. The page knows its OS synchronously
(`hostOS` in `platform/native.ts`, from the web view's user agent) and tags the root
element (`html.os-macos`) for the few styles that differ, such as room for the traffic
lights.
HDR passthrough (`target-colorspace-hint`) works differently on each OS. On Windows mpv
switches its swapchain's colour space itself. On macOS the surface watches
`video-params/gamma`: for PQ or HLG video it has mpv output PQ in BT.2020
(`target-trc`, `target-prim`) into the 16-bit float framebuffer and turns on the layer's
extended dynamic range with the BT.2100 PQ colour space, so macOS maps the picture
into the display's HDR headroom; SDR video returns both to their defaults.
On Windows the main window is created transparent and the page background turns
transparent only while video is visible (`html.video-active`), so browsing is opaque.
## Interface
@ -98,5 +85,4 @@ into the display's HDR headroom; SDR video returns both to their defaults.
cached in the app cache folder (`gpu-shader-cache-dir`), so a slow first Direct3D
compile happens once per shader set, mpv version and GPU driver.
- **Updates**: `app/updater.ts` checks the signed feed on start; installs need the
user's confirmation and then relaunch. One release carries every platform's build and
the feed lists each of them (`windows-x86_64`, `darwin-aarch64`).
user's confirmation and then relaunch.

View file

@ -11,22 +11,6 @@
debug builds and the Vite dev server. Never commit or print it.
5. `npm run tauri dev`
## Setup (macOS)
1. Node 22+, Rust stable (`brew install rustup && rustup default stable`), the Xcode
command line tools and Homebrew.
2. `npm ci`
3. `sh scripts/fetch-libmpv.sh` installs Homebrew's `mpv` and copies libmpv with every
library it links into `vendor/mpv/macos`, rewritten to find each other there
(`@loader_path`) and signed, so the bundle doesn't depend on Homebrew. Homebrew
builds for the macOS it runs on, so the app's minimum macOS is that of the build
machine (`scripts/build.sh` sets it from the libraries).
4. `.env` as on Windows, then `npm run tauri dev`.
Debug builds on macOS keep the Plex token in `dev-secrets.json` in the app data folder
rather than the Keychain: every rebuild is a new unsigned binary, which the Keychain
would ask about again. Release builds always use the Keychain.
The interface alone runs in a browser with `npm run dev` (port 1420), which is handy for
layout work; playback, downloads and native dialogs need the desktop app. In development
builds the stores are available as `window.__kaleido` for debugging.
@ -55,67 +39,43 @@ and copy back only the files already in `src-tauri/icons` (the Android and iOS s
## Releases
Releases are built and published locally: Windows on the Windows machine, macOS on the
Mac. CI only validates; it never builds installers on push (there are no Windows/macOS
runners). Versions follow SemVer; betas use a prerelease suffix (`0.1.0-beta.1`) and are
published as pre-releases. **Each release carries both platforms**, and the update feed
is written only once both are uploaded.
Releases are built and published from this Windows machine. CI only validates; it never
builds installers on push (there are no Windows/macOS runners). Versions follow SemVer;
betas use a prerelease suffix (`0.1.0-beta.1`) and are published as pre-releases.
Checklist for version `X.Y.Z` (run from the repository root):
1. **Version** (either machine): set `X.Y.Z` in `package.json`, `src-tauri/Cargo.toml`
and `src-tauri/tauri.conf.json`, then `npm install --package-lock-only` to update
1. **Version**: set `X.Y.Z` in `package.json`, `src-tauri/Cargo.toml` and
`src-tauri/tauri.conf.json`, then `npm install --package-lock-only` to update
`package-lock.json`.
2. **Changelog**: add a `## X.Y.Z` section at the top of `CHANGELOG.md`. It becomes the
release notes and the in-app update notes.
3. **Check**: `npm run typecheck`, `npm test`, `cargo check --manifest-path src-tauri/Cargo.toml`.
4. **Commit and tag**: commit as `Release Kaleido Desktop X.Y.Z`, then
4. **Build**: `.\scripts\build.ps1` → `src-tauri/target/release/bundle/nsis/Kaleido_X.Y.Z_x64-setup.exe`
and its `.sig`. The updater key is read from `.tools/updater.key` (ignored; keep it
safe — replacing it breaks in-app updates for existing installs) or from
`TAURI_SIGNING_PRIVATE_KEY`.
5. **Commit and tag**: commit as `Release Kaleido Desktop X.Y.Z`, then
`git tag -a vX.Y.Z -m "Kaleido Desktop X.Y.Z"` and `git push origin main vX.Y.Z`
(SSH remote `origin`, already configured). Pull it on the other machine.
5. **Build and publish on Windows**: `.\scripts\build.ps1` →
`src-tauri/target/release/bundle/nsis/Kaleido_X.Y.Z_x64-setup.exe` and its `.sig`;
then `node scripts/publish-release.mjs X.Y.Z` (add `--prerelease` for betas) creates
the Forgejo release with the notes from `CHANGELOG.md` and uploads them.
6. **Build and publish on macOS**: `sh scripts/build.sh` → `bundle/dmg/Kaleido_X.Y.Z_aarch64.dmg`
(first installs) and `bundle/macos/Kaleido_X.Y.Z_aarch64.app.tar.gz` with its `.sig`
(updates); then `node scripts/publish-release.mjs X.Y.Z [--prerelease]` adds them to
the same release. The order of 5 and 6 doesn't matter.
7. **Update feed** (either machine): `node scripts/update-manifest.mjs X.Y.Z` reads the
release's assets (downloading each `.sig`) and rewrites `updates/latest.json`; commit
it (`Publish the X.Y.Z update feed`) and push. Installed copies offer the update on
their next start. The script refuses while a platform's build is missing from the
release, so neither OS is ever pointed at an older build; `--allow-missing` publishes
the feed without it (that OS then sees no update until the feed is regenerated).
8. **Verify**: download each artifact from the release and compare its SHA-256 with the
local file; `https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json`
should list both platforms at the new version; CI on Actions should finish green.
(SSH remote `origin`, already configured).
6. **Publish**: `node scripts/publish-release.mjs X.Y.Z` (add `--prerelease` for betas)
creates the Forgejo release with the notes from `CHANGELOG.md` and uploads the
installer and `.sig`. It reads `FORGEJO_TOKEN` (repository read/write) from the
environment or the ignored `.env`, and never prints it. Re-running it replaces the
assets.
7. **Update feed**: `node scripts/update-manifest.mjs X.Y.Z https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/vX.Y.Z`
rewrites `updates/latest.json`; commit it (`Publish the X.Y.Z update feed`) and push.
Installed copies offer the update on their next start. Publish the feed only after
the release assets exist, or clients would be sent to a missing file.
8. **Verify**: download the installer from the release URL and compare its SHA-256 with
the local file; `https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json`
should show the new version; CI on Actions should finish green.
Both publishing scripts read `FORGEJO_TOKEN` (repository read/write) from the
environment or the ignored `.env`, and never print it. Re-running `publish-release.mjs`
replaces that machine's assets.
The installer is per user (`%LOCALAPPDATA%\Kaleido`, no admin) and is not code-signed,
so SmartScreen warns on first run. In-app updates run it in passive mode and relaunch.
**Update signing**: both build scripts sign update artifacts with the updater key from
`.tools/updater.key` (ignored; keep it safe — replacing it breaks in-app updates for
existing installs) or `TAURI_SIGNING_PRIVATE_KEY`. Both build machines need the same
key in `.tools/`; without it a build has no update archive.
**Windows** installs per user (`%LOCALAPPDATA%\Kaleido`, no admin) and is not
code-signed, so SmartScreen warns on first run. In-app updates run the installer in
passive mode and relaunch.
**macOS** builds are signed with a self-signed certificate, "Kaleido Self-Signed", in
the build Mac's login keychain (backed up, with its password, as
`.tools/macos-signing.p12` and `.tools/macos-signing.password`). A lasting signature
keeps the app's identity across updates, so the Keychain keeps trusting it with the
Plex token; ad hoc signatures change with every build and would make macOS ask again
after each update. To build on another Mac, import the backup:
`security import .tools/macos-signing.p12 -k ~/Library/Keychains/login.keychain-db -P "$(cat .tools/macos-signing.password)" -T /usr/bin/codesign`.
The app isn't notarized, so the first launch of a downloaded `.dmg` needs
System Settings → Privacy & Security → Open Anyway (or right-click → Open); in-app
updates aren't quarantined and install without that. Building runs Finder through
AppleScript to lay out the disk image window; set `CI=true` to skip that step.
Linux can be built with `sh scripts/fetch-libmpv.sh` and `npx tauri build` but isn't
published. `.forgejo/workflows/release.yml` validates every push and tag;
For macOS and Linux, build on those systems (`scripts/fetch-libmpv.sh`, then
`npx tauri build`) and merge their bundles into the same feed with `KALEIDO_BUNDLES`.
`.forgejo/workflows/release.yml` validates every push and tag;
`.forgejo/workflows/build-installers.yml` can build installers in CI once runners exist
for each platform, and only runs when started by hand.

4
package-lock.json generated
View file

@ -1,12 +1,12 @@
{
"name": "kaleido-desktop",
"version": "0.1.0-beta.8",
"version": "0.1.0-beta.7",
"lockfileVersion": 3,
"requires": true,
"packages": {
"": {
"name": "kaleido-desktop",
"version": "0.1.0-beta.8",
"version": "0.1.0-beta.7",
"dependencies": {
"@fontsource-variable/inter": "^5.3.0",
"@tanstack/react-query": "^5.105.0",

View file

@ -1,7 +1,7 @@
{
"name": "kaleido-desktop",
"private": true,
"version": "0.1.0-beta.8",
"version": "0.1.0-beta.7",
"type": "module",
"scripts": {
"dev": "vite",

View file

@ -1,54 +0,0 @@
#!/usr/bin/env sh
# Builds Kaleido for macOS: the .app, a .dmg for first installs and the signed updater
# archive, renamed Kaleido_<version>_<arch>.app.tar.gz for the release.
# sh scripts/build.sh # release build
# sh scripts/build.sh --debug # faster unoptimized build
set -eu
root=$(cd "$(dirname "$0")/.." && pwd)
cd "$root"
profile=release
[ "${1:-}" = "--debug" ] && profile=debug
sh scripts/fetch-libmpv.sh
# The bundled libraries decide the oldest macOS Kaleido runs on (Homebrew builds them
# for the macOS of the machine that installed them).
minos=$(for f in vendor/mpv/macos/*.dylib; do otool -l "$f" | awk '/LC_BUILD_VERSION/{b=1} b&&/minos/{print $2; b=0}'; done | sort -V | tail -1)
# Signing with one lasting certificate keeps the app's identity across updates, so the
# Keychain keeps trusting it with the Plex token (ad hoc signatures change every build).
# "Kaleido Self-Signed" lives in the login keychain; .tools/macos-signing.p12 backs it up.
identity=${KALEIDO_SIGNING_IDENTITY:-Kaleido Self-Signed}
if security find-identity -p codesigning | grep -q "\"$identity\""; then
codesign --force --sign "$identity" vendor/mpv/macos/*.dylib 2>/dev/null
else
echo "warning: no \"$identity\" signing certificate; signing ad hoc (the Keychain will ask again after updates)." >&2
identity=-
fi
# The updater signing key stays outside git (.tools/), as on Windows.
updater=true
if [ -z "${TAURI_SIGNING_PRIVATE_KEY:-}" ]; then
if [ -f .tools/updater.key ]; then
TAURI_SIGNING_PRIVATE_KEY=$(cat .tools/updater.key)
TAURI_SIGNING_PRIVATE_KEY_PASSWORD=${TAURI_SIGNING_PRIVATE_KEY_PASSWORD:-}
export TAURI_SIGNING_PRIVATE_KEY TAURI_SIGNING_PRIVATE_KEY_PASSWORD
else
echo "warning: no updater signing key (.tools/updater.key); building without update artifacts." >&2
updater=false
fi
fi
config="{\"bundle\":{\"createUpdaterArtifacts\":$updater,\"macOS\":{\"minimumSystemVersion\":\"$minos\",\"signingIdentity\":\"$identity\"}}}"
[ -d node_modules ] || npm ci
if [ "$profile" = debug ]; then npx tauri build --debug --config "$config"; else npx tauri build --config "$config"; fi
version=$(node -p "require('./package.json').version")
arch=$(uname -m | sed 's/arm64/aarch64/; s/x86_64/x64/')
bundle="src-tauri/target/$profile/bundle"
if [ -f "$bundle/macos/Kaleido.app.tar.gz" ]; then
cp "$bundle/macos/Kaleido.app.tar.gz" "$bundle/macos/Kaleido_${version}_${arch}.app.tar.gz"
cp "$bundle/macos/Kaleido.app.tar.gz.sig" "$bundle/macos/Kaleido_${version}_${arch}.app.tar.gz.sig"
fi
echo "Built for macOS $minos or later:"
ls -l "$bundle/dmg" "$bundle/macos"

View file

@ -1,39 +1,14 @@
#!/usr/bin/env sh
# macOS: copies Homebrew's libmpv and every library it links (ffmpeg, libplacebo, ...)
# into vendor/mpv/macos, pointing them at each other with @loader_path so the folder is
# self-contained; the bundle ships it as Contents/Frameworks.
# macOS: copies Homebrew's libmpv into vendor/mpv/macos for bundling.
# Linux: libmpv comes from the system package (libmpv2); nothing to copy.
set -eu
root=$(cd "$(dirname "$0")/.." && pwd)
case "$(uname -s)" in
Darwin)
out="$root/vendor/mpv/macos"
if [ -f "$out/libmpv.2.dylib" ] && [ "${1:-}" != "--force" ]; then
echo "libmpv already in vendor/mpv/macos (pass --force to refresh)"
exit 0
fi
brew list mpv >/dev/null 2>&1 || brew install mpv
command -v dylibbundler >/dev/null 2>&1 || brew install dylibbundler
rm -rf "$out" && mkdir -p "$out"
cp "$(brew --prefix mpv)/lib/libmpv.2.dylib" "$out/"
chmod u+w "$out/libmpv.2.dylib"
install_name_tool -id @loader_path/libmpv.2.dylib "$out/libmpv.2.dylib"
# -of: overwrite, -b: bundle dependencies, -x: fix this file, -d: where they go,
# -p: how they're referenced, -s: also search Homebrew's lib folder for @rpath names.
dylibbundler -of -b -x "$out/libmpv.2.dylib" -d "$out" -p @loader_path/ -s "$(brew --prefix)/lib" >/dev/null
for f in "$out"/*.dylib; do
# dylibbundler can repeat an rpath, which dyld refuses to load; keep one of each.
for rpath in $(otool -l "$f" | awk '/cmd LC_RPATH/{getline; getline; print $2}' | sort | uniq -d); do
while [ "$(otool -l "$f" | awk '/cmd LC_RPATH/{getline; getline; print $2}' | grep -cx "$rpath")" -gt 1 ]; do
install_name_tool -delete_rpath "$rpath" "$f" 2>/dev/null
done
done
# Rewriting load commands invalidates signatures; Apple silicon refuses unsigned code.
codesign --force --sign - "$f" 2>/dev/null
done
# Homebrew builds for the macOS it runs on: the oldest macOS these libraries load on.
minos=$(for f in "$out"/*.dylib; do otool -l "$f" | awk '/LC_BUILD_VERSION/{b=1} b&&/minos/{print $2; b=0}'; done | sort -V | tail -1)
echo "libmpv and $(($(ls "$out" | wc -l) - 1)) libraries copied to vendor/mpv/macos (need macOS $minos or later)" ;;
mkdir -p "$root/vendor/mpv/macos"
cp "$(brew --prefix mpv)/lib/libmpv.2.dylib" "$root/vendor/mpv/macos/"
echo "libmpv copied to vendor/mpv/macos" ;;
Linux)
echo "Install libmpv from your distribution (e.g. apt install libmpv2 libmpv-dev)." ;;
*) echo "Use scripts/fetch-libmpv.ps1 on Windows." ;;

View file

@ -1,12 +1,11 @@
// Creates (or reuses) a Forgejo release for a tag and uploads this machine's build of it:
// the Windows installer, or the macOS disk image and updater archive, each with its
// updater signature. Run it on each OS after building; both land in the same release.
// Reads FORGEJO_TOKEN from the environment or the ignored .env.
// Creates (or reuses) a Forgejo release for a tag and uploads the Windows installer and
// its updater signature. Reads FORGEJO_TOKEN from the environment or the ignored .env.
// Usage: node scripts/publish-release.mjs <version> [--prerelease]
import fs from 'node:fs';
import path from 'node:path';
import { api, bundleDir, releaseNotes, token } from './release-common.mjs';
const API = 'https://git.elijahkuntz.com/api/v1/repos/Elijah/Kaleido-Desktop';
const root = path.resolve(import.meta.dirname, '..');
const version = process.argv[2];
const prerelease = process.argv.includes('--prerelease');
if (!version) {
@ -14,38 +13,43 @@ if (!version) {
process.exit(1);
}
/** This version's release files as built on this OS (scripts/build.ps1 or scripts/build.sh). */
function builtFiles() {
if (process.platform === 'win32') {
const dir = path.join(bundleDir, 'nsis');
return [`Kaleido_${version}_x64-setup.exe`, `Kaleido_${version}_x64-setup.exe.sig`].map((n) => path.join(dir, n));
}
if (process.platform === 'darwin') {
const arch = process.arch === 'arm64' ? 'aarch64' : 'x64';
return [
path.join(bundleDir, 'dmg', `Kaleido_${version}_${arch}.dmg`),
path.join(bundleDir, 'macos', `Kaleido_${version}_${arch}.app.tar.gz`),
path.join(bundleDir, 'macos', `Kaleido_${version}_${arch}.app.tar.gz.sig`),
];
}
throw new Error('Publish releases from Windows or macOS.');
let token = process.env.FORGEJO_TOKEN;
if (!token && fs.existsSync(path.join(root, '.env'))) {
token = fs.readFileSync(path.join(root, '.env'), 'utf8').match(/^FORGEJO_TOKEN=(.*)$/m)?.[1]?.trim().replace(/^"|"$/g, '');
}
if (!token) {
console.error('FORGEJO_TOKEN is not set.');
process.exit(1);
}
const headers = { Authorization: `token ${token}`, Accept: 'application/json' };
token(true);
const files = builtFiles();
for (const file of files) {
if (!fs.existsSync(file)) throw new Error(`Missing ${file}; build this version first.`);
async function api(method, url, body) {
const r = await fetch(url.startsWith('http') ? url : API + url, {
method,
headers: body instanceof FormData ? headers : { ...headers, 'Content-Type': 'application/json' },
body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
});
const text = await r.text();
if (!r.ok) throw new Error(`${method} ${url} → ${r.status} ${text.slice(0, 300)}`);
return text ? JSON.parse(text) : null;
}
const tag = `v${version}`;
const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
const section = changelog.split(/^## /m).find((s) => s.startsWith(version));
const notes = section ? section.slice(version.length).trim() : '';
let release = await api('GET', `/releases/tags/${tag}`).catch(() => null);
if (!release) {
release = await api('POST', '/releases', { tag_name: tag, name: `Kaleido Desktop ${version}`, body: releaseNotes(version), prerelease, draft: false });
release = await api('POST', '/releases', { tag_name: tag, name: `Kaleido Desktop ${version}`, body: notes, prerelease, draft: false });
console.log(`Created release ${release.name}`);
} else console.log(`Using existing release ${release.name}`);
for (const file of files) {
const name = path.basename(file);
const dir = path.join(root, 'src-tauri/target/release/bundle/nsis');
const files = [`Kaleido_${version}_x64-setup.exe`, `Kaleido_${version}_x64-setup.exe.sig`];
for (const name of files) {
const file = path.join(dir, name);
if (!fs.existsSync(file)) throw new Error(`Missing ${file}; run scripts/build.ps1 first.`);
const existing = release.assets?.find((a) => a.name === name);
if (existing) await api('DELETE', `/releases/${release.id}/assets/${existing.id}`);
const form = new FormData();

View file

@ -1,49 +0,0 @@
// Shared by the release scripts: the Forgejo API (FORGEJO_TOKEN from the environment or
// the ignored .env, never printed), release notes and the bundle folder.
import fs from 'node:fs';
import path from 'node:path';
export const API = 'https://git.elijahkuntz.com/api/v1/repos/Elijah/Kaleido-Desktop';
export const root = path.resolve(import.meta.dirname, '..');
export const bundleDir = path.join(root, 'src-tauri/target/release/bundle');
/** FORGEJO_TOKEN; reads of a public repository work without it, uploads don't. */
export function token(required = false) {
let t = process.env.FORGEJO_TOKEN;
if (!t && fs.existsSync(path.join(root, '.env'))) {
t = fs.readFileSync(path.join(root, '.env'), 'utf8').match(/^FORGEJO_TOKEN=(.*)$/m)?.[1]?.trim().replace(/^"|"$/g, '');
}
if (!t && required) {
console.error('FORGEJO_TOKEN is not set.');
process.exit(1);
}
return t;
}
const auth = () => (token() ? { Authorization: `token ${token()}` } : {});
export async function api(method, url, body) {
const headers = { ...auth(), Accept: 'application/json' };
const r = await fetch(url.startsWith('http') ? url : API + url, {
method,
headers: body instanceof FormData ? headers : { ...headers, 'Content-Type': 'application/json' },
body: body === undefined ? undefined : body instanceof FormData ? body : JSON.stringify(body),
});
const text = await r.text();
if (!r.ok) throw new Error(`${method} ${url} → ${r.status} ${text.slice(0, 300)}`);
return text ? JSON.parse(text) : null;
}
/** Downloads a release asset's text (an updater signature). */
export async function download(url) {
const r = await fetch(url, { headers: auth() });
if (!r.ok) throw new Error(`GET ${url} → ${r.status}`);
return r.text();
}
/** The version's section of CHANGELOG.md. */
export function releaseNotes(version) {
const changelog = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8');
const section = changelog.split(/^## /m).find((s) => s.startsWith(version));
return section ? section.slice(version.length).trim() : '';
}

View file

@ -1,56 +1,53 @@
// Writes updates/latest.json, the feed Kaleido's updater reads, from a published release:
// each platform's updater artifact and signature are taken from the release's assets, so
// the feed only ever points at this version's files, whichever machine runs it.
// Usage: node scripts/update-manifest.mjs <version> [--allow-missing] [notesFile]
// Every platform in PLATFORMS must be in the release (publish from each OS first);
// --allow-missing writes the feed anyway, leaving the missing platforms out of it, so
// their installs simply see no update until the feed is regenerated.
// Writes updates/latest.json, the feed Kaleido's updater reads, from built bundles.
// Usage: node scripts/update-manifest.mjs <version> <baseDownloadUrl> [notesFile]
// Notes come from the version's CHANGELOG.md section unless a notes file is given.
// Each platform's signed artifact (and its .sig) must be in src-tauri/target/release/bundle,
// or pass several bundle folders via KALEIDO_BUNDLES (path;path) when collecting CI outputs.
import fs from 'node:fs';
import path from 'node:path';
import { api, download, releaseNotes, root } from './release-common.mjs';
const args = process.argv.slice(2);
const allowMissing = args.includes('--allow-missing');
const [version, notesFile] = args.filter((a) => !a.startsWith('--'));
if (!version) {
console.error('usage: node scripts/update-manifest.mjs <version> [--allow-missing] [notesFile]');
const [version, baseUrl, notesFile] = process.argv.slice(2);
if (!version || !baseUrl) {
console.error('usage: node scripts/update-manifest.mjs <version> <baseDownloadUrl> [notesFile]');
process.exit(1);
}
const root = path.resolve(import.meta.dirname, '..');
const bundles = (process.env.KALEIDO_BUNDLES ?? path.join(root, 'src-tauri/target/release/bundle')).split(';');
/** Tauri updater platform keys and the release asset each one installs. */
/** Tauri updater platform keys and the artifact each one installs. */
const PLATFORMS = [
{ key: 'windows-x86_64', match: (f) => f === `Kaleido_${version}_x64-setup.exe` },
{ key: 'darwin-aarch64', match: (f) => f === `Kaleido_${version}_aarch64.app.tar.gz` },
{ key: 'windows-x86_64', dir: 'nsis', match: /-setup\.exe$/ },
{ key: 'darwin-aarch64', dir: 'macos', match: /aarch64.*\.app\.tar\.gz$/ },
{ key: 'darwin-x86_64', dir: 'macos', match: /x64.*\.app\.tar\.gz$/ },
{ key: 'linux-x86_64', dir: 'appimage', match: /\.AppImage$/ },
];
const release = await api('GET', `/releases/tags/v${version}`).catch(() => null);
if (!release) throw new Error(`No release v${version}; publish it with scripts/publish-release.mjs first.`);
const assets = release.assets ?? [];
const platforms = {};
const missing = [];
for (const p of PLATFORMS) {
const artifact = assets.find((a) => p.match(a.name));
const sig = artifact && assets.find((a) => a.name === `${artifact.name}.sig`);
if (!artifact || !sig) {
missing.push(p.key);
continue;
}
platforms[p.key] = { signature: (await download(sig.browser_download_url)).trim(), url: artifact.browser_download_url };
console.log(`${p.key}: ${artifact.name}`);
}
if (missing.length && !allowMissing) {
console.error(`v${version} has no build for ${missing.join(', ')}. Publish it from that OS, or pass --allow-missing.`);
process.exit(1);
}
if (!Object.keys(platforms).length) throw new Error(`v${version} has no updater artifacts.`);
const manifest = {
version,
notes: notesFile ? fs.readFileSync(notesFile, 'utf8').trim() : releaseNotes(version),
pub_date: new Date().toISOString(),
platforms,
};
const manifestPath = path.join(root, 'updates/latest.json');
const manifest = fs.existsSync(manifestPath) ? JSON.parse(fs.readFileSync(manifestPath, 'utf8')) : { platforms: {} };
manifest.version = version;
// Notes default to this version's section of CHANGELOG.md.
const changelogNotes = () => {
const section = fs.readFileSync(path.join(root, 'CHANGELOG.md'), 'utf8').split(/^## /m).find((x) => x.startsWith(version));
return section ? section.slice(version.length).trim() : '';
};
manifest.notes = notesFile ? fs.readFileSync(notesFile, 'utf8').trim() : changelogNotes();
manifest.pub_date = new Date().toISOString();
manifest.platforms ??= {};
for (const bundle of bundles) {
for (const p of PLATFORMS) {
const dir = path.join(bundle, p.dir);
if (!fs.existsSync(dir)) continue;
const file = fs.readdirSync(dir).find((f) => p.match.test(f) && f.includes(version));
if (!file || !fs.existsSync(path.join(dir, `${file}.sig`))) continue;
manifest.platforms[p.key] = {
signature: fs.readFileSync(path.join(dir, `${file}.sig`), 'utf8').trim(),
url: `${baseUrl.replace(/\/$/, '')}/${encodeURIComponent(file)}`,
};
console.log(`${p.key}: ${file}`);
}
}
fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
console.log(`Wrote ${path.relative(root, manifestPath)}${missing.length ? ` (without ${missing.join(', ')})` : ''}`);
console.log(`Wrote ${path.relative(root, manifestPath)}`);

57
src-tauri/Cargo.lock generated
View file

@ -2173,21 +2173,13 @@ dependencies = [
[[package]]
name = "kaleido"
version = "0.1.0-beta.8"
version = "0.1.0-beta.7"
dependencies = [
"fs2",
"futures-util",
"keyring",
"libloading 0.8.9",
"log",
"objc2",
"objc2-app-kit",
"objc2-core-foundation",
"objc2-core-graphics",
"objc2-core-video",
"objc2-foundation",
"objc2-open-gl",
"objc2-quartz-core",
"once_cell",
"parking_lot",
"reqwest 0.12.28",
@ -2613,15 +2605,8 @@ checksum = "d49e936b501e5c5bf01fda3a9452ff86dc3ea98ad5f283e1455153142d97518c"
dependencies = [
"bitflags 2.13.2",
"block2",
"libc",
"objc2",
"objc2-cloud-kit",
"objc2-core-data",
"objc2-core-foundation",
"objc2-core-graphics",
"objc2-core-image",
"objc2-core-text",
"objc2-core-video",
"objc2-foundation",
"objc2-quartz-core",
]
@ -2643,7 +2628,6 @@ version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b402a653efbb5e82ce4df10683b6b28027616a2715e90009947d50b8dd298fa"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-foundation",
]
@ -2704,19 +2688,6 @@ dependencies = [
"objc2-core-graphics",
]
[[package]]
name = "objc2-core-video"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d425caf1df73233f29fd8a5c3e5edbc30d2d4307870f802d18f00d83dc5141a6"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-core-foundation",
"objc2-core-graphics",
"objc2-io-surface",
]
[[package]]
name = "objc2-encode"
version = "4.1.0"
@ -2756,26 +2727,6 @@ dependencies = [
"objc2-core-foundation",
]
[[package]]
name = "objc2-metal"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a0125f776a10d00af4152d74616409f0d4a2053a6f57fa5b7d6aa2854ac04794"
dependencies = [
"bitflags 2.13.2",
"objc2",
"objc2-foundation",
]
[[package]]
name = "objc2-open-gl"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0ecc7fd7519a189d9ba9ed9de51af81e41d096aea1d08cca59fd9d8c65d8f585"
dependencies = [
"objc2",
]
[[package]]
name = "objc2-osa-kit"
version = "0.3.2"
@ -2795,15 +2746,9 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96c1358452b371bf9f104e21ec536d37a650eb10f7ee379fff67d2e08d537f1f"
dependencies = [
"bitflags 2.13.2",
"block2",
"libc",
"objc2",
"objc2-core-foundation",
"objc2-core-graphics",
"objc2-core-video",
"objc2-foundation",
"objc2-metal",
"objc2-open-gl",
]
[[package]]

View file

@ -1,6 +1,6 @@
[package]
name = "kaleido"
version = "0.1.0-beta.8"
version = "0.1.0-beta.7"
description = "Kaleido — a Plex client for Windows"
authors = ["Elijah"]
edition = "2021"
@ -34,14 +34,6 @@ log = "0.4"
# Credentials use each OS's native store: Credential Manager, Keychain, Secret Service.
[target.'cfg(target_os = "macos")'.dependencies]
keyring = { version = "3", features = ["apple-native"] }
objc2 = "0.6"
objc2-foundation = { version = "0.3", features = ["NSGeometry", "NSString", "NSValue", "NSHost", "NSProcessInfo", "NSKeyValueCoding"] }
objc2-core-foundation = { version = "0.3", default-features = false, features = ["std", "CFDate", "CFString"] }
objc2-app-kit = { version = "0.3", features = ["NSView", "NSWindow", "NSResponder", "NSButton", "NSControl", "NSGraphics"] }
objc2-quartz-core = { version = "0.3", features = ["CALayer", "CAOpenGLLayer", "CATransaction", "CAMediaTiming", "objc2-open-gl", "objc2-core-video", "objc2-core-graphics"] }
objc2-core-graphics = { version = "0.3", default-features = false, features = ["std", "CGColorSpace"] }
objc2-open-gl = { version = "0.3", default-features = false, features = ["std", "CGLTypes", "CGLCurrent"] }
objc2-core-video = { version = "0.3", default-features = false, features = ["std", "CVBase"] }
[target.'cfg(target_os = "linux")'.dependencies]
keyring = { version = "3", features = ["sync-secret-service", "crypto-rust"] }

View file

@ -44,7 +44,6 @@ pub fn run() {
player::player_command,
player::player_set,
player::player_get,
player::window_buttons,
system::secret_get,
system::secret_set,
system::secret_delete,

View file

@ -192,21 +192,6 @@ impl Mpv {
}
}
/// The raw client handle, for platform code using parts of libmpv this
/// binding doesn't wrap (the render API).
pub fn raw_handle(&self) -> *mut c_void {
self.handle
}
/// Looks up another libmpv function by name.
///
/// # Safety
/// `T` must be the function's exact pointer type.
pub unsafe fn symbol<T: Copy>(&self, name: &str) -> Option<T> {
let name = CString::new(name).ok()?;
self.api._lib.get::<T>(name.as_bytes_with_nul()).ok().map(|s| *s)
}
fn error(&self, code: c_int) -> String {
unsafe { CStr::from_ptr((self.api.error_string)(code)).to_string_lossy().into_owned() }
}

View file

@ -1,5 +1,5 @@
//! Linux: render mpv through its render API (OpenGL) beneath the WebKitGTK
//! view, then implement `VideoSurface` here (see macos.rs for the same idea).
//! view, then implement `VideoSurface` here.
//!
//! Browsing, downloads, settings and updates already work here; only native
//! video composition remains to be written.
@ -20,11 +20,8 @@ impl VideoSurface {
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
Vec::new()
}
pub fn start(&mut self, _: &std::sync::Arc<Mpv>) -> Result<(), String> {
Ok(())
}
pub fn on_property(&mut self, _: &str, _: &serde_json::Value) {}
pub fn show<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: bool) {}
pub fn show(&mut self, _: bool) {}
pub fn fit<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>) {}
pub fn set_rect<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>, _: Option<(i32, i32, i32, i32)>) {}
}
@ -34,16 +31,6 @@ pub fn gpu_names() -> Vec<String> {
Vec::new()
}
pub fn device_name() -> String {
std::fs::read_to_string("/etc/hostname").map(|h| h.trim().to_string()).ok().filter(|h| !h.is_empty()).unwrap_or_else(|| "Linux PC".into())
}
pub fn os_version() -> String {
String::new()
}
pub fn set_window_buttons<R: Runtime>(_: &WebviewWindow<R>, _: bool) {}
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
// TODO(Linux): org.freedesktop.ScreenSaver.Inhibit over D-Bus.
let _ = rx.recv();

View file

@ -1,531 +1,37 @@
//! macOS: libmpv's render API (OpenGL) draws into a CAOpenGLLayer hosted by a
//! view placed beneath the WKWebView; libmpv names, power assertions, window
//! buttons and host details.
//! macOS: render mpv through its render API (libplacebo) into a CAMetalLayer
//! placed beneath the WKWebView, then implement `VideoSurface` here.
//!
//! OpenGL is deprecated on macOS but still supported (on Metal); it is the
//! render API libmpv offers, and what IINA and other mpv front ends use.
#![allow(deprecated)]
//! Browsing, downloads, settings and updates already work here; only native
//! video composition remains to be written.
use std::ffi::{c_char, c_int, c_void, CStr};
use std::ptr::{self, NonNull};
use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
use std::sync::Arc;
use objc2::rc::Retained;
use objc2::{define_class, msg_send, AllocAnyThread, DefinedClass, MainThreadMarker};
use objc2_app_kit::{NSAutoresizingMaskOptions, NSView, NSWindow, NSWindowButton, NSWindowOrderingMode};
use objc2_core_foundation::CFTimeInterval;
use objc2_core_graphics::{kCGColorSpaceITUR_2100_PQ, CGColorSpace};
use objc2_core_video::CVTimeStamp;
use objc2_foundation::{NSNumber, NSPoint, NSRect, NSSize, NSString};
use objc2_open_gl::*;
use objc2_quartz_core::{CALayer, CAOpenGLLayer, CATransaction};
use parking_lot::Mutex;
use tauri::{Runtime, WebviewWindow};
use crate::mpv::Mpv;
// —— OpenGL ————————————————————————————————————————————————————————————
const GL_COLOR_BUFFER_BIT: u32 = 0x4000;
const GL_VIEWPORT: u32 = 0x0BA2;
const GL_DRAW_FRAMEBUFFER_BINDING: u32 = 0x8CA6;
const GL_RGBA16F: c_int = 0x881A;
const RTLD_LAZY: c_int = 0x1;
#[link(name = "OpenGL", kind = "framework")]
extern "C" {
fn glGetIntegerv(pname: u32, data: *mut i32);
fn glClearColor(r: f32, g: f32, b: f32, a: f32);
fn glClear(mask: u32);
fn glFlush();
}
extern "C" {
fn dlopen(path: *const c_char, mode: c_int) -> *mut c_void;
fn dlsym(handle: *mut c_void, symbol: *const c_char) -> *mut c_void;
}
/// mpv resolves OpenGL functions through this (`ctx` is OpenGL.framework's handle).
extern "C" fn get_proc_address(ctx: *mut c_void, name: *const c_char) -> *mut c_void {
unsafe { dlsym(ctx, name) }
}
/// A 3.2 core context; 16-bit float colour (needed for HDR) when the renderer
/// offers it. Returns whether it got float colour.
unsafe fn create_gl_context() -> Result<(CGLContextObj, CGLPixelFormatObj, bool), String> {
let base = [
CGLPixelFormatAttribute::CGLPFAOpenGLProfile.0,
CGLOpenGLProfile::CGLOGLPVersion_3_2_Core.0,
CGLPixelFormatAttribute::CGLPFAAccelerated.0,
CGLPixelFormatAttribute::CGLPFADoubleBuffer.0,
CGLPixelFormatAttribute::CGLPFAAllowOfflineRenderers.0,
CGLPixelFormatAttribute::CGLPFASupportsAutomaticGraphicsSwitching.0,
];
let deep = [CGLPixelFormatAttribute::CGLPFAColorSize.0, 64, CGLPixelFormatAttribute::CGLPFAColorFloat.0];
for extra in [&deep[..], &[]] {
let mut attrs: Vec<CGLPixelFormatAttribute> = base.iter().chain(extra).map(|&a| CGLPixelFormatAttribute(a)).collect();
attrs.push(CGLPixelFormatAttribute(0));
let mut pf: CGLPixelFormatObj = ptr::null_mut();
let mut count = 0;
CGLChoosePixelFormat(NonNull::new_unchecked(attrs.as_mut_ptr()), NonNull::from(&mut pf), NonNull::from(&mut count));
if pf.is_null() {
continue;
}
let mut ctx: CGLContextObj = ptr::null_mut();
CGLCreateContext(pf, ptr::null_mut(), NonNull::from(&mut ctx));
if !ctx.is_null() {
return Ok((ctx, pf, !extra.is_empty()));
}
CGLReleasePixelFormat(pf);
}
Err("OpenGL is unavailable, so video can't be shown.".into())
}
// —— mpv render API ————————————————————————————————————————————————————
const RENDER_PARAM_API_TYPE: c_int = 1;
const RENDER_PARAM_OPENGL_INIT_PARAMS: c_int = 2;
const RENDER_PARAM_OPENGL_FBO: c_int = 3;
const RENDER_PARAM_FLIP_Y: c_int = 4;
const RENDER_UPDATE_FRAME: u64 = 1;
#[repr(C)]
struct RenderParam {
kind: c_int,
data: *mut c_void,
}
#[repr(C)]
struct OpenGlInitParams {
get_proc_address: extern "C" fn(*mut c_void, *const c_char) -> *mut c_void,
get_proc_address_ctx: *mut c_void,
}
#[repr(C)]
struct OpenGlFbo {
fbo: c_int,
w: c_int,
h: c_int,
internal_format: c_int,
}
type RenderCtx = *mut c_void;
/// An mpv render context and the functions that drive it. Every call happens
/// with the layer's OpenGL context locked and current, as libmpv requires.
struct Render {
ctx: RenderCtx,
render: unsafe extern "C" fn(RenderCtx, *mut RenderParam) -> c_int,
update: unsafe extern "C" fn(RenderCtx) -> u64,
report_swap: unsafe extern "C" fn(RenderCtx),
}
unsafe impl Send for Render {}
unsafe impl Sync for Render {}
/// libmpv calls this from its own threads when a frame is ready; it may not
/// call back into libmpv, so it only wakes the render thread.
extern "C" fn on_update(wake: *mut c_void) {
let wake = unsafe { &*(wake as *const SyncSender<()>) };
let _ = wake.try_send(());
}
// —— The video layer ———————————————————————————————————————————————————
struct LayerIvars {
cgl: CGLContextObj,
pixel_format: CGLPixelFormatObj,
/// The framebuffer holds 16-bit floats (so mpv needn't dither to 8 bits).
float: bool,
render: Mutex<Option<Arc<Render>>>,
}
define_class!(
#[unsafe(super(CAOpenGLLayer, CALayer))]
#[name = "KaleidoVideoLayer"]
#[ivars = LayerIvars]
struct VideoLayer;
impl VideoLayer {
#[unsafe(method(copyCGLPixelFormatForDisplayMask:))]
fn copy_pixel_format(&self, _mask: u32) -> CGLPixelFormatObj {
unsafe { CGLRetainPixelFormat(self.ivars().pixel_format) }
}
#[unsafe(method(copyCGLContextForPixelFormat:))]
fn copy_context(&self, _pf: CGLPixelFormatObj) -> CGLContextObj {
unsafe { CGLRetainContext(self.ivars().cgl) }
}
#[unsafe(method(releaseCGLContext:))]
fn release_context(&self, ctx: CGLContextObj) {
unsafe { CGLReleaseContext(ctx) }
}
#[unsafe(method(canDrawInCGLContext:pixelFormat:forLayerTime:displayTime:))]
fn can_draw(&self, _ctx: CGLContextObj, _pf: CGLPixelFormatObj, _t: CFTimeInterval, _ts: *const CVTimeStamp) -> bool {
true
}
#[unsafe(method(drawInCGLContext:pixelFormat:forLayerTime:displayTime:))]
fn draw(&self, ctx: CGLContextObj, _pf: CGLPixelFormatObj, _t: CFTimeInterval, _ts: *const CVTimeStamp) {
let render = self.ivars().render.lock().clone();
unsafe {
CGLLockContext(ctx);
CGLSetCurrentContext(ctx);
match render {
Some(r) => {
let mut fbo = 0;
let mut viewport = [0i32; 4];
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &mut fbo);
glGetIntegerv(GL_VIEWPORT, viewport.as_mut_ptr());
let mut target = OpenGlFbo { fbo, w: viewport[2], h: viewport[3], internal_format: if self.ivars().float { GL_RGBA16F } else { 0 } };
let mut flip: c_int = 1;
let mut params = [
RenderParam { kind: RENDER_PARAM_OPENGL_FBO, data: &mut target as *mut _ as *mut c_void },
RenderParam { kind: RENDER_PARAM_FLIP_Y, data: &mut flip as *mut _ as *mut c_void },
RenderParam { kind: 0, data: ptr::null_mut() },
];
(r.render)(r.ctx, params.as_mut_ptr());
}
None => {
glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
}
}
glFlush();
CGLUnlockContext(ctx);
}
}
}
);
// The layer is drawn from the render thread as well as by Core Animation;
// its mutable state is behind a mutex and the CGL context lock.
unsafe impl Send for VideoLayer {}
unsafe impl Sync for VideoLayer {}
impl VideoLayer {
fn new(cgl: CGLContextObj, pixel_format: CGLPixelFormatObj, float: bool) -> Retained<VideoLayer> {
let this = VideoLayer::alloc().set_ivars(LayerIvars { cgl, pixel_format, float, render: Mutex::new(None) });
let layer: Retained<VideoLayer> = unsafe { msg_send![super(this), init] };
layer.setAsynchronous(false);
layer.setNeedsDisplayOnBoundsChange(true);
layer.setOpaque(true);
layer
}
}
/// Redraws whenever mpv has a new frame. Drawing off the main thread needs an
/// explicit flush for Core Animation to pick the frame up.
fn render_loop(layer: Retained<VideoLayer>, wake: Receiver<()>) {
let cgl = layer.ivars().cgl;
while wake.recv().is_ok() {
let Some(render) = layer.ivars().render.lock().clone() else { continue };
let flags = unsafe {
CGLLockContext(cgl);
CGLSetCurrentContext(cgl);
let flags = (render.update)(render.ctx);
CGLUnlockContext(cgl);
flags
};
if flags & RENDER_UPDATE_FRAME != 0 {
layer.display();
CATransaction::flush();
unsafe {
CGLLockContext(cgl);
CGLSetCurrentContext(cgl);
(render.report_swap)(render.ctx);
CGLUnlockContext(cgl);
}
}
}
}
// —— VideoSurface ——————————————————————————————————————————————————————
/// The view is only touched on the main thread; the layer is also drawn by the
/// render thread and reconfigured for HDR inside explicit transactions.
struct Ui {
view: Retained<NSView>,
layer: Retained<VideoLayer>,
}
unsafe impl Send for Ui {}
unsafe impl Sync for Ui {}
pub struct VideoSurface {
ui: Arc<Ui>,
wake: &'static SyncSender<()>,
wake_rx: Option<Receiver<()>>,
/// Where the video is drawn, in physical pixels; `None` fills the window.
rect: Option<(i32, i32, i32, i32)>,
mpv: Option<Arc<Mpv>>,
/// HDR passthrough is on (the `target-colorspace-hint` option, as on Windows).
passthrough: bool,
/// The layer is showing HDR in extended dynamic range.
edr: bool,
}
/// Runs `f` on the main thread with the window's web view and waits for it.
fn on_main<R: Runtime, T: Send + 'static>(
window: &WebviewWindow<R>,
f: impl FnOnce(&NSView, &NSWindow) -> T + Send + 'static,
) -> Result<T, String> {
let (tx, rx) = std::sync::mpsc::channel();
window
.with_webview(move |webview| unsafe {
let view = &*(webview.inner() as *const NSView);
let window = &*(webview.ns_window() as *const NSWindow);
let _ = tx.send(f(view, window));
})
.map_err(|e| e.to_string())?;
rx.recv().map_err(|e| e.to_string())
}
/// Places the video view: the whole web view, or a rectangle of it given in
/// physical pixels from the top left (the web page's coordinates).
fn place(ui: &Ui, webview: &NSView, window: &NSWindow, rect: Option<(i32, i32, i32, i32)>) {
let bounds = webview.frame();
let scale = window.backingScaleFactor();
let frame = match rect {
None => bounds,
Some((x, y, w, h)) => {
let (x, y, w, h) = (x as f64 / scale, y as f64 / scale, (w.max(16)) as f64 / scale, (h.max(16)) as f64 / scale);
let flipped = unsafe { webview.superview() }.is_some_and(|s| s.isFlipped());
let top = if flipped { bounds.origin.y + y } else { bounds.origin.y + bounds.size.height - y - h };
NSRect::new(NSPoint::new(bounds.origin.x + x, top), NSSize::new(w, h))
}
};
ui.view.setFrame(frame);
ui.view.setAutoresizingMask(if rect.is_none() {
NSAutoresizingMaskOptions::ViewWidthSizable | NSAutoresizingMaskOptions::ViewHeightSizable
} else {
NSAutoresizingMaskOptions::ViewNotSizable
});
if ui.layer.contentsScale() != scale {
ui.layer.setContentsScale(scale);
}
}
impl VideoSurface {
pub fn create<R: Runtime>(window: &WebviewWindow<R>) -> Result<VideoSurface, String> {
let (cgl, pixel_format, float) = unsafe { create_gl_context()? };
let layer = VideoLayer::new(cgl, pixel_format, float);
let ui = on_main(window, move |webview, window| unsafe {
let view = NSView::initWithFrame(MainThreadMarker::new_unchecked().alloc(), webview.frame());
// Layer-hosting: set the layer before asking for one.
view.setLayer(Some(&layer));
view.setWantsLayer(true);
view.setHidden(true);
// Let the video show through wherever the page is transparent.
let no = NSNumber::new_bool(false);
let _: () = msg_send![webview, setValue: &*no, forKey: &*NSString::from_str("drawsBackground")];
if let Some(parent) = webview.superview() {
parent.addSubview_positioned_relativeTo(&view, NSWindowOrderingMode::Below, Some(webview));
}
let ui = Ui { view, layer };
place(&ui, webview, window, None);
ui
})?;
let (wake, wake_rx) = sync_channel::<()>(1);
Ok(VideoSurface {
ui: Arc::new(ui),
wake: Box::leak(Box::new(wake)),
wake_rx: Some(wake_rx),
rect: None,
mpv: None,
passthrough: false,
edr: false,
})
}
/// mpv renders through the render API (`vo=libmpv`). Its window is forced
/// open only once the render context exists (`start`).
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
vec![("vo", "libmpv".into()), ("force-window", "no".into())]
}
/// Creates mpv's render context on the layer's OpenGL context and starts
/// the render thread. Runs once, after `mpv_initialize`.
pub fn start(&mut self, mpv: &Arc<Mpv>) -> Result<(), String> {
let Some(wake_rx) = self.wake_rx.take() else { return Ok(()) };
let hint = mpv.get_property("target-colorspace-hint").unwrap_or_default();
self.passthrough = (hint == serde_json::Value::Bool(true) || hint == "yes") && self.ui.layer.ivars().float;
self.mpv = Some(mpv.clone());
type Create = unsafe extern "C" fn(*mut RenderCtx, *mut c_void, *mut RenderParam) -> c_int;
type SetCallback = unsafe extern "C" fn(RenderCtx, extern "C" fn(*mut c_void), *mut c_void);
unsafe {
let missing = |name: &str| format!("libmpv is missing {name}");
let create: Create = mpv.symbol("mpv_render_context_create").ok_or_else(|| missing("mpv_render_context_create"))?;
let set_callback: SetCallback = mpv.symbol("mpv_render_context_set_update_callback").ok_or_else(|| missing("the render API"))?;
let render = mpv.symbol("mpv_render_context_render").ok_or_else(|| missing("the render API"))?;
let update = mpv.symbol("mpv_render_context_update").ok_or_else(|| missing("the render API"))?;
let report_swap = mpv.symbol("mpv_render_context_report_swap").ok_or_else(|| missing("the render API"))?;
let gl = dlopen(c"/System/Library/Frameworks/OpenGL.framework/OpenGL".as_ptr(), RTLD_LAZY);
let mut init = OpenGlInitParams { get_proc_address, get_proc_address_ctx: gl };
let mut params = [
RenderParam { kind: RENDER_PARAM_API_TYPE, data: c"opengl".as_ptr() as *mut c_void },
RenderParam { kind: RENDER_PARAM_OPENGL_INIT_PARAMS, data: &mut init as *mut _ as *mut c_void },
RenderParam { kind: 0, data: ptr::null_mut() },
];
let cgl = self.ui.layer.ivars().cgl;
let mut ctx: RenderCtx = ptr::null_mut();
CGLLockContext(cgl);
CGLSetCurrentContext(cgl);
let code = create(&mut ctx, mpv.raw_handle(), params.as_mut_ptr());
CGLUnlockContext(cgl);
if code < 0 || ctx.is_null() {
return Err(format!("The video renderer couldn't start ({code})."));
}
set_callback(ctx, on_update, self.wake as *const SyncSender<()> as *mut c_void);
*self.ui.layer.ivars().render.lock() = Some(Arc::new(Render { ctx, render, update, report_swap }));
}
let layer = self.ui.layer.clone();
std::thread::Builder::new()
.name("mpv-render".into())
.spawn(move || render_loop(layer, wake_rx))
.map_err(|e| e.to_string())?;
mpv.set_property("force-window", &serde_json::Value::Bool(true))
}
/// HDR passthrough: for PQ or HLG video, mpv outputs PQ (BT.2020) instead of
/// tone-mapping to SDR, and the layer shows it in extended dynamic range, so
/// macOS maps it to the display's HDR headroom. SDR video uses the defaults.
pub fn on_property(&mut self, name: &str, value: &serde_json::Value) {
if name != "video-params/gamma" {
return;
}
let edr = self.passthrough && matches!(value.as_str(), Some("pq" | "hlg"));
if edr == self.edr {
return;
}
self.edr = edr;
if let Some(mpv) = &self.mpv {
let target = |v: &str| serde_json::Value::String(v.into());
let (trc, prim) = if edr { ("pq", "bt.2020") } else { ("auto", "auto") };
let _ = mpv.set_property("target-trc", &target(trc));
let _ = mpv.set_property("target-prim", &target(prim));
}
// Layer properties may change off the main thread inside a transaction.
let layer = &self.ui.layer;
CATransaction::begin();
layer.setWantsExtendedDynamicRangeContent(edr);
let pq = if edr { CGColorSpace::with_name(Some(unsafe { kCGColorSpaceITUR_2100_PQ })) } else { None };
layer.setColorspace(pq.as_deref());
CATransaction::commit();
}
pub fn show<R: Runtime>(&mut self, window: &WebviewWindow<R>, visible: bool) {
let ui = self.ui.clone();
let _ = window.run_on_main_thread(move || {
ui.view.setHidden(!visible);
if visible {
ui.layer.setNeedsDisplay();
}
});
}
/// Keeps the video view matched to the web view, or to the miniplayer
/// rectangle when one is set.
pub fn fit<R: Runtime>(&mut self, window: &WebviewWindow<R>, _: Option<&Mpv>) {
let ui = self.ui.clone();
let rect = self.rect;
let _ = window.with_webview(move |webview| unsafe {
let view = &*(webview.inner() as *const NSView);
let window = &*(webview.ns_window() as *const NSWindow);
place(&ui, view, window, rect);
});
}
pub fn set_rect<R: Runtime>(&mut self, window: &WebviewWindow<R>, mpv: Option<&Mpv>, rect: Option<(i32, i32, i32, i32)>) {
self.rect = rect;
self.fit(window, mpv);
}
}
/// mpv properties the surface needs to observe.
pub const SURFACE_PROPERTIES: &[&str] = &["video-params/gamma"];
/// File names libmpv may have on this platform.
pub const SURFACE_PROPERTIES: &[&str] = &[];
pub const MPV_LIBRARIES: &[&str] = &["libmpv.2.dylib", "libmpv.dylib"];
/// Not needed: the only GPU-specific tier (RTX Video) is Windows-only.
pub struct VideoSurface;
impl VideoSurface {
pub fn create<R: Runtime>(_: &WebviewWindow<R>) -> Result<VideoSurface, String> {
Err("Video playback is not available on this platform yet.".into())
}
pub fn mpv_options(&self) -> Vec<(&'static str, String)> {
Vec::new()
}
pub fn on_property(&mut self, _: &str, _: &serde_json::Value) {}
pub fn show(&mut self, _: bool) {}
pub fn fit<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>) {}
pub fn set_rect<R: Runtime>(&mut self, _: &WebviewWindow<R>, _: Option<&Mpv>, _: Option<(i32, i32, i32, i32)>) {}
}
/// Not needed yet: the only GPU-specific tier (RTX Video) is Windows-only.
pub fn gpu_names() -> Vec<String> {
Vec::new()
}
/// The Mac's name as set in System Settings → General → Sharing.
pub fn device_name() -> String {
objc2_foundation::NSHost::currentHost()
.localizedName()
.map(|n| n.to_string())
.filter(|n| !n.is_empty())
.unwrap_or_else(|| "Mac".into())
}
/// macOS version, e.g. "15.4".
pub fn os_version() -> String {
let v = objc2_foundation::NSProcessInfo::processInfo().operatingSystemVersion();
if v.patchVersion > 0 {
format!("{}.{}.{}", v.majorVersion, v.minorVersion, v.patchVersion)
} else {
format!("{}.{}", v.majorVersion, v.minorVersion)
}
}
/// Shows or hides the traffic lights (they fade with the player's controls).
pub fn set_window_buttons<R: Runtime>(window: &WebviewWindow<R>, visible: bool) {
let Ok(ns_window) = window.ns_window() else { return };
let ns_window = ns_window as usize;
let _ = window.run_on_main_thread(move || unsafe {
let window = &*(ns_window as *const NSWindow);
for kind in [NSWindowButton::CloseButton, NSWindowButton::MiniaturizeButton, NSWindowButton::ZoomButton] {
if let Some(button) = window.standardWindowButton(kind) {
button.setHidden(!visible);
}
}
// AppKit lays the buttons out again at their default place; the window's
// view restores the configured position (trafficLightPosition) when drawn.
if let Some(view) = window.contentView() {
view.setNeedsDisplay(true);
}
});
}
// —— Power —————————————————————————————————————————————————————————————
type CFStringRef = *const c_void;
const CF_STRING_ENCODING_UTF8: u32 = 0x0800_0100;
const IOPM_ASSERTION_LEVEL_ON: u32 = 255;
#[link(name = "CoreFoundation", kind = "framework")]
extern "C" {
fn CFStringCreateWithCString(alloc: *const c_void, s: *const c_char, encoding: u32) -> CFStringRef;
fn CFRelease(cf: *const c_void);
}
#[link(name = "IOKit", kind = "framework")]
extern "C" {
fn IOPMAssertionCreateWithName(kind: CFStringRef, level: u32, name: CFStringRef, id: *mut u32) -> i32;
fn IOPMAssertionRelease(id: u32) -> i32;
}
/// Keeps the display awake until `rx` closes or receives.
pub fn hold_awake(rx: Receiver<()>) {
let cf = |s: &CStr| unsafe { CFStringCreateWithCString(ptr::null(), s.as_ptr(), CF_STRING_ENCODING_UTF8) };
let kind = cf(c"PreventUserIdleDisplaySleep");
let name = cf(c"Kaleido is playing video");
let mut id = 0u32;
let held = unsafe { IOPMAssertionCreateWithName(kind, IOPM_ASSERTION_LEVEL_ON, name, &mut id) } == 0;
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
// TODO(macOS): IOPMAssertionCreateWithName(PreventUserIdleDisplaySleep).
let _ = rx.recv();
unsafe {
if held {
IOPMAssertionRelease(id);
}
CFRelease(kind);
CFRelease(name);
}
}

View file

@ -2,13 +2,11 @@
//! Each platform file exposes the same items:
//!
//! - `VideoSurface`: composes mpv's output beneath the web view
//! (`create`, `mpv_options`, `start`, `on_property`, `show`, `fit`, `set_rect`).
//! (`create`, `mpv_options`, `on_property`, `show`, `fit`, `set_rect`).
//! - `SURFACE_PROPERTIES`: mpv properties the surface observes.
//! - `MPV_LIBRARIES`: libmpv file names to look for.
//! - `hold_awake`: prevents display sleep until the receiver closes.
//! - `gpu_names`: the graphics adapters, by name.
//! - `device_name`, `os_version`: how the computer identifies itself to Plex.
//! - `set_window_buttons`: shows or hides native window buttons (macOS).
#[cfg(target_os = "windows")]
mod windows;

View file

@ -69,11 +69,6 @@ impl VideoSurface {
]
}
/// Nothing to set up once mpv is initialized: it creates its swapchain itself.
pub fn start(&mut self, _: &std::sync::Arc<Mpv>) -> Result<(), String> {
Ok(())
}
pub fn on_property(&mut self, name: &str, value: &serde_json::Value) {
if name == "display-swapchain" {
self.attach(value.as_i64().unwrap_or(0) as usize);
@ -99,7 +94,7 @@ impl VideoSurface {
}
}
pub fn show<R: Runtime>(&mut self, _: &WebviewWindow<R>, visible: bool) {
pub fn show(&mut self, visible: bool) {
if self.visible == visible {
return;
}
@ -146,6 +141,7 @@ pub const SURFACE_PROPERTIES: &[&str] = &["display-swapchain"];
/// File names libmpv may have on this platform.
pub const MPV_LIBRARIES: &[&str] = &["libmpv-2.dll", "mpv-2.dll"];
/// Keeps the display awake until `rx` closes or receives.
/// Hardware graphics adapters as DXGI names them (e.g. "NVIDIA GeForce RTX 4080").
pub fn gpu_names() -> Vec<String> {
use ::windows::Win32::Graphics::Dxgi::*;
@ -169,19 +165,6 @@ pub fn gpu_names() -> Vec<String> {
names
}
/// The computer's name, as Plex shows it.
pub fn device_name() -> String {
std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Windows PC".into())
}
pub fn os_version() -> String {
"11".into()
}
/// Windows draws its own caption buttons in the page.
pub fn set_window_buttons<R: Runtime>(_: &WebviewWindow<R>, _: bool) {}
/// Keeps the display awake until `rx` closes or receives.
pub fn hold_awake(rx: std::sync::mpsc::Receiver<()>) {
use ::windows::Win32::System::Power::*;
unsafe {

View file

@ -71,9 +71,7 @@ fn create_player<R: Runtime>(app: &AppHandle<R>, window: &WebviewWindow<R>, opts
set("hwdec", opts.hwdec.as_deref().unwrap_or("auto-safe"))?;
set("keep-open", "yes")?;
set("idle", "yes")?;
if !render_options.iter().any(|(k, _)| *k == "force-window") {
set("force-window", "yes")?;
}
set("force-window", "yes")?;
set("osc", "no")?;
set("osd-level", "0")?;
set("input-default-bindings", "no")?;
@ -109,9 +107,6 @@ fn create_player<R: Runtime>(app: &AppHandle<R>, window: &WebviewWindow<R>, opts
}
mpv.request_log_messages("warn");
mpv.initialize()?;
if let Some(surface) = app.state::<PlayerState>().surface.lock().as_mut() {
surface.start(&mpv)?;
}
for (i, name) in OBSERVED.iter().chain(crate::platform::SURFACE_PROPERTIES).enumerate() {
mpv.observe(i as u64 + 1, name);
}
@ -188,7 +183,7 @@ pub async fn player_show<R: Runtime>(app: AppHandle<R>, window: WebviewWindow<R>
let mut surface = state.surface.lock();
if let Some(surface) = surface.as_mut() {
surface.fit(&window, mpv.as_deref());
surface.show(&window, visible);
surface.show(visible);
}
Ok(())
}
@ -230,13 +225,6 @@ pub async fn player_get<R: Runtime>(app: AppHandle<R>, name: String) -> Result<V
player(&app)?.get_property(&name)
}
/// Shows or hides the native window buttons where the OS draws them (the
/// macOS traffic lights fade with the player's controls).
#[tauri::command]
pub fn window_buttons<R: Runtime>(window: WebviewWindow<R>, visible: bool) {
crate::platform::set_window_buttons(&window, visible);
}
/// Keeps the video surface matched to the window's client area.
pub fn on_resize<R: Runtime>(window: &WebviewWindow<R>) {
let app = window.app_handle();

View file

@ -13,14 +13,9 @@ fn entry(key: &str) -> Result<keyring::Entry, String> {
keyring::Entry::new(SERVICE, key).map_err(|e| e.to_string())
}
/// Secrets (Plex tokens) live in the OS's credential store (Windows Credential
/// Manager, the macOS Keychain), never in plain files; except in macOS debug
/// builds, see `dev_secrets`.
/// Secrets (Plex tokens) live in Windows Credential Manager, never in plain files.
#[tauri::command]
pub fn secret_get<R: Runtime>(app: AppHandle<R>, key: String) -> Result<Option<String>, String> {
if let Some(path) = dev_secrets(&app) {
return Ok(read_dev_secrets(&path).get(&key).and_then(|v| v.as_str()).map(String::from));
}
pub fn secret_get(key: String) -> Result<Option<String>, String> {
match entry(&key)?.get_password() {
Ok(v) => Ok(Some(v)),
Err(keyring::Error::NoEntry) => Ok(None),
@ -29,66 +24,18 @@ pub fn secret_get<R: Runtime>(app: AppHandle<R>, key: String) -> Result<Option<S
}
#[tauri::command]
pub fn secret_set<R: Runtime>(app: AppHandle<R>, key: String, value: String) -> Result<(), String> {
if let Some(path) = dev_secrets(&app) {
let mut all = read_dev_secrets(&path);
all.insert(key, Value::String(value));
return write_dev_secrets(&path, &all);
}
let entry = entry(&key)?;
match entry.set_password(&value) {
Ok(()) => Ok(()),
// A Keychain item left by a differently signed build can be impossible to
// update yet still block adding; replacing it recovers.
Err(keyring::Error::PlatformFailure(_)) if cfg!(target_os = "macos") => {
let _ = entry.delete_credential();
entry.set_password(&value).map_err(|e| e.to_string())
}
Err(e) => Err(e.to_string()),
}
pub fn secret_set(key: String, value: String) -> Result<(), String> {
entry(&key)?.set_password(&value).map_err(|e| e.to_string())
}
#[tauri::command]
pub fn secret_delete<R: Runtime>(app: AppHandle<R>, key: String) -> Result<(), String> {
if let Some(path) = dev_secrets(&app) {
let mut all = read_dev_secrets(&path);
all.remove(&key);
return write_dev_secrets(&path, &all);
}
pub fn secret_delete(key: String) -> Result<(), String> {
match entry(&key)?.delete_credential() {
Ok(()) | Err(keyring::Error::NoEntry) => Ok(()),
Err(e) => Err(e.to_string()),
}
}
/// macOS ties Keychain access to the app's code signature, and every debug
/// build is a new unsigned binary, so the Keychain would ask for permission
/// after each rebuild. Debug builds there keep secrets in a private file in the
/// app data folder instead (development only, like the `.env` sign-in).
fn dev_secrets<R: Runtime>(app: &AppHandle<R>) -> Option<std::path::PathBuf> {
if !(cfg!(debug_assertions) && cfg!(target_os = "macos")) {
return None;
}
app.path().app_data_dir().ok().map(|d| d.join("dev-secrets.json"))
}
fn read_dev_secrets(path: &std::path::Path) -> serde_json::Map<String, Value> {
std::fs::read_to_string(path).ok().and_then(|t| serde_json::from_str(&t).ok()).unwrap_or_default()
}
fn write_dev_secrets(path: &std::path::Path, all: &serde_json::Map<String, Value>) -> Result<(), String> {
use std::io::Write;
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir).map_err(|e| e.to_string())?;
}
let mut options = std::fs::OpenOptions::new();
options.write(true).create(true).truncate(true);
#[cfg(unix)]
std::os::unix::fs::OpenOptionsExt::mode(&mut options, 0o600);
let mut file = options.open(path).map_err(|e| e.to_string())?;
file.write_all(Value::Object(all.clone()).to_string().as_bytes()).map_err(|e| e.to_string())
}
#[derive(Serialize)]
#[serde(rename_all = "camelCase")]
pub struct AppInfo {
@ -96,7 +43,6 @@ pub struct AppInfo {
data_dir: String,
default_download_dir: String,
platform: String,
os_version: String,
device_name: String,
/// Graphics adapters by name (decides which upscaling tiers are offered).
gpus: Vec<String>,
@ -117,8 +63,7 @@ pub fn app_info<R: Runtime>(app: AppHandle<R>) -> AppInfo {
data_dir: data,
default_download_dir: downloads,
platform: std::env::consts::OS.to_string(),
os_version: crate::platform::os_version(),
device_name: crate::platform::device_name(),
device_name: std::env::var("COMPUTERNAME").unwrap_or_else(|_| "Windows PC".into()),
gpus: crate::platform::gpu_names(),
}
}

View file

@ -1,7 +1,7 @@
{
"$schema": "https://schema.tauri.app/config/2",
"productName": "Kaleido",
"version": "0.1.0-beta.8",
"version": "0.1.0-beta.7",
"identifier": "tv.kaleido.desktop",
"build": {
"beforeDevCommand": "npm run dev",
@ -58,7 +58,7 @@
},
"plugins": {
"updater": {
"pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEUxQjk1OTExMzBCRTRENEUKUldST1RiNHdFVm01NFFMQ1EvYm9CYlhhNU9jNTZXb254dVZOQW8relJYRlQ4ZjdLQll3cHR3VE4K",
"pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEU0MTA2RjI0OUFFQzU1QzUKUldURlZleWFKRzhRNUlqTTR3U095STFYS3BsUXd2UnZMYlRrQmt3aUk5YU5WSjdqcUxVcHllU1EK",
"endpoints": [
"https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/raw/branch/main/updates/latest.json"
]

View file

@ -1,39 +1,15 @@
{
"$schema": "https://schema.tauri.app/config/2",
"app": {
"windows": [
{
"label": "main",
"title": "Kaleido",
"width": 1480,
"height": 900,
"minWidth": 900,
"minHeight": 580,
"center": true,
"decorations": true,
"titleBarStyle": "Overlay",
"hiddenTitle": true,
"trafficLightPosition": { "x": 22, "y": 35 },
"backgroundColor": "#090a0c",
"transparent": false,
"shadow": true,
"visible": false,
"dragDropEnabled": false
}
]
},
"bundle": {
"targets": [
"app",
"dmg"
],
"macOS": {
"minimumSystemVersion": "26.0",
"signingIdentity": "-",
"hardenedRuntime": false,
"files": {
"Frameworks": "../vendor/mpv/macos"
}
"minimumSystemVersion": "12.0",
"frameworks": [
"../vendor/mpv/macos/libmpv.2.dylib"
]
}
}
}

View file

@ -11,7 +11,7 @@ import { PageLoader } from '../ui/primitives';
import { Splash } from '../screens/Splash';
import { SignIn } from '../screens/SignIn';
import { ServerPicker } from '../screens/ServerPicker';
import { isMac, win } from '../platform/native';
import { win } from '../platform/native';
import { usePlayer } from '../player/store';
import { PlayerOverlay } from '../player/PlayerOverlay';
import { DialogHost } from '../screens/dialogs/DialogHost';
@ -100,13 +100,13 @@ function useGlobalShortcuts() {
if ((e.ctrlKey || e.metaKey) && (e.key === 'k' || e.key === 'f')) {
e.preventDefault();
navigate({ name: 'search' });
} else if ((e.altKey && e.key === 'ArrowLeft') || (isMac && e.metaKey && e.key === '[')) {
} else if (e.altKey && e.key === 'ArrowLeft') {
e.preventDefault();
useRouter.getState().back();
} else if ((e.altKey && e.key === 'ArrowRight') || (isMac && e.metaKey && e.key === ']')) {
} else if (e.altKey && e.key === 'ArrowRight') {
e.preventDefault();
useRouter.getState().forward();
} else if (e.key === 'F11' || (isMac && e.metaKey && e.ctrlKey && e.key.toLowerCase() === 'f')) {
} else if (e.key === 'F11') {
e.preventDefault();
win.isFullscreen().then((fs) => win.setFullscreen(!fs));
} else if ((e.key === 'Escape' || e.key === 'Backspace') && !isTyping(e.target) && !document.querySelector('.menu-layer, .dialog-layer')) {
@ -225,16 +225,7 @@ export function App() {
useEffect(() => {
useSession.getState().init();
// The window appears once the first frame is painted (no white flash).
// WKWebView runs no animation frames until its window is shown, so a
// timeout stands in there.
let shown = false;
const show = () => {
if (!shown) win.show();
shown = true;
};
requestAnimationFrame(show);
const fallback = setTimeout(show, 150);
return () => clearTimeout(fallback);
requestAnimationFrame(() => win.show());
}, []);
useEffect(() => {

View file

@ -5,7 +5,7 @@ import { useSettings } from './settings';
import { Icon } from '../ui/Icon';
import { KaleidoMark } from '../ui/primitives';
import { openMenu, type MenuItem } from '../ui/overlays';
import { isMac, isNative, shortcut, win } from '../platform/native';
import { isNative, win } from '../platform/native';
import { useDownloads } from '../downloads/store';
import { useHomeUsers } from './useHomeUsers';
@ -16,18 +16,17 @@ const NAV = [
{ id: 'downloads', label: 'Downloads', route: { name: 'downloads' } as const },
];
/** Caption buttons drawn by the page; macOS shows its own traffic lights instead. */
export function WindowControls() {
const [maximized, setMaximized] = useState(false);
useEffect(() => {
if (!isNative || isMac) return;
if (!isNative) return;
let off: (() => void) | undefined;
const sync = () => win.isMaximized().then(setMaximized);
sync();
win.onResized(sync).then((u) => (off = u));
return () => off?.();
}, []);
if (!isNative || isMac) return null;
if (!isNative) return null;
return (
<div className="window-controls">
<button aria-label="Minimize" onClick={() => win.minimize()}>
@ -110,7 +109,7 @@ export function TopBar({ solid }: { solid: boolean }) {
</nav>
</div>
<div className="topbar-right" data-tauri-drag-region>
<button className={`icon-btn${active === 'search' ? ' on' : ''}`} aria-label="Search" title={`Search (${shortcut('K')})`} onClick={() => navigate({ name: 'search' })}>
<button className={`icon-btn${active === 'search' ? ' on' : ''}`} aria-label="Search" title="Search (Ctrl+K)" onClick={() => navigate({ name: 'search' })}>
<Icon name="search" size={19} />
</button>
<button className={`icon-btn${active === 'settings' ? ' on' : ''}`} aria-label="Settings" title="Settings" onClick={() => navigate({ name: 'settings', mode: 'app', tab: 'general' })}>

View file

@ -54,7 +54,7 @@ export const useSession = create<SessionState>((set, get) => ({
async init() {
const info = await appInfo();
configureClient({ version: info.version, deviceName: info.deviceName, platformVersion: info.osVersion });
configureClient({ version: info.version, deviceName: info.deviceName });
let token = await secrets.get('account-token');
const stored = loadStoredServer();

View file

@ -13,7 +13,6 @@ import { useRouter } from './app/router';
import { usePlayer } from './player/store';
import { useSettings } from './app/settings';
import { useDownloads } from './downloads/store';
import { hostOS, isMac, isNative, win } from './platform/native';
if (import.meta.env.DEV) (window as any).__kaleido = { useSession, useRouter, usePlayer, useSettings, useDownloads };
@ -25,15 +24,6 @@ window.addEventListener('contextmenu', (e) => {
installKeyboardNav();
// Platform styling: macOS keeps its traffic lights at the top left, except in
// full screen, where the system hides them.
document.documentElement.classList.add(`os-${hostOS}`);
if (isNative && isMac) {
const syncFullscreen = () => win.isFullscreen().then((fs) => document.documentElement.classList.toggle('window-fullscreen', fs));
syncFullscreen();
win.onResized(syncFullscreen);
}
createRoot(document.getElementById('root')!).render(
<StrictMode>
<App />

View file

@ -7,16 +7,6 @@ import type { UnlistenFn } from '@tauri-apps/api/event';
export const isNative = typeof window !== 'undefined' && '__TAURI_INTERNALS__' in window;
/** The host OS, known synchronously from the web view (WebView2, WKWebView, WebKitGTK). */
export const hostOS: 'windows' | 'macos' | 'linux' =
typeof navigator !== 'undefined' && /Macintosh|Mac OS X/.test(navigator.userAgent) ? 'macos' : typeof navigator !== 'undefined' && /Linux|X11/.test(navigator.userAgent) ? 'linux' : 'windows';
export const isMac = hostOS === 'macos';
/** A shortcut with the platform's command key: "⌘K" on macOS, "Ctrl + K" elsewhere. */
export const shortcut = (key: string) => (isMac ? `⌘${key}` : `Ctrl + ${key}`);
/** How the window enters full screen from the keyboard. */
export const fullscreenShortcut = isMac ? '⌃⌘F' : 'F11';
export async function invoke<T>(cmd: string, args?: Record<string, unknown>): Promise<T> {
if (!isNative) throw new Error(`${cmd} is only available in the desktop app.`);
const { invoke } = await import('@tauri-apps/api/core');
@ -57,7 +47,6 @@ export interface AppInfo {
dataDir: string;
defaultDownloadDir: string;
platform: string;
osVersion: string;
deviceName: string;
/** Graphics adapters by name (empty where not reported). */
gpus: string[];
@ -68,7 +57,7 @@ export async function appInfo(): Promise<AppInfo> {
if (info) return info;
info = isNative
? await invoke<AppInfo>('app_info')
: { version: '0.1.0-dev', dataDir: '', defaultDownloadDir: '', platform: 'browser', osVersion: '', deviceName: 'Browser preview', gpus: [] };
: { version: '0.1.0-dev', dataDir: '', defaultDownloadDir: '', platform: 'browser', deviceName: 'Browser preview', gpus: [] };
return info;
}
@ -118,10 +107,6 @@ export const win = {
await w.setFocus();
}
},
/** The OS's own window buttons (the macOS traffic lights); elsewhere the page draws them. */
async setButtonsVisible(visible: boolean) {
if (isNative && isMac) await invoke('window_buttons', { visible }).catch(() => {});
},
async onResized(cb: () => void): Promise<UnlistenFn> {
if (!isNative) {
window.addEventListener('resize', cb);

View file

@ -781,14 +781,6 @@ export function PlayerOverlay() {
return () => window.removeEventListener('keydown', onKey);
}, [st.open, st.mini, seekStep, poke]);
// The macOS traffic lights fade with the rest of the player's chrome.
const chromeHidden = st.open && !st.mini && !visible && st.firstFrame && !st.error;
useEffect(() => {
if (!chromeHidden) return;
win.setButtonsVisible(false);
return () => void win.setButtonsVisible(true);
}, [chromeHidden]);
if (!st.open || !st.item) return null;
if (st.mini) return <MiniPlayer />;
const item = st.item;

View file

@ -1,5 +1,5 @@
import { arr, bool, num, str } from './parse';
import { clientIdentifier, DEVICE, PLATFORM, PlexError, plexRequest, PRODUCT } from './client';
import { clientIdentifier, PlexError, plexRequest, PRODUCT } from './client';
import type { HomeUser, PlexUser, ServerConnection, ServerResource } from './types';
const TV = 'https://plex.tv/api/v2';
@ -26,8 +26,8 @@ export function authUrl(pin: Pin): string {
clientID: clientIdentifier(),
code: pin.code,
'context[device][product]': PRODUCT,
'context[device][platform]': PLATFORM,
'context[device][device]': DEVICE,
'context[device][platform]': 'Windows',
'context[device][device]': 'Windows',
});
return `https://app.plex.tv/auth#?${params.toString()}`;
}

View file

@ -1,9 +1,7 @@
import { hostOS, httpFetch } from '../platform/native';
import { httpFetch } from '../platform/native';
export const PRODUCT = 'Kaleido';
/** How Plex lists this player (Plex's own names for each OS and device). */
export const PLATFORM = hostOS === 'macos' ? 'macOS' : hostOS === 'linux' ? 'Linux' : 'Windows';
export const DEVICE = hostOS === 'macos' ? 'Mac' : hostOS === 'linux' ? 'Linux' : 'Windows';
export const PLATFORM = 'Windows';
export class PlexError extends Error {
constructor(
@ -16,8 +14,7 @@ export class PlexError extends Error {
let clientId = '';
let version = '0.1.0';
let deviceName = hostOS === 'macos' ? 'Mac' : 'Windows PC';
let platformVersion = hostOS === 'windows' ? '11' : '';
let deviceName = 'Windows PC';
/** A stable, random identifier for this installation (not secret). */
export function clientIdentifier(): string {
@ -30,24 +27,9 @@ export function clientIdentifier(): string {
return clientId;
}
export function configureClient(opts: { version?: string; deviceName?: string; platformVersion?: string }) {
export function configureClient(opts: { version?: string; deviceName?: string }) {
if (opts.version) version = opts.version;
if (opts.deviceName) deviceName = opts.deviceName;
if (opts.platformVersion) platformVersion = opts.platformVersion;
}
/**
* HTTP header values must be ASCII; Mac names usually aren't ("Elijah’s MacBook").
* Typographic punctuation becomes its plain form and accents are dropped.
*/
export function headerSafe(value: string): string {
return value
.replace(/[‘’]/g, "'")
.replace(/[“”]/g, '"')
.replace(/[–—]/g, '-')
.normalize('NFKD')
.replace(/[^\x20-\x7e]/g, '')
.trim();
}
export function plexHeaders(token?: string | null): Record<string, string> {
@ -57,9 +39,9 @@ export function plexHeaders(token?: string | null): Record<string, string> {
'X-Plex-Version': version,
'X-Plex-Client-Identifier': clientIdentifier(),
'X-Plex-Platform': PLATFORM,
'X-Plex-Platform-Version': platformVersion,
'X-Plex-Device': DEVICE,
'X-Plex-Device-Name': headerSafe(`Kaleido (${deviceName})`),
'X-Plex-Platform-Version': '11',
'X-Plex-Device': 'Windows',
'X-Plex-Device-Name': `Kaleido (${deviceName})`,
'X-Plex-Model': 'Desktop',
'X-Plex-Provides': 'player',
'X-Plex-Language': navigator.language || 'en',
@ -75,7 +57,7 @@ export function plexQuery(token?: string | null): Record<string, string> {
'X-Plex-Version': version,
'X-Plex-Client-Identifier': clientIdentifier(),
'X-Plex-Platform': PLATFORM,
'X-Plex-Device': DEVICE,
'X-Plex-Device': 'Windows',
'X-Plex-Device-Name': `Kaleido (${deviceName})`,
};
if (token) q['X-Plex-Token'] = token;

View file

@ -2,7 +2,6 @@ import { describe, expect, it } from 'vitest';
import { parseItem, parseScores } from './parse';
import { isLocalAddress } from './account';
import { partAt } from './playback';
import { headerSafe } from './client';
import { duration, formatBadges, isWatched, remaining, washGradient } from '../app/format';
import { buildFeatures } from '../screens/discover';
import type { Hub } from './types';
@ -113,10 +112,3 @@ describe('features', () => {
expect(washGradient(movie().ultraBlur)).toContain('rgba(48, 97, 143');
});
});
describe('headerSafe', () => {
it('turns Mac computer names into ASCII header values', () => {
expect(headerSafe('Elijah’s MacBook Pro')).toBe("Elijah's MacBook Pro");
expect(headerSafe('Zoë’s iMac — Studio')).toBe("Zoe's iMac - Studio");
});
});

View file

@ -174,7 +174,7 @@ export default function Downloads({ offline }: { offline?: boolean }) {
{!isNative && (
<div className="downloads-empty">
<EmptyState icon="download" title="Downloads need the desktop app">
Install the Kaleido desktop app to save movies and episodes for offline viewing.
Install Kaleido for Windows to save movies and episodes for offline viewing.
</EmptyState>
</div>
)}

View file

@ -1,12 +1,22 @@
import { isNative } from '../platform/native';
import { WindowControls } from '../app/TopBar';
import { isNative, win } from '../platform/native';
import { Icon } from '../ui/Icon';
/** A draggable strip with window controls for full-screen states without the top bar. */
export function WindowDrag() {
if (!isNative) return null;
return (
<div className="window-drag" data-tauri-drag-region>
<WindowControls />
<div className="window-controls">
<button aria-label="Minimize" onClick={() => win.minimize()}>
<Icon name="minimize" size={15} strokeWidth={1.4} />
</button>
<button aria-label="Maximize" onClick={() => win.toggleMaximize()}>
<Icon name="maximize" size={13} strokeWidth={1.4} />
</button>
<button aria-label="Close" className="close" onClick={() => win.close()}>
<Icon name="x" size={15} strokeWidth={1.4} />
</button>
</div>
</div>
);
}

View file

@ -5,7 +5,7 @@ import { useSections, useServerQuery } from '../../app/queries';
import * as api from '../../plex/api';
import { art } from '../../app/format';
import { useDownloads } from '../../downloads/store';
import { appInfo, fullscreenShortcut, isMac, isNative, openExternal, pickFolder, revealPath, shortcut, type AppInfo } from '../../platform/native';
import { appInfo, isNative, openExternal, pickFolder, revealPath, type AppInfo } from '../../platform/native';
import { checkForUpdate, installUpdate, useUpdater } from '../../app/updater';
import { Button, Segmented, Select, Switch } from '../../ui/primitives';
import { confirmDialog } from '../../ui/overlays';
@ -42,16 +42,14 @@ const skipOptions: { value: SkipMode; label: string }[] = [
{ value: 'off', label: 'Off' },
];
const OS_NAMES: Record<string, string> = { windows: 'Windows', macos: 'macOS', linux: 'Linux' };
const SHORTCUTS: [string, string][][] = [
[
[shortcut('K'), 'Search'],
[isMac ? '⌘[ / Mouse back' : 'Alt + ← / Mouse back', 'Go back'],
[isMac ? '⌘] / Mouse forward' : 'Alt + → / Mouse forward', 'Go forward'],
['Ctrl + K', 'Search'],
['Alt + ← / Mouse back', 'Go back'],
['Alt + → / Mouse forward', 'Go forward'],
['Esc', 'Go back or close a dialog'],
[fullscreenShortcut, 'Full screen'],
[shortcut(','), 'Settings'],
['F11', 'Full screen'],
['Ctrl + ,', 'Settings'],
['Right-click a title', 'Title actions'],
],
[
@ -184,7 +182,7 @@ export function AppSettings({ tab }: { tab: string }) {
<Pref label="Hardware decoding" description="Uses your graphics card to decode video. Turn off only if you see artifacts. Applies after restarting Kaleido.">
<Switch checked={s.hwdec} onChange={(v) => set('hwdec', v)} />
</Pref>
<Pref label="HDR passthrough" description={`Sends HDR video to HDR-capable displays${isMac ? '' : ' when Windows HDR is on'}. Applies after restarting Kaleido.`}>
<Pref label="HDR passthrough" description="Sends HDR video to HDR-capable displays when Windows HDR is on. Applies after restarting Kaleido.">
<Switch checked={s.hdrPassthrough} onChange={(v) => set('hdrPassthrough', v)} />
</Pref>
</SettingsSection>
@ -376,7 +374,7 @@ export function AppSettings({ tab }: { tab: string }) {
<div>
<h2>Kaleido</h2>
<p className="muted">
Version {info?.version ?? '—'} · {OS_NAMES[info?.platform ?? ''] ?? info?.platform}
Version {info?.version ?? '—'} · {info?.platform === 'windows' ? 'Windows' : info?.platform}
</p>
</div>
</div>

View file

@ -248,14 +248,6 @@
display: flex;
justify-content: flex-end;
}
/* macOS draws its traffic lights at the top left (tauri.macos.conf.json places
them in the bar's centre line); keep the bar's content clear of them. */
html.os-macos:not(.window-fullscreen) {
--traffic-lights: 92px;
}
html.os-macos:not(.window-fullscreen) .topbar {
padding-left: max(calc(var(--gutter) - 10px), var(--traffic-lights));
}
/* —— Splash ————————————————————————————————————————————————— */
.splash {

View file

@ -69,9 +69,6 @@
transition: opacity 400ms var(--ease);
}
/* The window's own buttons, top right, fading with the rest of the chrome. */
html.os-macos:not(.window-fullscreen) .player-top {
padding-left: var(--traffic-lights);
}
.player-top .window-controls {
position: absolute;
top: 0;

View file

@ -2,11 +2,14 @@
`latest.json` is the feed the in-app updater reads (see `plugins.updater.endpoints` in
`src-tauri/tauri.conf.json`). It lists one signed build per platform:
`windows-x86_64` and `darwin-aarch64`.
`windows-x86_64`, `darwin-aarch64`, `darwin-x86_64` and `linux-x86_64`.
Regenerate it once a release has every platform's build uploaded (see
`docs/development.md` → Releases); it reads the release's assets on Forgejo:
Regenerate it after building a release, pointing at the release's download folder:
```bash
node scripts/update-manifest.mjs 0.2.0
node scripts/update-manifest.mjs 0.2.0 https://git.elijahkuntz.com/Elijah/Kaleido-Desktop/releases/download/v0.2.0
```
Platforms built elsewhere can be merged in by listing their bundle folders in
`KALEIDO_BUNDLES` (separated by `;`). Existing platform entries are kept, so each OS
can publish independently.

View file

@ -6,7 +6,7 @@ folder, which is ignored by git and fetched by a script:
| OS | Folder | How to fetch |
| --- | --- | --- |
| Windows | `windows/libmpv-2.dll` | `scripts/fetch-libmpv.ps1` (shinchiro `mpv-dev-x86_64` build) |
| macOS | `macos/libmpv.2.dylib` and the libraries it links | `scripts/fetch-libmpv.sh` (Homebrew `mpv`, made self-contained) |
| macOS | `macos/libmpv.2.dylib` | `scripts/fetch-libmpv.sh` (Homebrew `mpv`) |
| Linux | system `libmpv.so.2` | Install your distribution's `libmpv2` package |
At runtime Kaleido looks in the app's resources, beside the executable, here, and