iOS 1.0.12: more space between seek bar and transport buttons

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

.gitignore

@@ -22,3 +22,4 @@ ios/build/
 ios/Stemify.xcodeproj/
 ios/Stemify/Info.plist
 ios/Stemify/Stemify.entitlements
+ios/prov

README.md

@@ -30,6 +30,12 @@ The stems folder mirrors the music folder. If a song lives at `Kansas/Leftovertu
   Plex Media Server :32400 ───────────────────────────────▶ library, artwork, playlists
 ```
 
+Three parts, and only stemd is required:
+
+- **stemd** is the daemon. It does the actual separating and nothing else.
+- **Stemify web UI** is optional, for desktop users. stemserve serves it at `/`. It plays the stems streamed from the server, and picks up a local stem server on `localhost:8765` by itself.
+- **iOS and Android apps** are optional and built from this repo too.
+
 - **stemd** works through the library on the GPU, one song at a time, and rescans every 30 minutes for new music.
 - **stemserve** serves the finished stems over HTTP with range requests, waveforms and optional Opus transcodes.
 - **Plex** handles the library, metadata, artwork and playlists.
@@ -132,6 +138,9 @@ To update, copy the new files, rebuild, `docker rm -f` the container and run it
 | `PORT` | `8765` | Listen port |
 | `TOKEN` | empty | If set, requests need `X-Stem-Token` or `?token=` |
 | `INDEX_TTL` | `30` | Seconds between rescans of the stems folder |
+| `PLEX_URL` | empty | Plex address. With `PLEX_TOKEN`, the web UI connects to Plex without signing in |
+| `PLEX_TOKEN` | empty | Plex token. Only handed out to clients that pass `TOKEN`, so set `TOKEN` too |
+| `WEB` | `1` | Set to `0` to turn off the web UI and serve the API only |
 
 </details>
 

ios/Stemify/UI/Screens/NowPlayingScreen.swift

@@ -173,6 +173,7 @@ struct NowPlayingScreen: View {
                 SideToggle(symbol: pm.repeatMode == .One ? "repeat.1" : "repeat", on: pm.repeatMode != .Off, action: pm.cycleRepeat)
             }
             .frame(height: 84)
+            .padding(.top, 14)
             HStack {
                 PanelToggle(symbol: "slider.vertical.3", on: panel == .Mixer) { show(.Mixer) }
                 SpeedMenu()

ios/project.yml

@@ -6,8 +6,8 @@ options:
 settings:
   base:
     SWIFT_VERSION: "5.0"
-    MARKETING_VERSION: "1.0.11"
-    CURRENT_PROJECT_VERSION: "12"
+    MARKETING_VERSION: "1.0.12"
+    CURRENT_PROJECT_VERSION: "13"
 targets:
   Stemify:
     type: application

ios/scripts/build-ipa.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
-# Builds an unsigned build/stemify-<version>.ipa on a Mac, for re-signing with Sideloadly/AltStore.
+# Builds build/stemify-<version>.ipa on a Mac: unsigned, for re-signing with Sideloadly/AltStore.
+# With prov/Stemify.mobileprovision, prov/key.p12 and P12_PASS set, it also writes a signed
+# prov/stemify-<version>-signed.ipa (keeps CarPlay/Siri) for the owner's own device.
 # Uses swiftc directly so it works even when xcodebuild/actool need -runFirstLaunch.
 set -euo pipefail
 cd "$(dirname "$0")/.."
@@ -34,5 +36,30 @@ SRC=Stemify/Resources/Assets.xcassets/AppIcon.appiconset/icon.png
 sips -z 120 120 $SRC --out $APP/AppIcon60x60@2x.png >/dev/null
 sips -z 180 180 $SRC --out $APP/AppIcon60x60@3x.png >/dev/null
 
+# Unsigned build, for the releases and AltStore/Sideloadly.
 (cd $OUT && zip -qry stemify-$VERSION.ipa Payload)
 echo "$OUT/stemify-$VERSION.ipa"
+
+if [ -f prov/Stemify.mobileprovision ] && [ -f prov/key.p12 ] && [ -n "${P12_PASS:-}" ]; then
+  KC=$PWD/$OUT/sign.keychain-db; KP=$(uuidgen)
+  security create-keychain -p "$KP" $KC
+  security set-keychain-settings -lut 3600 $KC
+  security unlock-keychain -p "$KP" $KC
+  security import prov/key.p12 -P "$P12_PASS" -A -t agg -f pkcs12 -k $KC >/dev/null
+  # The dev cert chains to Apple's WWDR G3 intermediate, which a fresh keychain doesn't have.
+  [ -f prov/wwdr.cer ] || curl -fsSL -o prov/wwdr.cer https://www.apple.com/certificateauthority/AppleWWDRCAG3.cer
+  security import prov/wwdr.cer -A -k $KC >/dev/null 2>&1 || true
+  security set-key-partition-list -S apple-tool:,apple: -s -k "$KP" $KC >/dev/null
+  security list-keychains -d user -s $KC $(security list-keychains -d user | tr -d '"')
+  ID=$(security find-identity -v -p codesigning $KC | sed -nE 's/.*"(Apple Development:.*)"/\1/p' | head -1)
+  security cms -D -i prov/Stemify.mobileprovision > $OUT/prov.plist
+  /usr/libexec/PlistBuddy -x -c 'Print :Entitlements' $OUT/prov.plist > $OUT/ent.plist
+  cp prov/Stemify.mobileprovision $APP/embedded.mobileprovision
+  codesign -f -s "$ID" --entitlements $OUT/ent.plist --timestamp=none $APP
+  security list-keychains -d user -s $(security list-keychains -d user | tr -d "\"" | grep -v sign.keychain)
+  security delete-keychain $KC
+  # Personal build for this device only: stays in prov/ (gitignored), never released.
+  (cd $OUT && zip -qry ../prov/stemify-$VERSION-signed.ipa Payload)
+  echo "prov/stemify-$VERSION-signed.ipa (signed as $ID)"
+fi
+

ios/source.json

@@ -15,6 +15,15 @@
       "tintColor": "#FA2D48",
       "category": "entertainment",
       "versions": [
+        {
+          "version": "1.0.11",
+          "buildVersion": "12",
+          "date": "2026-10-20T12:24:42-07:00",
+          "localizedDescription": "Tapping the lock screen / Control Center player opens the app again.",
+          "downloadURL": "https://git.iamchrisama.com/cdnutter/stemify/releases/download/ios-v1.0.11/stemify-1.0.11.ipa",
+          "size": 1529241,
+          "minOSVersion": "17.0"
+        },
         {
           "version": "1.0.10",
           "buildVersion": "11",

server/README.md

@@ -43,6 +43,9 @@ curl http://192.168.86.2:8765/api/info
 | `TOKEN`     | empty    | If set, requests need `X-Stem-Token` or `?token=`           |
 | `INDEX_TTL` | `30`     | Seconds between rescans of the stems folder                |
 | `QUEUE_DIR` | `/queue` | stemd's Stem Now folder (`stemd/state/queue` on unraid)    |
+| `PLEX_URL`  | empty    | Plex address; the web UI reaches it through `/plex/` on this server, so HTTPS pages work |
+| `PLEX_TOKEN`| empty    | Plex token for the web UI (set `TOKEN` too)                |
+| `WEB`       | `1`      | `0` turns off the web UI                                   |
 
 ## API
 

server/docker-compose.yml

@@ -14,3 +14,5 @@ services:
     environment:
       # Optional shared secret; set the same token in the app (Settings > Stem Server).
       - TOKEN=
+      - PLEX_URL=
+      - PLEX_TOKEN=

server/stemserve.py

@@ -16,6 +16,8 @@ Endpoints (all GET unless noted; add ?token=... or X-Stem-Token when TOKEN is se
   POST /api/prepare?key=<key>&fmt=opus&br=160 start transcodes in the background
   POST /api/stem  {"paths": [...]}           "Stem Now": stemd separates these Plex files next
   /file/<key>/<file>[?fmt=opus&br=160]       the stem itself, with Range support
+  /plex/...                                  proxy to PLEX_URL (needs TOKEN or the Plex token)
+  /api/config                                Plex URL and token from PLEX_URL / PLEX_TOKEN, if set
   /                                           the web player (web/, or WEB_DIR); no token needed
 
 <key> is the track's folder relative to STEMS_DIR, e.g. "Artist/Album/01 Song".
@@ -32,7 +34,9 @@ import subprocess
 import sys
 import threading
 import time
+import urllib.error
 import urllib.parse
+import urllib.request
 from array import array
 from concurrent.futures import ThreadPoolExecutor
 from http import HTTPStatus
@@ -44,6 +48,9 @@ PORT = int(os.environ.get("PORT", "8765"))
 TOKEN = os.environ.get("TOKEN", "")
 INDEX_TTL = float(os.environ.get("INDEX_TTL", "30"))
 QUEUE_DIR = os.environ.get("QUEUE_DIR", "/queue")  # stemd's request folder, shared with it
+PLEX_URL = os.environ.get("PLEX_URL", "").rstrip("/")
+PLEX_TOKEN = os.environ.get("PLEX_TOKEN", "")
+SERVE_WEB = os.environ.get("WEB", "1") != "0"  # WEB=0: API only, no web player
 MAX_BODY = 8 << 20
 MARKER = ".stemify.json"
 VERSION = 1
@@ -259,6 +266,31 @@ class Handler(BaseHTTPRequestHandler):
             return True
         return TOKEN in (self.headers.get("X-Stem-Token"), query.get("token", [None])[0])
 
+    def _plex_proxy(self, path, rawquery, query):
+        """Forward to PLEX_URL so an HTTPS page can reach an HTTP Plex. Needs the stem or Plex token."""
+        given = self.headers.get("X-Plex-Token") or query.get("X-Plex-Token", [None])[0]
+        if not (self._authorized(query) or (PLEX_TOKEN and given == PLEX_TOKEN)):
+            return self._error(HTTPStatus.UNAUTHORIZED, "bad token")
+        pairs = [(k, v) for k, v in urllib.parse.parse_qsl(rawquery, keep_blank_values=True) if k not in ("token", "X-Plex-Token")]
+        req = urllib.request.Request(PLEX_URL + path + ("?" + urllib.parse.urlencode(pairs) if pairs else ""))
+        req.add_header("X-Plex-Token", PLEX_TOKEN or given or "")
+        for h in ("Range", "Accept", "X-Plex-Client-Identifier", "X-Plex-Product", "If-None-Match"):
+            if self.headers.get(h):
+                req.add_header(h, self.headers[h])
+        try:
+            r = urllib.request.urlopen(req, timeout=30)
+        except urllib.error.HTTPError as e:
+            r = e
+        except OSError as e:
+            return self._error(502, f"plex unreachable: {e}")
+        self.send_response(r.status if hasattr(r, "status") else r.code)
+        for h in ("Content-Type", "Content-Length", "Content-Range", "Accept-Ranges", "ETag", "Cache-Control"):
+            if r.headers.get(h):
+                self.send_header(h, r.headers[h])
+        self.end_headers()
+        while chunk := r.read(65536):
+            self.wfile.write(chunk)
+
     def _send(self, status, body=b"", ctype="application/json", headers=None):
         self.send_response(status)
         self.send_header("Content-Type", ctype)
@@ -273,6 +305,8 @@ class Handler(BaseHTTPRequestHandler):
         self._send(status, json.dumps({"error": msg}).encode())
 
     def _web(self, path):
+        if not SERVE_WEB:
+            return self._error(404, "not found")
         if path == "/":
             path = "/index.html"
         full = os.path.realpath(os.path.join(WEB_DIR, path.lstrip("/")))
@@ -293,6 +327,8 @@ class Handler(BaseHTTPRequestHandler):
         url = urllib.parse.urlsplit(self.path)
         query = urllib.parse.parse_qs(url.query)
         path = urllib.parse.unquote(url.path)
+        if path.startswith("/plex/") and PLEX_URL:
+            return self._plex_proxy(path[len("/plex"):], url.query, query)
         if not path.startswith(("/api/", "/file/")):
             return self._web(path)
         if not self._authorized(query):
@@ -304,6 +340,9 @@ class Handler(BaseHTTPRequestHandler):
                     "name": "stemserve", "version": VERSION, "tracks": INDEX.count,
                     "ffmpeg": bool(FFMPEG), "opus": list(OPUS_RATES) if FFMPEG else [],
                     "stemNow": os.access(QUEUE_DIR, os.W_OK)}).encode())
+            if path == "/api/config":
+                plex = {"url": PLEX_URL, "token": PLEX_TOKEN} if PLEX_URL and PLEX_TOKEN else None
+                return self._send(200, json.dumps({"plex": plex}).encode(), headers={"Cache-Control": "no-store"})
             if path == "/api/index":
                 body, etag = INDEX.get()
                 if self.headers.get("If-None-Match") == etag:

web/app.js

@@ -60,7 +60,7 @@ const plexHeaders = token => ({
 
 async function px(path, params = {}) {
   if (!S.plex) throw new Error("Not signed in to Plex");
-  const u = new URL(S.plex.url + path);
+  const u = new URL(S.plex.url + path, location.href);
   for (const [k, v] of Object.entries(params)) u.searchParams.set(k, v);
   const r = await fetch(u, { headers: plexHeaders(S.plex.token) });
   if (!r.ok) throw new Error(`Plex ${r.status}`);
@@ -782,7 +782,7 @@ const routes = {
     if (S.plex) secs = ((await px("/library/sections").catch(() => ({}))).Directory || []).filter(d => d.type === "artist");
     view.innerHTML = `<h1>Settings</h1>
       <h2>Plex</h2><div class="form">
-        <p class="note">${S.plex ? `Connected to <b>${esc(S.plex.name || S.plex.url)}</b> at ${esc(S.plex.url)}` : "Not signed in."}</p>
+        <p class="note">${S.plex ? `Plex: <b>${esc(S.plex.env ? "via this server" : S.plex.name && S.plex.name !== S.plex.url ? S.plex.name + " (" + S.plex.url + ")" : S.plex.url)}</b>${S.plex.env ? " (set by the server)" : ""}` : "Not signed in."}</p>
         <div class="row"><button class="btn primary" id="signin">Sign in with Plex</button>${S.plex ? `<button class="btn" id="signout">Sign out</button>` : ""}<span class="note" id="sstatus"></span></div>
         ${secs.length > 1 ? `<label>Music library<select id="sec">${secs.map(d => `<option value="${d.key}" ${d.key == S.section ? "selected" : ""}>${esc(d.title)}</option>`).join("")}</select></label>` : ""}
         <details><summary class="note">Enter a server and token by hand</summary><div class="form" style="margin-top:12px">
@@ -835,10 +835,32 @@ $("#search").onsubmit = ev => {
   if (q) location.hash = "#/search/" + encodeURIComponent(q);
 };
 
+// Plex from the server's PLEX_URL / PLEX_TOKEN when nothing was signed in by hand, and a
+// local stemserve when this page's own server has none.
+async function autoConnect() {
+  const ok = await Stems.refresh();
+  if (!ok && !Stems.ok && !S.stemUrl && !/^(localhost|127\.0\.0\.1)$/.test(location.hostname)) {
+    for (const u of ["http://localhost:8765", "http://127.0.0.1:8765"]) {
+      try {
+        const r = await fetch(u + "/api/info" + stemQuery(), { signal: AbortSignal.timeout(1500) });
+        if (r.ok) { S.stemUrl = u; save(); await Stems.refresh(); break; }
+      } catch {}
+    }
+  }
+  if (!S.plex || S.plex.env) {
+    try {
+      const c = await fetch(stemBase() + "/api/config" + stemQuery()).then(r => r.ok ? r.json() : null);
+      if (c?.plex) S.plex = { token: c.plex.token, url: stemBase() + "/plex", name: "", env: true };
+      else if (S.plex?.env) S.plex = null;
+      save();
+    } catch {}
+  }
+}
+
 // ---- start -----------------------------------------------------------------------------
 
 (async () => {
-  await Promise.race([Stems.refresh(), new Promise(r => setTimeout(r, 4000))]);
+  await Promise.race([autoConnect(), new Promise(r => setTimeout(r, 4000))]);
   const saved = load(KEY + "-queue");
   if (saved?.items?.length) {
     Q.items = saved.items; Q.orig = saved.orig; Q.i = Math.min(saved.i, saved.items.length - 1);