Compare commits

..
3 Commits
Author SHA1 Message Date
Aleksandr Bogomiakov 939fc00e4c Reworked new users login, improved share feature, enabled track downloads
Build and Publish / Build and Publish Docker Image (push) Failing after 4m21s
2026-11-18 14:40:16 +00:00
Aleksandr Bogomiakov 2b7117a4f6 Fixed metadata AI assistant
Build and Publish / Build and Publish Docker Image (push) Successful in 4m28s
2026-11-16 01:10:59 +00:00
Aleksandr Bogomiakov 3d886d1acd Improved metadata AI Assistant.
Build and Publish / Build and Publish Docker Image (push) Successful in 5m54s
2026-11-16 00:32:33 +00:00
29 changed files with 2294 additions and 1221 deletions

No files matched your search

+1
View File
@@ -48,4 +48,5 @@ jobs:
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.docker_tags }}
cache-from: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache
# Export intermediate stages, including cargo-chef's compiled dependencies.
cache-to: type=registry,ref=${{ env.IMAGE_NAME }}:buildcache,mode=max
Generated
+1 -1
View File
@@ -1988,7 +1988,7 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "furumusic"
version = "0.12.2"
version = "0.12.3"
dependencies = [
"anyhow",
"async-stream",
+1 -1
View File
@@ -1,6 +1,6 @@
[package]
name = "furumusic"
version = "0.12.2"
version = "0.12.4"
edition = "2024"
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
+16 -3
View File
@@ -1,18 +1,31 @@
FROM rust:1-bookworm AS builder
FROM rust:1.97.0-bookworm AS chef
RUN apt-get update \
&& apt-get install -y --no-install-recommends pkg-config libssl-dev ca-certificates \
&& rm -rf /var/lib/apt/lists/*
RUN cargo install cargo-chef --version 0.1.74 --locked
WORKDIR /app
COPY Cargo.toml Cargo.lock* ./
FROM chef AS planner
COPY Cargo.toml Cargo.lock ./
COPY build.rs ./build.rs
COPY src ./src
RUN cargo chef prepare --recipe-path recipe.json
FROM chef AS builder
COPY --from=planner /app/recipe.json ./recipe.json
# Keep compiled dependencies in an ordinary layer exported by CI's registry cache.
RUN cargo chef cook --release --locked --recipe-path recipe.json
COPY Cargo.toml Cargo.lock ./
COPY build.rs ./build.rs
COPY prompts ./prompts
COPY src ./src
COPY templates ./templates
RUN cargo build --release
RUN cargo build --release --locked --bin furumusic
FROM denoland/deno:bin-2.8.3 AS deno
+85 -1
View File
@@ -23,7 +23,8 @@ catalog and media files; the browser is only the player.
- a responsive web player with artists, releases, search, queue, and playlists;
- direct file uploads and imports from YouTube, torrent files, or magnet links;
- optional AI-assisted recognition and normalization of metadata;
- password login or OIDC/SSO with group-based access control;
- password login or OIDC/SSO with group grants and local administrator approval;
- public track, release, and queue links with scoped guest playback and downloads;
- optional federation without a central catalog or search service;
- trusted-device pairing, playback handoff, and synchronization between Furumi
players;
@@ -32,6 +33,46 @@ catalog and media files; the browser is only the player.
Furumusic does not include music. Import only media you are allowed to store and
share.
## Access and public sharing
OIDC identifies accounts by issuer and subject. Matching admin groups take
precedence over matching user groups, and either SSO grant takes precedence over
a local role. Without matching groups (including an empty group configuration),
a new account waits for approval in **Admin → Users**. Any instance administrator
can approve it as a user or administrator. The waiting page updates automatically.
On subsequent SSO logins the group grant is refreshed: if it disappears, only an
independently assigned local role preserves access. Existing password accounts
keep their local roles; existing OIDC-only accounts retain their last SSO grant
until the next login, without receiving an implicit local approval.
Sharing creates an unguessable `/share/{token}` link to a snapshot of track IDs,
including their order and repetitions. Guests and accounts awaiting approval can
play and download only the tracks in that snapshot, using the regular player.
They cannot browse the library, search, use recommendations, or write personal
history. Signing in from a share returns to that share; signing in from the root
shows only the approval page until access is granted. Track info offers a browser
download of the original audio file. The old radio implementation is removed.
Migration `m_0053_local_approval_and_public_shares` deletes the old share records.
Old track/release/playlist URL routes are removed, with no compatibility layer.
Link expiry, cleanup, and revocation are not part of this implementation.
The access regression suite uses a disposable migrated database and a local OIDC
provider with signed tokens and PKCE:
```bash
node --test tests/*.test.cjs
FURU_ACCESS_TEST_DATABASE_URL=postgresql://... cargo test postgres_approval_survives_sso_changes_without_implicit_grants -- --ignored
# Fresh disposable instance on :18048, media root /tmp/furumi-access-media,
# PostgreSQL container furumi-access-test-pg, database furumi_access_test:
node tests/browser-access-sharing.cjs
```
The browser test requires Playwright (`PLAYWRIGHT_MODULE`) and Chrome
(`CHROME_PATH`), and uses local port 18049 for its OIDC provider. It checks
approval, SSO precedence and group removal, guest playback and downloads,
unauthorized track substitution, and desktop/mobile player behavior.
## Importing music
Users can add audio files from the web interface or ask the server to download
@@ -96,6 +137,13 @@ The repository also contains a multi-stage `Dockerfile` for building a small
runtime image. A deployment must provide PostgreSQL plus persistent, writable
volumes for the inbox and music library.
CI uses Rust 1.97.0 and cargo-chef 0.1.74 to cache compiled dependencies separately
from application sources. Buildx imports and exports intermediate layers through
`ultradesu/furumusic:buildcache` (`mode=max`). After the first build, changes to
source code, templates or prompts reuse the dependency layer when its recipe and
toolchain are unchanged. Both dependency and application builds use `--locked`.
Update the pinned build tools in `Dockerfile`; changing them rebuilds the cache.
## Admin statistics
The only admin interface is `/admin/v2`, also reachable from `/admin/`.
@@ -132,6 +180,42 @@ container `furumi-statistics-test-pg`. It requires Playwright (or
`PLAYWRIGHT_MODULE`) and Chrome (or `CHROME_PATH`). Never point this test at a
live service.
## Metadata Repair
Admin → Library Tools provides a chat for editing the selected library resources.
Use **Show related**, then **Deselect all** to choose only the resources needed
for the task. Selecting a release includes its tracks; individual tracks can
then be unchecked to exclude them. Unselected artists remain read-only context
and their IDs can still be used in credits. Releases show their years; tracks
show their source release.
The assistant sees the complete selected scope and replaces the proposed plan
after every clarification. Expand **Proposed changes** in the chat to review or
edit it before applying. Plans support moving tracks, creating releases, merging
releases, and deleting artists, releases, or tracks. Release deletion requires
explicit moves or deletion of all its tracks. Artist deletion detaches credits
and requires all credited releases and tracks to be included.
Applied plans are transactional and can be undone from History. Metadata Repair
retains audio and artwork files for Undo. Undo refuses to overwrite subsequent
metadata, playback, or federation changes.
```bash
node --test tests/admin_metadata_repair.test.cjs
cargo test admin::metadata_fix::tests
```
`tests/browser-metadata-repair.cjs` checks the chat and plan updates, a four-release
merge, deletion and restoration of tracks and artist credits, playlists, playback
queues, and undo conflicts. Run it only against a disposable instance and a
PostgreSQL container named `furumi-repair-test-pg`, with database
`furumi_repair_test`. Set `FURU_TEST_URL`, `FURU_REPAIR_TEST_PG`, `CHROME_PATH`, and
`PLAYWRIGHT_MODULE` as needed. It seeds `tests/metadata_repair_fixture.sql` after
creating the test administrator. Set `FURU_REPAIR_SKIP_SEED=1` for a seeded database.
With `FURU_REPAIR_TEST_MODEL=1`, it additionally checks the reported release-only
selection and full ordered tracklist against the configured model, applies and
undoes that plan, and verifies individual track exclusions.
## Importing into playlists
The player's download manager offers **Add downloads to a playlist** for file
+18 -6
View File
@@ -28,7 +28,18 @@ pub(super) async fn manage_user(
Ok(u) => u,
Err(r) => return Ok(r),
};
if body.action == "delete" {
if body.action == "approve" {
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
if Role::from_code(&body.role).is_none() || (id == admin.id && body.role != "admin") {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid role"));
}
let Some(mut user) = User::get_by_id(&db, id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "User not found"));
};
user.approve(&db, &body.role, admin.id).await?;
} else if body.action == "delete" {
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
@@ -43,7 +54,8 @@ pub(super) async fn manage_user(
if !["create", "update"].contains(&body.action.as_str())
|| body.username.trim().is_empty()
|| body.username.chars().count() > 255
|| Role::from_code(&body.role).is_none()
|| (Role::from_code(&body.role).is_none()
&& !(body.action == "update" && body.role.is_empty()))
|| (body.action == "create" && body.password.is_empty())
{
return Ok(json_error(
@@ -74,15 +86,15 @@ pub(super) async fn manage_user(
let Some(id) = body.id.filter(|id| *id > 0) else {
return Ok(json_error(StatusCode::BAD_REQUEST, "Invalid user"));
};
if id == admin.id && body.role != "admin" {
let Some(mut user) = User::get_by_id(&db, id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "User not found"));
};
if id == admin.id && body.role != "admin" && !user.has_sso_admin_role() {
return Ok(json_error(
StatusCode::BAD_REQUEST,
"You cannot remove your own administrator role",
));
}
let Some(mut user) = User::get_by_id(&db, id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "User not found"));
};
if User::get_by_username(&db, body.username.trim())
.await?
.is_some_and(|u| u.id_val() != id)
+713 -182
View File
File diff suppressed because it is too large. Load diff
+9 -3
View File
@@ -230,6 +230,8 @@ struct AdminUserRowDto {
email: Option<String>,
role: String,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
is_online: bool,
last_seen_ms: Option<i64>,
plays: i64,
@@ -2667,6 +2669,8 @@ struct AdminUserSqlRow {
email: Option<String>,
role: String,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
plays: i64,
listened_seconds: i64,
last_play_ms: Option<i64>,
@@ -2700,7 +2704,7 @@ async fn load_admin_users_page(
let total: i64 = count_qb.build_query_scalar().fetch_one(pool).await?;
let mut qb = QueryBuilder::<Postgres>::new(
"SELECT id, username::text, display_name, email, role::text, is_active, \
"SELECT id, username::text, display_name, email, role::text, is_active, local_role, sso_role, \
(SELECT COUNT(*) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS plays, \
(SELECT (COALESCE(SUM(listened_ms), 0) / 1000)::bigint FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id) AS listened_seconds, \
(SELECT MAX(started_at_ms) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS last_play_ms \
@@ -2715,7 +2719,7 @@ async fn load_admin_users_page(
qb.push_bind(pattern);
qb.push(")");
}
qb.push(" ORDER BY username ASC LIMIT ");
qb.push(" ORDER BY is_active ASC, username ASC LIMIT ");
qb.push_bind(limit);
qb.push(" OFFSET ");
qb.push_bind(offset);
@@ -2747,7 +2751,7 @@ async fn load_admin_user_detail(
user_id: i64,
) -> anyhow::Result<Option<AdminUserDetailDto>> {
let row = sqlx::query_as::<_, AdminUserSqlRow>(
"SELECT id, username::text, display_name, email, role::text, is_active, \
"SELECT id, username::text, display_name, email, role::text, is_active, local_role, sso_role, \
(SELECT COUNT(*) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS plays, \
(SELECT (COALESCE(SUM(listened_ms), 0) / 1000)::bigint FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id) AS listened_seconds, \
(SELECT MAX(started_at_ms) FROM furumusic__listen_event le WHERE le.user_id = furumusic__user.id AND qualified) AS last_play_ms \
@@ -2939,6 +2943,8 @@ fn admin_user_row(
email: row.email,
role: row.role,
is_active: row.is_active,
local_role: row.local_role,
sso_role: row.sso_role,
plays: row.plays,
listened_seconds: row.listened_seconds,
last_play_ms: row.last_play_ms,
+7 -2
View File
@@ -72,8 +72,13 @@ fn authenticated_user_from_user(user: User) -> Option<AuthenticatedUser> {
})
}
/// Read `user_id` from the session, fetch the `User` from DB, return
/// `AuthenticatedUser` if the user exists and is active.
/// Return the signed-in identity, including an account awaiting approval.
pub async fn get_session_identity(session: &Session, db: &Database) -> Option<User> {
let user_id: i64 = session.get(SESSION_USER_ID).await.ok()??;
User::get_by_id(db, user_id).await.ok()?
}
/// Return a session user only when access to the instance has been granted.
pub async fn get_session_user(session: &Session, db: &Database) -> Option<AuthenticatedUser> {
let user_id: i64 = session.get(SESSION_USER_ID).await.ok()??;
let user = User::get_by_id(db, user_id).await.ok()??;
+7 -3
View File
@@ -1,6 +1,12 @@
use super::translations;
translations! {
approval_heading: "Awaiting approval", "Ожидается одобрение";
approval_message: "You are signed in. An instance administrator must approve your account before you can access the library.", "Вы вошли в аккаунт. Для доступа к библиотеке нужно одобрение администратора инстанса.";
guest_login: "Sign in / register", "Войти / зарегистрироваться";
guest_label: "Shared music", "Музыка по ссылке";
share_unavailable: "This link is unavailable or contains no playable tracks.", "Ссылка недоступна или не содержит доступных треков.";
track_download: "Download", "Скачать";
// Global
site_name: "furumusic" , "furumusic";
@@ -71,7 +77,7 @@ translations! {
settings_oidc_admin_groups: "Admin groups" , "Группы администраторов";
settings_oidc_admin_groups_help: "Comma-separated OIDC group names that grant admin role (e.g. /admin,/furumusic-admins)" , "OIDC группы через запятую, дающие роль администратора (напр. /admin,/furumusic-admins)";
settings_oidc_user_groups: "User groups" , "Группы пользователей";
settings_oidc_user_groups_help: "Comma-separated OIDC group names allowed to access the service. If empty, any authenticated SSO user is allowed." , "OIDC группы через запятую, которым разрешён доступ к сервису. Если пусто, разрешён любой SSO пользователь.";
settings_oidc_user_groups_help: "Comma-separated OIDC groups granting automatic user access. Everyone else needs local administrator approval." , "OIDC группы через запятую, дающие автоматический доступ. Остальным нужно локальное одобрение администратора.";
// User management
nav_users: "Users" , "Пользователи";
@@ -360,8 +366,6 @@ translations! {
player_play: "Play" , "Играть";
player_listen: "Listen" , "Слушать";
player_listen_artist: "Listen to artist" , "Слушать артиста";
player_start_radio: "Start radio" , "Запустить радио";
player_radio_failed: "Could not start radio" , "Не удалось запустить радио";
player_played_at: "Played" , "Прослушано";
player_like: "Like" , "Лайк";
player_add_to_queue: "Add to queue" , "Добавить в очередь";
+82 -108
View File
@@ -70,59 +70,64 @@ fn build_registry() -> Arc<JobRegistry> {
// Handlers
// ---------------------------------------------------------------------------
#[derive(Deserialize)]
struct IndexQuery {
track: Option<i64>,
release: Option<i64>,
playlist_share: Option<String>,
async fn index(session: Session, db: Database, i18n: I18n) -> cot::Result<cot::response::Response> {
render_player(session, db, i18n, String::new()).await
}
async fn index(
async fn render_player(
session: Session,
db: Database,
i18n: I18n,
UrlQuery(query): UrlQuery<IndexQuery>,
share_token: String,
) -> cot::Result<cot::response::Response> {
let _user = match auth::get_session_user(&session, &db).await {
Some(u) => u,
None => {
if let Some(location) = share_query_redirect(&query) {
auth::remember_post_login_redirect(&session, &location).await?;
}
return Ok(auth::redirect("/login"));
let guest = auth::get_session_user(&session, &db).await.is_none();
if guest && share_token.is_empty() {
if auth::get_session_identity(&session, &db).await.is_some() {
return Html::new(PendingTemplate { t: i18n.t }.render()?).into_response();
}
};
return Ok(auth::redirect("/login"));
}
let (config, _) = AppConfig::load_with_db(&db).await;
let template = player::PlayerPageTemplate {
t: i18n.t,
downloads_enabled: config.downloads_enabled,
torrent_downloads_enabled: config.downloads_enabled && config.torrent_downloads_enabled,
youtube_downloads_enabled: config.downloads_enabled && config.youtube_downloads_enabled,
};
Html::new(template.render()?).into_response()
Html::new(
player::PlayerPageTemplate {
t: i18n.t,
guest,
share_token,
downloads_enabled: !guest && config.downloads_enabled,
torrent_downloads_enabled: !guest
&& config.downloads_enabled
&& config.torrent_downloads_enabled,
youtube_downloads_enabled: !guest
&& config.downloads_enabled
&& config.youtube_downloads_enabled,
}
.render()?,
)
.into_response()
}
fn share_query_redirect(query: &IndexQuery) -> Option<String> {
if let Some(track_id) = query.track.filter(|id| *id > 0) {
return Some(format!("/?track={track_id}"));
}
if let Some(release_id) = query.release.filter(|id| *id > 0) {
return Some(format!("/?release={release_id}"));
}
let token = query.playlist_share.as_deref()?.trim();
if is_share_token(token) {
Some(format!("/?playlist_share={token}"))
} else {
None
}
#[derive(Debug, Template)]
#[template(path = "pending.html")]
struct PendingTemplate {
t: &'static Translations,
}
async fn access_status(session: Session, db: Database) -> cot::Result<cot::response::Response> {
let identity = auth::get_session_identity(&session, &db).await;
let status = match identity {
Some(user) if user.is_active() => "active",
Some(_) => "pending",
None => "anonymous",
};
let mut response = cot::json::Json(serde_json::json!({"status": status})).into_response()?;
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
fn is_share_token(token: &str) -> bool {
!token.is_empty()
&& token.len() <= 64
&& token
.bytes()
.all(|b| b.is_ascii_alphanumeric() || matches!(b, b'-' | b'_'))
token.len() == 32 && token.bytes().all(|b| b.is_ascii_hexdigit())
}
#[derive(Deserialize)]
@@ -187,11 +192,7 @@ struct LoginForm {
#[derive(Deserialize)]
struct LoginQuery {
error: Option<String>,
}
#[derive(Deserialize)]
struct SharePathId {
id: i64,
next: Option<String>,
}
#[derive(Deserialize)]
@@ -236,56 +237,26 @@ async fn metrics_handler(
.expect("valid response"))
}
async fn share_track_handler(
session: Session,
db: Database,
Path(path): Path<SharePathId>,
) -> cot::Result<cot::response::Response> {
let location = if path.id > 0 {
format!("/?track={}", path.id)
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
}
Ok(auth::redirect(&location))
}
async fn share_release_handler(
session: Session,
db: Database,
Path(path): Path<SharePathId>,
) -> cot::Result<cot::response::Response> {
let location = if path.id > 0 {
format!("/?release={}", path.id)
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
}
Ok(auth::redirect(&location))
}
async fn share_playlist_handler(
async fn share_handler(
session: Session,
db: Database,
i18n: I18n,
Path(path): Path<SharePathToken>,
) -> cot::Result<cot::response::Response> {
let token = path.token.trim();
let location = if is_share_token(token) {
format!("/?playlist_share={token}")
} else {
"/".to_string()
};
if auth::get_session_user(&session, &db).await.is_none() {
auth::remember_post_login_redirect(&session, &location).await?;
return Ok(auth::redirect("/login"));
if !is_share_token(&path.token) {
return Ok(cot::http::Response::builder()
.status(cot::http::StatusCode::NOT_FOUND)
.body(Body::fixed("Shared music not found"))
.expect("valid response"));
}
Ok(auth::redirect(&location))
let mut response = render_player(session, db, i18n, path.token).await?;
response
.headers_mut()
.insert("Referrer-Policy", "no-referrer".parse().unwrap());
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
// ---------------------------------------------------------------------------
@@ -316,26 +287,13 @@ impl App for FuruApp {
),
Route::with_handler_and_name(
"/",
|session: Session, db: Database, i18n: I18n, query: UrlQuery<IndexQuery>| async move {
index(session, db, i18n, query).await
|session: Session, db: Database, i18n: I18n| async move {
index(session, db, i18n).await
},
"index",
),
Route::with_handler_and_name(
"/share/track/{id}",
get(share_track_handler),
"share_track",
),
Route::with_handler_and_name(
"/share/release/{id}",
get(share_release_handler),
"share_release",
),
Route::with_handler_and_name(
"/share/playlist/{token}",
get(share_playlist_handler),
"share_playlist",
),
Route::with_handler_and_name("/share/{token}", get(share_handler), "share"),
Route::with_handler_and_name("/auth/status", get(access_status), "access_status"),
Route::with_handler_and_name(
"/metrics",
get({
@@ -353,13 +311,29 @@ impl App for FuruApp {
"/login",
get({
let config = Arc::clone(&self.config);
move |i18n: I18n, db: Database, query: UrlQuery<LoginQuery>| {
move |i18n: I18n,
db: Database,
session: Session,
query: UrlQuery<LoginQuery>| {
let config = Arc::clone(&config);
async move {
// No users at all → redirect to first-run setup
if User::count_all(&db).await.unwrap_or(0) == 0 {
return Ok(auth::redirect("/admin/setup"));
}
if let Some(next) = query.0.next.as_deref() {
if next.strip_prefix("/share/").is_some_and(is_share_token) {
auth::remember_post_login_redirect(&session, next).await?;
}
} else {
auth::clear_post_login_redirect(&session).await?;
}
if auth::get_session_identity(&session, &db).await.is_some() {
let destination = auth::get_post_login_redirect(&session)
.await?
.unwrap_or_else(|| "/".into());
return Ok(auth::redirect(&destination));
}
let message = query.0.error.unwrap_or_default();
login_page_handler(i18n, &config, db, message)
.await?
+9 -12
View File
@@ -808,9 +808,8 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/admin",
"/swagger",
"/swagger/openapi.json",
"/share/track/{id}",
"/share/release/{id}",
"/share/playlist/{token}",
"/share/{token}",
"/auth/status",
"/metrics",
"/login",
"/logout",
@@ -880,10 +879,11 @@ const KNOWN_HTTP_ROUTES: &[&str] = &[
"/api/player/artists",
"/api/player/artists/{id}",
"/api/player/releases/{id}",
"/api/player/radio/{kind}/{id}",
"/api/player/playlists",
"/api/player/share-playlist",
"/api/player/share-playlist/{id}",
"/api/player/shares",
"/api/player/shares/{id}",
"/api/player/shares/{token}/{action}/{track_id}",
"/api/player/download/{track_id}",
"/api/player/playlists/{id}",
"/api/player/playlists/{id}/tracks",
"/api/player/likes",
@@ -928,13 +928,10 @@ mod tests {
known_http_route("/admin/v2/api/jobs/metadata_backfill/runs/123"),
Some("/admin/v2/api/jobs/{name}/runs/{run_id}")
);
assert_eq!(known_http_route("/share/abcDEF123"), Some("/share/{token}"));
assert_eq!(
known_http_route("/share/playlist/abcDEF123"),
Some("/share/playlist/{token}")
);
assert_eq!(
known_http_route("/share/release/42"),
Some("/share/release/{id}")
known_http_route("/api/player/shares/abcDEF123/stream/42"),
Some("/api/player/shares/{token}/{action}/{track_id}")
);
assert_eq!(
known_http_route("/api/player/youtube/start"),
+135 -84
View File
@@ -418,16 +418,6 @@ pub async fn oidc_callback_handler(
config.oidc_user_groups,
);
if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
tracing::warn!(
"OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
config.oidc_user_groups,
config.oidc_admin_groups,
);
crate::metrics::record_auth_attempt("oidc", "failure", "not_in_group");
return redirect_login_with_error(i18n.t.login_access_denied);
}
// User provisioning logic.
let user = match provision_user(
&db,
@@ -437,6 +427,7 @@ pub async fn oidc_callback_handler(
name.as_deref(),
&groups,
&config.oidc_admin_groups,
&config.oidc_user_groups,
)
.await
{
@@ -728,17 +719,6 @@ pub async fn oidc_mobile_callback_handler(
.map(|n| n.to_string());
let groups = extract_groups_from_jwt(&id_token.to_string());
if !is_allowed_by_groups(&groups, &config.oidc_user_groups, &config.oidc_admin_groups) {
tracing::warn!(
"Mobile OIDC login denied by group allowlist: sub={sub}, groups={groups:?}, user_groups={:?}, admin_groups={:?}",
config.oidc_user_groups,
config.oidc_admin_groups,
);
crate::metrics::record_auth_attempt("mobile_oidc", "failure", "not_in_group");
clear_mobile_oidc_session(&session).await?;
return Ok(mobile_redirect_error(&app_redirect_uri, "access_denied"));
}
let user = match provision_user(
&db,
&issuer,
@@ -747,6 +727,7 @@ pub async fn oidc_mobile_callback_handler(
name.as_deref(),
&groups,
&config.oidc_admin_groups,
&config.oidc_user_groups,
)
.await
{
@@ -759,6 +740,11 @@ pub async fn oidc_mobile_callback_handler(
}
};
if !user.is_active() {
clear_mobile_oidc_session(&session).await?;
return Ok(mobile_redirect_error(&app_redirect_uri, "approval_pending"));
}
let exchange_code = auth::create_mobile_exchange_code(&db, user.id_val())
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
@@ -773,48 +759,26 @@ pub async fn oidc_mobile_callback_handler(
// User provisioning
// ---------------------------------------------------------------------------
/// Resolve the role based on OIDC group membership.
/// If `admin_groups` is non-empty and any user group matches, return "admin";
/// otherwise return "user".
fn resolve_role(groups: &[String], admin_groups: &str) -> &'static str {
if admin_groups.is_empty() {
return auth::Role::User.code();
/// Group-derived access always takes precedence over local approval.
fn resolve_sso_role(
groups: &[String],
admin_groups: &str,
user_groups: &str,
) -> Option<&'static str> {
let matches = |configured: &str| {
configured
.split(',')
.map(str::trim)
.filter(|group| !group.is_empty())
.any(|group| groups.iter().any(|g| g == group))
};
if matches(admin_groups) {
Some("admin")
} else if matches(user_groups) {
Some("user")
} else {
None
}
let admin_set: std::collections::HashSet<&str> = admin_groups
.split(',')
.map(|s| s.trim())
.filter(|s| !s.is_empty())
.collect();
if admin_set.is_empty() {
return auth::Role::User.code();
}
for g in groups {
if admin_set.contains(g.as_str()) {
return auth::Role::Admin.code();
}
}
auth::Role::User.code()
}
fn parse_group_set(groups: &str) -> std::collections::HashSet<&str> {
groups
.split(',')
.map(str::trim)
.filter(|s| !s.is_empty())
.collect()
}
fn has_any_group(groups: &[String], allowed: &std::collections::HashSet<&str>) -> bool {
groups.iter().any(|g| allowed.contains(g.as_str()))
}
fn is_allowed_by_groups(groups: &[String], user_groups: &str, admin_groups: &str) -> bool {
let user_set = parse_group_set(user_groups);
if user_set.is_empty() {
return true;
}
let admin_set = parse_group_set(admin_groups);
has_any_group(groups, &user_set) || has_any_group(groups, &admin_set)
}
async fn provision_user(
@@ -825,8 +789,9 @@ async fn provision_user(
name: Option<&str>,
groups: &[String],
admin_groups: &str,
user_groups: &str,
) -> Result<User, String> {
let role = resolve_role(groups, admin_groups);
let role = resolve_sso_role(groups, admin_groups, user_groups);
// 1. Check for existing OIDC link.
if let Some(mut link) = OidcLink::find_by_issuer_sub(db, issuer, sub)
@@ -841,8 +806,8 @@ async fn provision_user(
.await
.map_err(|e| format!("DB error updating OIDC link: {e}"))?;
// Always update role on login.
user.update_role(db, role)
// Refresh only the SSO grant; preserve independent local approval.
user.sync_sso_role(db, role)
.await
.map_err(|e| format!("DB error updating user role: {e}"))?;
@@ -863,25 +828,6 @@ async fn provision_user(
}
}
// 2. No existing link — try to find a user by email.
if let Some(email_str) = email {
if let Some(mut user) = User::get_by_email(db, email_str)
.await
.map_err(|e| format!("DB error finding user by email: {e}"))?
{
// Create OIDC link for existing user.
OidcLink::create_link(db, user.id_val(), issuer, sub, email, name)
.await
.map_err(|e| format!("DB error creating OIDC link: {e}"))?;
user.update_role(db, role)
.await
.map_err(|e| format!("DB error updating user role: {e}"))?;
return Ok(user);
}
}
// 3. Create a brand-new user + OIDC link.
// Generate a unique username from the sub or email.
let username = if let Some(email_str) = email {
@@ -1300,3 +1246,108 @@ mod tests {
assert!(safe_mobile_redirect_uri(Some("http://127.0.0.1:notaport/x")).is_none());
}
}
#[cfg(test)]
mod approval_tests {
use super::*;
#[test]
fn matching_groups_are_required_and_admin_wins() {
let groups = vec!["listeners".into(), "admins".into()];
assert_eq!(
resolve_sso_role(&groups, " admins ", "listeners"),
Some("admin")
);
assert_eq!(
resolve_sso_role(&groups, "other", "listeners"),
Some("user")
);
assert_eq!(resolve_sso_role(&groups, "other", ""), None);
assert_eq!(resolve_sso_role(&[], "", ""), None);
}
#[tokio::test]
#[ignore = "requires a migrated disposable database in FURU_ACCESS_TEST_DATABASE_URL"]
async fn postgres_approval_survives_sso_changes_without_implicit_grants() {
let db = Database::new(std::env::var("FURU_ACCESS_TEST_DATABASE_URL").unwrap())
.await
.unwrap();
let subject = format!("approval-test-{}", uuid::Uuid::new_v4());
let provision = |groups: Vec<String>| {
let db = &db;
let subject = &subject;
async move {
provision_user(
db,
"https://test.example",
subject,
None,
Some("Test pending user"),
&groups,
"admins",
"listeners",
)
.await
.unwrap()
}
};
let first = provision(vec![]).await;
assert!(!first.is_active());
let mut again = provision(vec![]).await;
assert_eq!(again.id_val(), first.id_val());
again.approve(&db, "admin", 1).await.unwrap();
assert_eq!(provision(vec![]).await.role(), auth::Role::Admin);
assert_eq!(
provision(vec!["listeners".into()]).await.role(),
auth::Role::User
);
assert_eq!(
provision(vec!["admins".into()]).await.role(),
auth::Role::Admin
);
assert_eq!(provision(vec![]).await.role(), auth::Role::Admin);
let auto_sub = format!("auto-{subject}");
let automatic = provision_user(
&db,
"https://test.example",
&auto_sub,
None,
None,
&["listeners".into()],
"admins",
"listeners",
)
.await
.unwrap();
assert!(automatic.is_active());
let removed = provision_user(
&db,
"https://test.example",
&auto_sub,
None,
None,
&[],
"admins",
"listeners",
)
.await
.unwrap();
assert!(!removed.is_active());
assert_eq!(automatic.id_val(), removed.id_val());
// A stale User held by an OIDC callback must retain a newer local grant.
let mut stale = removed.clone();
let mut approving = removed.clone();
approving.approve(&db, "admin", 1).await.unwrap();
stale.sync_sso_role(&db, Some("user")).await.unwrap();
stale.sync_sso_role(&db, None).await.unwrap();
assert!(stale.is_active());
assert_eq!(stale.role(), auth::Role::Admin);
let username = stale.username_str().to_owned();
stale
.update_fields(&db, &username, None, Some("Renamed"), None, "")
.await
.unwrap();
assert!(!stale.is_active());
}
}
+1 -1
View File
@@ -324,7 +324,7 @@ pub(super) struct ShareLinkResponse {
}
#[derive(Debug, Serialize, JsonSchema)]
pub(super) struct PlaylistShareDetail {
pub(super) struct ShareDetail {
pub(super) token: String,
pub(super) title: String,
pub(super) tracks: Vec<TrackItem>,
+133 -565
View File
@@ -30,6 +30,7 @@ mod dto;
mod helpers;
mod queries;
mod rows;
mod sharing;
use dto::*;
use helpers::{cover_variant_url, load_release_uploaders, track_cover_variant_url};
@@ -114,9 +115,6 @@ const PLAYER_DEVICE_COMMAND_TTL_MS: i64 = 20_000;
const PLAYER_DEVICE_MAX_COMMANDS: usize = 32;
const PLAYER_JAM_IDLE_TTL_MS: i64 = 4 * 60 * 60 * 1000;
const PLAYER_JAM_MAX_INVITEES: usize = 25;
const PLAYER_RADIO_TRACK_LIMIT: usize = 40;
const PLAYER_RADIO_CANDIDATE_LIMIT: i64 = 220;
const PLAYER_RADIO_RELEASE_SEED_TRACKS: i64 = 4;
const FED_DEVICE_PREFIX: &str = "fed:";
#[derive(Debug, Clone)]
@@ -1641,6 +1639,8 @@ struct LastfmCallbackQuery {
#[template(path = "player.html")]
pub struct PlayerPageTemplate {
pub t: &'static Translations,
pub guest: bool,
pub share_token: String,
pub downloads_enabled: bool,
pub torrent_downloads_enabled: bool,
pub youtube_downloads_enabled: bool,
@@ -1655,6 +1655,8 @@ mod page_template_tests {
fn download_manager_button_follows_the_global_switch() {
let disabled = PlayerPageTemplate {
t: Translations::for_lang(Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: false,
torrent_downloads_enabled: false,
youtube_downloads_enabled: false,
@@ -1666,6 +1668,8 @@ mod page_template_tests {
let enabled = PlayerPageTemplate {
t: Translations::for_lang(Lang::En),
guest: false,
share_token: String::new(),
downloads_enabled: true,
torrent_downloads_enabled: true,
youtube_downloads_enabled: true,
@@ -4770,15 +4774,15 @@ async fn similarity_search_handler(
}
// ---------------------------------------------------------------------------
// POST /api/player/share-playlist
// POST /api/player/shares
// ---------------------------------------------------------------------------
async fn create_playlist_share_handler(
async fn create_share_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
Json(body): Json<CreatePlaylistShareRequest>,
Json(body): Json<CreateShareRequest>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
@@ -4818,7 +4822,7 @@ async fn create_playlist_share_handler(
let now = chrono::Utc::now().format("%Y-%m-%dT%H:%M:%SZ").to_string();
sqlx::query(
r#"INSERT INTO furumusic__playlist_share_link
r#"INSERT INTO furumusic__share_link
(token, creator_user_id, title, track_ids_json, created_at)
VALUES ($1, $2, $3, $4, $5)"#,
)
@@ -4833,51 +4837,7 @@ async fn create_playlist_share_handler(
Json(ShareLinkResponse {
token: token.clone(),
url: format!("/share/playlist/{token}"),
})
.into_response()
}
// ---------------------------------------------------------------------------
// GET /api/player/share-playlist/{id}
// ---------------------------------------------------------------------------
async fn playlist_share_detail_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathStringId>,
) -> cot::Result<cot::response::Response> {
let Some(_user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let token = path.0.id.trim().to_string();
let share: Option<(String, String)> = sqlx::query_as(
r#"SELECT title::text, track_ids_json::text
FROM furumusic__playlist_share_link
WHERE token = $1"#,
)
.bind(&token)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let Some((title, track_ids_json)) = share else {
return Ok(json_error(
StatusCode::NOT_FOUND,
"shared playlist not found",
));
};
let ids: Vec<i64> = serde_json::from_str(&track_ids_json).unwrap_or_default();
let tracks = load_track_items_by_ids(pool, &ids).await?;
Json(PlaylistShareDetail {
token,
title,
tracks,
url: format!("/share/{token}"),
})
.into_response()
}
@@ -4993,11 +4953,20 @@ async fn stream_handler(
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let track_id = path.0.track_id;
audio_response(pool, config, request, path.0.track_id, false).await
}
async fn audio_response(
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
track_id: i64,
download: bool,
) -> cot::Result<cot::http::Response<Body>> {
// Look up track → audio_file_id → MediaFile
let media = sqlx::query_as::<_, MediaFileRow>(
r#"SELECT mf.file_path,
mf.original_filename::text AS original_filename,
mf.mime_type::text as mime_type,
mf.file_size_bytes,
mf.sha256_hash::text AS sha256_hash,
@@ -5025,7 +4994,29 @@ async fn stream_handler(
));
}
let file_size = media.file_size_bytes as u64;
let file_size = tokio::fs::metadata(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?
.len();
let filename = media
.original_filename
.rsplit(['/', '\\'])
.next()
.filter(|name| !name.is_empty())
.unwrap_or("track");
let disposition = if download {
format!(
"attachment; filename=\"track-{}\"; filename*=UTF-8''{}",
track_id,
filename
.as_bytes()
.iter()
.map(|b| format!("%{b:02X}"))
.collect::<String>()
)
} else {
"inline".to_owned()
};
let etag = media_etag("audio", track_id, &media.sha256_hash, None);
// Parse Range header
@@ -5037,40 +5028,61 @@ async fn stream_handler(
let (start, end) = range;
let chunk_size = end - start + 1;
let data = read_file_range(&full_path, start, chunk_size).await?;
use futures_util::TryStreamExt;
use tokio::io::{AsyncReadExt, AsyncSeekExt};
let mut file = tokio::fs::File::open(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
file.seek(std::io::SeekFrom::Start(start))
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let data = tokio_util::io::ReaderStream::new(file.take(chunk_size))
.map_err(|e| cot::Error::internal(e.to_string()));
crate::metrics::record_stream_request(true, chunk_size);
let response = cot::http::Response::builder()
.status(StatusCode::PARTIAL_CONTENT)
.header(CONTENT_TYPE, media.mime_type.as_str())
.header(ACCEPT_RANGES, "bytes")
.header("Content-Disposition", disposition.as_str())
.header("Cache-Control", "private, no-store")
.header(CONTENT_RANGE, format!("bytes {start}-{end}/{file_size}"))
.header(CONTENT_LENGTH, chunk_size.to_string())
.header("ETag", etag.as_str())
.header("X-Furumi-Content-Sha256", media.sha256_hash.as_str())
.header("X-Furumi-Content-Updated-At", media.created_at.as_str())
.body(Body::fixed(data))
.body(Body::streaming(data))
.expect("valid response");
return Ok(response);
}
return Ok(cot::http::Response::builder()
.status(StatusCode::RANGE_NOT_SATISFIABLE)
.header(CONTENT_RANGE, format!("bytes */{file_size}"))
.body(Body::fixed(""))
.expect("valid response"));
}
// No Range or invalid range: return full file
let data = tokio::fs::read(&full_path)
// No Range: stream the full file.
let file = tokio::fs::File::open(&full_path)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
use futures_util::TryStreamExt;
let data =
tokio_util::io::ReaderStream::new(file).map_err(|e| cot::Error::internal(e.to_string()));
crate::metrics::record_stream_request(false, file_size);
let response = cot::http::Response::builder()
.status(StatusCode::OK)
.header(CONTENT_TYPE, media.mime_type.as_str())
.header(ACCEPT_RANGES, "bytes")
.header("Content-Disposition", disposition.as_str())
.header("Cache-Control", "private, no-store")
.header(CONTENT_LENGTH, file_size.to_string())
.header("ETag", etag.as_str())
.header("X-Furumi-Content-Sha256", media.sha256_hash.as_str())
.header("X-Furumi-Content-Updated-At", media.created_at.as_str())
.body(Body::fixed(data))
.body(Body::streaming(data))
.expect("valid response");
Ok(response)
@@ -5167,7 +5179,10 @@ async fn local_upload_handler(
{
Some(id) => Some(id),
None => {
return Ok(json_error(StatusCode::BAD_REQUEST, "invalid target playlist ID"));
return Ok(json_error(
StatusCode::BAD_REQUEST,
"invalid target playlist ID",
));
}
},
};
@@ -5319,7 +5334,8 @@ async fn local_upload_handler(
use sha2::{Digest, Sha256};
let sha256 = format!("{:x}", Sha256::digest(&bytes));
if let Err(error) =
crate::import_playlists::register(pool, user.id, playlist_id, &inbox_path, &sha256).await
crate::import_playlists::register(pool, user.id, playlist_id, &inbox_path, &sha256)
.await
{
return Ok(json_error(StatusCode::BAD_REQUEST, &error.to_string()));
}
@@ -5452,6 +5468,9 @@ fn hex_value(byte: u8) -> Option<u8> {
}
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
if file_size == 0 {
return None;
}
let bytes_prefix = "bytes=";
if !header.starts_with(bytes_prefix) {
return None;
@@ -5559,8 +5578,18 @@ async fn cover_response(
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
cover_file_response(pool, config, media_file_id, variant_name).await
}
async fn cover_file_response(
pool: &sqlx::PgPool,
config: &AppConfig,
media_file_id: i64,
variant_name: Option<&str>,
) -> cot::Result<cot::http::Response<Body>> {
let media = sqlx::query_as::<_, MediaFileRow>(
r#"SELECT file_path,
original_filename::text AS original_filename,
mime_type::text as mime_type,
file_size_bytes,
sha256_hash::text AS sha256_hash,
@@ -8085,474 +8114,6 @@ async fn toggle_follow_artist_handler(
}
}
// ---------------------------------------------------------------------------
// GET /api/player/radio/{kind}/{id}
// ---------------------------------------------------------------------------
fn append_unique_track_ids(track_ids: &mut Vec<i64>, candidates: Vec<i64>, limit: usize) {
let mut seen: HashSet<i64> = track_ids.iter().copied().collect();
for candidate in candidates {
if track_ids.len() >= limit {
break;
}
if seen.insert(candidate) {
track_ids.push(candidate);
}
}
}
async fn track_primary_artist_ids(pool: &sqlx::PgPool, track_id: i64) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"SELECT artist_id
FROM furumusic__track_artist
WHERE track_id = $1 AND role <> 'featuring'
ORDER BY position, artist_id"#,
)
.bind(track_id)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn release_primary_artist_ids(pool: &sqlx::PgPool, release_id: i64) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"SELECT artist_id
FROM furumusic__release_artist
WHERE release_id = $1
ORDER BY position, artist_id"#,
)
.bind(release_id)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn fallback_radio_track_ids(
pool: &sqlx::PgPool,
user_id: i64,
artist_ids: &[i64],
excluded_ids: &[i64],
limit: i64,
) -> cot::Result<Vec<i64>> {
if limit <= 0 {
return Ok(Vec::new());
}
sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND NOT (t.id = ANY($3::bigint[]))
ORDER BY (
CASE WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $1 AND ult.track_id = t.id
) THEN 9.0 ELSE 0.0 END
+ CASE WHEN EXISTS (
SELECT 1 FROM furumusic__track_artist ta
WHERE ta.track_id = t.id
AND ta.role <> 'featuring'
AND ta.artist_id = ANY($2::bigint[])
) THEN 5.0 ELSE 0.0 END
+ COALESCE(t.lastfm_rating, 0.0) * 0.7
+ ln(COALESCE(t.lastfm_playcount, 0)::double precision + 1.0) * 0.04
+ ln(COALESCE(t.lastfm_listeners, 0)::double precision + 1.0) * 0.03
+ random() * 2.0
) DESC, t.id
LIMIT $4"#,
)
.bind(user_id)
.bind(artist_ids)
.bind(excluded_ids)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn track_radio_candidate_ids(
pool: &sqlx::PgPool,
user_id: i64,
track_id: i64,
limit: i64,
) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"WITH seed_track AS (
SELECT t.id, t.release_id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.id = $1 AND t.is_hidden = false AND r.is_hidden = false
),
seed_artists AS (
SELECT ta.artist_id
FROM furumusic__track_artist ta
JOIN seed_track st ON st.id = ta.track_id
WHERE ta.role <> 'featuring'
),
seed_tag_sources AS (
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_track st ON egt.entity_kind = 'track' AND egt.entity_id = st.id
UNION ALL
SELECT tg.genre_id, 1.0 AS weight
FROM furumusic__track_genre tg
JOIN seed_track st ON st.id = tg.track_id
UNION ALL
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_track st ON egt.entity_kind = 'release' AND egt.entity_id = st.release_id
),
seed_tags AS (
SELECT genre_id, max(weight) AS seed_weight
FROM seed_tag_sources
GROUP BY genre_id
),
candidate_tag_sources AS (
SELECT egt.entity_id AS track_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
WHERE egt.entity_kind = 'track'
UNION ALL
SELECT tg.track_id, tg.genre_id, 1.0 AS weight
FROM furumusic__track_genre tg
UNION ALL
SELECT t.id AS track_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'release' AND egt.entity_id = t.release_id
),
candidate_tags AS (
SELECT track_id, genre_id, max(weight) AS weight
FROM candidate_tag_sources
GROUP BY track_id, genre_id
),
tag_scores AS (
SELECT ct.track_id, sum(st.seed_weight * ct.weight) AS tag_score
FROM candidate_tags ct
JOIN seed_tags st ON st.genre_id = ct.genre_id
GROUP BY ct.track_id
)
SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
LEFT JOIN tag_scores score ON score.track_id = t.id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND t.id <> $1
AND (
COALESCE(score.tag_score, 0.0) > 0.0
OR EXISTS (
SELECT 1
FROM furumusic__track_artist ta
JOIN seed_artists sa ON sa.artist_id = ta.artist_id
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
)
OR EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
)
)
ORDER BY (
COALESCE(score.tag_score, 0.0) * 12.0
+ CASE
WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) AND COALESCE(score.tag_score, 0.0) > 0.0 THEN 12.0
WHEN EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) THEN 3.0
ELSE 0.0
END
+ CASE WHEN EXISTS (
SELECT 1
FROM furumusic__track_artist ta
JOIN seed_artists sa ON sa.artist_id = ta.artist_id
WHERE ta.track_id = t.id AND ta.role <> 'featuring'
) THEN 4.0 ELSE 0.0 END
+ COALESCE(t.lastfm_rating, 0.0) * 0.65
+ ln(COALESCE(t.lastfm_playcount, 0)::double precision + 1.0) * 0.04
+ ln(COALESCE(t.lastfm_listeners, 0)::double precision + 1.0) * 0.03
+ random() * 1.6
) DESC, t.id
LIMIT $3"#,
)
.bind(track_id)
.bind(user_id)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn release_radio_candidate_ids(
pool: &sqlx::PgPool,
user_id: i64,
release_id: i64,
excluded_ids: &[i64],
limit: i64,
) -> cot::Result<Vec<i64>> {
sqlx::query_scalar::<_, i64>(
r#"WITH seed_release AS (
SELECT id
FROM furumusic__release
WHERE id = $1 AND is_hidden = false
),
seed_artists AS (
SELECT ra.artist_id
FROM furumusic__release_artist ra
JOIN seed_release sr ON sr.id = ra.release_id
),
seed_tag_sources AS (
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
JOIN seed_release sr ON egt.entity_kind = 'release' AND egt.entity_id = sr.id
UNION ALL
SELECT egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN seed_release sr ON sr.id = t.release_id
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'track' AND egt.entity_id = t.id
UNION ALL
SELECT tg.genre_id, 1.0 AS weight
FROM furumusic__track t
JOIN seed_release sr ON sr.id = t.release_id
JOIN furumusic__track_genre tg ON tg.track_id = t.id
),
seed_tags AS (
SELECT genre_id, max(weight) AS seed_weight
FROM seed_tag_sources
GROUP BY genre_id
),
candidate_release_tag_sources AS (
SELECT egt.entity_id AS release_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__entity_genre_tag egt
WHERE egt.entity_kind = 'release'
UNION ALL
SELECT t.release_id,
egt.genre_id,
ln(greatest(COALESCE(egt.weight, 1.0), 1.0) + 1.0) AS weight
FROM furumusic__track t
JOIN furumusic__entity_genre_tag egt
ON egt.entity_kind = 'track' AND egt.entity_id = t.id
UNION ALL
SELECT t.release_id, tg.genre_id, 1.0 AS weight
FROM furumusic__track t
JOIN furumusic__track_genre tg ON tg.track_id = t.id
),
candidate_release_tags AS (
SELECT release_id, genre_id, max(weight) AS weight
FROM candidate_release_tag_sources
GROUP BY release_id, genre_id
),
release_scores AS (
SELECT crt.release_id, sum(st.seed_weight * crt.weight) AS tag_score
FROM candidate_release_tags crt
JOIN seed_tags st ON st.genre_id = crt.genre_id
GROUP BY crt.release_id
),
candidate_tracks AS (
SELECT t.id,
t.release_id,
COALESCE(score.tag_score, 0.0) AS tag_score,
EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
) AS liked,
EXISTS (
SELECT 1
FROM furumusic__release_artist ra
JOIN seed_artists sa ON sa.artist_id = ra.artist_id
WHERE ra.release_id = t.release_id
) AS same_artist,
COALESCE(t.lastfm_rating, 0.0) AS rating,
COALESCE(t.lastfm_playcount, 0)::double precision AS playcount,
COALESCE(t.lastfm_listeners, 0)::double precision AS listeners
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
LEFT JOIN release_scores score ON score.release_id = t.release_id
WHERE t.is_hidden = false
AND r.is_hidden = false
AND t.release_id <> $1
AND NOT (t.id = ANY($3::bigint[]))
AND (
COALESCE(score.tag_score, 0.0) > 0.0
OR EXISTS (
SELECT 1
FROM furumusic__release_artist ra
JOIN seed_artists sa ON sa.artist_id = ra.artist_id
WHERE ra.release_id = t.release_id
)
OR EXISTS (
SELECT 1 FROM furumusic__user_liked_track ult
WHERE ult.user_id = $2 AND ult.track_id = t.id
)
)
),
ranked_tracks AS (
SELECT *,
row_number() OVER (
PARTITION BY release_id
ORDER BY rating DESC, playcount DESC, listeners DESC, random() DESC, id
) AS release_rank
FROM candidate_tracks
)
SELECT id
FROM ranked_tracks
WHERE release_rank <= 4
ORDER BY (
tag_score * 12.0
+ CASE
WHEN liked AND tag_score > 0.0 THEN 11.0
WHEN liked THEN 3.0
ELSE 0.0
END
+ CASE WHEN same_artist THEN 3.5 ELSE 0.0 END
+ rating * 0.65
+ ln(playcount + 1.0) * 0.04
+ ln(listeners + 1.0) * 0.03
+ random() * 1.6
) DESC, id
LIMIT $4"#,
)
.bind(release_id)
.bind(user_id)
.bind(excluded_ids)
.bind(limit)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))
}
async fn build_track_radio_ids(
pool: &sqlx::PgPool,
user_id: i64,
track_id: i64,
) -> cot::Result<Option<Vec<i64>>> {
let seed_track = sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.id = $1 AND t.is_hidden = false AND r.is_hidden = false"#,
)
.bind(track_id)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if seed_track.is_none() {
return Ok(None);
}
let mut ids = vec![track_id];
let candidate_ids =
track_radio_candidate_ids(pool, user_id, track_id, PLAYER_RADIO_CANDIDATE_LIMIT).await?;
append_unique_track_ids(&mut ids, candidate_ids, PLAYER_RADIO_TRACK_LIMIT);
let artist_ids = track_primary_artist_ids(pool, track_id).await?;
let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
let fallback_ids =
fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
Ok(Some(ids))
}
async fn build_release_radio_ids(
pool: &sqlx::PgPool,
user_id: i64,
release_id: i64,
) -> cot::Result<Option<Vec<i64>>> {
let seed_release = sqlx::query_scalar::<_, i64>(
r#"SELECT id FROM furumusic__release WHERE id = $1 AND is_hidden = false"#,
)
.bind(release_id)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if seed_release.is_none() {
return Ok(None);
}
let mut ids = sqlx::query_scalar::<_, i64>(
r#"SELECT t.id
FROM furumusic__track t
JOIN furumusic__release r ON r.id = t.release_id
WHERE t.release_id = $1
AND t.is_hidden = false
AND r.is_hidden = false
ORDER BY COALESCE(t.lastfm_rating, 0.0) DESC,
COALESCE(t.lastfm_playcount, 0) DESC,
COALESCE(t.lastfm_listeners, 0) DESC,
t.disc_number NULLS FIRST,
t.track_number NULLS LAST,
t.id
LIMIT $2"#,
)
.bind(release_id)
.bind(PLAYER_RADIO_RELEASE_SEED_TRACKS)
.fetch_all(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let candidate_ids = release_radio_candidate_ids(
pool,
user_id,
release_id,
&ids,
PLAYER_RADIO_CANDIDATE_LIMIT,
)
.await?;
append_unique_track_ids(&mut ids, candidate_ids, PLAYER_RADIO_TRACK_LIMIT);
let artist_ids = release_primary_artist_ids(pool, release_id).await?;
let remaining = PLAYER_RADIO_TRACK_LIMIT.saturating_sub(ids.len()) as i64;
let fallback_ids =
fallback_radio_track_ids(pool, user_id, &artist_ids, &ids, remaining).await?;
append_unique_track_ids(&mut ids, fallback_ids, PLAYER_RADIO_TRACK_LIMIT);
Ok(Some(ids))
}
async fn radio_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathRadioSeed>,
) -> cot::Result<cot::response::Response> {
let Some(user) = auth::get_request_user(&auth_ctx, &session, &db).await else {
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
};
let seed = path.0;
let ids = match seed.kind.as_str() {
"track" => build_track_radio_ids(pool, user.id, seed.id).await?,
"release" => build_release_radio_ids(pool, user.id, seed.id).await?,
_ => return Ok(json_error(StatusCode::BAD_REQUEST, "unknown radio seed")),
};
let Some(ids) = ids else {
return Ok(json_error(StatusCode::NOT_FOUND, "radio seed not found"));
};
let tracks = load_track_items_by_ids(pool, &ids).await?;
Json(tracks).into_response()
}
// ---------------------------------------------------------------------------
// POST /api/player/tracks-by-ids
// ---------------------------------------------------------------------------
@@ -10017,35 +9578,6 @@ impl App for PlayerApp {
},
"player_release_detail",
),
Route::with_handler_and_name(
"/radio/{kind}/{id}",
{
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
get(
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
path: Path<PathRadioSeed>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let pg_pool = pool
.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new()
.max_connections(5)
.connect(&pool_config.database_url)
.await
.expect("player pool")
})
.await;
radio_handler(auth_ctx, session, db, pg_pool, path).await
}
},
)
},
"player_radio",
),
// -- Playlists (list + create) --
Route::with_handler_and_name(
"/playlists",
@@ -10096,14 +9628,14 @@ impl App for PlayerApp {
),
// -- Shared playlist snapshots --
Route::with_handler_and_name(
"/share-playlist",
"/shares",
post({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |auth_ctx: auth::AuthContext,
session: Session,
db: Database,
json: Json<CreatePlaylistShareRequest>| {
json: Json<CreateShareRequest>| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
@@ -10116,15 +9648,15 @@ impl App for PlayerApp {
.expect("player pool")
})
.await;
create_playlist_share_handler(auth_ctx, session, db, pg_pool, json)
create_share_handler(auth_ctx, session, db, pg_pool, json)
.await
}
}
}),
"player_share_playlist",
"player_create_share",
),
Route::with_handler_and_name(
"/share-playlist/{id}",
"/shares/{id}",
get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
@@ -10144,12 +9676,12 @@ impl App for PlayerApp {
.expect("player pool")
})
.await;
playlist_share_detail_handler(auth_ctx, session, db, pg_pool, path)
sharing::detail_handler(auth_ctx, session, db, pg_pool, path)
.await
}
}
}),
"player_share_playlist_detail",
"player_share_detail",
),
// -- Playlist detail (get, update, delete) --
Route::with_handler_and_name(
@@ -10447,6 +9979,42 @@ impl App for PlayerApp {
}),
"player_follow_toggle",
),
Route::with_handler_and_name(
"/shares/{token}/{action}/{track_id}", get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |db: Database, path: Path<sharing::MediaPath>, request: cot::request::Request| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new().max_connections(5)
.connect(&pool_config.database_url).await.expect("player pool")
}).await;
let (live_config, _) = AppConfig::load_with_db(&db).await;
sharing::media_handler(pg_pool, &live_config, &request, path).await
}
}
}), "player_shared_media",
),
Route::with_handler_and_name(
"/download/{track_id}", get({
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
move |db: Database, auth_ctx: auth::AuthContext, session: Session, path: Path<PathTrackId>, request: cot::request::Request| {
let pool = Arc::clone(&pool);
let pool_config = Arc::clone(&pool_config);
async move {
let pg_pool = pool.get_or_init(|| async {
sqlx::postgres::PgPoolOptions::new().max_connections(5)
.connect(&pool_config.database_url).await.expect("player pool")
}).await;
let (live_config, _) = AppConfig::load_with_db(&db).await;
sharing::download_handler(auth_ctx, session, db, pg_pool, &live_config, &request, path).await
}
}
}), "player_download",
),
// -- Audio stream --
Route::with_handler_and_name(
"/stream/{track_id}",
+1 -7
View File
@@ -54,7 +54,7 @@ pub(super) struct ReorderPlaylistRequest {
}
#[derive(Debug, Deserialize)]
pub(super) struct CreatePlaylistShareRequest {
pub(super) struct CreateShareRequest {
pub(super) track_ids: Vec<i64>,
pub(super) title: Option<String>,
}
@@ -76,12 +76,6 @@ pub(super) struct PathStringId {
pub(super) id: String,
}
#[derive(Debug, Deserialize)]
pub(super) struct PathRadioSeed {
pub(super) kind: String,
pub(super) id: i64,
}
#[derive(Debug, Deserialize)]
pub(super) struct SearchQuery {
pub(super) q: String,
+1 -1
View File
@@ -54,8 +54,8 @@ pub(super) struct ReleaseArtistRefRow {
#[derive(sqlx::FromRow)]
pub(super) struct MediaFileRow {
pub(super) file_path: String,
pub(super) original_filename: String,
pub(super) mime_type: String,
pub(super) file_size_bytes: i64,
pub(super) sha256_hash: String,
pub(super) created_at: String,
}
+125
View File
@@ -0,0 +1,125 @@
//! Public capabilities grant access only to a stored snapshot's visible tracks.
use super::*;
#[derive(Deserialize)]
pub(super) struct MediaPath {
token: String,
action: String,
track_id: i64,
}
async fn load_share(pool: &sqlx::PgPool, token: &str) -> cot::Result<Option<ShareDetail>> {
if !crate::is_share_token(token) {
return Ok(None);
}
let row: Option<(String, String)> =
sqlx::query_as("SELECT title, track_ids_json FROM furumusic__share_link WHERE token = $1")
.bind(token)
.fetch_optional(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
let Some((title, json)) = row else {
return Ok(None);
};
let ids: Vec<i64> =
serde_json::from_str(&json).map_err(|e| cot::Error::internal(e.to_string()))?;
let tracks = load_track_items_by_ids(pool, &ids).await?;
Ok(Some(ShareDetail {
token: token.to_owned(),
title,
tracks,
}))
}
pub(super) async fn detail_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
path: Path<PathStringId>,
) -> cot::Result<cot::response::Response> {
let Some(mut share) = load_share(pool, &path.0.id).await? else {
return Ok(json_error(StatusCode::NOT_FOUND, "shared music not found"));
};
if auth::get_request_user(&auth_ctx, &session, &db)
.await
.is_none()
{
for track in &mut share.tracks {
track.stream_url = format!("/api/player/shares/{}/stream/{}", share.token, track.id);
if track.cover_url.is_some() {
track.cover_url = Some(format!(
"/api/player/shares/{}/cover/{}",
share.token, track.id
));
}
}
}
let mut response = Json(share).into_response()?;
response
.headers_mut()
.insert("Cache-Control", "private, no-store".parse().unwrap());
Ok(response)
}
pub(super) async fn media_handler(
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
path: Path<MediaPath>,
) -> cot::Result<cot::response::Response> {
let p = path.0;
if !crate::is_share_token(&p.token) {
return Ok(json_error(StatusCode::NOT_FOUND, "shared music not found"));
}
// Media range requests need only a membership check, not the metadata and
// artist lists of every track in a potentially large shared queue.
let allowed: bool = sqlx::query_scalar(
"SELECT EXISTS (SELECT 1 FROM furumusic__share_link s
JOIN furumusic__track t ON t.id = $2
JOIN furumusic__release r ON r.id = t.release_id
WHERE s.token = $1 AND s.track_ids_json::jsonb @> jsonb_build_array($2::bigint)
AND t.is_hidden = false AND r.is_hidden = false)",
)
.bind(&p.token)
.bind(p.track_id)
.fetch_one(pool)
.await
.map_err(|e| cot::Error::internal(e.to_string()))?;
if !allowed {
return Ok(json_error(StatusCode::NOT_FOUND, "shared track not found"));
}
match p.action.as_str() {
"stream" | "download" => {
audio_response(pool, config, request, p.track_id, p.action == "download").await
}
"cover" => {
let cover: Option<i64> = sqlx::query_scalar(
"SELECT COALESCE(t.cover_file_id, r.cover_file_id) FROM furumusic__track t JOIN furumusic__release r ON r.id = t.release_id WHERE t.id = $1")
.bind(p.track_id).fetch_one(pool).await.map_err(|e| cot::Error::internal(e.to_string()))?;
match cover {
Some(id) => cover_file_response(pool, config, id, Some("card")).await,
None => Ok(json_error(StatusCode::NOT_FOUND, "cover not found")),
}
}
_ => Ok(json_error(StatusCode::NOT_FOUND, "not found")),
}
}
pub(super) async fn download_handler(
auth_ctx: auth::AuthContext,
session: Session,
db: Database,
pool: &sqlx::PgPool,
config: &AppConfig,
request: &cot::http::Request<Body>,
path: Path<PathTrackId>,
) -> cot::Result<cot::response::Response> {
if auth::get_request_user(&auth_ctx, &session, &db)
.await
.is_none()
{
return Ok(json_error(StatusCode::UNAUTHORIZED, "not authenticated"));
}
audio_response(pool, config, request, path.0.track_id, true).await
}
+80 -14
View File
@@ -19,6 +19,10 @@ pub struct User {
avatar_url: Option<String>,
role: LimitedString<32>,
is_active: bool,
local_role: Option<String>,
sso_role: Option<String>,
approved_by: Option<i64>,
approved_at: Option<String>,
}
// ---------------------------------------------------------------------------
@@ -50,6 +54,10 @@ impl User {
avatar_url: None,
role: LimitedString::new(role).unwrap(),
is_active: true,
local_role: Some(role.to_owned()),
sso_role: None,
approved_by: None,
approved_at: None,
};
user.insert(db).await?;
Ok(user)
@@ -72,8 +80,13 @@ impl User {
if let Some(pw) = new_password {
self.password = Some(PasswordHash::from_password(&Password::new(pw)).into_string());
}
self.role = LimitedString::new(role).unwrap();
self.save(db).await
let local_role = (!role.is_empty()).then(|| role.to_owned());
db.raw_with("UPDATE furumusic__user SET username = $1, email = $2, display_name = $3, password = $4, local_role = $5, role = COALESCE(sso_role, $5, 'user'), is_active = (sso_role IS NOT NULL OR $5 IS NOT NULL) WHERE id = $6",
&[&username.to_owned(), &self.email, &self.display_name, &self.password, &local_role, &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
/// Look up a user by username.
@@ -126,13 +139,17 @@ impl User {
self.is_active
}
pub fn has_sso_admin_role(&self) -> bool {
self.sso_role.as_deref() == Some("admin")
}
/// Create a user without a password (for OIDC-only accounts).
pub async fn create_oidc(
db: &Database,
username: &str,
email: Option<&str>,
display_name: Option<&str>,
role: &str,
sso_role: Option<&str>,
) -> cot::db::Result<Self> {
let mut user = Self {
id: Auto::auto(),
@@ -141,24 +158,44 @@ impl User {
email: email.map(str::to_owned),
display_name: display_name.map(str::to_owned),
avatar_url: None,
role: LimitedString::new(role).unwrap(),
is_active: true,
role: LimitedString::new(sso_role.unwrap_or("user")).unwrap(),
is_active: sso_role.is_some(),
local_role: None,
sso_role: sso_role.map(str::to_owned),
approved_by: None,
approved_at: None,
};
user.insert(db).await?;
Ok(user)
}
/// Update the user's role and persist the change.
pub async fn update_role(&mut self, db: &Database, role: &str) -> cot::db::Result<()> {
self.role = LimitedString::new(role).unwrap();
self.save(db).await
pub async fn sync_sso_role(
&mut self,
db: &Database,
role: Option<&str>,
) -> cot::db::Result<()> {
let role = role.map(str::to_owned);
// Change just this grant atomically: a concurrent administrator approval
// must not be overwritten by a stale User loaded before the OIDC callback.
db.raw_with("UPDATE furumusic__user SET sso_role = $1, role = COALESCE($1, local_role, 'user'), is_active = ($1 IS NOT NULL OR local_role IS NOT NULL) WHERE id = $2", &[&role, &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
/// Find a user by email address.
pub async fn get_by_email(db: &Database, email: &str) -> cot::db::Result<Option<Self>> {
cot::db::query!(User, $email == Some(email.to_owned()))
.get(db)
.await
pub async fn approve(
&mut self,
db: &Database,
role: &str,
admin_id: i64,
) -> cot::db::Result<()> {
db.raw_with("UPDATE furumusic__user SET local_role = $1, role = COALESCE(sso_role, $1), is_active = true, approved_by = $2, approved_at = $3 WHERE id = $4",
&[&role.to_owned(), &admin_id, &chrono::Utc::now().to_rfc3339(), &self.id_val()]).await?;
if let Some(updated) = Self::get_by_id(db, self.id_val()).await? {
*self = updated;
}
Ok(())
}
}
@@ -393,9 +430,38 @@ pub mod db_migrations {
&[Operation::custom(create_oidc_link_indexes).build()];
}
#[cot::db::migrations::migration_op]
async fn add_local_approval(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
ctx.db.raw("ALTER TABLE furumusic__user ADD COLUMN local_role text, ADD COLUMN sso_role text, ADD COLUMN approved_by bigint, ADD COLUMN approved_at text").await?;
// Existing password accounts retain local access. OIDC-only accounts retain
// their last SSO role until the next verified login refreshes group membership.
ctx.db.raw("UPDATE furumusic__user SET local_role = CASE WHEN password IS NOT NULL AND is_active THEN role ELSE NULL END, sso_role = CASE WHEN password IS NULL AND is_active THEN role ELSE NULL END").await?;
ctx.db
.raw("DROP TABLE furumusic__playlist_share_link")
.await?;
ctx.db.raw("CREATE TABLE furumusic__share_link (token text PRIMARY KEY, creator_user_id bigint NOT NULL, title text NOT NULL, track_ids_json text NOT NULL, created_at text NOT NULL)").await?;
Ok(())
}
#[derive(Debug, Copy, Clone)]
pub struct M0053LocalApprovalAndPublicShares;
impl migrations::Migration for M0053LocalApprovalAndPublicShares {
const APP_NAME: &'static str = "furumusic";
const MIGRATION_NAME: &'static str = "m_0053_local_approval_and_public_shares";
const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
migrations::MigrationDependency::migration("furumusic", "m_0005_oidc_link_indexes"),
migrations::MigrationDependency::migration(
"furumusic",
"m_0037_create_playlist_share_links",
),
];
const OPERATIONS: &'static [Operation] = &[Operation::custom(add_local_approval).build()];
}
pub const MIGRATIONS: &[&SyncDynMigration] = &[
&M0003CreateUser,
&M0004CreateOidcLink,
&M0005OidcLinkIndexes,
&M0053LocalApprovalAndPublicShares,
];
}
+186 -72
View File
@@ -184,28 +184,58 @@ button {
}
.repair-shell { display:grid;grid-template-columns:290px minmax(0,1fr);gap:14px;height:calc(100dvh - 116px);min-height:520px; }
.repair-side,.repair-work { min-height:0;display:flex;flex-direction:column;gap:12px; }
.repair-side,.repair-work { min-width:0;min-height:0;display:flex;flex-direction:column;gap:12px; }
.repair-side .panel,.repair-plan,.repair-chat { min-height:0;display:flex;flex-direction:column; }
.repair-side .panel { flex:1; }
.repair-scroll { overflow:auto;min-height:0;padding:12px; }
.repair-work .repair-plan { flex:1; }
.repair-work .repair-chat { height:220px;flex:none; }
.repair-work .repair-chat { flex:1; }
.repair-chat > .repair-scroll { flex:1;display:flex;flex-direction:column;gap:12px; }
.repair-plan { border:1px solid var(--border-color);border-radius:8px;background:var(--bg-primary);flex:none; }
.repair-plan summary { cursor:pointer;padding:14px;display:flex;align-items:center;gap:10px;flex-wrap:wrap; }
.repair-plan summary::before { content:'▸'; }
.repair-plan[open] summary::before { content:'▾'; }
.repair-plan-body { padding:0 12px 14px;overflow:auto; }
.repair-preview { display:grid;gap:8px;margin:10px 0; }
.repair-preview-row { padding:10px 12px;border:1px solid var(--border-color);border-radius:6px; }
.repair-preview-row strong { display:block;font-size:13px;margin:4px 0;overflow-wrap:anywhere; }
.repair-preview-row p { margin:0;font-size:12px;line-height:1.5;color:var(--text-secondary);white-space:pre-line;overflow-wrap:anywhere; }
.repair-manual > summary { font-size:12px;color:var(--text-secondary); }
.repair-plan-actions { display:flex;align-items:center;justify-content:space-between;gap:10px;padding:12px;border-top:1px solid var(--border-color); }
.repair-delete { color:var(--red); }
.repair-context { display:block;color:var(--text-subdued);font-size:11px;margin-top:3px; }
@media (max-width:800px) {
html:has(.repair-view),body:has(.repair-view) { min-width:0; }
.repair-view { grid-template-columns:minmax(0,1fr);grid-template-rows:auto minmax(0,1fr); }
.repair-view .sidebar { border-right:0;border-bottom:1px solid var(--border-color); }
.repair-view .sidebar .brand,.repair-view .sidebar .nav-label,.repair-view .sidebar .nav-group:last-child { display:none; }
.repair-view .sidebar .nav-group { display:flex;overflow-x:auto;gap:4px;padding:8px; }
.repair-view .sidebar .nav-btn { width:auto;flex:none;white-space:nowrap;padding:10px; }
.repair-view .sidebar .nav-count { display:none; }
.repair-view .topbar { height:auto;padding:12px;flex-wrap:wrap; }
.repair-view .content { padding:12px; }
.repair-view .panel-head { flex-wrap:wrap;gap:12px; }
.repair-plan-actions { align-items:stretch;flex-direction:column; }
.repair-shell { grid-template-columns:1fr;height:auto;min-height:0; }
.repair-side .panel:first-child .repair-scroll { max-height:280px; }
.repair-work .repair-chat { min-height:65dvh;max-height:90dvh; }
}
.repair-group { margin:12px 0 5px;color:var(--text-secondary);font-size:11px;font-weight:800;text-transform:uppercase; }
.repair-entity { display:flex;align-items:flex-start;gap:8px;padding:6px 0;font-size:12px; }
.repair-entity span { overflow-wrap:anywhere; }
.repair-search-results { max-height:160px;overflow:auto;border:1px solid var(--border-color);border-radius:6px;margin-top:6px; }
.repair-search-results button { display:block;width:100%;padding:8px;background:transparent;color:var(--text-primary);text-align:left;cursor:pointer; }
.repair-search-results button:hover { background:var(--bg-hover); }
.repair-diff { width:100%;border-collapse:collapse;font-size:12px; }
.repair-diff { min-width:850px;width:100%;border-collapse:collapse;font-size:12px; }
.repair-diff th,.repair-diff td { text-align:left;border-bottom:1px solid var(--border-color);padding:7px;vertical-align:top; }
.repair-diff th { color:var(--text-subdued);font-size:10px;text-transform:uppercase; }
.repair-diff input,.repair-diff select { width:100%;min-width:90px;background:var(--bg-primary);color:var(--text-primary);border:1px solid var(--border-color);border-radius:5px;padding:6px; }
.repair-diff .compact { min-width:65px;max-width:90px; }
.repair-message { padding:7px 9px;border-radius:7px;max-width:86%;font-size:12px;white-space:pre-wrap;overflow-wrap:anywhere; }
.repair-message { padding:12px 14px;border-radius:9px;max-width:90%;font-size:14px;line-height:1.6;white-space:pre-wrap;overflow-wrap:anywhere; }
.repair-message.user { background:#16452a;align-self:flex-end; }
.repair-message.assistant { background:var(--bg-elevated);align-self:flex-start; }
.repair-composer { border-top:1px solid var(--border-color);padding:9px;display:flex;gap:8px;align-items:end; }
.repair-composer textarea { flex:1;min-width:0;resize:vertical;max-height:100px;background:var(--bg-primary);color:var(--text-primary);border:1px solid var(--border-color);border-radius:6px;padding:8px; }
.repair-composer textarea { flex:1;min-width:0;resize:vertical;max-height:180px;background:var(--bg-primary);color:var(--text-primary);border:1px solid var(--border-color);border-radius:6px;padding:8px; }
.repair-thinking { display:flex;align-items:center;gap:8px;color:var(--amber);font-size:12px;padding:10px; }
.repair-thinking::before { content:"";width:10px;height:10px;border:2px solid currentColor;border-right-color:transparent;border-radius:50%;animation:repair-spin .8s linear infinite; }
@keyframes repair-spin { to { transform:rotate(360deg); } }
@@ -2060,7 +2090,7 @@ tbody tr:hover {
{% endblock head_extra %}
{% block content %}
<div class="admin-shell" :class="{'statistics-view': activeView === 'statistics'}" x-data="adminV2()" x-cloak>
<div class="admin-shell" :class="{'statistics-view': activeView === 'statistics', 'repair-view': activeView === 'tools'}" x-data="adminV2()" x-cloak>
<aside class="sidebar">
<div class="brand">
<div class="brand-title">
@@ -2637,7 +2667,12 @@ tbody tr:hover {
</td>
<td x-text="fmt(user.plays)"></td><td x-text="durationApprox(user.listened_seconds)"></td><td x-text="user.last_play_ms ? statisticsDate(user.last_play_ms) : '—'"></td><td><span x-text="user.role"></span></td>
<td>
<span class="badge" :class="user.is_active ? 'ok' : 'disabled'" x-text="user.is_active ? 'active' : 'disabled'"></span>
<span class="badge" :class="user.is_active ? 'ok' : 'disabled'" x-text="user.is_active ? 'active' : 'pending approval'"></span>
<div x-show="!user.local_role" @click.stop>
<button class="btn" @click="approveUser(user, 'user')">Approve as user</button>
<button class="btn" @click="approveUser(user, 'admin')">Approve as admin</button>
</div>
<div class="secondary-line" x-text="user.sso_role ? 'SSO: ' + user.sso_role : (user.local_role ? 'Local: ' + user.local_role : '')"></div>
</td>
<td><span x-text="userLastSeenLabel(user)"></span></td>
</tr>
@@ -2674,42 +2709,56 @@ tbody tr:hover {
<template x-for="item in repairSearchResults" :key="item.kind + ':' + item.id"><button type="button" @click="addRepairEntity(item)" x-text="item.title + (item.subtitle ? ' · ' + item.subtitle : '')"></button></template>
</div>
<div class="repair-group">Selected and related · <span x-text="repairIncludedCount()"></span></div>
<div class="toolbar"><button class="btn" @click="setAllRepairIncluded(true)" :disabled="repairBusy || !repairRowsCount()">Select all</button><button class="btn" @click="setAllRepairIncluded(false)" :disabled="repairBusy || !repairIncludedCount()">Deselect all</button></div>
<div class="muted" x-show="!repairExpanded && repairSelected.length === 0">Search and select an artist, release, or track.</div>
<template x-for="kind in ['artists','releases','tracks']" :key="kind">
<div x-show="repairRows(kind).length">
<div class="repair-group" x-text="kind"></div>
<template x-for="item in repairRows(kind)" :key="kind + item.id">
<label class="repair-entity"><input type="checkbox" :checked="repairIncluded[kind + ':' + item.id] !== false" @change="setRepairIncluded(kind,item.id,$event.target.checked)" :disabled="repairBusy" /><span x-text="(item.name || item.title) + ' #' + item.id"></span></label>
<label class="repair-entity"><input type="checkbox" :checked="repairIsIncluded(kind,item.id)" @change="setRepairIncluded(kind,item.id,$event.target.checked)" :disabled="repairBusy" /><span><span x-text="(item.name || item.title) + ' #' + item.id"></span><small class="repair-context" x-text="repairEntityContext(kind,item)"></small></span></label>
</template>
</div>
</template>
<div class="toolbar" style="margin-top:12px"><button class="btn" @click="expandRepair()" :disabled="repairSelected.length === 0 || repairBusy">Show related</button><button class="btn" @click="clearRepair()" :disabled="repairBusy">Clear</button></div>
<div class="muted" style="margin-top:8px">Uncheck any related item to exclude it from the plan. Audio files stay in their current folders.</div>
<div class="muted" style="margin-top:8px">Selecting a release includes its tracks. Uncheck individual tracks to exclude them. Artist names are read-only unless the artist is checked. Audio files stay in their current folders.</div>
</div>
</section>
<section class="panel" style="max-height:160px"><div class="panel-head"><div class="panel-title"><strong>History</strong><span>Recent applied plans</span></div></div><div class="repair-scroll repair-history"><template x-for="entry in repairHistory" :key="entry.id"><div class="repair-entity"><span style="flex:1" x-text="'#' + entry.id + ' · ' + entry.instruction.slice(0,55) + (entry.undone_at ? ' · undone' : '')"></span><button class="btn" x-show="!entry.undone_at" @click="undoRepair(entry.id)" :disabled="repairBusy">Undo</button></div></template><div class="muted" x-show="repairHistory.length === 0">No applied plans yet.</div></div></section>
</aside>
<div class="repair-work">
<section class="panel repair-plan">
<div class="panel-head"><div class="panel-title"><strong>Proposed changes</strong><span x-text="repairIncomplete ? (repairBusy ? 'Processing tracks: ' : 'Paused at track: ') + repairTrackOffset + ' / ' + repairTrackTotal : (repairPlan ? 'Review and edit before applying' : 'The agent’s plan will appear here')"></span></div><div class="toolbar"><span class="selection-summary" x-show="repairPlan" x-text="repairChangeCount() + ' changes'"></span><button class="btn primary" x-show="repairPlan" @click="applyRepair()" :disabled="repairBusy || repairIncomplete || !repairChangeCount()">Apply plan</button></div></div>
<div class="repair-scroll" :style="repairBusy ? 'pointer-events:none' : ''">
<div class="repair-thinking" x-show="repairBusy && repairStage === 'thinking'">Agent is reviewing the selected metadata…</div>
<div class="empty" x-show="!repairPlan && !(repairBusy && repairStage === 'thinking')">Select entities and describe the correction in the chat below.</div>
<section class="panel repair-chat">
<div class="panel-head"><div class="panel-title"><strong>Metadata assistant</strong><span>Discuss the task. The proposed plan updates with each reply.</span></div></div>
<div class="repair-scroll" x-ref="repairChat">
<div class="muted" x-show="repairChat.length === 0">Select resources and describe what should change. You can ask to combine releases, move tracks, edit metadata, or delete resources.</div>
<template x-for="(turn,index) in repairChat" :key="index"><div class="repair-message" :class="turn.role" x-text="turn.content"></div></template>
<div class="repair-thinking" x-show="repairBusy" x-text="repairStage === 'applying' ? 'Applying changes…' : 'Agent is reviewing the selected metadata and updating the plan…'" role="status"></div>
<details class="repair-plan" x-show="repairPlan" :open="repairPlanOpen" @toggle="repairPlanOpen = $el.open">
<summary><strong>Proposed changes</strong><span class="selection-summary" x-text="repairChangeCount() + ' changes' + (repairDeleteCount() ? ' · ' + repairDeleteCount() + ' deletions' : '')"></span><span class="muted" x-text="repairIncomplete ? 'Update incomplete · retry your message' : 'Expand to review the current plan'"></span></summary>
<div class="repair-plan-body"><fieldset :disabled="repairBusy || repairIncomplete" style="border:0;padding:0;margin:0;min-width:0">
<template x-if="repairPlan"><div>
<div class="repair-section-title" x-show="repairPlan.questions.length">Questions to review</div>
<template x-for="question in repairPlan.questions" :key="question"><div class="repair-entity" style="color:var(--amber)" x-text="question"></div></template>
<div class="repair-preview"><template x-for="row in repairPreview()" :key="row.key"><div class="repair-preview-row"><small class="muted" x-text="row.action"></small><strong x-text="row.title"></strong><p x-text="row.detail"></p></div></template></div>
<details class="repair-manual"><summary>Edit fields manually</summary>
<div class="repair-section-title" x-show="repairPlan.artists.length">Artists</div>
<table class="repair-diff" x-show="repairPlan.artists.length"><thead><tr><th>Before</th><th>After</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.artists" :key="edit.id"><tr><td x-text="repairBefore('artists',edit.id)?.name || ''"></td><td><input x-model="edit.name" /></td><td><button class="btn" @click="repairPlan.artists.splice(index,1)">Remove</button></td></tr></template></tbody></table>
<table class="repair-diff" x-show="repairPlan.artists.length"><thead><tr><th>Before</th><th>After</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.artists" :key="edit.id"><tr><td x-text="repairEntityLabel('artists',edit.id)"></td><td><input x-model="edit.name" /></td><td><button class="btn" @click="repairPlan.artists.splice(index,1)">Remove edit</button></td></tr></template></tbody></table>
<div class="repair-section-title" x-show="repairPlan.releases.length">Releases</div>
<table class="repair-diff" x-show="repairPlan.releases.length"><thead><tr><th>Before</th><th>After</th><th>Type</th><th>Year</th><th>Artist IDs</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.releases" :key="edit.id || edit.key"><tr><td><div x-text="edit.id ? (repairBefore('releases',edit.id)?.title || '') : 'New release'"></div><small class="muted" x-show="edit.id" x-text="edit.id ? [repairBefore('releases',edit.id)?.release_type,repairBefore('releases',edit.id)?.year].filter(x => x != null).join(' · ') : ''"></small></td><td><input x-model="edit.title" /></td><td><select x-model="edit.release_type"><template x-for="type in ['album','single','ep','compilation','mixtape','live','soundtrack','remix','demo']" :key="type"><option :value="type" x-text="type"></option></template></select></td><td><input class="compact" type="number" x-model.number="edit.year" /></td><td><input :value="edit.artist_ids.join(', ')" @change="edit.artist_ids = parseRepairIds($event.target.value)" /></td><td><button class="btn" @click="repairPlan.releases.splice(index,1)">Remove</button></td></tr></template></tbody></table>
<table class="repair-diff" x-show="repairPlan.releases.length"><thead><tr><th>Before</th><th>After</th><th>Type</th><th>Year</th><th>Artist IDs</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.releases" :key="edit.id || edit.key"><tr><td><div x-text="edit.id ? repairEntityLabel('releases',edit.id) : 'New release'"></div><small class="muted" x-show="edit.id" x-text="edit.id ? [repairBefore('releases',edit.id)?.release_type,repairBefore('releases',edit.id)?.year].filter(x => x != null).join(' · ') : ''"></small></td><td><input x-model="edit.title" /></td><td><select x-model="edit.release_type"><template x-for="type in ['album','single','ep','compilation','mixtape','live','soundtrack','remix','demo']" :key="type"><option :value="type" x-text="type"></option></template></select></td><td><input class="compact" type="number" x-model.number="edit.year" /></td><td><input :value="edit.artist_ids.join(', ')" @change="edit.artist_ids = parseRepairIds($event.target.value)" /><small class="repair-context" x-text="repairArtistNames(edit.artist_ids)"></small></td><td><button class="btn" @click="repairPlan.releases.splice(index,1)">Remove edit</button></td></tr></template></tbody></table>
<div class="toolbar" x-show="repairPlan"><button class="btn" @click="addRepairRelease()">+ New release</button></div>
<div class="repair-section-title" x-show="repairPlan.tracks.length">Tracks</div>
<table class="repair-diff" x-show="repairPlan.tracks.length"><thead><tr><th>Before</th><th>After</th><th>Release</th><th>#</th><th>Disc</th><th>Year</th><th>Artist IDs</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.tracks" :key="edit.id"><tr><td><div x-text="repairBefore('tracks',edit.id)?.title || ''"></div><small class="muted" x-text="'#' + (repairBefore('tracks',edit.id)?.track_number ?? '—') + ' · release #' + (repairBefore('tracks',edit.id)?.release_id || '')"></small></td><td><input x-model="edit.title" /></td><td><select x-model="edit.target_release"><template x-for="release in repairTargetReleases()" :key="release.value"><option :value="release.value" x-text="release.label"></option></template></select></td><td><input class="compact" type="number" x-model.number="edit.track_number" /></td><td><input class="compact" type="number" x-model.number="edit.disc_number" /></td><td><input class="compact" type="number" x-model.number="edit.year" /></td><td><input :value="edit.artist_ids.join(', ')" @change="edit.artist_ids = parseRepairIds($event.target.value)" /></td><td><button class="btn" @click="repairPlan.tracks.splice(index,1)">Remove</button></td></tr></template></tbody></table>
<table class="repair-diff" x-show="repairPlan.tracks.length"><thead><tr><th>Before</th><th>After</th><th>Release</th><th>#</th><th>Disc</th><th>Year</th><th>Artist IDs</th><th></th></tr></thead><tbody><template x-for="(edit,index) in repairPlan.tracks" :key="edit.id"><tr><td><div x-text="repairEntityLabel('tracks',edit.id)"></div><small class="muted" x-text="repairEntityContext('tracks',repairBefore('tracks',edit.id))"></small></td><td><input x-model="edit.title" /></td><td><select x-model="edit.target_release"><template x-for="release in repairTargetReleases()" :key="release.value"><option :value="release.value" x-text="release.label"></option></template></select></td><td><input class="compact" type="number" x-model.number="edit.track_number" /></td><td><input class="compact" type="number" x-model.number="edit.disc_number" /></td><td><input class="compact" type="number" x-model.number="edit.year" /></td><td><input :value="edit.artist_ids.join(', ')" @change="edit.artist_ids = parseRepairIds($event.target.value)" /><small class="repair-context" x-text="repairArtistNames(edit.artist_ids)"></small></td><td><button class="btn" @click="repairPlan.tracks.splice(index,1)">Remove edit</button></td></tr></template></tbody></table>
<div class="toolbar"><button class="btn" @click="addRepairTrack()">+ Track edit</button></div>
</details>
<div class="repair-section-title repair-delete" x-show="repairDeleteCount()">Delete resources · <span x-text="repairDeleteCount()"></span></div>
<p class="muted" x-show="repairDeleteCount()">These resources will be removed from the library. Audio files are retained for Undo. Release tracks must be moved or explicitly deleted; artist credits are detached.</p>
<template x-for="kind in ['artists','releases','tracks']" :key="kind"><div><template x-for="id in (repairPlan.delete?.[kind] || [])" :key="id"><div class="repair-entity repair-delete"><span style="flex:1" x-text="kind + ' · ' + repairEntityLabel(kind,id) + (kind === 'releases' ? ' · ' + repairEntityContext(kind,repairBefore(kind,id)) : '')"></span><button class="btn" @click="repairPlan.delete[kind] = repairPlan.delete[kind].filter(value => value !== id)">Keep resource</button></div></template></div></template>
</div></template>
</fieldset></div>
<div class="repair-plan-actions"><span class="muted">Review the plan before applying.</span><button class="btn primary" @click="applyRepair()" :disabled="repairBusy || repairIncomplete || !repairChangeCount()">Apply plan</button></div>
</details>
</div>
<form class="repair-composer" @submit.prevent="sendRepair()"><textarea rows="3" placeholder="Describe the task or clarify the current plan…" aria-label="Message to metadata assistant" x-model="repairDraft" :disabled="repairBusy" @keydown.ctrl.enter.prevent="sendRepair()"></textarea><button class="btn primary" type="submit" :disabled="repairBusy || !repairDraft.trim() || !repairIncludedCount()" x-text="repairIncomplete && repairDraft.trim() === repairPendingInstruction ? 'Retry' : 'Send'"></button></form>
</section>
<section class="panel repair-chat"><div class="repair-scroll" style="display:flex;flex-direction:column;gap:7px" x-ref="repairChat"><template x-for="(turn,index) in repairChat" :key="index"><div class="repair-message" :class="turn.role" x-text="turn.content"></div></template><div class="muted" x-show="repairChat.length === 0">Describe what should change. The agent will respond in your language.</div></div><form class="repair-composer" @submit.prevent="sendRepair()"><textarea rows="2" placeholder="Describe the metadata problem…" x-model="repairDraft" @keydown.ctrl.enter.prevent="sendRepair()"></textarea><button class="btn primary" type="submit" :disabled="repairBusy || !repairDraft.trim() || !repairIncludedCount()" x-text="repairIncomplete && repairDraft.trim() === repairPendingInstruction ? 'Retry' : 'Send'"></button></form></section>
</div>
</div>
</div>
@@ -3334,7 +3383,7 @@ tbody tr:hover {
<section class="modal user-modal"><div class="modal-head"><strong x-text="userDraft.id ? 'Edit user' : 'Add user'"></strong><button class="btn" @click="userEditorOpen = false">Close</button></div>
<form class="modal-body" @submit.prevent="saveUser()">
<template x-for="field in ['username', 'email', 'display_name', 'password']" :key="field"><label class="field"><span x-text="field === 'password' && userDraft.id ? 'Password (leave blank to keep)' : field.replace('_', ' ')"></span><input class="search" :type="field === 'password' ? 'password' : (field === 'email' ? 'email' : 'text')" :autocomplete="field === 'password' ? 'new-password' : 'off'" :required="field === 'username' || (field === 'password' && !userDraft.id)" maxlength="255" x-model="userDraft[field]"></label></template>
<label class="field">Role<select class="search" x-model="userDraft.role"><option value="user">User</option><option value="admin">Administrator</option></select></label>
<label class="field">Local access<select class="search" x-model="userDraft.role"><option value="" x-show="userDraft.id">No local approval (SSO only)</option><option value="user">User</option><option value="admin">Administrator</option></select></label>
<button class="btn primary" type="submit" :disabled="userSaving">Save user</button>
</form></section>
</div>
@@ -3368,7 +3417,7 @@ tbody tr:hover {
</div>
<div class="user-summary-card">
<span>Account</span>
<strong x-text="activeUserDetail?.user.is_active ? 'active' : 'disabled'"></strong>
<strong x-text="activeUserDetail?.user.is_active ? 'active' : 'pending approval'"></strong>
</div>
<div class="user-summary-card">
<span>Last.fm</span>
@@ -4093,7 +4142,7 @@ function adminV2() {
scheduleDraft: '',
editUser(user = null) {
this.userModalOpen = false;
this.userDraft = {id:user?.id || null, username:user?.username || '', email:user?.email || '', display_name:user?.display_name || '', password:'', role:user?.role || 'user'};
this.userDraft = {id:user?.id || null, username:user?.username || '', email:user?.email || '', display_name:user?.display_name || '', password:'', role:user ? (user.local_role || '') : 'user'};
this.userEditorOpen = true;
},
async saveUser() {
@@ -4211,19 +4260,18 @@ function adminV2() {
repairSelected: [],
repairExpanded: null,
repairIncluded: {},
repairExcludedTracks: [],
repairDraft: '',
repairChat: [],
repairPlan: null,
repairPlanOpen: false,
repairSnapshot: null,
repairInstruction: '',
repairBusy: false,
repairStage: '',
repairIncomplete: false,
repairTrackOffset: 0,
repairTrackTotal: 0,
repairPendingInstruction: '',
repairReference: '',
repairExpandedReference: '',
repairHistory: [],
settings: { values: {}, sources: {}, youtube_cookie_files: [], lastfm_api_key_configured: false, lastfm_shared_secret_configured: false, lastfm_scrobbling_configured: false },
settingsDraft: {
@@ -4479,11 +4527,10 @@ function adminV2() {
this.repairSelected.push({kind:item.kind,id:Number(item.id),title:item.title});
this.repairExpanded = null;
this.repairPlan = null;
this.repairSnapshot = null;
this.repairIncomplete = false;
this.repairTrackOffset = 0;
this.repairPendingInstruction = '';
this.repairReference = '';
this.repairExpandedReference = '';
this.repairSearch = '';
this.repairSearchResults = [];
},
@@ -4491,16 +4538,14 @@ function adminV2() {
this.repairSelected = [];
this.repairExpanded = null;
this.repairIncluded = {};
this.repairExcludedTracks = [];
this.repairPlan = null;
this.repairSnapshot = null;
this.repairChat = [];
this.repairDraft = '';
this.repairIncomplete = false;
this.repairTrackOffset = 0;
this.repairTrackTotal = 0;
this.repairPendingInstruction = '';
this.repairReference = '';
this.repairExpandedReference = '';
},
repairSelection(expanded = false) {
const selection = {artists:[],releases:[],tracks:[]};
@@ -4513,8 +4558,15 @@ function adminV2() {
} else {
for (const item of this.repairSelected) if (this.repairIncluded[item.kind + ':' + item.id] !== false) selection[item.kind].push(item.id);
}
if (expanded && this.repairExpanded) {
for (const track of this.repairExpanded.snapshot.tracks || []) {
if (selection.releases.includes(track.release_id) && !this.repairExcludedTracks.includes(track.id) && !selection.tracks.includes(track.id)) selection.tracks.push(track.id);
}
selection.tracks = selection.tracks.filter(id => !this.repairExcludedTracks.includes(id)).sort((a,b) => a-b);
}
return selection;
},
repairIsIncluded(kind,id) { return this.repairSelection(true)[kind].includes(Number(id)); },
repairRows(kind) {
if (this.repairExpanded) return this.repairExpanded.snapshot[kind] || [];
return this.repairSelected.filter(item => item.kind === kind);
@@ -4522,16 +4574,50 @@ function adminV2() {
repairIncludedCount() {
return Object.values(this.repairSelection(true)).reduce((total, ids) => total + ids.length, 0);
},
setRepairIncluded(kind,id,checked) {
if (this.repairBusy) return;
this.repairIncluded[kind + ':' + id] = checked;
repairRowsCount() { return ['artists','releases','tracks'].reduce((count,kind) => count + this.repairRows(kind).length,0); },
invalidateRepairPlan() {
this.repairPlan = null;
this.repairSnapshot = null;
this.repairIncomplete = false;
this.repairTrackOffset = 0;
this.repairPendingInstruction = '';
this.repairReference = '';
this.repairExpandedReference = '';
},
setAllRepairIncluded(checked) {
if (this.repairBusy) return;
this.repairExcludedTracks = [];
for (const kind of ['artists','releases','tracks']) {
for (const item of this.repairRows(kind)) this.repairIncluded[kind + ':' + item.id] = checked;
}
this.invalidateRepairPlan();
},
setRepairIncluded(kind,id,checked) {
if (this.repairBusy) return;
this.repairIncluded[kind + ':' + id] = checked;
if (kind === 'tracks') {
this.repairExcludedTracks = this.repairExcludedTracks.filter(value => value !== id);
if (!checked) this.repairExcludedTracks.push(id);
}
if (kind === 'releases' && checked) {
const tracks = this.repairRows('tracks').filter(track => track.release_id === id).map(track => track.id);
this.repairExcludedTracks = this.repairExcludedTracks.filter(id => !tracks.includes(id));
}
this.invalidateRepairPlan();
},
repairEntityLabel(kind,id) {
const row = this.repairBefore(kind,id) || this.repairRows(kind).find(row => Number(row.id) === Number(id));
return (row?.name || row?.title || kind) + ' #' + id;
},
repairArtistNames(ids) {
return ids.map(id => this.repairEntityLabel('artists',id)).join(', ');
},
repairEntityContext(kind,item) {
if (!item) return '';
const scope = this.repairSnapshot || this.repairExpanded?.snapshot;
if (kind === 'releases') return [item.year, item.release_type, (scope?.release_artists || []).filter(link => link.owner_id === item.id).map(link => this.repairEntityLabel('artists',link.artist_id)).join(', ')].filter(Boolean).join(' · ');
if (kind === 'tracks') {
const release = (scope?.releases || []).find(row => row.id === item.release_id);
return [release ? release.title + ' #' + release.id : 'Release #' + item.release_id, release?.year, item.track_number ? 'Track ' + item.track_number : ''].filter(Boolean).join(' · ');
}
return '';
},
async expandRepair() {
if (this.repairSelected.length === 0) return;
@@ -4541,12 +4627,11 @@ function adminV2() {
this.repairExpanded = await this.request(`${this.apiBase}/metadata-fix/expand`, {
method:'POST',body:JSON.stringify({selection:this.repairSelection(false),reference:this.repairReference || null})
});
this.repairExpandedReference = this.repairReference;
this.repairPlan = null;
this.repairSnapshot = null;
this.repairIncluded = {};
this.repairExcludedTracks = [];
this.repairIncomplete = false;
this.repairTrackOffset = 0;
this.repairPendingInstruction = '';
} catch (error) { this.showToast(error.message); }
finally { this.repairBusy = false; this.repairStage = ''; }
@@ -4557,9 +4642,9 @@ function adminV2() {
return relations.filter(row => Number(row.owner_id) === Number(id)).map(row => Number(row.artist_id));
},
repairTargetReleases() {
const existing = (this.repairSnapshot?.releases || []).map(row => ({value:'existing:' + row.id,label:row.title + ' #' + row.id}));
const existing = (this.repairSnapshot?.releases || []).filter(row => !this.repairPlan?.delete?.releases?.includes(row.id)).map(row => ({value:'existing:' + row.id,label:row.title + (row.year ? ' (' + row.year + ')' : '') + ' #' + row.id}));
for (const track of this.repairSnapshot?.tracks || []) {
if (!existing.some(row => row.value === 'existing:' + track.release_id)) existing.push({value:'existing:' + track.release_id,label:'Current release #' + track.release_id});
if (!this.repairPlan?.delete?.releases?.includes(track.release_id) && !existing.some(row => row.value === 'existing:' + track.release_id)) existing.push({value:'existing:' + track.release_id,label:'Current release #' + track.release_id});
}
const created = (this.repairPlan?.releases || []).filter(row => row.key && !row.id).map(row => ({value:'new:' + row.key,label:(row.title || 'New release') + ' · new'}));
return existing.concat(created);
@@ -4573,11 +4658,32 @@ function adminV2() {
},
addRepairTrack() {
if (!this.repairPlan || !this.repairSnapshot) return;
const row = this.repairSnapshot.tracks.find(x => !this.repairPlan.tracks.some(edit => edit.id === x.id));
const row = this.repairSnapshot.tracks.find(x => !this.repairPlan.tracks.some(edit => edit.id === x.id) && !this.repairPlan.delete?.tracks?.includes(x.id));
if (!row) { this.showToast('All selected tracks are already in the plan'); return; }
this.repairPlan.tracks.push({id:row.id,title:row.title,target_release:'existing:' + row.release_id,track_number:row.track_number,disc_number:row.disc_number,year:row.year,artist_ids:this.repairArtistIds('tracks',row.id)});
},
repairChangeCount() { return this.repairPlan ? this.repairPlan.artists.length + this.repairPlan.releases.length + this.repairPlan.tracks.length : 0; },
repairPreview() {
if (!this.repairPlan) return [];
const rows = [];
for (const edit of this.repairPlan.artists) rows.push({key:'artist:' + edit.id,action:'Rename artist',title:this.repairEntityLabel('artists',edit.id),detail:'→ ' + edit.name});
for (const edit of this.repairPlan.releases) {
const old = edit.id ? this.repairBefore('releases',edit.id) : null;
rows.push({key:'release:' + (edit.id || edit.key),action:old ? 'Edit release' : 'Create release',title:edit.title + (edit.year != null ? ' (' + edit.year + ')' : ''),detail:[old ? 'Before: ' + this.repairEntityLabel('releases',edit.id) + (old.year != null ? ' (' + old.year + ')' : '') : '',edit.release_type,this.repairArtistNames(edit.artist_ids)].filter(Boolean).join(' · ')});
}
for (const edit of this.repairPlan.tracks) {
const old = this.repairBefore('tracks',edit.id);
const moved = old && edit.target_release !== 'existing:' + old.release_id;
const details = [];
if (moved) details.push(this.repairEntityLabel('releases',old.release_id) + ' → ' + (this.repairTargetReleases().find(row => row.value === edit.target_release)?.label || edit.target_release));
if (old && old.title !== edit.title) details.push('Title: ' + old.title + ' → ' + edit.title);
for (const [field,label] of [['track_number','Track number'],['disc_number','Disc'],['year','Year']]) if (old && old[field] !== edit[field]) details.push(label + ': ' + (old[field] ?? '—') + ' → ' + (edit[field] ?? '—'));
if (JSON.stringify(this.repairArtistIds('tracks',edit.id)) !== JSON.stringify(edit.artist_ids)) details.push('Artists: ' + this.repairArtistNames(edit.artist_ids));
rows.push({key:'track:' + edit.id,action:moved ? 'Move track' : 'Edit track',title:edit.title + ' #' + edit.id,detail:details.join('\n')});
}
return rows;
},
repairDeleteCount() { return Object.values(this.repairPlan?.delete || {}).reduce((count,ids) => count + ids.length,0); },
repairChangeCount() { return this.repairPlan ? this.repairPlan.artists.length + this.repairPlan.releases.length + this.repairPlan.tracks.length + this.repairDeleteCount() : 0; },
repairPlanPayload() {
const plan = JSON.parse(JSON.stringify(this.repairPlan));
for (const edit of [...plan.releases, ...plan.tracks]) {
@@ -4590,52 +4696,43 @@ function adminV2() {
async sendRepair() {
const instruction = this.repairDraft.trim();
if (!instruction || this.repairBusy || !this.repairIncludedCount()) return;
if (!this.repairReference) {
const source = this.repairChat.find(turn => turn.role === 'user' && turn.content.includes('### ') && /^\s*\d+\.\s+\S/m.test(turn.content));
if (source) this.repairReference = source.content;
}
const resuming = this.repairIncomplete && this.repairPendingInstruction === instruction;
if (instruction.includes('### ') && /^\s*\d+\.\s+\S/m.test(instruction)) this.repairReference = instruction;
if (!resuming) {
this.repairTrackOffset = 0;
this.repairTrackTotal = 0;
}
const resuming = this.repairIncomplete && this.repairPendingInstruction === instruction;
this.repairBusy = true;
this.repairStage = 'thinking';
this.repairIncomplete = true;
this.repairPendingInstruction = instruction;
this.repairTrackTotal = this.repairSelection(true).tracks.length;
this.repairDraft = '';
const previous = this.repairChat.slice(-6);
const previous = this.repairChat.slice(-20);
if (resuming && previous.at(-1)?.role === 'user' && previous.at(-1).content === instruction) previous.pop();
if (!resuming) this.repairChat.push({role:'user',content:instruction});
this.scrollRepairChat();
try {
if (!this.repairExpanded || this.repairExpandedReference !== this.repairReference) {
this.repairExpanded = await this.request(`${this.apiBase}/metadata-fix/expand`, {method:'POST',body:JSON.stringify({selection:this.repairSelection(false),reference:this.repairReference || null})});
this.repairExpandedReference = this.repairReference;
if (!this.repairExpanded) {
await this.expandRepairForChat();
}
while (true) {
const result = await this.request(`${this.apiBase}/metadata-fix/plan`, {method:'POST',body:JSON.stringify({selection:this.repairSelection(true),instruction,reference:this.repairReference || null,primary_artist_ids:this.repairSelected.filter(item => item.kind === 'artists').map(item => item.id),conversation:previous,current_plan:this.repairPlan ? this.repairPlanPayload() : null,track_offset:this.repairTrackOffset})});
this.repairPlan = result.plan;
this.repairSnapshot = result.snapshot;
this.repairTrackTotal = result.total_tracks;
this.repairTrackOffset = result.next_track_offset ?? result.total_tracks;
if (result.next_track_offset == null) {
this.repairChat.push({role:'assistant',content:result.message});
this.repairIncomplete = false;
this.repairPendingInstruction = '';
break;
}
}
this.repairInstruction = instruction;
const result = await this.request(`${this.apiBase}/metadata-fix/plan`, {method:'POST',body:JSON.stringify({selection:this.repairSelection(true),excluded_track_ids:this.repairExcludedTracks,instruction,reference:this.repairReference || null,primary_artist_ids:this.repairSelected.filter(item => item.kind === 'artists').map(item => item.id),conversation:previous,current_plan:this.repairPlan ? this.repairPlanPayload() : null})});
this.repairPlan = result.plan;
this.repairSnapshot = result.snapshot;
this.repairChat.push({role:'assistant',content:result.message});
this.repairIncomplete = false;
this.repairPendingInstruction = '';
this.repairInstruction = this.repairChat.filter(turn => turn.role === 'user').map(turn => turn.content).join('\n\n').slice(-8000);
} catch (error) {
this.repairDraft = instruction;
this.showToast(error.message);
} finally {
this.repairBusy = false;
this.repairStage = '';
this.$nextTick(() => { if (this.$refs.repairChat) this.$refs.repairChat.scrollTop = this.$refs.repairChat.scrollHeight; });
this.scrollRepairChat();
}
},
async expandRepairForChat() {
this.repairExpanded = await this.request(`${this.apiBase}/metadata-fix/expand`, {method:'POST',body:JSON.stringify({selection:this.repairSelection(false),reference:this.repairReference || null})});
},
scrollRepairChat() {
this.$nextTick(() => { if (this.$refs.repairChat) this.$refs.repairChat.scrollTop = this.$refs.repairChat.scrollHeight; });
},
async applyRepair() {
if (!this.repairPlan || !this.repairSnapshot || this.repairBusy || this.repairIncomplete || !this.repairChangeCount()) return;
this.repairBusy = true;
@@ -4643,6 +4740,11 @@ function adminV2() {
try {
const result = await this.request(`${this.apiBase}/metadata-fix/apply`, {method:'POST',body:JSON.stringify({snapshot:this.repairSnapshot,plan:this.repairPlanPayload(),instruction:this.repairInstruction})});
this.showToast('Applied · history #' + result.history_id);
this.repairChat.push({role:'assistant',content:'Plan applied · history #' + result.history_id + '. You can undo it from History.'});
this.repairSelected = [];
this.repairIncluded = {};
this.repairExcludedTracks = [];
this.repairIncomplete = false;
this.repairPlan = null;
this.repairSnapshot = null;
this.repairExpanded = null;
@@ -4662,8 +4764,13 @@ function adminV2() {
await this.request(`${this.apiBase}/metadata-fix/undo`, {method:'POST',body:JSON.stringify({history_id:historyId})});
await this.loadRepairHistory();
this.repairExpanded = null;
this.repairPlan = null;
this.invalidateRepairPlan();
this.repairSelected = [];
this.repairIncluded = {};
this.repairExcludedTracks = [];
this.repairChat.push({role:'assistant',content:'Metadata repair #' + historyId + ' undone.'});
this.showToast('Metadata repair undone');
await this.loadLibrary(false);
} catch (error) { this.showToast(error.message); }
finally { this.repairBusy = false; }
},
@@ -4722,6 +4829,13 @@ function adminV2() {
}
},
async approveUser(user, role) {
try {
await this.request(`${this.apiBase}/users/manage`, {method:'POST', body:JSON.stringify({action:'approve', id:user.id, role})});
await this.loadUsers(false);
} catch (error) { this.showToast(error.message); }
},
async loadUsers(resetOffset = true) {
if (this.activeView !== 'users' && resetOffset) return;
if (resetOffset) this.users.offset = 0;
+23
View File
@@ -0,0 +1,23 @@
{% extends "base.html" %}
{% block title %}{{ t.approval_heading }} | {{ t.site_name }}{% endblock title %}
{% block head_extra %}
<style>
body { margin:0; min-height:100vh; display:grid; place-items:center; background:#121212; color:#eee; font-family:system-ui,sans-serif; }
.approval-card { max-width:440px; margin:24px; padding:36px; border:1px solid #333; border-radius:18px; background:#1b1b1b; }
h1 { font-size:24px; } p { line-height:1.6; color:#bbb; } a { color:#b7d79f; }
</style>
{% endblock head_extra %}
{% block body %}
<main class="approval-card"><h1>{{ t.approval_heading }}</h1><p>{{ t.approval_message }}</p><a href="/logout">{{ t.player_log_out }}</a></main>
<script>
setInterval(async () => {
try {
const response = await fetch('/auth/status', {cache:'no-store'});
if (!response.ok) return;
const {status} = await response.json();
if (status === 'active') location.replace('/');
else if (status === 'anonymous') location.replace('/login');
} catch {}
}, 5000);
</script>
{% endblock body %}
+83 -108
View File
@@ -1,9 +1,11 @@
<script defer src="https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js"></script>
<script>
const GUEST = {{ guest }};
const SHARE_TOKEN = "{{ share_token }}";
// Handle expired sessions centrally, including background player requests.
let loginRedirectStarted = false;
function redirectOnUnauthorized(status) {
if (status !== 401 || loginRedirectStarted) return;
if (GUEST || status !== 401 || loginRedirectStarted) return;
loginRedirectStarted = true;
window.location.replace('/login');
}
@@ -60,8 +62,8 @@ const T = {
lastfmDisconnectConfirm: "{{ t.player_lastfm_disconnect_confirm }}",
lastfmConnectFailed: "{{ t.player_lastfm_connect_failed }}",
lastfmDisconnectFailed: "{{ t.player_lastfm_disconnect_failed }}",
startRadio: "{{ t.player_start_radio }}",
radioFailed: "{{ t.player_radio_failed }}",
download: "{{ t.track_download }}",
shareUnavailable: "{{ t.share_unavailable }}",
searchSimilarTo: "{{ t.player_search_similar_to }}",
findSimilar: "{{ t.player_find_similar }}",
similarityFailed: "{{ t.player_similarity_failed }}",
@@ -342,6 +344,7 @@ document.addEventListener('alpine:init', () => {
}
},
navigate(link) {
if (GUEST) return;
if (!link || !link.id) return;
this.close();
const library = Alpine.store('library');
@@ -388,35 +391,39 @@ document.addEventListener('alpine:init', () => {
return copied;
},
copyTrack(track, trigger = null) {
async copyTrack(track, trigger = null) {
const id = Number(track?.id || track);
if (!id) return;
this.copyUrl(`/share/track/${id}`, trigger);
if (id) return this.copyTracks([{id}], track?.title || T.sharedPlaylist, trigger);
},
async copyQueue(trigger = null) {
const queue = Alpine.store('queue');
return this.copyTracks(queue?.tracks || [], T.sharedPlaylist, trigger);
return this.copyTracks(Alpine.store('queue')?.tracks || [], T.sharedPlaylist, trigger);
},
async copyRelease(release, trigger = null) {
const id = Number(release?.id || release || 0);
if (!id) return;
return this.copyUrl(`/share/release/${id}`, trigger);
try {
const id = Number(release?.id || release || 0);
if (!id) return;
const response = await fetch(`/api/player/releases/${id}`);
if (!response.ok) throw new Error('release load failed');
const data = await response.json();
return this.copyTracks(data.tracks || [], data.title || T.sharedPlaylist, trigger);
} catch { this.flashTrigger(trigger, false); }
},
async copyTracks(tracks, title = T.sharedPlaylist, trigger = null) {
if (GUEST) return this.copyUrl(`/share/${SHARE_TOKEN}`, trigger);
const trackIds = (tracks || []).map(track => Number(track.id)).filter(Boolean);
if (!trackIds.length) return;
try {
const res = await fetch('/api/player/share-playlist', {
const res = await fetch('/api/player/shares', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ track_ids: trackIds, title }),
});
if (!res.ok) throw new Error('share failed');
const data = await res.json();
await this.copyUrl(data.url || `/share/playlist/${data.token}`, trigger);
await this.copyUrl(data.url || `/share/${data.token}`, trigger);
} catch (err) {
this.flashTrigger(trigger, false);
console.warn(err);
@@ -468,84 +475,24 @@ document.addEventListener('alpine:init', () => {
},
async handleInitialShareLinks() {
if (this._handledInitialLink) return;
if (this._handledInitialLink || !SHARE_TOKEN) return;
this._handledInitialLink = true;
const params = new URLSearchParams(window.location.search);
const trackId = Number(params.get('track') || 0);
const releaseId = Number(params.get('release') || 0);
const playlistToken = (params.get('playlist_share') || '').trim();
if (trackId > 0) {
await this.openSharedTrack(trackId);
this._clearShareQuery();
} else if (releaseId > 0) {
await this.openSharedRelease(releaseId);
this._clearShareQuery();
} else if (playlistToken) {
await this.openSharedPlaylist(playlistToken);
this._clearShareQuery();
}
},
async openSharedTrack(trackId) {
try {
const res = await fetch('/api/player/tracks-by-ids', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ ids: [Number(trackId)] }),
});
if (!res.ok) throw new Error('track load failed');
const tracks = await res.json();
const track = Array.isArray(tracks) ? tracks[0] : null;
if (!track) return;
this.markSharedTrack(track.id);
if (track.release_id) {
await Alpine.store('library').openRelease(track.release_id, { focusSharedTrackId: track.id });
}
const queue = Alpine.store('queue');
queue.tracks = [track];
queue.currentIndex = 0;
Alpine.store('player')._playLocal(track, { paused: true });
this.focusSharedTrack(track.id);
} catch (err) {
console.warn(err);
}
},
async openSharedRelease(releaseId) {
const id = Number(releaseId || 0);
if (!id) return;
this.markSharedTrack(null);
await Alpine.store('library').openRelease(id);
},
async openSharedPlaylist(token) {
try {
const res = await fetch(`/api/player/share-playlist/${encodeURIComponent(token)}`);
if (!res.ok) throw new Error('playlist load failed');
const data = await res.json();
const tracks = Array.isArray(data.tracks) ? data.tracks : [];
if (!tracks.length) return;
const response = await fetch(`/api/player/shares/${SHARE_TOKEN}`);
if (!response.ok) throw new Error('share unavailable');
const data = await response.json();
const tracks = data.tracks || [];
Alpine.store('library').showSharedPlaylist(data);
if (!tracks.length) throw new Error('share empty');
const queue = Alpine.store('queue');
queue.tracks = tracks;
queue.currentIndex = 0;
Alpine.store('player')._playLocal(tracks[0], { paused: true });
Alpine.store('library').showSharedPlaylist(data);
} catch (err) {
console.warn(err);
Alpine.store('player')._playLocal(tracks[0], {paused:true});
} catch {
Alpine.store('library').showSharedPlaylist({title:T.shareUnavailable, tracks:[]});
}
},
_clearShareQuery() {
const url = new URL(window.location.href);
url.searchParams.delete('track');
url.searchParams.delete('release');
url.searchParams.delete('playlist_share');
const query = url.searchParams.toString();
const next = `${url.pathname}${query ? '?' + query : ''}${window.location.hash}`;
history.replaceState({}, '', next);
},
});
// -----------------------------------------------------------------------
@@ -553,17 +500,33 @@ document.addEventListener('alpine:init', () => {
// -----------------------------------------------------------------------
Alpine.store('user', {
profile: null,
accessStatus: "anonymous",
menuOpen: false,
settingsOpen: false,
lastfm: { configured: false, connected: false, username: null, reauth_required: false, last_error: null },
lastfmBusy: false,
init() {
if (GUEST) {
this.checkAccess();
setInterval(() => this.checkAccess(), 5000);
return;
}
this.cleanLastfmQuery();
this.load();
this.loadLastfm();
},
async checkAccess() {
try {
const response = await fetch('/auth/status', {cache:'no-store'});
if (!response.ok) return;
const data = await response.json();
this.accessStatus = data.status;
if (data.status === 'active') window.location.reload();
} catch {}
},
cleanLastfmQuery() {
const url = new URL(window.location.href);
if (!url.searchParams.has('lastfm')) return;
@@ -799,11 +762,7 @@ document.addEventListener('alpine:init', () => {
_prefetchedQueueKey: null,
_baseDocumentTitle: '',
_hasInitialShareLink() {
const params = new URLSearchParams(window.location.search);
return Number(params.get('track') || 0) > 0
|| (params.get('playlist_share') || '').trim().length > 0;
},
_hasInitialShareLink() { return !!SHARE_TOKEN; },
init() {
audio.volume = this.volume;
@@ -1447,6 +1406,7 @@ document.addEventListener('alpine:init', () => {
},
_saveState() {
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
const state = this._buildStatePayload();
@@ -1458,6 +1418,7 @@ document.addEventListener('alpine:init', () => {
},
_saveStateSync() {
if (GUEST) return;
const queue = Alpine.store('queue');
if (!this.currentTrack && queue.tracks.length === 0) return;
const state = this._buildStatePayload();
@@ -1466,6 +1427,7 @@ document.addEventListener('alpine:init', () => {
},
async _restoreState() {
if (GUEST) return;
try {
const res = await fetch('/api/player/state');
if (!res.ok) return;
@@ -1521,6 +1483,7 @@ document.addEventListener('alpine:init', () => {
},
_recordHistory(endedReason, unloading = false) {
if (GUEST) return;
const track = this._historyTrack;
if (this._historyRecorded || !track || !this._playbackStartedAt) return;
if (!Number.isInteger(Number(track.id)) || track.federated_cache) return;
@@ -1603,6 +1566,7 @@ document.addEventListener('alpine:init', () => {
},
_sendNowPlaying() {
if (GUEST) return;
if (this._nowPlayingSent || !this.currentTrack) return;
if (!Number.isInteger(Number(this.currentTrack.id)) || this.currentTrack.federated_cache) {
return;
@@ -1652,6 +1616,7 @@ document.addEventListener('alpine:init', () => {
_lastPlaybackState: null,
init() {
if (GUEST) return;
this.id = this._ensureId();
this.currentJamId = sessionStorage.getItem('furu_player_jam_id') || null;
this.heartbeat();
@@ -1868,6 +1833,7 @@ document.addEventListener('alpine:init', () => {
},
isActive() {
if (GUEST) return true;
if (this.isControllingRemoteJam()) return false;
return !this.activeDeviceId || this.activeDeviceId === this.id;
},
@@ -2635,6 +2601,10 @@ document.addEventListener('alpine:init', () => {
_hashNav: false, // guard against circular hash updates
init() {
if (GUEST) {
this.$nextTick(() => Alpine.store('sharing').handleInitialShareLinks());
return;
}
this._setupScroll();
this.loadFederationLikes();
window.addEventListener('furumi:track-availability', event => {
@@ -2668,6 +2638,7 @@ document.addEventListener('alpine:init', () => {
},
_navigateFromHash(options = {}) {
if (GUEST) return;
if (this._hashNav) return;
const hash = location.hash || '#artists';
const match = hash.match(/^#(\w+)(?:\/([-]?\d+))?(?:\?(.*))?$/);
@@ -2778,6 +2749,7 @@ document.addEventListener('alpine:init', () => {
},
goArtists(options = {}) {
if (GUEST) return;
this._beginNavigation('#artists', options);
if (this.artistFilter !== 'all' || this.artistsPage === 0) {
this._resetArtistList('all');
@@ -2795,6 +2767,7 @@ document.addEventListener('alpine:init', () => {
},
goMyUploads(options = {}) {
if (GUEST) return;
this._beginNavigation('#uploads', options);
if (this.artistFilter !== 'uploads' || this.artistsPage === 0) {
this._resetArtistList('uploads');
@@ -2854,6 +2827,7 @@ document.addEventListener('alpine:init', () => {
},
async openArtist(id, options = {}) {
if (GUEST) return;
this.stopArtistFederation();
this._beginNavigation('#artist/' + id, options);
this.searchQuery = '';
@@ -3145,26 +3119,22 @@ document.addEventListener('alpine:init', () => {
return `${T.lastfmRating}: ${Math.round(value)}\n${this.trackInfo(track)}`;
},
async startRadio(kind, id) {
if (!kind || !id) return;
try {
const res = await fetch(`/api/player/radio/${encodeURIComponent(kind)}/${encodeURIComponent(id)}`);
if (!res.ok) throw new Error('radio failed');
const tracks = await res.json();
if (!Array.isArray(tracks) || tracks.length === 0) throw new Error('radio empty');
Alpine.store('queue').playRelease(tracks, 0);
Alpine.store('info').close();
} catch (err) {
console.warn(err);
window.alert(T.radioFailed);
}
downloadTrack(track) {
if (!track?.id) return;
const link = document.createElement('a');
link.href = GUEST ? `/api/player/shares/${SHARE_TOKEN}/download/${track.id}` : `/api/player/download/${track.id}`;
link.download = '';
document.body.appendChild(link);
link.click();
link.remove();
},
openTrackInfo(track) {
Alpine.store('info').openRows(T.trackInfoTitle, this.trackInfoRows(track), [
{ label: T.startRadio, run: () => this.startRadio('track', track?.id) },
{ label: T.findSimilar, run: () => this.searchSimilar(track) },
]);
const rows = this.trackInfoRows(track).map(row => GUEST && row.links
? {...row, value: row.links.map(link => link.label).join(', '), links: null} : row);
const actions = [{label:T.download, run:() => this.downloadTrack(track)}];
if (!GUEST) actions.push({label:T.findSimilar, run:() => this.searchSimilar(track)});
Alpine.store('info').openRows(T.trackInfoTitle, rows, actions);
},
uploadersInfo(uploaders) {
@@ -3188,9 +3158,7 @@ document.addEventListener('alpine:init', () => {
},
openReleaseInfo(release) {
Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release), [
{ label: T.startRadio, run: () => this.startRadio('release', release?.id) },
]);
Alpine.store('info').openRows(T.releaseInfoTitle, this.releaseInfoRows(release));
},
infoLinks(items, type) {
@@ -3289,6 +3257,7 @@ document.addEventListener('alpine:init', () => {
},
async openRelease(id, options = {}) {
if (GUEST) return;
this.stopReleaseFederation();
this._beginNavigation('#release/' + id, options);
this.searchQuery = '';
@@ -3405,6 +3374,7 @@ document.addEventListener('alpine:init', () => {
},
async openPlaylist(id, options = {}) {
if (GUEST) return;
this._beginNavigation('#playlist/' + id, options);
Alpine.store('playlists')?.stopEdit?.();
this.view = 'playlist_detail';
@@ -3491,6 +3461,7 @@ document.addEventListener('alpine:init', () => {
},
async search(query, options = {}) {
if (GUEST) return;
const q = (query || '').trim();
if (!q) {
this.clearSearch();
@@ -3518,6 +3489,7 @@ document.addEventListener('alpine:init', () => {
},
async searchSimilar(trackOrId, options = {}) {
if (GUEST) return;
const id = Number(typeof trackOrId === 'object' ? trackOrId?.id : trackOrId);
if (!Number.isInteger(id) || id <= 0) return;
const track = typeof trackOrId === 'object' ? trackOrId : null;
@@ -4494,6 +4466,7 @@ document.addEventListener('alpine:init', () => {
_set: new Set(),
init() {
if (GUEST) return;
this.reload();
},
@@ -4563,6 +4536,7 @@ document.addEventListener('alpine:init', () => {
artists: [],
init() {
if (GUEST) return;
this.reload();
},
@@ -6503,6 +6477,7 @@ document.addEventListener('alpine:init', () => {
_pointerDragEnd: null,
init() {
if (GUEST) return;
this.reload();
},
+54 -45
View File
@@ -1,4 +1,4 @@
<div class="app-layout"
<div class="app-layout{% if guest %} guest-player{% endif %}"
x-data
@keydown.window.space="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.toggle(); }"
@keydown.window.arrow-left="if (!['INPUT','TEXTAREA','SELECT'].includes(document.activeElement?.tagName)) { $event.preventDefault(); $store.player.seekRelative(-5); }"
@@ -7,6 +7,7 @@
>
<div class="main-content">
{% if !guest %}
<!-- Left Sidebar -->
<div class="sidebar-left">
<div class="user-widget" x-show="$store.user.profile" x-cloak>
@@ -119,17 +120,17 @@
</div>
<template x-if="pl.is_own && pl.kind === 'user'">
<div class="playlist-item-actions">
<button class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
</button>
<button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
</button>
</div>
</template>
</div>
</template>
<button class="sidebar-create-btn" @click="$store.playlists.showCreate()">
<button data-member-only class="sidebar-create-btn" @click="$store.playlists.showCreate()">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
{{ t.player_new_playlist }}
</button>
@@ -156,6 +157,7 @@
</div>
</div>
{% endif %}
<template x-if="$store.mobile.libraryOpen">
<div class="mobile-library-backdrop" @click.self="$store.mobile.closeLibrary()" x-cloak>
<aside class="mobile-library-drawer">
@@ -212,7 +214,7 @@
</div>
<div class="following-name" x-text="artist.name"></div>
</div>
<button class="mobile-list-action"
<button data-member-only class="mobile-list-action"
@click.stop="$store.follows.toggle(artist.id)"
title="{{ t.player_unfollow_artist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -244,17 +246,17 @@
</div>
<template x-if="pl.is_own && pl.kind === 'user'">
<div class="playlist-item-actions">
<button class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.mobile.closeLibrary(); $store.playlists.startRename(pl)" title="{{ t.player_rename }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M11 4H4a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2v-7"/><path d="M18.5 2.5a2.12 2.12 0 013 3L12 15l-4 1 1-4 9.5-9.5z"/></svg>
</button>
<button class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<button data-member-only class="playlist-action-btn" @click.stop="$store.playlists.deletePlaylist(pl.id)" title="{{ t.player_delete }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="3 6 5 6 21 6"/><path d="M19 6v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6m3 0V4a2 2 0 012-2h4a2 2 0 012 2v2"/></svg>
</button>
</div>
</template>
</div>
</template>
<button class="sidebar-create-btn" @click="$store.mobile.closeLibrary(); $store.playlists.showCreate()">
<button data-member-only class="sidebar-create-btn" @click="$store.mobile.closeLibrary(); $store.playlists.showCreate()">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
{{ t.player_new_playlist }}
</button>
@@ -288,7 +290,7 @@
<div class="center-content" id="center-scroll">
<!-- Search / account bar -->
<div class="content-topbar" @click.outside="$store.user.menuOpen = false">
<button class="mobile-library-btn"
<button data-member-only class="mobile-library-btn"
@click="$store.user.menuOpen = false; $store.mobile.toggleLibrary()"
title="{{ t.player_library }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -310,6 +312,13 @@
</svg>
<span class="connection-alert-text">{{ t.player_connection_lost }}</span>
</div>
{% if guest %}
<div class="guest-account">
<strong>{{ t.guest_label }}</strong>
<div x-show="$store.user.accessStatus === 'pending'" x-cloak><span>{{ t.approval_heading }}</span> · <a href="/logout">{{ t.player_log_out }}</a></div>
<a x-show="$store.user.accessStatus === 'anonymous'" href="/login?next=/share/{{ share_token }}">{{ t.guest_login }}</a>
</div>
{% endif %}
<div class="search-bar">
<span class="search-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="11" cy="11" r="8"/><line x1="21" y1="21" x2="16.65" y2="16.65"/></svg></span>
<input id="search-input" type="text" placeholder="{{ t.player_search_placeholder }}"
@@ -518,7 +527,7 @@
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
</button>
<button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
</button>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -527,10 +536,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -670,7 +679,7 @@
title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="$store.playlists.showFederationPicker(track)"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -714,7 +723,7 @@
<template x-if="!artist.image_url">
<span class="placeholder-icon"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="12" cy="8" r="4"/><path d="M20 21a8 8 0 10-16 0"/></svg></span>
</template>
<button class="artist-follow-card-btn"
<button data-member-only class="artist-follow-card-btn"
:class="{ followed: $store.follows.has(artist.id) }"
@click.stop="$store.follows.toggle(artist.id)"
:title="$store.follows.has(artist.id) ? '{{ t.player_unfollow_artist }}' : '{{ t.player_follow_artist }}'">
@@ -794,7 +803,7 @@
</svg>
<span>{{ t.player_listen }}</span>
</button>
<button class="release-action-btn secondary artist-follow-action"
<button data-member-only class="release-action-btn secondary artist-follow-action"
x-show="$store.library.currentArtist.id"
:class="{ followed: $store.follows.has($store.library.currentArtist.id) }"
@click="$store.follows.toggle($store.library.currentArtist.id)"
@@ -881,7 +890,7 @@
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
</button>
<button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
</button>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -890,10 +899,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -1037,7 +1046,7 @@
title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="$store.playlists.showFederationPicker(track)"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
@@ -1110,7 +1119,7 @@
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
</button>
<button class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<button data-member-only class="like-btn" :class="{ liked: $store.likes.has(track.id) }" @click.stop="$store.likes.toggle(track.id)" title="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has(track.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
</button>
<button class="track-action-btn queue-insert-btn queue-next-btn" @click.stop="$store.queue.addNextInQueue([track])" title="{{ t.player_play_next }}">
@@ -1119,10 +1128,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<button data-member-only class="track-action-btn playlist-add-btn" @click.stop="$store.playlists.showPicker([track.id])" title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
</button>
</div>
@@ -1193,7 +1202,7 @@
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="10"/><line x1="12" y1="16" x2="12" y2="12"/><line x1="12" y1="8" x2="12.01" y2="8"/></svg>
{{ t.player_info }}
</button>
<button class="release-action-btn secondary release-share-btn"
<button data-member-only class="release-action-btn secondary release-share-btn"
x-show="!$store.library.currentRelease.federated"
@click.stop="$store.sharing.copyRelease($store.library.currentRelease, $event.currentTarget)"
title="{{ t.player_share }}"
@@ -1290,7 +1299,7 @@
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
</button>
<button class="like-btn"
<button data-member-only class="like-btn"
:class="{ liked: track.federation_pending ? $store.library.federationIsLiked(track._federationTrack) : $store.likes.has(track.id) }"
@click.stop="track.federation_pending ? $store.library.toggleFederationLike(track._federationTrack) : $store.likes.toggle(track.id)"
title="{{ t.player_like }}">
@@ -1304,12 +1313,12 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn"
<button data-member-only class="track-action-btn track-share-btn"
x-show="!track.federation_pending"
@click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="track.federation_pending ? $store.playlists.showFederationPicker(track._federationTrack) : $store.playlists.showPicker([track.id])"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
@@ -1331,7 +1340,7 @@
</div>
<div class="playlist-detail-heading">
<h1 class="section-title" x-text="$store.playlists.displayTitle($store.library.currentPlaylist)"></h1>
<button class="release-action-btn secondary playlist-edit-toggle"
<button data-member-only class="release-action-btn secondary playlist-edit-toggle"
x-show="$store.playlists.canEditCurrent()"
x-cloak
@click="$store.playlists.toggleEditCurrent()"
@@ -1379,7 +1388,7 @@
@dragover.prevent="$store.playlists.dragOver($event, idx)"
@dragleave="$event.currentTarget.classList.remove('drag-over')"
@drop.prevent="$event.currentTarget.classList.remove('drag-over'); $store.playlists.dropOn(idx)">
<button class="playlist-track-remove"
<button data-member-only class="playlist-track-remove"
x-show="$store.playlists.isEditingCurrent()"
x-cloak
@click.stop="$store.playlists.removeCurrentTrack(track, idx)"
@@ -1422,7 +1431,7 @@
</template>
</span>
<div class="track-info playlist-track-info">
<button class="playlist-drag-handle"
<button data-member-only class="playlist-drag-handle"
x-show="$store.playlists.isEditingCurrent() && !!track.playlist_track_id"
x-cloak
@mousedown.stop
@@ -1457,7 +1466,7 @@
<span x-show="$store.library.hasPopularity(track)" x-text="$store.library.popularityLabel(track)"></span>
<span x-show="!$store.library.hasPopularity(track)" class="info-letter">i</span>
</button>
<button class="like-btn"
<button data-member-only class="like-btn"
:class="{ liked: track.federation_pending ? $store.library.federationIsLiked(track._federationTrack) : $store.likes.has(track.id) }"
@click.stop="track.federation_pending ? $store.library.toggleFederationLike(track._federationTrack) : $store.likes.toggle(track.id)"
title="{{ t.player_like }}">
@@ -1471,10 +1480,10 @@
<button class="track-action-btn queue-insert-btn queue-end-btn" @click.stop="$store.queue.addToEnd([track])" title="{{ t.player_add_to_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M5 6h14M5 12h14M5 18h7"/><path d="M17 15l4 3-4 3" fill="currentColor" stroke="none"/></svg>
</button>
<button class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<button data-member-only class="track-action-btn track-share-btn" @click.stop="$store.sharing.copyTrack(track, $event.currentTarget)" title="{{ t.player_share_track }}" aria-label="{{ t.player_share_track }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="track-action-btn playlist-add-btn"
<button data-member-only class="track-action-btn playlist-add-btn"
@click.stop="track.federation_pending ? $store.playlists.showFederationPicker(track._federationTrack) : $store.playlists.showPicker([track.id])"
title="{{ t.player_add_to_playlist }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01"/></svg>
@@ -1496,7 +1505,7 @@
<div class="queue-header">
<h3>{{ t.player_queue }}</h3>
<div class="queue-header-actions">
<button class="queue-share-btn" @click="$store.sharing.copyQueue($event.currentTarget)" :disabled="$store.queue.tracks.length === 0" title="{{ t.player_share_queue }}" aria-label="{{ t.player_share_queue }}">
<button data-member-only class="queue-share-btn" @click="$store.sharing.copyQueue($event.currentTarget)" :disabled="$store.queue.tracks.length === 0" title="{{ t.player_share_queue }}" aria-label="{{ t.player_share_queue }}">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="18" cy="5" r="3"/><circle cx="6" cy="12" r="3"/><circle cx="18" cy="19" r="3"/><path d="M8.6 10.6l6.8-3.9M8.6 13.4l6.8 3.9"/></svg>
</button>
<button class="queue-clear-btn" @click="$store.queue.clear()">{{ t.player_clear }}</button>
@@ -1620,14 +1629,14 @@
<div class="player-track-info">
<div class="player-track-title-row">
<div class="player-track-title" x-text="$store.player.currentTrack.title"></div>
<button class="like-btn player-current-like"
<button data-member-only class="like-btn player-current-like"
:class="{ liked: $store.likes.has($store.player.currentTrack.id) }"
@click.stop="$store.likes.toggle($store.player.currentTrack.id)"
title="{{ t.player_like }}"
aria-label="{{ t.player_like }}">
<svg viewBox="0 0 24 24" :fill="$store.likes.has($store.player.currentTrack.id) ? 'currentColor' : 'none'" stroke="currentColor" stroke-width="2"><path d="M20.84 4.61a5.5 5.5 0 00-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 00-7.78 7.78L12 21.23l8.84-8.84a5.5 5.5 0 000-7.78z"/></svg>
</button>
<button class="track-action-btn player-current-share"
<button data-member-only class="track-action-btn player-current-share"
@click.stop="$store.sharing.copyTrack($store.player.currentTrack, $event.currentTarget)"
title="{{ t.player_share_track }}"
aria-label="{{ t.player_share_track }}">
@@ -1727,7 +1736,7 @@
</button>
<div class="device-picker" @click.outside="$store.devices.open = false">
<template x-if="$store.devices.remoteHintVisible">
<button class="remote-playback-hint"
<button data-member-only class="remote-playback-hint"
type="button"
@click="$store.devices.dismissRemoteHint()"
x-transition
@@ -1736,7 +1745,7 @@
<span class="remote-playback-hint-progress"></span>
</button>
</template>
<button class="queue-toggle-btn device-toggle-btn"
<button data-member-only class="queue-toggle-btn device-toggle-btn"
:class="{ active: $store.devices.isActive() }"
@click="$store.devices.toggle()"
:title="$store.devices.activeLabel()"
@@ -1757,7 +1766,7 @@
<div class="device-popover" x-show="$store.devices.open" x-transition x-cloak>
<div class="device-section-label">Web players</div>
<template x-for="device in $store.devices.webDevices()" :key="device.id">
<button class="device-row"
<button data-member-only class="device-row"
:class="{ active: device.is_active, 'current-device': device.is_current }"
@click="$store.devices.select(device.id)">
<span class="device-row-icon">
@@ -1792,7 +1801,7 @@
</div>
</template>
<template x-for="device in $store.devices.playbackFedDevices()" :key="device.id">
<button class="device-row federation-device-row"
<button data-member-only class="device-row federation-device-row"
:class="{ active: device.is_active }"
@click="$store.devices.select(device.id)">
<span class="device-row-icon federation-device-icon">
@@ -1818,7 +1827,7 @@
<div class="device-section-label jam-section-label">Jams</div>
</template>
<template x-for="jam in $store.devices.jams" :key="jam.id">
<button class="device-row jam-row"
<button data-member-only class="device-row jam-row"
:class="{ active: jam.is_active, pending: jam.is_pending }"
@click="$store.devices.handleJamRowClick(jam)">
<span class="device-row-icon">
@@ -1841,7 +1850,7 @@
</span>
</button>
</template>
<button class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
<button data-member-only class="device-row start-jam-row" x-show="!$store.devices.hasJoinedJam()" @click="$store.devices.openJamPanel()">
<span class="device-row-icon">
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
<path d="M12 5v14"/>
@@ -1865,7 +1874,7 @@
</label>
<div class="jam-selected-users" x-show="$store.devices.jamSelectedUsers.length > 0">
<template x-for="user in $store.devices.jamSelectedUsers" :key="user.id">
<button class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
<button data-member-only class="jam-user-chip" @click="$store.devices.removeJamInvitee(user.id)">
<span x-text="user.display_name || user.username"></span>
<span aria-hidden="true">×</span>
</button>
@@ -1878,18 +1887,18 @@
@input="$store.devices.queueJamSearch()">
<div class="jam-search-results" x-show="$store.devices.jamUsers.length > 0">
<template x-for="user in $store.devices.jamUsers" :key="user.id">
<button class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
<button data-member-only class="jam-search-row" @click="$store.devices.addJamInvitee(user)">
<span x-text="user.display_name || user.username"></span>
<small x-text="user.email || user.username"></small>
</button>
</template>
</div>
<div class="jam-panel-actions">
<button class="jam-create-btn"
<button data-member-only class="jam-create-btn"
:disabled="$store.devices.jamSelectedUsers.length === 0 && $store.devices.jamPanelMode === 'manage'"
@click="$store.devices.submitJamPanel()"
x-text="$store.devices.jamPanelMode === 'manage' ? 'Invite' : 'Create Jam'"></button>
<button class="jam-leave-btn"
<button data-member-only class="jam-leave-btn"
x-show="$store.devices.jamPanelMode === 'manage'"
@click="$store.devices.leaveJam($store.devices.jamPanelJamId)">Leave</button>
</div>
+17
View File
@@ -7002,3 +7002,20 @@ button.user-stat:hover {
.queue-tracks::-webkit-scrollbar-thumb,
.playlist-list::-webkit-scrollbar-thumb { background: var(--bg-active); border-radius: 3px; }
</style>
<style>
.guest-player [data-member-only], .guest-player .search-bar, .guest-player .breadcrumb,
.guest-player .device-picker, .guest-player .mobile-library-backdrop,
.guest-player .mobile-library-btn, .guest-player .mobile-library-toggle { display:none !important; }
.guest-player .artist-link, .guest-player .track-artist a, .guest-player .player-artist a { pointer-events:none; cursor:default; }
.guest-account { display:flex; align-items:center; justify-content:space-between; gap:16px; width:100%; font-size:14px; }
.guest-account a { color:var(--accent); text-decoration:none; }
.guest-account div { color:var(--text-secondary); }
@media(max-width:600px) { .guest-account { flex-wrap:wrap; gap:8px; font-size:12px; } }
@media(max-width:1100px) {
.guest-player .playlist-track-row > span:nth-child(4) { display:none; }
.guest-player .playlist-track-row .track-num { grid-column:1; grid-row:1; }
.guest-player .playlist-track-row .playlist-track-info { grid-column:2; grid-row:1; }
.guest-player .playlist-track-row .track-actions { grid-column:3; grid-row:1; }
}
</style>
+130
View File
@@ -0,0 +1,130 @@
const assert = require('node:assert/strict');
const { readFileSync } = require('node:fs');
const { test } = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/admin/v2.html`, 'utf8');
const script = template.match(/<script>\s*(function adminV2\(\)[\s\S]*?)<\/script>/)[1];
function createApp() {
const context = vm.createContext({URLSearchParams});
vm.runInContext(script, context);
const app = context.adminV2();
app.showToast = message => { app.toastMessage = message; };
app.$nextTick = fn => fn();
app.$refs = {};
app.repairSelected = [{kind:'artists',id:1,title:'Artist'}];
app.repairExpanded = {snapshot:{artists:[{id:1,name:'Artist'}],releases:[{id:2,title:'#ИЗИРОК',year:2018}],tracks:[{id:3,title:'Actual song',release_id:2}]}};
return app;
}
const emptyPlan = () => ({artists:[],releases:[],tracks:[],questions:[],delete:{artists:[],releases:[],tracks:[]}});
test('deselect all retains related rows and allows selecting only the needed resources', async () => {
const app = createApp();
app.setAllRepairIncluded(false);
assert.equal(app.repairIncludedCount(),0);
assert.equal(app.repairRowsCount(),3);
app.setRepairIncluded('releases',2,true);
app.setRepairIncluded('tracks',3,true);
assert.equal(app.repairIncludedCount(),2);
app.repairDraft = 'Only these';
app.request = async (url,options) => {
assert.ok(url.endsWith('/plan'), 'must not re-expand exclusions');
const body = JSON.parse(options.body);
assert.deepEqual(body.selection,{artists:[],releases:[2],tracks:[3]});
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Done'};
};
await app.sendRepair();
assert.equal(app.repairChat.length,2);
app.setAllRepairIncluded(true);
assert.equal(app.repairIncludedCount(),3);
});
test('checking only releases includes their contents without selecting the artist', () => {
const app = createApp();
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairSelection(true))),{artists:[],releases:[2],tracks:[3]});
assert.equal(app.repairIsIncluded('tracks',3),true);
assert.equal(app.repairIsIncluded('artists',1),false);
app.setRepairIncluded('tracks',3,false);
assert.equal(app.repairIsIncluded('tracks',3),false);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairSelection(true))).tracks,[]);
assert.deepEqual(JSON.parse(JSON.stringify(app.repairExcludedTracks)),[3]);
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
assert.equal(app.repairIsIncluded('tracks',3),true);
});
test('explicit track exclusions are sent to planning without re-expanding them', async () => {
const app=createApp();
app.setAllRepairIncluded(false);
app.setRepairIncluded('releases',2,true);
app.setRepairIncluded('tracks',3,false);
app.repairDraft='Edit release only';
app.request=async(url,options)=>{
assert.ok(url.endsWith('/plan'));
const body=JSON.parse(options.body);
assert.deepEqual(body.selection,{artists:[],releases:[2],tracks:[]});
assert.deepEqual(body.excluded_track_ids,[3]);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Done'};
};
await app.sendRepair();
});
test('clarification replaces the single plan including removed changes and questions', async () => {
const app = createApp();
app.repairPlan = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]},questions:['Which release?']};
app.repairChat = [{role:'user',content:'Delete song'},{role:'assistant',content:'Please review'}];
app.repairPlanOpen = true;
app.repairDraft = 'Keep song, cancel everything';
app.request = async (_url,options) => {
const body=JSON.parse(options.body);
assert.deepEqual(body.current_plan.delete.tracks,[3]);
assert.equal(body.conversation.length,2);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Cancelled'};
};
await app.sendRepair();
assert.equal(app.repairChangeCount(),0);
assert.equal(app.repairPlan.questions.length,0);
assert.equal(app.repairPlanOpen,true);
assert.equal(app.repairChat.length,4);
});
test('failed revision preserves prior plan and retry avoids duplicate user messages', async () => {
const app = createApp();
const prior = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]}};
app.repairPlan = prior;
app.repairDraft = 'Keep song';
app.request = async () => {throw Error('Offline');};
await app.sendRepair();
assert.equal(app.repairPlan,prior);
assert.equal(app.repairIncomplete,true);
assert.equal(app.repairChat.length,1);
app.request = async (_url,options) => {
assert.equal(JSON.parse(options.body).conversation.length,0);
return {plan:emptyPlan(),snapshot:app.repairExpanded.snapshot,message:'Kept'};
};
await app.sendRepair();
assert.equal(app.repairChat.length,2);
assert.equal(app.repairIncomplete,false);
});
test('incomplete plan cannot apply, deletion-only plan can apply and clears stale selection', async () => {
const app = createApp();
app.repairPlan = {...emptyPlan(),delete:{artists:[],releases:[],tracks:[3]}};
app.repairSnapshot = app.repairExpanded.snapshot;
app.repairIncomplete = true;
app.request = async () => assert.fail('must not apply incomplete plan');
await app.applyRepair();
app.repairIncomplete = false;
app.request = async (url,options) => {
assert.ok(url.endsWith('/apply'));
assert.deepEqual(JSON.parse(options.body).plan.delete.tracks,[3]);
return {history_id:7};
};
app.loadRepairHistory = async () => {};
app.loadLibrary = async () => {};
await app.applyRepair();
assert.equal(app.repairIncludedCount(),0);
assert.equal(app.repairPlan,null);
assert.equal(app.repairChat.at(-1).content.includes('#7'),true);
});
+141
View File
@@ -0,0 +1,141 @@
// Run against a disposable, freshly migrated instance only.
// Requires Docker PostgreSQL (FURU_ACCESS_TEST_PG), Playwright and Chrome.
const assert = require('node:assert/strict');
const {chromium} = require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const {spawnSync} = require('node:child_process');
const {mkdirSync, writeFileSync} = require('node:fs');
const {createServer} = require('node:http');
const {generateKeyPairSync, sign, randomUUID, createHash} = require('node:crypto');
const base = process.env.FURU_TEST_URL || 'http://127.0.0.1:18048';
const issuer = 'http://127.0.0.1:18049';
const mediaRoot = process.env.FURU_ACCESS_TEST_MEDIA || '/tmp/furumi-access-media';
function sql(statement) {
const result = spawnSync('docker', ['exec', '-i', process.env.FURU_ACCESS_TEST_PG || 'furumi-access-test-pg', 'psql', '-U', 'postgres', '-d', 'furumi_access_test', '-At', '-v', 'ON_ERROR_STOP=1'], {input:statement, encoding:'utf8'});
assert.equal(result.status, 0, result.stderr); return result.stdout.trim();
}
const encode = value => Buffer.from(JSON.stringify(value)).toString('base64url');
const {privateKey, publicKey} = generateKeyPairSync('rsa', {modulusLength:2048});
const jwk = {...publicKey.export({format:'jwk'}), kid:'test', use:'sig', alg:'RS256'};
let claims = {sub:'pending-test', email:'pending@example.test', name:'Pending Listener', groups:[]};
const codes = new Map();
const oidc = createServer(async (request, response) => {
const url = new URL(request.url, issuer);
let data;
if (url.pathname === '/.well-known/openid-configuration') {
data = {issuer, authorization_endpoint:issuer+'/authorize', token_endpoint:issuer+'/token', jwks_uri:issuer+'/jwks', response_types_supported:['code'], subject_types_supported:['public'], id_token_signing_alg_values_supported:['RS256'], token_endpoint_auth_methods_supported:['client_secret_basic'], scopes_supported:['openid','email','profile'], claims_supported:['sub','email','email_verified','name','groups']};
} else if (url.pathname === '/jwks') data = {keys:[jwk]};
else if (url.pathname === '/authorize') {
const code = randomUUID(); codes.set(code, {...claims, nonce:url.searchParams.get('nonce'), challenge:url.searchParams.get('code_challenge')});
const target = new URL(url.searchParams.get('redirect_uri'));
target.searchParams.set('code', code); target.searchParams.set('state', url.searchParams.get('state'));
response.writeHead(302, {Location:target.toString()}); response.end(); return;
} else if (url.pathname === '/token') {
let body=''; for await (const chunk of request) body += chunk;
const form = new URLSearchParams(body); const saved = codes.get(form.get('code')); codes.delete(form.get('code'));
assert.ok(saved); assert.equal(createHash('sha256').update(form.get('code_verifier')).digest('base64url'), saved.challenge);
const {challenge, ...identity} = saved;
const payload = {iss:issuer, aud:'furumi-test', iat:Math.floor(Date.now()/1000), exp:Math.floor(Date.now()/1000)+300, email_verified:true, ...identity};
const token = encode({alg:'RS256',kid:'test'})+'.'+encode(payload);
data = {access_token:'test-access', token_type:'Bearer', expires_in:300, id_token:token+'.'+sign('RSA-SHA256',Buffer.from(token),privateKey).toString('base64url')};
} else { response.writeHead(404); response.end(); return; }
response.writeHead(200, {'Content-Type':'application/json'}); response.end(JSON.stringify(data));
});
(async () => {
await new Promise(resolve => oidc.listen(18049,'127.0.0.1',resolve));
const browser = await chromium.launch({headless:true, executablePath:process.env.CHROME_PATH || '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'});
const errors=[];
try {
const admin = await browser.newContext({viewport:{width:1440,height:1000}});
let response = await admin.request.post(base+'/admin/setup', {form:{username:'access-admin',password:'access-test-password',confirm_password:'access-test-password'}});
assert.ok(response.ok());
response = await admin.request.post(base+'/login',{form:{username:'access-admin',password:'access-test-password'}}); assert.ok(response.ok());
sql(`INSERT INTO furumusic__config_entry (key,value) VALUES ('auth_sso_enabled','true'),('oidc_issuer','${issuer}'),('oidc_client_id','furumi-test'),('oidc_client_secret','test-${randomUUID()}'),('oidc_admin_groups','admins'),('oidc_user_groups','listeners') ON CONFLICT (key) DO UPDATE SET value=EXCLUDED.value;`);
sql("UPDATE furumusic__user SET local_role=NULL, sso_role=NULL, is_active=false WHERE username IN ('pending','automatic','root-new');");
mkdirSync(mediaRoot,{recursive:true});
const wav=Buffer.alloc(44+8000*2*10); wav.write('RIFF'); wav.writeUInt32LE(wav.length-8,4); wav.write('WAVEfmt ',8); wav.writeUInt32LE(16,16); wav.writeUInt16LE(1,20); wav.writeUInt16LE(1,22); wav.writeUInt32LE(8000,24); wav.writeUInt32LE(16000,28); wav.writeUInt16LE(2,32); wav.writeUInt16LE(16,34); wav.write('data',36); wav.writeUInt32LE(wav.length-44,40);
writeFileSync(mediaRoot+'/shared-test.wav',wav);
const cover=Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aPioAAAAASUVORK5CYII=','base64'); writeFileSync(mediaRoot+'/cover.png',cover);
sql(`INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,uploader_name,created_at) VALUES (9001,'audio','shared-test.wav','Shared test.wav','audio/wav',${wav.length},'${createHash('sha256').update(wav).digest('hex')}','Test','2026-11-18T00:00:00Z'),(9002,'cover_art','cover.png','cover.png','image/png',${cover.length},'${createHash('sha256').update(cover).digest('hex')}','Test','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__artist (id,name,name_sort,is_hidden,created_at,updated_at) VALUES (9001,'Test Artist','test artist',false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__release (id,title,title_sort,release_type,is_hidden,cover_file_id,created_at,updated_at) VALUES (9001,'Shared Album','shared album','album',false,9002,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__track (id,title,title_sort,release_id,duration_seconds,audio_file_id,is_hidden,created_at,updated_at) VALUES (9001,'Shared Song','shared song',9001,10,9001,false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z'),(9002,'Private Song','private song',9001,10,9001,false,'2026-11-18T00:00:00Z','2026-11-18T00:00:00Z') ON CONFLICT (id) DO NOTHING;
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) SELECT id,9001,'main',0 FROM furumusic__track WHERE id IN (9001,9002) AND NOT EXISTS (SELECT 1 FROM furumusic__track_artist WHERE track_id=furumusic__track.id);`);
response=await admin.request.post(base+'/api/player/shares',{data:{track_ids:[9001],title:'Shared Song'}}); assert.equal(response.status(),200); const share=await response.json();
const guest=await browser.newContext({viewport:{width:1440,height:1000}});
const page=await guest.newPage(); page.on('pageerror',e=>errors.push(e.message));
const api=[]; page.on('request',r=>{if(r.url().includes('/api/'))api.push(new URL(r.url()).pathname);});
await page.goto(base+share.url); await page.waitForSelector('.playlist-track-row');
assert.equal(await page.locator('.playlist-track-row').count(),1);
assert.equal(await page.getByRole('link',{name:'Sign in / register'}).count(),1);
assert.equal(await page.locator('#search-input').isVisible(),false);
assert.equal(await page.locator('.sidebar-left').count(),0);
await page.locator('.player-btn-play').click(); await page.waitForFunction(()=>Alpine.store('player').currentTime>0);
assert.equal(await page.locator('.device-picker').isVisible(),false);
await page.locator('.playlist-track-row [aria-label="Track info"]').click();
assert.equal(await page.getByRole('button',{name:'Start radio',exact:true}).count(),0);
assert.equal(await page.getByRole('button',{name:'Find similar',exact:true}).count(),0);
const downloading=page.waitForEvent('download'); await page.getByRole('button',{name:'Download',exact:true}).click(); const download=await downloading;
assert.equal(download.suggestedFilename(),'Shared test.wav'); await download.saveAs('/tmp/furumi-access-download.wav');
await page.locator('.modal-overlay [title="Close"]').click(); await page.screenshot({path:'/tmp/furumi-guest-desktop.png',fullPage:true});
assert.ok(api.every(path=>path.startsWith('/api/player/shares/')),JSON.stringify(api));
for (const action of ['stream','download','cover']) {
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/${action}/9002`)).status(),404);
assert.equal((await guest.request.get(`${base}/api/player/shares/${'0'.repeat(32)}/${action}/9001`)).status(),404);
}
assert.equal((await guest.request.get(`${base}/api/player/stream/9001`)).status(),401);
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),401);
response=await guest.request.get(`${base}/api/player/shares/${share.token}/stream/9001`,{headers:{Range:'bytes=0-43'}}); assert.equal(response.status(),206); assert.equal((await response.body()).length,44);
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/stream/9001`,{headers:{Range:'bytes=999999999-'}})).status(),416);
assert.equal((await guest.request.get(`${base}/api/player/shares/${share.token}/cover/9001`)).status(),200);
assert.equal((await guest.request.post(`${base}/api/player/shares`,{data:{track_ids:[9001]}})).status(),401);
await page.getByRole('link',{name:'Sign in / register'}).click(); await page.locator('.sso-btn').click();
await page.waitForURL(base+share.url); await page.getByText('Awaiting approval',{exact:true}).waitFor(); await page.waitForSelector('.playlist-track-row');
assert.equal(await page.locator('.playlist-track-row').count(),1);
const pendingId=Number(sql("SELECT id FROM furumusic__user WHERE username='pending'")); assert.ok(pendingId);
await page.goto(base+'/'); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(await page.locator('.app-layout').count(),0);
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),401);
assert.equal((await guest.request.post(`${base}/admin/v2/api/users/manage`,{data:{action:'approve',id:pendingId,role:'admin'}})).status(),401);
const adminPage=await admin.newPage(); adminPage.on('pageerror',e=>errors.push(e.message));
await adminPage.goto(base+'/admin/#users');
const pendingRow=adminPage.locator('.users-table tr').filter({hasText:'Pending Listener'});
await pendingRow.getByRole('button',{name:'Approve as user',exact:true}).click();
await page.waitForSelector('.app-layout',{timeout:15000});
assert.equal((await guest.request.get(`${base}/api/player/artists`)).status(),200);
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'user:user');
// Priority: a user SSO group overrides even a local admin grant; losing
// that group restores the separate local grant.
response=await admin.request.post(base+'/admin/v2/api/users/manage',{data:{action:'approve',id:pendingId,role:'admin'}}); assert.equal(response.status(),200);
claims.groups=['listeners']; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'admin:user');
claims.groups=[]; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql(`SELECT local_role || ':' || role FROM furumusic__user WHERE id=${pendingId}`),'admin:admin');
claims={sub:'automatic-test',email:'automatic@example.test',name:'Automatic Listener',groups:['admins']};
await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.waitForURL(base+'/');
assert.equal(sql("SELECT COALESCE(local_role,'none') || ':' || role FROM furumusic__user WHERE username='automatic'"),'none:admin');
const automaticId=Number(sql("SELECT id FROM furumusic__user WHERE username='automatic'"));
response=await admin.request.post(base+'/admin/v2/api/users/manage',{data:{action:'update',id:automaticId,username:'automatic',display_name:'Renamed Automatic Listener',email:'automatic@example.test',role:''}});
assert.equal(response.status(),200);
assert.equal(sql("SELECT COALESCE(local_role,'none') || ':' || role FROM furumusic__user WHERE username='automatic'"),'none:admin');
claims.groups=[]; await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(sql("SELECT is_active FROM furumusic__user WHERE username='automatic'"),'f');
// A completely new identity arriving at the root never sees a demo player.
claims={sub:'new-root-test',email:'root-new@example.test',name:'New Root Listener',groups:[]};
await page.goto(base+'/logout'); await page.locator('.sso-btn').click(); await page.getByRole('heading',{name:'Awaiting approval'}).waitFor();
assert.equal(await page.locator('.app-layout').count(),0);
// Queue snapshots preserve order and repeated tracks.
response=await admin.request.post(base+'/api/player/shares',{data:{track_ids:[9002,9001,9002],title:'Shared queue'}}); const queue=await response.json();
response=await guest.request.get(base+'/api/player/shares/'+queue.token); assert.deepEqual((await response.json()).tracks.map(t=>t.id),[9002,9001,9002]);
const mobile=await browser.newContext({viewport:{width:390,height:844},isMobile:true,hasTouch:true}); const mobilePage=await mobile.newPage(); mobilePage.on('pageerror',e=>errors.push(e.message));
await mobilePage.goto(base+queue.url); await mobilePage.waitForSelector('.playlist-track-row');
assert.equal(await mobilePage.getByRole('link',{name:'Sign in / register'}).isVisible(),true);
const info=mobilePage.locator('.playlist-track-row [aria-label="Track info"]').first();
const bounds=await info.boundingBox(); assert.ok(bounds && bounds.x>=0 && bounds.x+bounds.width<=390,JSON.stringify(bounds));
await info.click(); await mobilePage.getByRole('button',{name:'Download',exact:true}).waitFor();
await mobilePage.locator('.modal-overlay [title="Close"]').click();
await mobilePage.screenshot({path:'/tmp/furumi-guest-mobile.png',fullPage:true});
for (const old of ['/share/track/9001','/share/release/9001','/share/playlist/abc','/api/player/radio/track/9001','/api/player/share-playlist']) assert.equal((await guest.request.get(base+old)).status(),404);
assert.deepEqual(errors,[]);
console.log('PASS: OIDC approval, live activation, SSO precedence and removal, anonymous playback/download/cover, scope enforcement, queue snapshots, desktop and mobile, removal of legacy routes.');
} finally { await browser.close(); await new Promise(resolve=>oidc.close(resolve)); }
})().catch(error=>{console.error(error);process.exitCode=1;});
+181
View File
@@ -0,0 +1,181 @@
// Run against a fresh disposable instance with tests/metadata_repair_fixture.sql.
// FURU_REPAIR_TEST_PG must name its disposable PostgreSQL container.
const {chromium}=require(process.env.PLAYWRIGHT_MODULE || 'playwright');
const assert=require('node:assert/strict');
const {readFileSync}=require('node:fs');
const {spawnSync}=require('node:child_process');
const base=process.env.FURU_TEST_URL || 'http://127.0.0.1:3029';
const container=process.env.FURU_REPAIR_TEST_PG || 'furumi-repair-test-pg';
function sql(statement) {
const result=spawnSync('docker',['exec','-i',container,'psql','-U','postgres','-d','furumi_repair_test','-At','-v','ON_ERROR_STOP=1'],{input:statement,encoding:'utf8'});
assert.equal(result.status,0,result.stderr);
return result.stdout.trim();
}
const emptyPlan=()=>({artists:[],releases:[],tracks:[],questions:[],delete:{artists:[],releases:[],tracks:[]}});
(async()=>{
const browser=await chromium.launch({headless:true,executablePath:process.env.CHROME_PATH || '/run/current-system/sw/bin/chromium',args:['--no-sandbox']});
try {
const context=await browser.newContext({viewport:{width:1440,height:1000}});
if (process.env.FURU_TEST_ASSETS) {
for (const [url,file] of [['alpinejs@3/dist/cdn.min.js','alpine.js'],['lucide@latest/dist/umd/lucide.min.js','lucide.js']]) {
await context.route('https://cdn.jsdelivr.net/npm/'+url,route=>route.fulfill({path:process.env.FURU_TEST_ASSETS+'/'+file}));
}
}
const api=context.request;
assert.equal((await api.post(base+'/admin/v2/api/metadata-fix/apply',{data:{snapshot:{},plan:{},instruction:'test'}})).status()>=400,true);
const page=await context.newPage(); const errors=[]; page.on('pageerror',error=>errors.push(error.message));
await page.goto(base+'/admin/setup');
if (page.url().includes('/admin/setup')) {
await page.locator('[name=username]').fill('repair_admin');
await page.locator('[name=password]').fill('repair-test-password');
await page.locator('[name=confirm_password]').fill('repair-test-password');
await page.locator('button[type=submit]').click();
await page.waitForURL('**/admin/v2');
} else {
await page.goto(base+'/login');
await page.locator('[name=username]').fill('repair_admin');
await page.locator('[name=password]').fill('repair-test-password');
await page.locator('button[type=submit]').click();
await page.waitForURL(base+'/');
await page.goto(base+'/admin/v2');
}
if (!process.env.FURU_REPAIR_SKIP_SEED) sql(readFileSync(__dirname+'/metadata_repair_fixture.sql','utf8'));
const post=async(path,data,status=200)=>{
const response=await api.post(base+'/admin/v2/api/metadata-fix/'+path,{data,timeout:240000});
assert.equal(response.status(),status,await response.text());
return response.json();
};
const expanded=await post('expand',{selection:{artists:[2719],releases:[],tracks:[]}});
const before=expanded.snapshot;
assert.equal(before.releases.length,4); assert.equal(before.tracks.length,10);
// Reproduce the reported request using ONLY the four release checkboxes.
if (process.env.FURU_REPAIR_TEST_MODEL) {
const selection={artists:[],releases:before.releases.map(r=>r.id),tracks:[]};
const instruction=`релизы #ИЗИРОК на самом деле один релиз типа компиляция 2021 года. тебе нужно сделать план по объединению в один релиз. вот полный треклист по порядку 01. Старик и братья
02. Потрошитель
03. Последняя песня
04. Песня для твоей подруги
05. Просто я сегодня... (feat. Перегаз)
06. Отзвуки тьмы
07. Битва за Москву
08. Настроение лето
09. Пробил час
10. Цусима`;
const proposed=await post('plan',{selection,instruction});
assert.equal(proposed.snapshot.artists.length,0);
assert.equal(proposed.snapshot.tracks.length,10);
assert.deepEqual(proposed.plan.artists,[]);
assert.deepEqual(proposed.plan.delete.artists,[]);
assert.deepEqual(proposed.plan.delete.tracks,[]);
const destination=proposed.plan.releases.find(r=>r.release_type==='compilation' && r.year===2021);
assert.ok(destination,JSON.stringify(proposed.plan));
const target=destination.id ? 'existing:'+destination.id : 'new:'+destination.key;
for (const [index,track] of before.tracks.entries()) {
const edit=proposed.plan.tracks.find(t=>t.id===track.id);
assert.equal(edit?.target_release || 'existing:'+track.release_id,target);
assert.equal(edit?.track_number ?? track.track_number,index+1);
assert.deepEqual(edit?.artist_ids || [2719],[2719]);
}
const result=await post('apply',{snapshot:proposed.snapshot,plan:proposed.plan,instruction});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__release'),'1');
assert.equal(sql('SELECT name FROM furumusic__artist'),'Radio Tapok');
await post('undo',{history_id:result.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const excluded=await post('plan',{selection,excluded_track_ids:[33683],instruction:'Ничего не меняй. Верни пустой план.'});
assert.equal(excluded.snapshot.tracks.length,9);
assert.equal(excluded.snapshot.tracks.some(t=>t.id===33683),false);
assert.deepEqual(excluded.plan.tracks,[]);
const recovered=await post('plan',{selection,instruction:'__TEST_INVALID_ARTIST__ Объедини четыре релиза в компиляцию 2021 года.'});
assert.deepEqual(recovered.plan.artists,[]);
assert.equal(recovered.plan.releases[0].year,2021);
console.log('Release-only scope, exact ordered tracklist, model correction and exclusions passed.');
}
const artistIds=track=>before.track_artists.filter(link=>link.owner_id===track.id).map(link=>link.artist_id);
const merge={...emptyPlan(),releases:[{id:null,key:'collection',title:'#ИЗИРОК Сборник',release_type:'compilation',year:2021,artist_ids:[2719]}],tracks:before.tracks.map(track=>({id:track.id,title:track.title,target_release:'new:collection',track_number:track.track_number,disc_number:track.disc_number,year:track.year,artist_ids:artistIds(track)})),delete:{artists:[],releases:before.releases.map(release=>release.id),tracks:[]}};
await page.getByRole('button',{name:'Library Tools',exact:true}).click();
const tools=page.locator('.content').filter({has:page.getByText('Metadata assistant',{exact:true})});
await tools.locator('select').first().selectOption('artists');
await tools.getByPlaceholder('Search library…').fill('Radio Tapok');
await tools.locator('.repair-search-results button').first().click();
await tools.getByRole('button',{name:'Show related',exact:true}).click();
await page.waitForFunction(()=>Alpine.$data(document.querySelector('.admin-shell')).repairRowsCount()===15);
await tools.getByRole('button',{name:'Deselect all',exact:true}).click();
assert.equal(await tools.locator('.repair-entity input:checked').count(),0);
assert.equal(await tools.locator('.repair-entity input[type=checkbox]').count(),15);
for (const release of before.releases) {
await tools.getByRole('checkbox',{name:new RegExp('^#ИЗИРОК #' + release.id + ' ')}).check();
}
assert.equal(await tools.locator('.repair-entity input:checked').count(),14);
assert.equal(await tools.getByRole('checkbox',{name:'Radio Tapok #2719',exact:true}).isChecked(),false);
let calls=0;
await page.route('**/metadata-fix/plan',async route=>{
const body=route.request().postDataJSON(); calls++;
assert.deepEqual(body.selection,{...expanded.selection,artists:[]});
if (calls===1) await route.fulfill({json:{snapshot:before,plan:merge,message:'Объединю все 10 треков в сборник 2021 года.'}});
else {
assert.equal(body.current_plan.releases[0].year,2021);
assert.equal(body.conversation.length,2);
await route.fulfill({json:{snapshot:before,plan:{...merge,releases:[{...merge.releases[0],year:2022}]},message:'Год сборника изменён на 2022.'}});
}
});
const composer=tools.getByRole('textbox',{name:'Message to metadata assistant'});
await composer.fill('Объедини #ИЗИРОК в #ИЗИРОК Сборник, год 2021');
await tools.getByRole('button',{name:'Send',exact:true}).click();
await tools.getByText('Объединю все 10 треков в сборник 2021 года.',{exact:true}).waitFor();
const plan=tools.locator('details.repair-plan');
assert.equal(await plan.getAttribute('open'),null);
await plan.locator(':scope > summary').click();
await plan.getByText('Edit fields manually',{exact:true}).click();
assert.equal(await plan.locator('.repair-diff').nth(1).locator('input[type=number]').inputValue(),'2021');
await composer.fill('Сделай год 2022');
await tools.getByRole('button',{name:'Send',exact:true}).click();
await tools.getByText('Год сборника изменён на 2022.',{exact:true}).waitFor();
assert.equal(await tools.locator('details.repair-plan').count(),1);
assert.equal(await plan.locator('.repair-diff').nth(1).locator('input[type=number]').inputValue(),'2022');
await plan.getByText('Edit fields manually',{exact:true}).click();
await plan.locator(':scope > summary').scrollIntoViewIfNeeded();
await page.screenshot({path:'/tmp/furumi-repair-desktop.png'});
await page.setViewportSize({width:390,height:844});
assert.equal(await page.evaluate(()=>document.documentElement.scrollWidth<=innerWidth),true);
await page.screenshot({path:'/tmp/furumi-repair-mobile.png'});
await page.setViewportSize({width:1440,height:1000});
// Apply the 2021 plan against the original snapshot, then undo it.
const applied=await post('apply',{snapshot:before,plan:merge,instruction:'Merge #ИЗИРОК'});
assert.equal(sql("SELECT title || '|' || year || '|' || total_tracks FROM furumusic__release"),'#ИЗИРОК Сборник|2021|10');
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__media_file'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'2');
await post('undo',{history_id:applied.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const deletion={...emptyPlan(),delete:{artists:[],releases:[],tracks:[33683,33684]}};
const removed=await post('apply',{snapshot:before,plan:deletion,instruction:'Delete two tracks'});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'8');
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'0');
assert.equal(sql('SELECT count(*) FROM furumusic__track_ref WHERE local_track_id IS NULL'),'2');
assert.equal(sql('SELECT queue_json FROM furumusic__playback_state'),'[33685]');
await post('undo',{history_id:removed.history_id});
assert.equal(sql('SELECT count(*) FROM furumusic__playlist_track'),'2');
assert.equal(sql('SELECT local_track_id FROM furumusic__track_ref ORDER BY content_id'),'33683\n33684');
assert.equal(sql('SELECT current_track_id || \'|\' || position_ms || \'|\' || queue_json FROM furumusic__playback_state'),'33683|1234|[33683,33684,33685]');
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const artistRemoval=await post('apply',{snapshot:before,plan:{...emptyPlan(),delete:{artists:[2719],releases:[],tracks:[]}},instruction:'Delete artist'});
assert.equal(sql('SELECT count(*) FROM furumusic__artist'),'0');
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.equal(sql('SELECT count(*) FROM furumusic__track_artist'),'0');
await post('undo',{history_id:artistRemoval.history_id});
assert.deepEqual((await post('expand',{selection:expanded.selection})).snapshot,before);
const invalid={...emptyPlan(),delete:{artists:[],releases:[4256],tracks:[]}};
await post('apply',{snapshot:before,plan:invalid,instruction:'Invalid deletion'},400);
// A changed detached reference must block undo atomically.
const conflict=await post('apply',{snapshot:before,plan:deletion,instruction:'Delete before playback changes'});
sql("UPDATE furumusic__playback_state SET position_ms=9876");
await post('undo',{history_id:conflict.history_id},409);
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'8');
sql('UPDATE furumusic__playback_state SET position_ms=0');
await post('undo',{history_id:conflict.history_id});
assert.equal(sql('SELECT count(*) FROM furumusic__track'),'10');
assert.deepEqual(errors,[]);
console.log('Metadata Repair browser, merge, deletion, undo and conflict checks passed.');
} finally { await browser.close(); }
})().catch(error=>{console.error(error);process.exit(1);});
+45
View File
@@ -0,0 +1,45 @@
INSERT INTO furumusic__artist (id,name,is_hidden,name_sort,model_name,updated_at,created_at) VALUES (2719,'Radio Tapok',false,'radio tapok','unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','2026-11-15T23:13:56Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4256,2018,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:33Z',NULL,'album',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4257,2019,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:34Z',NULL,'album',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4258,2020,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:46Z',NULL,'ep',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release (id,year,title,is_hidden,model_name,title_sort,updated_at,total_discs,release_type,total_tracks,cover_file_id,created_at) VALUES (4259,2021,'#ИЗИРОК',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K','#изирок','2026-11-15T23:25:47Z',NULL,'ep',NULL,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33683,'audio','/tmp/test-33683.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033683','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33683,2018,'Старик и братья',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'старик и братья','2026-11-15T23:25:32Z',NULL,1,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33683,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33684,'audio','/tmp/test-33684.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033684','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33684,2018,'Потрошитель',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'потрошитель','2026-11-15T23:25:33Z',NULL,2,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33684,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33685,'audio','/tmp/test-33685.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033685','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33685,2018,'Последняя песня',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'последняя песня','2026-11-15T23:25:33Z',NULL,3,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33685,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33686,'audio','/tmp/test-33686.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033686','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33686,2018,'Песня для твоей подруги',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'песня для твоей подруги','2026-11-15T23:25:33Z',NULL,4,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33686,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33687,'audio','/tmp/test-33687.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033687','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33687,2018,'Просто я сегодня...',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4256,'просто я сегодня...','2026-11-15T23:25:33Z',NULL,5,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33687,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33688,'audio','/tmp/test-33688.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033688','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33688,2019,'Отзвуки тьмы',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4257,'отзвуки тьмы','2026-11-15T23:25:34Z',NULL,6,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33688,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33689,'audio','/tmp/test-33689.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033689','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33689,2019,'Битва за Москву',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4257,'битва за москву','2026-11-15T23:25:34Z',NULL,7,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33689,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33690,'audio','/tmp/test-33690.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033690','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33690,2020,'Настроение лето',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4258,'настроение лето','2026-11-15T23:25:46Z',NULL,8,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33690,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33691,'audio','/tmp/test-33691.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033691','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33691,2020,'Пробил час',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4258,'пробил час','2026-11-15T23:25:47Z',NULL,9,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33691,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__media_file (id,file_type,file_path,original_filename,mime_type,file_size_bytes,sha256_hash,created_at) VALUES (33692,'audio','/tmp/test-33692.mp3','test.mp3','audio/mpeg',1,'0000000000000000000000000000000000000000000000000000000000033692','2026-01-01T00:00:00Z');
INSERT INTO furumusic__track (id,year,title,is_hidden,model_name,release_id,title_sort,updated_at,disc_number,track_number,lastfm_rating,lastfm_listeners,lastfm_playcount,lastfm_checked_at,lastfm_updated_at,lastfm_lookup_title,lastfm_lookup_artist,duration_seconds,audio_file_id,cover_file_id,created_at) VALUES (33692,2021,'Цусима',false,'unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q6_K',4259,'цусима','2026-11-15T23:25:47Z',NULL,10,NULL,NULL,NULL,NULL,NULL,NULL,NULL,180,33692,NULL,'2026-01-01T00:00:00Z');
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4256,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4257,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4258,2719,0);
INSERT INTO furumusic__release_artist (release_id,artist_id,position) VALUES (4259,2719,0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33683,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33684,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33685,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33686,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33687,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33688,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33689,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33690,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33691,2719,'main',0);
INSERT INTO furumusic__track_artist (track_id,artist_id,role,position) VALUES (33692,2719,'main',0);
INSERT INTO furumusic__playlist (id,owner_id,title,is_public,created_at,updated_at) VALUES (1,1,'Repair test',false,'2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playlist_track (playlist_id,track_id,position,added_at,added_by_user_id) VALUES (1,33683,0,'2026-01-01T00:00:00Z',1);
INSERT INTO furumusic__track_ref (content_id,local_track_id,title,created_at,updated_at) VALUES ('content-33683',33683,'Старик и братья','2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playlist_track (playlist_id,track_id,position,added_at,added_by_user_id) VALUES (1,33684,1,'2026-01-01T00:00:00Z',1);
INSERT INTO furumusic__track_ref (content_id,local_track_id,title,created_at,updated_at) VALUES ('content-33684',33684,'Потрошитель','2026-01-01T00:00:00Z','2026-01-01T00:00:00Z');
INSERT INTO furumusic__playback_state (user_id,current_track_id,position_ms,queue_json,queue_position,shuffle,repeat_mode,volume,updated_at) VALUES (1,33683,1234,'[33683,33684,33685]',0,false,'off',1.0,'2026-01-01T00:00:00Z');
+9 -2
View File
@@ -3,11 +3,11 @@ const {readFileSync} = require('node:fs');
const {test} = require('node:test');
const vm = require('node:vm');
const template = readFileSync(`${__dirname}/../templates/player/scripts.html`, 'utf8');
function player(fetchImpl = async () => ({ok:true}), beacon = () => true) {
function player(fetchImpl = async () => ({ok:true}), beacon = () => true, guest = false) {
// Exercise the production methods with audio and network stubs.
const methods = template.slice(template.indexOf(' _recordHistory(endedReason'), template.indexOf(' _sendNowPlaying()'));
const audio = {currentTime:60};
const context = vm.createContext({audio, fetch:fetchImpl, navigator:{sendBeacon:beacon}, Blob,
const context = vm.createContext({GUEST:guest, audio, fetch:fetchImpl, navigator:{sendBeacon:beacon}, Blob,
globalThis:{crypto:{randomUUID:()=> 'uuid'}}, setTimeout: fn => { fn(); }, console});
vm.runInContext('this.methods = {' + methods + '};', context);
return Object.assign(context.methods, {
@@ -50,3 +50,10 @@ test('unstarted tracks and sub-five-second interrupted sessions are not recorded
p._playbackStartedAt=123; p._listenedSeconds=4; p._recordHistory('skipped'); await flush();
assert.equal(p._historyRecorded,false);
});
test('guest listening never writes personal history or sends a beacon', async () => {
const calls = [];
const p = player(async () => {calls.push('fetch'); return {ok:true};}, () => {calls.push('beacon'); return true;}, true);
p._recordHistory('finished'); p._recordHistory('stopped', true);
await flush(); assert.deepEqual(calls, []);
});