@amoshydra/davison 0.0.1

package/dist-server/services/playlist-store.js

@@ -0,0 +1,84 @@
+import { readFile, writeFile, mkdir, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { config } from '../config.js';
+const ALLOWED_UPDATES = new Set(['name', 'trackIds']);
+let playlists = [];
+function isValidPlaylistArray(data) {
+    if (!Array.isArray(data))
+        return false;
+    return data.every(item => item !== null &&
+        typeof item === 'object' &&
+        typeof item.id === 'string' &&
+        typeof item.name === 'string' &&
+        Array.isArray(item.trackIds));
+}
+export async function loadPlaylists() {
+    try {
+        if (!existsSync(config.playlistsFile)) {
+            await mkdir(config.dataDir, { recursive: true });
+            playlists = [];
+            return;
+        }
+        const data = await readFile(config.playlistsFile, 'utf-8');
+        const parsed = JSON.parse(data);
+        if (isValidPlaylistArray(parsed)) {
+            playlists = parsed;
+        }
+        else {
+            console.warn('Corrupted playlists.json, starting fresh');
+            playlists = [];
+        }
+    }
+    catch (err) {
+        console.warn('Failed to load playlists:', err);
+        playlists = [];
+    }
+}
+async function savePlaylists() {
+    await mkdir(config.dataDir, { recursive: true });
+    const tmp = config.playlistsFile + '.tmp';
+    await writeFile(tmp, JSON.stringify(playlists, null, 2), 'utf-8');
+    await rename(tmp, config.playlistsFile);
+}
+export function getPlaylists() {
+    return playlists.map(p => ({ ...p }));
+}
+export function getPlaylist(id) {
+    const p = playlists.find(p => p.id === id);
+    return p ? { ...p } : undefined;
+}
+export async function createPlaylist(name, trackIds = []) {
+    const playlist = {
+        id: randomUUID(),
+        name,
+        trackIds,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+    };
+    playlists.push(playlist);
+    await savePlaylists();
+    return { ...playlist };
+}
+export async function deletePlaylist(id) {
+    const idx = playlists.findIndex(p => p.id === id);
+    if (idx === -1)
+        return false;
+    playlists.splice(idx, 1);
+    await savePlaylists();
+    return true;
+}
+export async function updatePlaylist(id, updates) {
+    const playlist = playlists.find(p => p.id === id);
+    if (!playlist)
+        return null;
+    const safe = {};
+    for (const key of ALLOWED_UPDATES) {
+        if (key in updates) {
+            safe[key] = updates[key];
+        }
+    }
+    Object.assign(playlist, safe, { updatedAt: new Date().toISOString() });
+    await savePlaylists();
+    return { ...playlist };
+}

package/dist-server/services/queue-manager.js

@@ -0,0 +1,339 @@
+import { EventEmitter } from 'node:events';
+import { getTrackById, getMusicLibrary } from './music-discovery.js';
+import { sonosController } from './sonos-controller.js';
+import { config } from '../config.js';
+const VALID_LOOP_MODES = new Set(['none', 'one', 'all']);
+function folderPath(relativePath) {
+    const idx = relativePath.lastIndexOf('/');
+    return idx >= 0 ? relativePath.slice(0, idx) : null;
+}
+class QueueManager extends EventEmitter {
+    state = {
+        queue: [],
+        history: [],
+        currentIndex: null,
+        loopMode: 'all',
+        autoPlay: true,
+    };
+    mutationQueue = Promise.resolve();
+    serialized(fn) {
+        return new Promise((resolve, reject) => {
+            this.mutationQueue = this.mutationQueue.then(() => fn().then(resolve, reject));
+        });
+    }
+    getState() {
+        return { ...this.state, currentTrack: this.getCurrentTrack(), nextTrack: this.getNextTrack() };
+    }
+    getQueue() {
+        return [...this.state.queue];
+    }
+    getCurrentTrack() {
+        if (this.state.currentIndex === null)
+            return null;
+        return this.state.queue[this.state.currentIndex] ?? null;
+    }
+    getNextTrack() {
+        if (this.state.currentIndex === null)
+            return null;
+        const next = this.getNextIndex();
+        return next !== null ? this.state.queue[next] : null;
+    }
+    getNextIndex() {
+        const { queue, currentIndex, loopMode } = this.state;
+        if (queue.length === 0)
+            return null;
+        if (currentIndex === null)
+            return 0;
+        if (loopMode === 'one')
+            return currentIndex;
+        const next = currentIndex + 1;
+        if (next >= queue.length) {
+            return loopMode === 'all' ? 0 : null;
+        }
+        return next;
+    }
+    getPreviousIndex() {
+        const { queue, history } = this.state;
+        if (history.length > 0) {
+            const track = history[history.length - 1];
+            this.state.history = history.slice(0, -1);
+            const idx = queue.findIndex(t => t.id === track.id);
+            return idx >= 0 ? idx : this.state.currentIndex;
+        }
+        if (queue.length === 0)
+            return null;
+        if (this.state.currentIndex === null)
+            return 0;
+        const prev = this.state.currentIndex - 1;
+        return prev >= 0 ? prev : (this.state.loopMode === 'all' ? queue.length - 1 : 0);
+    }
+    async playTrack(index) {
+        const track = this.state.queue[index];
+        if (!track)
+            return;
+        this.state.currentIndex = index;
+        this.emit('track-change', track);
+        try {
+            const encodedPath = track.relativePath.split('/').map(s => encodeURIComponent(s)).join('/');
+            const streamUrl = `http://${config.host}:${config.port}/music-files/${track.baseIdx}/${encodedPath}`;
+            await sonosController.playUri(streamUrl, track.title);
+        }
+        catch (err) {
+            console.error('Failed to play track:', track.id, track.title, err);
+        }
+    }
+    async play() {
+        await this.serialized(async () => {
+            if (this.state.currentIndex === null && this.state.queue.length > 0) {
+                await this.playTrack(0);
+            }
+            else {
+                await sonosController.play();
+            }
+        });
+    }
+    async pause() {
+        await sonosController.pause();
+    }
+    async stop() {
+        await this.serialized(async () => {
+            await sonosController.stop();
+            this.state.currentIndex = null;
+            this.emit('state-change', this.getState());
+        });
+    }
+    async next() {
+        await this.serialized(async () => {
+            const nextIdx = this.getNextIndex();
+            if (nextIdx === null)
+                return;
+            const current = this.getCurrentTrack();
+            if (current) {
+                this.state.history = [...this.state.history, current];
+            }
+            await this.playTrack(nextIdx);
+        });
+    }
+    async previous() {
+        await this.serialized(async () => {
+            const prevIdx = this.getPreviousIndex();
+            if (prevIdx === null)
+                return;
+            const current = this.getCurrentTrack();
+            if (current && this.state.history[this.state.history.length - 1]?.id !== current.id) {
+                this.state.history = [...this.state.history, current];
+            }
+            await this.playTrack(prevIdx);
+        });
+    }
+    resolveTracks(trackIds) {
+        const seen = new Set();
+        const result = [];
+        for (const id of trackIds) {
+            if (seen.has(id))
+                continue;
+            seen.add(id);
+            const track = getTrackById(id);
+            if (track)
+                result.push(track);
+        }
+        return result;
+    }
+    async addToQueue(trackIds) {
+        await this.serialized(async () => {
+            const tracks = this.resolveTracks(trackIds);
+            if (tracks.length === 0)
+                return;
+            // Deduplicate against existing queue
+            const existingIds = new Set(this.state.queue.map(t => t.id));
+            const newTracks = tracks.filter(t => !existingIds.has(t.id));
+            if (newTracks.length === 0)
+                return;
+            this.state.queue = [...this.state.queue, ...newTracks];
+            this.emit('queue-change', this.getQueue());
+            if (this.state.currentIndex === null && this.state.autoPlay) {
+                await this.playTrack(0);
+            }
+        });
+    }
+    async playNow(trackIds) {
+        await this.serialized(async () => {
+            const tracks = this.resolveTracks(trackIds);
+            if (tracks.length === 0)
+                return;
+            this.state.queue = tracks;
+            this.state.history = [];
+            this.state.currentIndex = null;
+            this.emit('queue-change', this.getQueue());
+            await this.playTrack(0);
+        });
+    }
+    async playNext(trackIds) {
+        await this.serialized(async () => {
+            const tracks = this.resolveTracks(trackIds);
+            if (tracks.length === 0)
+                return;
+            // Deduplicate against existing queue
+            const existingIds = new Set(this.state.queue.map(t => t.id));
+            const newTracks = tracks.filter(t => !existingIds.has(t.id));
+            if (newTracks.length === 0)
+                return;
+            const insertAt = this.state.currentIndex !== null ? this.state.currentIndex + 1 : this.state.queue.length;
+            this.state.queue.splice(insertAt, 0, ...newTracks);
+            this.emit('queue-change', this.getQueue());
+        });
+    }
+    async playFolderOrNow(trackId) {
+        await this.serialized(async () => {
+            const track = getTrackById(trackId);
+            if (!track)
+                return;
+            const existingIds = new Set(this.state.queue.map(t => t.id));
+            if (existingIds.has(track.id))
+                return;
+            const folder = folderPath(track.relativePath);
+            // Folder-fill: queue empty + track has a directory
+            if (this.state.queue.length === 0 && folder) {
+                const allTracks = getMusicLibrary();
+                const folderTracks = allTracks
+                    .filter(t => t.baseIdx === track.baseIdx && folderPath(t.relativePath) === folder)
+                    .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+                const startIdx = folderTracks.findIndex(t => t.id === trackId);
+                this.state.queue = [...folderTracks.slice(startIdx), ...folderTracks.slice(0, startIdx)];
+                this.state.history = [];
+                this.state.currentIndex = null;
+                this.emit('queue-change', this.getQueue());
+                await this.playTrack(0);
+                return;
+            }
+            // Insert next + play
+            const insertAt = this.state.currentIndex !== null
+                ? this.state.currentIndex + 1
+                : this.state.queue.length;
+            this.state.queue.splice(insertAt, 0, track);
+            this.emit('queue-change', this.getQueue());
+            await this.playTrack(insertAt);
+        });
+    }
+    removeFromQueue(index) {
+        if (index < 0 || index >= this.state.queue.length)
+            return;
+        if (!Number.isInteger(index))
+            return;
+        this.state.queue = this.state.queue.filter((_, i) => i !== index);
+        if (this.state.queue.length === 0) {
+            this.state.currentIndex = null;
+            this.state.history = [];
+        }
+        else if (this.state.currentIndex !== null) {
+            if (index < this.state.currentIndex) {
+                this.state.currentIndex--;
+            }
+            else if (index === this.state.currentIndex) {
+                this.state.currentIndex = Math.min(this.state.currentIndex, this.state.queue.length - 1);
+            }
+        }
+        this.emit('queue-change', this.getQueue());
+    }
+    clearQueue() {
+        this.state.queue = [];
+        this.state.history = [];
+        this.state.currentIndex = null;
+        this.emit('queue-change', this.getQueue());
+    }
+    reorderQueue(from, to) {
+        if (from < 0 || from >= this.state.queue.length)
+            return;
+        if (to < 0 || to >= this.state.queue.length)
+            return;
+        if (!Number.isInteger(from) || !Number.isInteger(to))
+            return;
+        const queue = [...this.state.queue];
+        const [moved] = queue.splice(from, 1);
+        queue.splice(to, 0, moved);
+        this.state.queue = queue;
+        this.emit('queue-change', this.getQueue());
+    }
+    setLoopMode(mode) {
+        if (!VALID_LOOP_MODES.has(mode)) {
+            console.warn('Invalid loop mode:', mode);
+            return;
+        }
+        this.state.loopMode = mode;
+        this.emit('loop-change', mode);
+    }
+    async setAutoPlay(auto) {
+        this.state.autoPlay = auto;
+    }
+    /** Re-send current track URI — used when device becomes available after queue was filled */
+    async resumePlayback() {
+        await this.serialized(async () => {
+            if (!sonosController.hasDevice())
+                return;
+            const track = this.getCurrentTrack();
+            if (!track)
+                return;
+            // Don't resume if Sonos is already playing something
+            const status = await sonosController.getStatus();
+            if (status && status.state !== 'STOPPED')
+                return;
+            await this.playTrack(this.state.currentIndex);
+        });
+    }
+    async jumpTo(trackId) {
+        await this.serialized(async () => {
+            const idx = this.state.queue.findIndex(t => t.id === trackId);
+            if (idx === -1)
+                return;
+            await this.playTrack(idx);
+        });
+    }
+    setQueue(tracks, startIndex = 0) {
+        this.state.queue = [...tracks];
+        this.state.history = [];
+        this.state.currentIndex = null;
+        this.emit('queue-change', this.getQueue());
+        if (tracks.length > 0) {
+            this.playTrack(startIndex).catch(err => {
+                console.error('Failed to start new queue:', err);
+            });
+        }
+    }
+}
+export const queueManager = new QueueManager();
+let pollTimer = null;
+const POLL_INTERVAL = 2000;
+const AUTO_ADVANCE_THRESHOLD = 2;
+export function startAutoAdvancePolling() {
+    if (pollTimer)
+        return;
+    pollTimer = setInterval(async () => {
+        try {
+            const status = await sonosController.getStatus();
+            if (!status)
+                return;
+            const current = queueManager.getCurrentTrack();
+            if (!current || status.state === 'PLAYING')
+                return;
+            if (status.state === 'STOPPED' && status.track.duration > 0) {
+                const elapsed = status.track.position;
+                const remaining = status.track.duration - elapsed;
+                if (remaining < AUTO_ADVANCE_THRESHOLD) {
+                    const nextId = queueManager.getNextTrack();
+                    if (nextId) {
+                        await queueManager.next();
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.warn('Auto-advance poll error:', err);
+        }
+    }, POLL_INTERVAL);
+}
+export function stopAutoAdvancePolling() {
+    if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+    }
+}