BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

WIP: Duplicate detection
timfa Tim Falken · pushed by timfa · 6 months ago
3fcdc0ca History
app.js 139.4 KiB Download Raw
1/* =========================================================
2 FILE MANAGER — CLIENT SPA
3 =========================================================
4 Architecture:
5 - RSA-OAEP + AES-256-GCM hybrid encryption via Web Crypto API
6 - Token is stored in localStorage to survive full page refresh
7 - Token is sent as Bearer header on every API call
8 - Fingerprint (derived from navigator info) locks the token to this browser
9 ========================================================= */
10'use strict';
11
12// ───────────────────────────────────────────────────────────────────────────
13// STATE
14// ───────────────────────────────────────────────────────────────────────────
15const STATE = {
16 token: null, // decrypted JWT string
17 username: null,
18 isAdmin: false,
19 permissions: {},
20 roots: [], // [{ label, path }]
21 currentDir: null, // absolute path currently shown (null = roots view)
22 currentRoot: null, // { label, path } of the active root
23 items: [], // current directory listing
24 selectedItem: null, // item object selected in sidebar
25
26 // Ephemeral key pair per session (client-side)
27 clientPrivateKey: null,
28 clientPublicKeyJwk: null,
29
30 // Server public key for encrypting login
31 serverPublicKeyJwk: null,
32
33 // Stable per-browser binding id used in fingerprint derivation
34 clientBindingId: null,
35
36 // Persisted view state
37 restoreDir: null,
38 restoreRootPath: null,
39 lastOperationAt: null,
40
41 // Background refresh state
42 autoRefreshTimer: null,
43 uploadInProgress: false,
44 // Blob URLs for thumbnail previews — revoked on each grid rebuild
45 thumbnailUrls: [],
46 thumbnailObserver: null,
47 folderIconObserver: null,
48
49 // Preview overlay state
50 previewObjectUrl: null,
51 previewCleanup: null,
52 previewDownloadAction: null,
53 previewVideoStreamSessionId: null,
54 previewSourceEl: null, // SVG element that triggered the preview
55 previewClosing: false, // guard to prevent double-close during animation
56 previewExpandState: null, // in-place expanded tile preview state
57 movePicker: null,
58};
59
60const SESSION_KEY = 'filemanager.session.v1';
61const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
62const CLIENT_BINDING_KEY = 'filemanager.client-binding-id.v1';
63const MOBILE_BREAKPOINT_QUERY = '(max-width: 600px)';
64const MOBILE_LONG_PRESS_MS = 420;
65const MOBILE_LONG_PRESS_MOVE_THRESHOLD = 10;
66const THUMB_OBSERVER_ROOT_MARGIN = '120px';
67const VIDEO_PREFS_KEY_PREFIX = 'filemanager.video-prefs.v1.';
68const VIDEO_TEXT_TRACK_SETTINGS_KEY = 'vjs-text-track-settings';
69const VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW = JSON.stringify({
70 backgroundOpacity: '0',
71 edgeStyle: 'uniform',
72});
73const VIDEO_FORWARD_BUFFER_SECONDS = 60 * 60;
74const VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED = false;
75let videoJsLoaderPromise = null;
76
77// ───────────────────────────────────────────────────────────────────────────
78// CRYPTO HELPERS (Web Crypto API)
79// ───────────────────────────────────────────────────────────────────────────
80
81async function generateClientKeyPair ()
82{
83 if (!hasWebCrypto()) return;
84 const kp = await crypto.subtle.generateKey(
85 { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
86 true,
87 ['encrypt', 'decrypt'],
88 );
89 STATE.clientPrivateKey = kp.privateKey;
90 STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
91}
92
93/**
94 * Hybrid-encrypt a JS object using the server's RSA public key.
95 * Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
96 */
97async function hybridEncryptForServer (obj)
98{
99 if (!hasWebCrypto() || !STATE.serverPublicKeyJwk)
100 {
101 return { plaintext: obj };
102 }
103
104 const serverPub = await crypto.subtle.importKey(
105 'jwk', STATE.serverPublicKeyJwk,
106 { name: 'RSA-OAEP', hash: 'SHA-256' },
107 false, ['encrypt'],
108 );
109
110 const plaintext = new TextEncoder().encode(JSON.stringify(obj));
111 const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
112 const iv = crypto.getRandomValues(new Uint8Array(12));
113 const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
114
115 // gcmResult = ciphertext || tag (last 16 bytes are auth tag)
116 const gcmBytes = new Uint8Array(gcmResult);
117 const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
118 const tag = gcmBytes.slice(gcmBytes.length - 16);
119
120 const rawAes = await crypto.subtle.exportKey('raw', aesKey);
121 const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
122
123 return {
124 encryptedKey: b64(encryptedKey),
125 iv: b64(iv),
126 ciphertext: b64(ciphertext),
127 tag: b64(tag),
128 };
129}
130
131/**
132 * Hybrid-decrypt a payload encrypted by the server for us (using our public key).
133 */
134async function hybridDecryptFromServer (payload)
135{
136 if (!payload) return null;
137 if (payload.token) return payload.token;
138 if (!hasWebCrypto()) return null;
139
140 const encryptedKey = unb64(payload.encryptedKey);
141 const iv = unb64(payload.iv);
142 const ciphertext = unb64(payload.ciphertext);
143 const tag = unb64(payload.tag);
144
145 const rawAes = await crypto.subtle.decrypt(
146 { name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
147 );
148
149 const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
150
151 // Recombine ciphertext + tag for AES-GCM
152 const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
153 combined.set(new Uint8Array(ciphertext));
154 combined.set(new Uint8Array(tag), ciphertext.byteLength);
155
156 const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
157 return new TextDecoder().decode(plain);
158}
159
160// ───────────────────────────────────────────────────────────────────────────
161// UTIL
162// ───────────────────────────────────────────────────────────────────────────
163
164function b64 (buf)
165{
166 return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
167}
168
169function hasWebCrypto ()
170{
171 return !!(window.crypto && window.crypto.subtle);
172}
173
174function unb64 (str)
175{
176 const binary = atob(str);
177 const buf = new Uint8Array(binary.length);
178 for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
179 return buf.buffer;
180}
181
182/** Stable browser fingerprint (not stored, derived fresh each load) */
183function getFingerprint ()
184{
185 const binding = getOrCreateClientBindingId();
186 const nav = navigator;
187
188 // Keep this stable: avoid viewport/screen metrics that can change when
189 // devtools opens, orientation changes, or window state changes.
190 return [
191 binding,
192 nav.userAgent || '',
193 nav.language,
194 nav.platform || nav.userAgentData?.platform || '',
195 Intl.DateTimeFormat().resolvedOptions().timeZone,
196 ].join('|');
197}
198
199function randomIdHex (bytes = 16)
200{
201 const arr = new Uint8Array(bytes);
202 if (window.crypto && typeof window.crypto.getRandomValues === 'function')
203 {
204 window.crypto.getRandomValues(arr);
205 } else
206 {
207 for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
208 }
209 return Array.from(arr).map(n => n.toString(16).padStart(2, '0')).join('');
210}
211
212function userVideoPrefsKey ()
213{
214 const name = String(STATE.username || 'anonymous').trim().toLowerCase() || 'anonymous';
215 return VIDEO_PREFS_KEY_PREFIX + name;
216}
217
218function loadUserVideoPrefs ()
219{
220 try
221 {
222 const raw = localStorage.getItem(userVideoPrefsKey());
223 const parsed = raw ? JSON.parse(raw) : {};
224 if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return {};
225 return parsed;
226 } catch
227 {
228 return {};
229 }
230}
231
232function saveUserVideoPrefs (patch)
233{
234 try
235 {
236 const current = loadUserVideoPrefs();
237 localStorage.setItem(userVideoPrefsKey(), JSON.stringify({ ...current, ...(patch || {}) }));
238 } catch
239 {
240 // Ignore localStorage failures.
241 }
242}
243
244function applyUserVideoTextTrackPrefs ()
245{
246 try
247 {
248 // Only override the two requested defaults and leave other settings at Video.js defaults.
249 localStorage.setItem(VIDEO_TEXT_TRACK_SETTINGS_KEY, VIDEO_TEXT_TRACK_OVERRIDE_SETTINGS_RAW);
250 } catch
251 {
252 // Ignore localStorage failures.
253 }
254}
255
256function normaliseTrackName (name)
257{
258 return String(name || '').trim().toLowerCase();
259}
260
261function getTrackName (track)
262{
263 if (!track || typeof track !== 'object') return '';
264 const label = String(track.label || '').trim();
265 if (label) return label;
266 const name = String(track.name || '').trim();
267 if (name) return name;
268 const language = String(track.language || '').trim();
269 if (language) return language;
270 const id = String(track.id || '').trim();
271 if (id) return id;
272 return '';
273}
274
275function trackListToArray (trackList)
276{
277 if (!trackList || typeof trackList.length !== 'number') return [];
278 const out = [];
279 for (let i = 0; i < trackList.length; i++)
280 {
281 const track = trackList[i] || (typeof trackList.item === 'function' ? trackList.item(i) : null);
282 if (track) out.push(track);
283 }
284 return out;
285}
286
287function subtitleTracksFromPlayer (player)
288{
289 if (!player || typeof player.textTracks !== 'function') return [];
290 return trackListToArray(player.textTracks()).filter((track) =>
291 {
292 const kind = String(track.kind || '').toLowerCase();
293 return kind === 'subtitles' || kind === 'captions';
294 });
295}
296
297function audioTracksFromPlayer (player)
298{
299 if (!player || typeof player.audioTracks !== 'function') return [];
300 return trackListToArray(player.audioTracks());
301}
302
303function applySavedSubtitleTrack (player, savedName)
304{
305 if (typeof savedName !== 'string') return;
306 const tracks = subtitleTracksFromPlayer(player);
307 if (!tracks.length) return;
308
309 const wanted = normaliseTrackName(savedName);
310 if (!wanted)
311 {
312 for (const track of tracks) track.mode = 'disabled';
313 return;
314 }
315
316 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
317 if (!match) return;
318
319 for (const track of tracks)
320 {
321 track.mode = track === match ? 'showing' : 'disabled';
322 }
323}
324
325function applySavedAudioTrack (player, savedName)
326{
327 if (typeof savedName !== 'string') return;
328 const tracks = audioTracksFromPlayer(player);
329 if (!tracks.length) return;
330
331 const wanted = normaliseTrackName(savedName);
332 if (!wanted) return;
333
334 const match = tracks.find((track) => normaliseTrackName(getTrackName(track)) === wanted);
335 if (!match) return;
336
337 for (const track of tracks)
338 {
339 track.enabled = track === match;
340 }
341}
342
343function getSelectedSubtitleTrackName (player)
344{
345 const tracks = subtitleTracksFromPlayer(player);
346 if (!tracks.length) return null;
347 const active = tracks.find((track) => String(track.mode || '').toLowerCase() === 'showing');
348 return active ? getTrackName(active) : '';
349}
350
351function getSelectedAudioTrackName (player)
352{
353 const tracks = audioTracksFromPlayer(player);
354 if (!tracks.length) return null;
355 const active = tracks.find((track) => !!track.enabled);
356 return active ? getTrackName(active) : '';
357}
358
359function bindUserVideoTrackPrefs (player, prefs)
360{
361 const applySavedTracks = () =>
362 {
363 applySavedSubtitleTrack(player, prefs.subtitleTrackName);
364 applySavedAudioTrack(player, prefs.audioTrackName);
365 };
366
367 const captureSelectedTracks = () =>
368 {
369 const subtitleTrackName = getSelectedSubtitleTrackName(player);
370 const audioTrackName = getSelectedAudioTrackName(player);
371 const patch = {};
372
373 if (subtitleTrackName !== null) patch.subtitleTrackName = subtitleTrackName;
374 if (audioTrackName !== null) patch.audioTrackName = audioTrackName;
375
376 if (Object.keys(patch).length) saveUserVideoPrefs(patch);
377 };
378
379 const textTrackList = typeof player.textTracks === 'function' ? player.textTracks() : null;
380 const audioTrackList = typeof player.audioTracks === 'function' ? player.audioTracks() : null;
381 const onTrackListChange = () => captureSelectedTracks();
382
383 if (textTrackList && typeof textTrackList.addEventListener === 'function')
384 {
385 textTrackList.addEventListener('change', onTrackListChange);
386 }
387
388 if (audioTrackList && typeof audioTrackList.addEventListener === 'function')
389 {
390 audioTrackList.addEventListener('change', onTrackListChange);
391 }
392
393 return {
394 applySavedTracks,
395 captureSelectedTracks,
396 detach: () =>
397 {
398 if (textTrackList && typeof textTrackList.removeEventListener === 'function')
399 {
400 textTrackList.removeEventListener('change', onTrackListChange);
401 }
402 if (audioTrackList && typeof audioTrackList.removeEventListener === 'function')
403 {
404 audioTrackList.removeEventListener('change', onTrackListChange);
405 }
406 },
407 };
408}
409
410function normaliseVideoDuration (player, durationSeconds)
411{
412 const duration = Number(durationSeconds);
413 if (!player || !Number.isFinite(duration) || duration <= 0) return;
414
415 let originalDuration = null;
416 let durationWasChanged = false;
417 try
418 {
419 originalDuration = typeof player.duration === 'function' ? player.duration.bind(player) : null;
420 installDurationFallback(player, originalDuration, duration);
421 if (player.__filemanagerDurationApplied) return;
422
423 const current = originalDuration ? Number(originalDuration()) : NaN;
424 const withinTolerance = Number.isFinite(current) && current >= duration * 0.95;
425 console.log(`Current duration: ${formatDurationForDebug(current)}, Target time: ${formatDurationForDebug(duration)}, within 95%? ${withinTolerance ? 'yes' : 'no'}`);
426 if (withinTolerance)
427 {
428 player.__filemanagerDurationApplied = true;
429 return;
430 }
431
432 if (originalDuration)
433 {
434 durationWasChanged = true;
435 originalDuration(duration);
436 }
437 } catch
438 {
439 // Ignore players that do not support setting duration.
440 }
441
442 try
443 {
444 const updated = originalDuration ? Number(originalDuration()) : NaN;
445 if (Number.isFinite(updated) && updated >= duration * 0.95)
446 {
447 player.__filemanagerDurationApplied = true;
448 if (durationWasChanged && typeof player.trigger === 'function') player.trigger('durationchange');
449 return;
450 }
451
452 player.__filemanagerDurationApplied = true;
453 if (typeof player.trigger === 'function') player.trigger('durationchange');
454 } catch
455 {
456 // Ignore duration fallback failures.
457 }
458}
459
460function installDurationFallback (player, originalDuration, duration)
461{
462 if (!player || !originalDuration || player.__filemanagerDurationFallback) return;
463
464 player.__filemanagerDurationFallback = true;
465 player.duration = function durationWithFallback (...args)
466 {
467 if (args.length) return originalDuration(...args);
468 const current = Number(originalDuration());
469 return Number.isFinite(current) && current >= duration * 0.95 ? current : duration;
470 };
471}
472
473function formatDurationForDebug (seconds)
474{
475 const value = Number(seconds);
476 if (!Number.isFinite(value) || value < 0) return 'unknown';
477
478 const totalSeconds = Math.floor(value);
479 const hh = String(Math.floor(totalSeconds / 3600)).padStart(2, '0');
480 const mm = String(Math.floor((totalSeconds % 3600) / 60)).padStart(2, '0');
481 const ss = String(totalSeconds % 60).padStart(2, '0');
482 return `${hh}:${mm}:${ss}`;
483}
484
485function ensureVideoPlaybackUi (player, durationSeconds)
486{
487 if (!player || typeof player.on !== 'function') return;
488
489 const forceVodUi = () =>
490 {
491 normaliseVideoDuration(player, durationSeconds);
492
493 try
494 {
495 if (player.liveTracker && typeof player.liveTracker.stopTracking === 'function')
496 {
497 player.liveTracker.stopTracking();
498 }
499 } catch
500 {
501 // Ignore live tracker availability issues.
502 }
503
504 try
505 {
506 if (typeof player.removeClass === 'function')
507 {
508 player.removeClass('vjs-live');
509 }
510 } catch
511 {
512 // Ignore class update failures.
513 }
514
515 try
516 {
517 const display = player.el() && player.el().querySelector('.vjs-live-display');
518 if (display) display.style.display = 'none';
519 } catch
520 {
521 // Ignore missing DOM.
522 }
523 };
524
525 player.ready(forceVodUi);
526 player.on('loadedmetadata', forceVodUi);
527 player.on('durationchange', forceVodUi);
528 player.on('loadedplaylist', forceVodUi);
529}
530
531async function reportWatchProgress (filePath, progress)
532{
533 if (!filePath || !Number.isFinite(progress)) return;
534 await api('POST', '/files/watch-progress', {
535 filePath,
536 progress,
537 }).catch(() => null);
538}
539
540function getOrCreateClientBindingId ()
541{
542 if (STATE.clientBindingId) return STATE.clientBindingId;
543
544 try
545 {
546 const existing = localStorage.getItem(CLIENT_BINDING_KEY);
547 if (existing && typeof existing === 'string')
548 {
549 STATE.clientBindingId = existing;
550 return existing;
551 }
552 } catch
553 {
554 // Ignore storage read errors.
555 }
556
557 const created = randomIdHex(16);
558 STATE.clientBindingId = created;
559
560 try
561 {
562 localStorage.setItem(CLIENT_BINDING_KEY, created);
563 } catch
564 {
565 // Ignore storage write errors; in-memory fallback still keeps this stable
566 // for the current page session.
567 }
568
569 return created;
570}
571
572function formatBytes (bytes)
573{
574 if (bytes == null) return '—';
575 if (bytes < 1024) return bytes + ' B';
576 if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
577 if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
578 return (bytes / 1073741824).toFixed(2) + ' GB';
579}
580
581function extOf (name)
582{
583 const i = name.lastIndexOf('.');
584 return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
585}
586
587function getPathSep (basePath)
588{
589 return basePath && basePath.includes('\\') ? '\\' : '/';
590}
591
592function joinServerPath (basePath, segment)
593{
594 const sep = getPathSep(basePath);
595 const base = String(basePath || '').replace(/[\\/]+$/, '');
596 return base + sep + segment;
597}
598
599function samePath (a, b)
600{
601 if (!a || !b) return false;
602 return String(a).toLowerCase() === String(b).toLowerCase();
603}
604
605function pathInside (child, root)
606{
607 if (!child || !root) return false;
608 if (samePath(child, root)) return true;
609 const sep = getPathSep(root);
610 return String(child).toLowerCase().startsWith((String(root) + sep).toLowerCase());
611}
612
613function splitNameExt (name)
614{
615 const dot = String(name || '').lastIndexOf('.');
616 if (dot <= 0) return { stem: String(name || ''), ext: '' };
617 return {
618 stem: String(name).slice(0, dot),
619 ext: String(name).slice(dot),
620 };
621}
622
623function nextAvailableName (requestedName, existingNames)
624{
625 const set = existingNames instanceof Set ? existingNames : new Set(existingNames || []);
626 if (!set.has(requestedName)) return requestedName;
627
628 const { stem, ext } = splitNameExt(requestedName);
629 let n = 1;
630 while (n <= 10000)
631 {
632 const candidate = `${stem || 'file'} (${n})${ext}`;
633 if (!set.has(candidate)) return candidate;
634 n++;
635 }
636
637 return requestedName;
638}
639
640async function listDirNameSet (dir)
641{
642 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dir)}`);
643 const names = new Set();
644 for (const it of ((data && data.items) || [])) names.add(it.name);
645 return names;
646}
647
648function cloneFileWithName (file, newName)
649{
650 return new File([file], newName, {
651 type: file.type,
652 lastModified: file.lastModified,
653 });
654}
655
656function saveSessionState ()
657{
658 if (!STATE.token) return;
659 const now = Date.now();
660 STATE.lastOperationAt = now;
661 const payload = {
662 token: STATE.token,
663 dir: STATE.currentDir || null,
664 rootPath: STATE.currentRoot ? STATE.currentRoot.path : null,
665 lastOperationAt: STATE.lastOperationAt,
666 };
667 try
668 {
669 localStorage.setItem(SESSION_KEY, JSON.stringify(payload));
670 } catch
671 {
672 // Ignore storage errors (private mode/full quota).
673 }
674}
675
676function loadSessionState ()
677{
678 try
679 {
680 const raw = localStorage.getItem(SESSION_KEY);
681 if (!raw) return null;
682 const parsed = JSON.parse(raw);
683 if (!parsed || typeof parsed.token !== 'string') return null;
684 if (!Number.isFinite(parsed.lastOperationAt)) return null;
685
686 if (Date.now() - parsed.lastOperationAt > SESSION_IDLE_TIMEOUT_MS)
687 {
688 clearSessionState();
689 return null;
690 }
691
692 return parsed;
693 } catch
694 {
695 return null;
696 }
697}
698
699function clearSessionState ()
700{
701 try { localStorage.removeItem(SESSION_KEY); } catch { /* ignore */ }
702}
703
704// ───────────────────────────────────────────────────────────────────────────
705// API
706// ───────────────────────────────────────────────────────────────────────────
707
708async function api (method, path, body, opts = {})
709{
710 const headers = { 'Content-Type': 'application/json' };
711 const noAutoLogout = !!opts.noAutoLogout;
712 if (STATE.token)
713 {
714 headers['Authorization'] = 'Bearer ' + STATE.token;
715 try
716 {
717 const fp = getFingerprint();
718 if (fp) headers['X-Fp'] = fp;
719 } catch
720 {
721 // Continue without a fingerprint header in constrained test/runtime contexts.
722 }
723 }
724 const fetchOpts = { ...opts };
725 delete fetchOpts.noAutoLogout;
726 const res = await fetch('/api' + path, {
727 method,
728 headers,
729 body: body != null ? JSON.stringify(body) : undefined,
730 ...fetchOpts,
731 });
732 if (!res.ok)
733 {
734 const j = await res.json().catch(() => ({}));
735 // Session-expired → force re-login
736 if (res.status === 401)
737 {
738 if (!noAutoLogout) logout();
739 return null;
740 }
741 throw new Error(j.error || res.statusText);
742 }
743 if (STATE.token && !path.startsWith('/auth/server-key') && !path.startsWith('/auth/setup-needed'))
744 {
745 saveSessionState();
746 }
747 return res.json();
748}
749
750// ───────────────────────────────────────────────────────────────────────────
751// TOAST
752// ───────────────────────────────────────────────────────────────────────────
753
754function toast (msg, type = '')
755{
756 const el = document.createElement('div');
757 el.className = 'toast-msg' + (type ? ' ' + type : '');
758 el.textContent = msg;
759 document.getElementById('toast').appendChild(el);
760 setTimeout(() => el.remove(), 3500);
761}
762
763// ───────────────────────────────────────────────────────────────────────────
764// DIALOG MODALS — centralised replacements for alert / confirm / prompt
765// ───────────────────────────────────────────────────────────────────────────
766
767/**
768 * Show a confirmation dialog.
769 * @param {string} title
770 * @param {string} message
771 * @returns {Promise<boolean>} true = OK, false = Cancel
772 */
773function showConfirm (title, message, { html = false, okLabel = null } = {})
774{
775 return new Promise((resolve) =>
776 {
777 const overlay = document.getElementById('confirm-modal');
778 document.getElementById('confirm-modal-title').textContent = title;
779 const msgEl = document.getElementById('confirm-modal-message');
780 if (html) msgEl.innerHTML = message;
781 else msgEl.textContent = message;
782 overlay.classList.remove('hidden');
783
784 const ok = document.getElementById('confirm-modal-ok');
785 const prevOkLabel = ok.textContent;
786 if (okLabel != null) ok.textContent = okLabel;
787
788 const cancel = document.getElementById('confirm-modal-cancel');
789
790 function finish (result)
791 {
792 overlay.classList.add('hidden');
793 ok.textContent = prevOkLabel;
794 ok.removeEventListener('click', onOk);
795 cancel.removeEventListener('click', onCancel);
796 resolve(result);
797 }
798 function onOk () { finish(true); }
799 function onCancel () { finish(false); }
800
801 ok.addEventListener('click', onOk);
802 cancel.addEventListener('click', onCancel);
803 ok.focus();
804 });
805}
806
807function escHtml (s)
808{
809 return String(s || '')
810 .replace(/&/g, '&amp;')
811 .replace(/</g, '&lt;')
812 .replace(/>/g, '&gt;')
813 .replace(/"/g, '&quot;');
814}
815
816/**
817 * Show a text-input dialog.
818 * @param {string} title
819 * @param {string} [message] — optional helper text shown above the input
820 * @param {string} [defaultValue] — pre-filled value
821 * @returns {Promise<string|null>} string = submitted value, null = cancelled
822 */
823function showPrompt (title, message = '', defaultValue = '')
824{
825 return new Promise((resolve) =>
826 {
827 const overlay = document.getElementById('prompt-modal');
828 const msgEl = document.getElementById('prompt-modal-message');
829 const input = document.getElementById('prompt-modal-input');
830 const errorEl = document.getElementById('prompt-modal-error');
831 const form = document.getElementById('prompt-modal-form');
832 const cancel = document.getElementById('prompt-modal-cancel');
833
834 document.getElementById('prompt-modal-title').textContent = title;
835 msgEl.textContent = message;
836 msgEl.classList.toggle('hidden', !message);
837 input.value = defaultValue;
838 errorEl.classList.add('hidden');
839 overlay.classList.remove('hidden');
840 input.focus();
841 input.select();
842
843 function finish (result)
844 {
845 overlay.classList.add('hidden');
846 form.removeEventListener('submit', onSubmit);
847 cancel.removeEventListener('click', onCancel);
848 resolve(result);
849 }
850 function onSubmit (e)
851 {
852 e.preventDefault();
853 finish(input.value);
854 }
855 function onCancel () { finish(null); }
856
857 form.addEventListener('submit', onSubmit);
858 cancel.addEventListener('click', onCancel);
859 });
860}
861
862/**
863 * Show an overwrite-decision dialog for a single file conflict.
864 * @param {string} filename
865 * @returns {Promise<'yes'|'no'|'all'|'none'>}
866 */
867function showOverwrite (filename)
868{
869 return new Promise((resolve) =>
870 {
871 const overlay = document.getElementById('overwrite-modal');
872 document.getElementById('overwrite-modal-filename').textContent = filename;
873 overlay.classList.remove('hidden');
874
875 const btnYes = document.getElementById('overwrite-modal-yes');
876 const btnNo = document.getElementById('overwrite-modal-no');
877 const btnAll = document.getElementById('overwrite-modal-all');
878 const btnSkipAll = document.getElementById('overwrite-modal-skip-all');
879
880 function finish (result)
881 {
882 overlay.classList.add('hidden');
883 btnYes.removeEventListener('click', onYes);
884 btnNo.removeEventListener('click', onNo);
885 btnAll.removeEventListener('click', onAll);
886 btnSkipAll.removeEventListener('click', onSkipAll);
887 resolve(result);
888 }
889 function onYes () { finish('yes'); }
890 function onNo () { finish('no'); }
891 function onAll () { finish('all'); }
892 function onSkipAll () { finish('none'); }
893
894 btnYes.addEventListener('click', onYes);
895 btnNo.addEventListener('click', onNo);
896 btnAll.addEventListener('click', onAll);
897 btnSkipAll.addEventListener('click', onSkipAll);
898 btnNo.focus();
899 });
900}
901
902/**
903 * Show single-file conflict options.
904 * @param {string} filename
905 * @param {string} renameTo
906 * @param {string} mode - upload|move
907 * @returns {Promise<'overwrite'|'rename'|'cancel'>}
908 */
909function showFileConflictChoice (filename, renameTo, mode = 'upload')
910{
911 return new Promise((resolve) =>
912 {
913 const overlay = document.getElementById('file-conflict-modal');
914 const title = document.getElementById('file-conflict-title');
915 const fileEl = document.getElementById('file-conflict-filename');
916 const renameEl = document.getElementById('file-conflict-rename');
917 const btnOverwrite = document.getElementById('file-conflict-overwrite');
918 const btnRename = document.getElementById('file-conflict-rename-btn');
919 const btnCancel = document.getElementById('file-conflict-cancel');
920
921 title.textContent = mode === 'move' ? 'Move file' : 'Upload file';
922 fileEl.textContent = filename;
923 renameEl.textContent = renameTo;
924 btnRename.textContent = `Rename (${renameTo})`;
925
926 overlay.classList.remove('hidden');
927
928 function finish (result)
929 {
930 overlay.classList.add('hidden');
931 btnOverwrite.removeEventListener('click', onOverwrite);
932 btnRename.removeEventListener('click', onRename);
933 btnCancel.removeEventListener('click', onCancel);
934 resolve(result);
935 }
936
937 function onOverwrite () { finish('overwrite'); }
938 function onRename () { finish('rename'); }
939 function onCancel () { finish('cancel'); }
940
941 btnOverwrite.addEventListener('click', onOverwrite);
942 btnRename.addEventListener('click', onRename);
943 btnCancel.addEventListener('click', onCancel);
944 btnCancel.focus();
945 });
946}
947
948// ───────────────────────────────────────────────────────────────────────────
949// SHARE MODAL
950// ───────────────────────────────────────────────────────────────────────────
951
952async function openShareModal (item)
953{
954 const overlay = document.getElementById('share-modal');
955 const urlInput = document.getElementById('share-url-input');
956 const copyBtn = document.getElementById('share-copy-btn');
957 const okBtn = document.getElementById('share-modal-ok');
958 const closeBtn = document.getElementById('share-modal-close');
959 const msgEl = document.getElementById('share-modal-msg');
960
961 urlInput.value = 'Creating link...';
962 copyBtn.disabled = true;
963 msgEl.textContent = 'This link is valid for 24 hours.';
964 overlay.classList.remove('hidden');
965
966 let data;
967 try
968 {
969 data = await api('POST', '/share/create', { filePath: item.path });
970 } catch (err)
971 {
972 msgEl.textContent = 'Error: ' + (err.message || 'Could not create link.');
973 urlInput.value = '';
974 return;
975 }
976
977 if (!data || !data.token)
978 {
979 msgEl.textContent = 'Unknown error while creating link.';
980 urlInput.value = '';
981 return;
982 }
983
984 const shareUrl = `${location.origin}/share/${data.token}`;
985 urlInput.value = shareUrl;
986 copyBtn.disabled = false;
987
988 function close ()
989 {
990 overlay.classList.add('hidden');
991 okBtn.removeEventListener('click', close);
992 closeBtn.removeEventListener('click', close);
993 copyBtn.removeEventListener('click', onCopy);
994 }
995
996 function onCopy ()
997 {
998 navigator.clipboard.writeText(shareUrl).then(() =>
999 {
1000 const orig = copyBtn.textContent;
1001 copyBtn.textContent = 'Copied!';
1002 setTimeout(() => { copyBtn.textContent = orig; }, 1500);
1003 }).catch(() =>
1004 {
1005 // Fallback: select the text
1006 urlInput.select();
1007 });
1008 }
1009
1010 okBtn.addEventListener('click', close);
1011 closeBtn.addEventListener('click', close);
1012 copyBtn.addEventListener('click', onCopy);
1013 okBtn.focus();
1014}
1015
1016// ───────────────────────────────────────────────────────────────────────────
1017// AUTH FLOW
1018// ───────────────────────────────────────────────────────────────────────────
1019
1020function showAuthOverlay (setupMode = false)
1021{
1022 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1023 document.getElementById('app').classList.add('hidden');
1024 const overlay = document.getElementById('auth-overlay');
1025 const usernameInput = document.getElementById('auth-username');
1026 const passwordInput = document.getElementById('auth-password');
1027 overlay.classList.remove('hidden');
1028 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
1029 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
1030 const submitBtn = document.getElementById('auth-submit');
1031 submitBtn.disabled = false;
1032 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
1033 document.getElementById('auth-error').classList.add('hidden');
1034 usernameInput.value = '';
1035 passwordInput.value = '';
1036 usernameInput.autocomplete = 'username';
1037 passwordInput.autocomplete = setupMode ? 'new-password' : 'current-password';
1038 usernameInput.focus();
1039 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
1040}
1041
1042function showApp ()
1043{
1044 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1045 document.getElementById('auth-overlay').classList.add('hidden');
1046 document.getElementById('app').classList.remove('hidden');
1047 if (isMobileViewport())
1048 {
1049 hideSidebarPanel();
1050 } else
1051 {
1052 openFolderSidebar();
1053 }
1054 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
1055 startAutoRefresh();
1056}
1057
1058async function initAuth ()
1059{
1060 // Generate a fresh key pair in the background; login falls back gracefully
1061 // while this is still in progress.
1062 generateClientKeyPair().catch(() =>
1063 {
1064 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
1065 });
1066
1067 // Fetch server public key
1068 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
1069 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
1070 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
1071 STATE.serverPublicKeyJwk = publicKey;
1072
1073 // Check whether first-run setup is needed
1074 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
1075
1076 if (!needed)
1077 {
1078 const saved = loadSessionState();
1079 if (saved && saved.token)
1080 {
1081 STATE.token = saved.token;
1082 STATE.restoreDir = saved.dir || null;
1083 STATE.restoreRootPath = saved.rootPath || null;
1084 STATE.lastOperationAt = saved.lastOperationAt;
1085
1086 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
1087 if (me)
1088 {
1089 STATE.username = me.username;
1090 STATE.isAdmin = me.isAdmin;
1091 STATE.permissions = me.permissions;
1092 showApp();
1093 await loadRoots({
1094 preferredDir: STATE.restoreDir,
1095 preferredRootPath: STATE.restoreRootPath,
1096 });
1097 return;
1098 }
1099
1100 STATE.token = null;
1101 clearSessionState();
1102 }
1103 }
1104
1105 showAuthOverlay(needed);
1106}
1107
1108async function doLogin (username, password, isSetup)
1109{
1110 const encrypted = await hybridEncryptForServer({ username, password });
1111 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
1112
1113 let data;
1114 try
1115 {
1116 data = await api('POST', endpoint, {
1117 encrypted,
1118 clientPublicKey: STATE.clientPublicKeyJwk,
1119 fingerprint: getFingerprint(),
1120 });
1121 } catch (err)
1122 {
1123 return err.message;
1124 }
1125
1126 if (!data) return 'Login failed.';
1127
1128 // Decrypt the token sent back by the server
1129 const token = await hybridDecryptFromServer(data.encrypted || data);
1130 if (!token) return 'Login failed.';
1131 STATE.token = token;
1132
1133 // Load user info
1134 const me = await api('GET', '/auth/me');
1135 if (!me) return 'Session error.';
1136
1137 STATE.username = me.username;
1138 STATE.isAdmin = me.isAdmin;
1139 STATE.permissions = me.permissions;
1140
1141 saveSessionState();
1142 showApp();
1143 await loadRoots();
1144 return null; // no error
1145}
1146
1147function logout ()
1148{
1149 void performLogout();
1150}
1151
1152async function performLogout ()
1153{
1154 const tokenAtStart = STATE.token;
1155 stopAutoRefresh();
1156
1157 if (tokenAtStart)
1158 {
1159 try
1160 {
1161 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
1162 } catch
1163 {
1164 // Ignore network errors while logging out locally.
1165 }
1166 }
1167
1168 STATE.token = null;
1169 STATE.username = null;
1170 STATE.isAdmin = false;
1171 STATE.permissions = {};
1172 STATE.currentDir = null;
1173 STATE.currentRoot = null;
1174 STATE.items = [];
1175 STATE.restoreDir = null;
1176 STATE.restoreRootPath = null;
1177 STATE.lastOperationAt = null;
1178 clearSessionState();
1179 closePreview({ force: true });
1180 closeSidebar();
1181 await initAuth();
1182}
1183
1184// ───────────────────────────────────────────────────────────────────────────
1185// NAVIGATION
1186// ───────────────────────────────────────────────────────────────────────────
1187
1188async function loadRoots (opts = {})
1189{
1190 const data = await api('GET', '/files/roots');
1191 if (!data) return;
1192 STATE.roots = data.roots;
1193
1194 const preferredDir = opts.preferredDir || null;
1195 const preferredRootPath = opts.preferredRootPath || null;
1196
1197 if (preferredDir && preferredRootPath)
1198 {
1199 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
1200 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
1201 {
1202 try
1203 {
1204 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
1205 return;
1206 } catch
1207 {
1208 // Fall back to default root behavior.
1209 }
1210 }
1211 }
1212
1213 if (STATE.roots.length === 1)
1214 {
1215 // Single root → open it directly
1216 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
1217 } else
1218 {
1219 renderRootsView();
1220 }
1221}
1222
1223function renderRootsView ()
1224{
1225 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1226 disconnectThumbnailObserver();
1227 disconnectFolderIconObserver();
1228 revokeThumbnails();
1229
1230 STATE.currentDir = null;
1231 STATE.currentRoot = null;
1232 saveSessionState();
1233 renderBreadcrumb();
1234 const grid = document.getElementById('file-grid');
1235 grid.innerHTML = '';
1236 document.getElementById('empty-notice').classList.add('hidden');
1237 document.getElementById('folder-stats').classList.add('hidden');
1238 closeSidebar();
1239
1240 for (const root of STATE.roots)
1241 {
1242 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
1243 grid.appendChild(el);
1244 }
1245
1246 loadThumbnails();
1247}
1248
1249async function navigateTo (absPath, root, opts = {})
1250{
1251 if (root) STATE.currentRoot = root;
1252 STATE.currentDir = absPath;
1253
1254 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
1255 if (!data) return;
1256
1257 STATE.items = data.items;
1258 saveSessionState();
1259 renderBreadcrumb();
1260 renderFileGrid();
1261 await refreshFolderStats();
1262 closeSidebar();
1263}
1264
1265function renderBreadcrumb ()
1266{
1267 if (typeof document === 'undefined') return;
1268 const nav = document.getElementById('breadcrumb');
1269 if (!nav) return;
1270 nav.innerHTML = '';
1271
1272 // "Home" crumb
1273 const home = document.createElement('span');
1274 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
1275 home.textContent = 'Home';
1276 home.addEventListener('click', () =>
1277 {
1278 if (STATE.roots.length === 1)
1279 {
1280 navigateTo(STATE.roots[0].path, STATE.roots[0]);
1281 } else
1282 {
1283 renderRootsView();
1284 }
1285 });
1286 nav.appendChild(home);
1287
1288 if (!STATE.currentDir || !STATE.currentRoot) return;
1289
1290 // Build path segments relative to the root
1291 const rootPath = STATE.currentRoot.path;
1292 const relative = STATE.currentDir === rootPath
1293 ? ''
1294 : STATE.currentDir.replace(rootPath, '').replace(/^[\\/]/, '');
1295
1296 const parts = [STATE.currentRoot.label, ...relative.split(/[\\/]/).filter(Boolean)];
1297 let accumulated = rootPath;
1298
1299 for (let i = 0; i < parts.length; i++)
1300 {
1301 const sep = document.createElement('span');
1302 sep.className = 'sep';
1303 sep.textContent = ' / ';
1304 nav.appendChild(sep);
1305
1306 const crumb = document.createElement('span');
1307 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
1308 crumb.textContent = parts[i];
1309
1310 // Capture the path for this crumb
1311 const capturedPath = i === 0 ? rootPath : accumulated;
1312 crumb.classList.add('crumb-drop-target');
1313 crumb.dataset.path = capturedPath;
1314 if (i < parts.length - 1)
1315 {
1316 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
1317 }
1318
1319 nav.appendChild(crumb);
1320
1321 // Advance accumulated path (skip for root label)
1322 if (i > 0) accumulated = accumulated + '/' + parts[i];
1323 else if (i === 0 && parts.length > 1)
1324 {
1325 // After root label, next crumb should append the next segment
1326 accumulated = rootPath;
1327 }
1328 }
1329}
1330
1331async function refreshFolderStats ()
1332{
1333 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1334 const el = document.getElementById('folder-stats');
1335 if (!STATE.currentDir)
1336 {
1337 el.classList.add('hidden');
1338 return;
1339 }
1340
1341 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
1342 if (!data)
1343 {
1344 el.classList.add('hidden');
1345 return;
1346 }
1347
1348 const used = formatBytes(data.usedBytes);
1349 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
1350 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
1351 el.classList.remove('hidden');
1352}
1353
1354function itemsSignature (items)
1355{
1356 return JSON.stringify(
1357 (items || []).map(it => [it.path, it.mtime, it.size, it.isDir])
1358 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
1359 );
1360}
1361
1362async function incrementalRefreshCurrentDir ()
1363{
1364 if (STATE.previewExpandState) return;
1365 if (!STATE.currentDir || STATE.uploadInProgress) return;
1366
1367 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
1368 if (!data) return;
1369
1370 const oldSig = itemsSignature(STATE.items);
1371 const newSig = itemsSignature(data.items);
1372 if (oldSig !== newSig)
1373 {
1374 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
1375 STATE.items = data.items;
1376 renderFileGrid();
1377
1378 if (selectedPath)
1379 {
1380 const match = STATE.items.find(i => i.path === selectedPath);
1381 if (match)
1382 {
1383 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
1384 .find(el => el.dataset.path === selectedPath);
1385 if (selectedEl) selectItem(selectedEl, match);
1386 } else
1387 {
1388 closeSidebar();
1389 }
1390 }
1391 }
1392 else
1393 {
1394 loadThumbnails();
1395 }
1396
1397 await refreshFolderStats();
1398}
1399
1400function startAutoRefresh ()
1401{
1402 stopAutoRefresh();
1403 STATE.autoRefreshTimer = setInterval(() =>
1404 {
1405 if (document.hidden) return;
1406 incrementalRefreshCurrentDir();
1407 }, 5000);
1408}
1409
1410function stopAutoRefresh ()
1411{
1412 if (STATE.autoRefreshTimer)
1413 {
1414 clearInterval(STATE.autoRefreshTimer);
1415 STATE.autoRefreshTimer = null;
1416 }
1417}
1418
1419// ───────────────────────────────────────────────────────────────────────────
1420// FILE GRID RENDERING
1421// ───────────────────────────────────────────────────────────────────────────
1422
1423function renderFileGrid ()
1424{
1425 if (typeof document === 'undefined' || typeof document.getElementById !== 'function') return;
1426 disconnectThumbnailObserver();
1427 disconnectFolderIconObserver();
1428 revokeThumbnails();
1429 const grid = document.getElementById('file-grid');
1430 grid.innerHTML = '';
1431 const empty = document.getElementById('empty-notice');
1432
1433 const sorted = [...STATE.items].sort((a, b) =>
1434 {
1435 if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
1436 return a.name.localeCompare(b.name);
1437 });
1438
1439 empty.classList.toggle('hidden', sorted.length > 0);
1440
1441 for (const item of sorted)
1442 {
1443 grid.appendChild(makeFileItem(item));
1444 }
1445
1446 loadThumbnails();
1447}
1448
1449function makeFileItem (item)
1450{
1451 const el = document.createElement('div');
1452 el.className = 'file-item';
1453 el.dataset.path = item.path;
1454 if (item.isDir) el.dataset.isdir = '1';
1455
1456 const icon = document.createElement('div');
1457 icon.className = 'icon';
1458 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
1459 if (!item.isDir)
1460 {
1461 icon.dataset.previewPath = item.path;
1462 } else
1463 {
1464 icon.dataset.folderPath = item.path;
1465 }
1466 el.appendChild(icon);
1467
1468 const name = document.createElement('div');
1469 name.className = 'name';
1470 name.textContent = item.name;
1471 el.appendChild(name);
1472
1473 if (!item._root) makeDraggable(el, item);
1474 attachMobileLongPress(el, item);
1475
1476 el.addEventListener('contextmenu', (e) =>
1477 {
1478 if (!isMobileViewport()) return;
1479 e.preventDefault();
1480 e.stopPropagation();
1481 });
1482
1483 // Single-click: open sidebar
1484 el.addEventListener('click', (e) =>
1485 {
1486 e.stopPropagation();
1487 if (isMobileViewport())
1488 {
1489 if (el.dataset.longPressTriggered === '1')
1490 {
1491 el.dataset.longPressTriggered = '0';
1492 return;
1493 }
1494
1495 if (item.isDir)
1496 {
1497 navigateTo(item.path, item._root || STATE.currentRoot);
1498 } else
1499 {
1500 downloadOrView(item, icon.querySelector('svg'));
1501 }
1502 return;
1503 }
1504
1505 selectItem(el, item);
1506 });
1507
1508 // Double-click: enter folder or view/download file
1509 el.addEventListener('dblclick', (e) =>
1510 {
1511 e.stopPropagation();
1512 if (item.isDir)
1513 {
1514 navigateTo(item.path, item._root || STATE.currentRoot);
1515 } else
1516 {
1517 downloadOrView(item, icon.querySelector('svg'));
1518 }
1519 });
1520
1521 return el;
1522}
1523
1524function attachMobileLongPress (el, item)
1525{
1526 if (item._root) return;
1527
1528 let pressTimer = null;
1529 let startX = 0;
1530 let startY = 0;
1531
1532 function clearPress ()
1533 {
1534 if (!pressTimer) return;
1535 clearTimeout(pressTimer);
1536 pressTimer = null;
1537 }
1538
1539 function cancelPress ()
1540 {
1541 clearPress();
1542 }
1543
1544 el.addEventListener('pointerdown', (e) =>
1545 {
1546 if (!isMobileViewport()) return;
1547 if (e.button !== undefined && e.button !== 0) return;
1548 if (e.pointerType && e.pointerType === 'mouse') return;
1549
1550 startX = e.clientX;
1551 startY = e.clientY;
1552 clearPress();
1553
1554 pressTimer = setTimeout(() =>
1555 {
1556 pressTimer = null;
1557 el.dataset.longPressTriggered = '1';
1558 selectItem(el, item);
1559 }, MOBILE_LONG_PRESS_MS);
1560 });
1561
1562 el.addEventListener('pointermove', (e) =>
1563 {
1564 if (!pressTimer) return;
1565 if (Math.hypot(e.clientX - startX, e.clientY - startY) > MOBILE_LONG_PRESS_MOVE_THRESHOLD)
1566 {
1567 clearPress();
1568 }
1569 });
1570
1571 el.addEventListener('pointerup', cancelPress);
1572 el.addEventListener('pointercancel', cancelPress);
1573 el.addEventListener('pointerleave', cancelPress);
1574}
1575
1576function selectItem (el, item)
1577{
1578 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
1579 el.classList.add('selected');
1580 STATE.selectedItem = item;
1581 openSidebar(item);
1582}
1583
1584// ───────────────────────────────────────────────────────────────────────────
1585// SIDEBAR
1586// ───────────────────────────────────────────────────────────────────────────
1587
1588/**
1589 * Renders (or clears) the duplicates panel at the bottom of the sidebar.
1590 * @param {object|null} item — the item whose duplicates are shown; null = clear
1591 * @param {Array|null} duplicates — array of {path, name, dir}; null = loading state
1592 */
1593function renderSidebarDuplicates (item, duplicates)
1594{
1595 const panel = document.getElementById('sidebar-duplicates');
1596 if (!panel) return;
1597
1598 // Clear / hide when no item or no duplicates.
1599 if (!item || (Array.isArray(duplicates) && duplicates.length === 0))
1600 {
1601 panel.classList.add('hidden');
1602 panel.innerHTML = '';
1603 return;
1604 }
1605
1606 // Loading state.
1607 if (duplicates === null)
1608 {
1609 panel.classList.add('hidden');
1610 panel.innerHTML = '';
1611 return;
1612 }
1613
1614 panel.innerHTML = '';
1615 const heading = document.createElement('p');
1616 heading.className = 'sidebar-duplicates-heading';
1617 heading.textContent = `Duplicates (${duplicates.length})`;
1618 panel.appendChild(heading);
1619
1620 const list = document.createElement('ul');
1621 list.className = 'sidebar-duplicates-list';
1622
1623 for (const dup of duplicates)
1624 {
1625 const li = document.createElement('li');
1626 const btn = document.createElement('button');
1627 btn.className = 'sidebar-duplicate-entry';
1628 btn.title = dup.path;
1629 // Show the full path; let CSS truncate with ellipsis if it does not fit.
1630 btn.textContent = dup.path;
1631 btn.addEventListener('click', () => navigateToDuplicate(dup));
1632 li.appendChild(btn);
1633 list.appendChild(li);
1634 }
1635
1636 panel.appendChild(list);
1637 panel.classList.remove('hidden');
1638}
1639
1640/**
1641 * Navigates to the folder containing a duplicate file and then auto-opens it.
1642 * @param {{ path: string, name: string, dir: string }} dup
1643 */
1644async function navigateToDuplicate (dup)
1645{
1646 // Find the root that contains the duplicate.
1647 const root = STATE.roots.find(
1648 (r) => dup.dir === r.path || dup.dir.startsWith(r.path + '/') || dup.dir.startsWith(r.path + '\\'),
1649 );
1650 if (!root)
1651 {
1652 toast('Cannot navigate to duplicate: root not accessible.', 'err');
1653 return;
1654 }
1655
1656 await navigateTo(dup.dir, root);
1657
1658 // After navigation, find and select the file tile to open it.
1659 const tile = Array.from(document.querySelectorAll('.file-item'))
1660 .find((el) => el.dataset.path === dup.path);
1661 const dupItem = STATE.items.find((i) => i.path === dup.path);
1662
1663 if (tile && dupItem)
1664 {
1665 selectItem(tile, dupItem);
1666 }
1667}
1668// ───────────────────────────────────────────────────────────────────────────
1669
1670async function openSidebar (item)
1671{
1672 const sidebar = document.getElementById('sidebar');
1673 sidebar.classList.remove('hidden');
1674 document.getElementById('app').classList.add('sidebar-open');
1675
1676 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
1677 if (item.isDir)
1678 {
1679 document.getElementById('sidebar-icon').dataset.folderPath = item.path;
1680 } else
1681 {
1682 delete document.getElementById('sidebar-icon').dataset.folderPath;
1683 }
1684 document.getElementById('sidebar-name').textContent = item.name;
1685
1686 // Load metadata
1687 const dl = document.getElementById('sidebar-meta');
1688 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
1689
1690 const actions = document.getElementById('sidebar-actions');
1691 actions.innerHTML = '';
1692
1693 // Reset duplicates panel whenever a new item is opened.
1694 renderSidebarDuplicates(null, null);
1695
1696 if (!item.isDir)
1697 {
1698 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`);
1699 if (meta)
1700 {
1701 const watchedBy = VIDEO_EXTS.has(extOf(item.name))
1702 ? Object.entries(meta.watchedBy || {})
1703 .map(([user, status]) => `${String(user)}: ${String(status)}`)
1704 .sort((a, b) => a.localeCompare(b))
1705 : [];
1706
1707 dl.innerHTML = `
1708 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
1709 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
1710 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
1711 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
1712 ${VIDEO_EXTS.has(extOf(item.name)) ? `<dt>Watched by</dt><dd>${watchedBy.join(', ') || '—'}</dd>` : ''}
1713 `;
1714 }
1715
1716 // Fetch and render duplicate files.
1717 renderSidebarDuplicates(item, null); // show loading state
1718 api('GET', `/files/duplicates?file=${encodeURIComponent(item.path)}`)
1719 .then((data) => renderSidebarDuplicates(item, data ? data.duplicates : []))
1720 .catch(() => renderSidebarDuplicates(item, []));
1721
1722 // View / download button
1723 const btnDl = document.createElement('button');
1724 btnDl.textContent = 'View / Download';
1725 btnDl.addEventListener('click', () =>
1726 {
1727 const tile = Array.from(document.querySelectorAll('.file-item')).find(node => node.dataset.path === item.path);
1728 const source = (tile ? tile.querySelector('.icon svg') : null) || document.querySelector('#sidebar-icon svg');
1729 downloadOrView(item, source);
1730 });
1731 actions.appendChild(btnDl);
1732
1733 // Share button (file)
1734 const btnShareFile = document.createElement('button');
1735 btnShareFile.textContent = 'Share';
1736 btnShareFile.addEventListener('click', () => openShareModal(item));
1737 actions.appendChild(btnShareFile);
1738 } else
1739 {
1740 dl.innerHTML = `<dt>Type</dt><dd>${item._root ? 'Root folder' : 'Folder'}</dd>`;
1741
1742 if (item._root)
1743 {
1744 dl.innerHTML += `
1745 <dt>Alias</dt><dd>${item.name}</dd>
1746 <dt>Original name</dt><dd>${item._root.originalName || basenameOfPath(item.path)}</dd>
1747 `;
1748
1749 const space = await api('GET', `/files/space?dir=${encodeURIComponent(item.path)}`).catch(() => null);
1750 if (space)
1751 {
1752 const used = formatBytes(space.usedBytes);
1753 const free = space.freeBytes == null ? 'unknown' : formatBytes(space.freeBytes);
1754 dl.innerHTML += `
1755 <dt>Used</dt><dd>${used}</dd>
1756 <dt>Remaining</dt><dd>${free}</dd>
1757 `;
1758 }
1759
1760 const accessUsers = await fetchRootAccessList(item.path);
1761 if (accessUsers)
1762 {
1763 dl.innerHTML += `
1764 <dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>
1765 `;
1766 }
1767 }
1768
1769 const btnOpen = document.createElement('button');
1770 btnOpen.textContent = 'Open folder';
1771 btnOpen.addEventListener('click', () => navigateTo(item.path, item._root || STATE.currentRoot));
1772 actions.appendChild(btnOpen);
1773
1774 // Download as zip button (folder)
1775 const btnZip = document.createElement('button');
1776 btnZip.textContent = 'Download as zip';
1777 btnZip.addEventListener('click', () =>
1778 {
1779 btnZip.disabled = true;
1780 btnZip.textContent = 'Working...';
1781 const url = `/api/files/download-zip?dir=${encodeURIComponent(item.path)}`;
1782 const headers = {
1783 Authorization: 'Bearer ' + STATE.token,
1784 'X-Fp': getFingerprint(),
1785 };
1786 fetch(url, { headers })
1787 .then(res =>
1788 {
1789 if (!res.ok) throw new Error('Download mislukt');
1790 return res.blob();
1791 })
1792 .then(blob =>
1793 {
1794 const blobUrl = URL.createObjectURL(blob);
1795 const a = document.createElement('a');
1796 a.href = blobUrl;
1797 a.download = item.name + '.zip';
1798 a.click();
1799 setTimeout(() => URL.revokeObjectURL(blobUrl), 10000);
1800 })
1801 .catch((err) => toast(err.message || 'Download mislukt', 'err'))
1802 .finally(() =>
1803 {
1804 btnZip.disabled = false;
1805 btnZip.textContent = 'Download as zip';
1806 });
1807 });
1808 actions.appendChild(btnZip);
1809
1810 // Share button (folder)
1811 const btnShareFolder = document.createElement('button');
1812 btnShareFolder.textContent = 'Share';
1813 btnShareFolder.addEventListener('click', () => openShareModal(item));
1814 actions.appendChild(btnShareFolder);
1815
1816 // Load folder icon thumbnail into the sidebar icon element.
1817 void loadOneFolderIcon(document.getElementById('sidebar-icon'));
1818 }
1819
1820 // Rename button (write access required)
1821 if (canWrite(item))
1822 {
1823 if (item.isDir)
1824 {
1825 const btnSetIcon = document.createElement('button');
1826 btnSetIcon.textContent = 'Set icon';
1827 btnSetIcon.addEventListener('click', () => openFolderIconPicker(item));
1828 actions.appendChild(btnSetIcon);
1829 }
1830
1831 if (!item._root)
1832 {
1833 const btnMove = document.createElement('button');
1834 btnMove.textContent = 'Move to';
1835 btnMove.addEventListener('click', () => openMovePicker(item));
1836 actions.appendChild(btnMove);
1837 }
1838
1839 const btnRen = document.createElement('button');
1840 btnRen.textContent = 'Rename';
1841 btnRen.addEventListener('click', () => openRenameModal(item));
1842 actions.appendChild(btnRen);
1843
1844 if (!item._root)
1845 {
1846 const btnDel = document.createElement('button');
1847 btnDel.textContent = 'Delete';
1848 btnDel.className = 'danger';
1849 btnDel.addEventListener('click', () => deleteItem(item));
1850 actions.appendChild(btnDel);
1851 }
1852 }
1853}
1854
1855function openFolderSidebar ()
1856{
1857 const sidebar = document.getElementById('sidebar');
1858 sidebar.classList.remove('hidden');
1859 document.getElementById('app').classList.add('sidebar-open');
1860
1861 document.getElementById('sidebar-icon').innerHTML = iconFolder(64);
1862
1863 const nameEl = document.getElementById('sidebar-name');
1864 const dl = document.getElementById('sidebar-meta');
1865 const actions = document.getElementById('sidebar-actions');
1866 actions.innerHTML = '';
1867
1868 if (!STATE.currentDir || !STATE.currentRoot)
1869 {
1870 nameEl.textContent = 'Storage Roots';
1871 dl.innerHTML = `
1872 <dt>Type</dt><dd>Root overview</dd>
1873 <dt>Roots</dt><dd>${STATE.roots.length}</dd>
1874 `;
1875 return;
1876 }
1877
1878 const parts = String(STATE.currentDir).split(/[\\/]/).filter(Boolean);
1879 const fallback = STATE.currentRoot.label || 'Folder';
1880 nameEl.textContent = parts.length ? parts[parts.length - 1] : fallback;
1881
1882 const dirs = STATE.items.filter(i => i.isDir).length;
1883 const files = STATE.items.length - dirs;
1884 const baseDetails = `
1885 <dt>Path</dt><dd>${STATE.currentDir}</dd>
1886 <dt>Folders</dt><dd>${dirs}</dd>
1887 <dt>Files</dt><dd>${files}</dd>
1888 `;
1889 dl.innerHTML = baseDetails;
1890
1891 if (samePath(STATE.currentDir, STATE.currentRoot.path))
1892 {
1893 dl.innerHTML += '<dt>Access</dt><dd>Loading…</dd>';
1894 const currentDirAtStart = STATE.currentDir;
1895 const currentRootPathAtStart = STATE.currentRoot.path;
1896 void fetchRootAccessList(currentRootPathAtStart).then((accessUsers) =>
1897 {
1898 if (!accessUsers) return;
1899 if (!STATE.currentRoot) return;
1900 if (!samePath(STATE.currentDir, currentDirAtStart)) return;
1901 if (!samePath(STATE.currentRoot.path, currentRootPathAtStart)) return;
1902 dl.innerHTML = `${baseDetails}<dt>Access</dt><dd>${formatRootAccessList(accessUsers)}</dd>`;
1903 });
1904 }
1905}
1906
1907function closeSidebar ()
1908{
1909 if (typeof document === 'undefined' || typeof document.querySelectorAll !== 'function') return;
1910 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
1911 STATE.selectedItem = null;
1912
1913 if (isMobileViewport())
1914 {
1915 hideSidebarPanel();
1916 return;
1917 }
1918
1919 openFolderSidebar();
1920}
1921
1922function isMobileViewport ()
1923{
1924 return window.matchMedia(MOBILE_BREAKPOINT_QUERY).matches;
1925}
1926
1927function hideSidebarPanel ()
1928{
1929 const sidebar = document.getElementById('sidebar');
1930 const app = document.getElementById('app');
1931 sidebar.classList.add('hidden');
1932 app.classList.remove('sidebar-open');
1933}
1934
1935function basenameOfPath (p)
1936{
1937 const parts = String(p || '').split(/[\\/]/).filter(Boolean);
1938 return parts.length ? parts[parts.length - 1] : String(p || '');
1939}
1940
1941async function fetchRootAccessList (rootPath)
1942{
1943 if (!rootPath) return null;
1944 const data = await api('GET', `/files/root-access?rootPath=${encodeURIComponent(rootPath)}`).catch(() => null);
1945 if (!data || !Array.isArray(data.users)) return null;
1946 return data.users;
1947}
1948
1949function formatRootAccessList (users)
1950{
1951 if (!Array.isArray(users) || users.length === 0) return 'No users';
1952
1953 const sorted = [...users].sort((a, b) =>
1954 {
1955 const modeRank = (mode) => mode === 'R+W' ? 0 : 1;
1956 const byMode = modeRank(a.mode) - modeRank(b.mode);
1957 if (byMode !== 0) return byMode;
1958 return String(a.username).localeCompare(String(b.username));
1959 });
1960
1961 const items = sorted
1962 .map((u) => `<li>${escapeHtml(String(u.username || ''))} ${escapeHtml(String(u.mode || 'R'))}</li>`)
1963 .join('');
1964 return `<ul class="root-access-list">${items}</ul>`;
1965}
1966
1967function rootPermissionLabel (root)
1968{
1969 return (root && (root.originalName || root.label)) || '';
1970}
1971
1972function resolveRootForPath (targetPath)
1973{
1974 if (!targetPath) return null;
1975 return STATE.roots.find((r) => samePath(targetPath, r.path) || pathInside(targetPath, r.path)) || null;
1976}
1977
1978function writableRoots ()
1979{
1980 if (STATE.isAdmin) return STATE.roots.slice();
1981 return STATE.roots.filter((r) =>
1982 {
1983 const perm = STATE.permissions[rootPermissionLabel(r)];
1984 return !!(perm && perm.write);
1985 });
1986}
1987
1988async function moveWithConflictResolution (item, targetDir)
1989{
1990 try
1991 {
1992 return await api('POST', '/files/move', { from: item.path, toDir: targetDir });
1993 }
1994 catch (err)
1995 {
1996 if (!/already exists/i.test(err.message || '')) throw err;
1997
1998 const existingNames = await listDirNameSet(targetDir);
1999 const desiredName = item.name || basenameOfPath(item.path) || 'file';
2000 const suggestedName = nextAvailableName(desiredName, existingNames);
2001 const decision = await showFileConflictChoice(desiredName, suggestedName, 'move');
2002 if (decision === 'cancel') return null;
2003
2004 if (decision === 'overwrite')
2005 {
2006 return api('POST', '/files/move', {
2007 from: item.path,
2008 toDir: targetDir,
2009 conflict: 'overwrite',
2010 });
2011 }
2012
2013 return api('POST', '/files/move', {
2014 from: item.path,
2015 toDir: targetDir,
2016 conflict: 'rename',
2017 targetName: suggestedName,
2018 });
2019 }
2020}
2021
2022function ensureMoveModal ()
2023{
2024 let overlay = document.getElementById('move-modal');
2025 if (overlay) return overlay;
2026
2027 overlay = document.createElement('div');
2028 overlay.id = 'move-modal';
2029 overlay.className = 'modal-overlay hidden';
2030 overlay.innerHTML = `
2031 <div class="modal move-modal">
2032 <button class="modal-close" id="move-modal-close" aria-label="Close">✕</button>
2033 <h2>Move To</h2>
2034 <p id="move-modal-caption" class="muted"></p>
2035 <div id="move-tree" class="move-tree"></div>
2036 <p id="move-selected" class="muted"></p>
2037 <div class="dialog-actions">
2038 <button id="move-modal-cancel">Cancel</button>
2039 <button id="move-modal-confirm" class="primary">Move</button>
2040 </div>
2041 </div>
2042 `;
2043 document.body.appendChild(overlay);
2044
2045 const closeBtn = overlay.querySelector('#move-modal-close');
2046 const cancelBtn = overlay.querySelector('#move-modal-cancel');
2047 const confirmBtn = overlay.querySelector('#move-modal-confirm');
2048
2049 function hide ()
2050 {
2051 overlay.classList.add('hidden');
2052 STATE.movePicker = null;
2053 }
2054
2055 closeBtn.addEventListener('click', hide);
2056 cancelBtn.addEventListener('click', hide);
2057 overlay.addEventListener('click', (e) =>
2058 {
2059 if (e.target === overlay) hide();
2060 });
2061
2062 confirmBtn.addEventListener('click', async () =>
2063 {
2064 const st = STATE.movePicker;
2065 if (!st || !st.item || !st.selectedPath)
2066 {
2067 toast('Select a destination folder first.', 'err');
2068 return;
2069 }
2070
2071 try
2072 {
2073 const moved = await moveWithConflictResolution(st.item, st.selectedPath);
2074 if (!moved) return;
2075 }
2076 catch (err)
2077 {
2078 toast('Move failed: ' + err.message, 'err');
2079 return;
2080 }
2081
2082 hide();
2083 if (STATE.selectedItem && STATE.selectedItem.path === st.item.path) closeSidebar();
2084 navigateTo(STATE.currentDir, STATE.currentRoot);
2085 });
2086
2087 return overlay;
2088}
2089
2090function setMoveSelection (path, buttonEl)
2091{
2092 if (!STATE.movePicker) return;
2093 STATE.movePicker.selectedPath = path;
2094
2095 document.querySelectorAll('.move-node-label.selected').forEach((el) => el.classList.remove('selected'));
2096 if (buttonEl) buttonEl.classList.add('selected');
2097
2098 const selectedEl = document.getElementById('move-selected');
2099 selectedEl.textContent = path ? `Destination: ${path}` : 'Destination: none';
2100}
2101
2102async function loadMoveChildren (containerEl, dirPath)
2103{
2104 if (containerEl.dataset.loaded === '1') return;
2105 containerEl.dataset.loaded = '1';
2106
2107 const data = await api('GET', `/files/list?dir=${encodeURIComponent(dirPath)}`).catch(() => null);
2108 const folders = data ? data.items.filter((it) => it.isDir).sort((a, b) => a.name.localeCompare(b.name)) : [];
2109
2110 if (!folders.length)
2111 {
2112 const empty = document.createElement('div');
2113 empty.className = 'move-empty';
2114 empty.textContent = 'No subfolders';
2115 containerEl.appendChild(empty);
2116 return;
2117 }
2118
2119 for (const child of folders)
2120 {
2121 containerEl.appendChild(createMoveNode(child.path, child.name));
2122 }
2123}
2124
2125function createMoveNode (folderPath, label)
2126{
2127 const node = document.createElement('div');
2128 node.className = 'move-node';
2129
2130 const row = document.createElement('div');
2131 row.className = 'move-node-row';
2132
2133 const toggle = document.createElement('button');
2134 toggle.type = 'button';
2135 toggle.className = 'move-toggle';
2136 toggle.textContent = '▸';
2137
2138 const selectBtn = document.createElement('button');
2139 selectBtn.type = 'button';
2140 selectBtn.className = 'move-node-label';
2141 selectBtn.textContent = label;
2142 selectBtn.addEventListener('click', () => setMoveSelection(folderPath, selectBtn));
2143
2144 const children = document.createElement('div');
2145 children.className = 'move-children hidden';
2146
2147 toggle.addEventListener('click', async () =>
2148 {
2149 if (children.classList.contains('hidden'))
2150 {
2151 await loadMoveChildren(children, folderPath);
2152 children.classList.remove('hidden');
2153 toggle.textContent = '▾';
2154 } else
2155 {
2156 children.classList.add('hidden');
2157 toggle.textContent = '▸';
2158 }
2159 });
2160
2161 row.appendChild(toggle);
2162 row.appendChild(selectBtn);
2163 node.appendChild(row);
2164 node.appendChild(children);
2165 return node;
2166}
2167
2168function openMovePicker (item)
2169{
2170 if (!canWrite())
2171 {
2172 toast('No write access.', 'err');
2173 return;
2174 }
2175
2176 const roots = writableRoots();
2177 if (!roots.length)
2178 {
2179 toast('No writable destination roots available.', 'err');
2180 return;
2181 }
2182
2183 const overlay = ensureMoveModal();
2184 const tree = overlay.querySelector('#move-tree');
2185 const caption = overlay.querySelector('#move-modal-caption');
2186
2187 STATE.movePicker = { item, selectedPath: null };
2188 caption.textContent = `Select destination folder for: ${item.name}`;
2189 tree.innerHTML = '';
2190
2191 for (const root of roots)
2192 {
2193 tree.appendChild(createMoveNode(root.path, root.label));
2194 }
2195
2196 setMoveSelection(null, null);
2197 overlay.classList.remove('hidden');
2198}
2199
2200// ───────────────────────────────────────────────────────────────────────────
2201// FOLDER ICON PICKER
2202// ───────────────────────────────────────────────────────────────────────────
2203
2204async function openFolderIconPicker (item)
2205{
2206 if (!canWrite(item))
2207 {
2208 toast('No write access.', 'err');
2209 return;
2210 }
2211
2212 // Fetch the list of available images (only those with cached thumbnails).
2213 const data = await api('GET', `/files/folder-images?dir=${encodeURIComponent(item.path)}`).catch(() => null);
2214 const images = data ? data.images : [];
2215
2216 let existingIconOverlay = document.getElementById('folder-icon-picker');
2217 if (existingIconOverlay) existingIconOverlay.remove();
2218
2219 const overlay = document.createElement('div');
2220 overlay.id = 'folder-icon-picker';
2221 overlay.className = 'modal-overlay';
2222
2223 const modal = document.createElement('div');
2224 modal.className = 'modal folder-icon-modal';
2225
2226 const closeBtn = document.createElement('button');
2227 closeBtn.className = 'modal-close';
2228 closeBtn.setAttribute('aria-label', 'Close');
2229 closeBtn.textContent = '✕';
2230
2231 const title = document.createElement('h2');
2232 title.textContent = 'Set folder icon';
2233
2234 const subtitle = document.createElement('p');
2235 subtitle.className = 'muted';
2236
2237 const grid = document.createElement('div');
2238 grid.className = 'folder-icon-grid';
2239
2240 if (!images.length)
2241 {
2242 subtitle.textContent = 'No images with cached thumbnails were found inside this folder.';
2243 } else
2244 {
2245 subtitle.textContent = 'Select an image to use as the folder icon.';
2246
2247 for (const { filePath } of images)
2248 {
2249 const cell = document.createElement('div');
2250 cell.className = 'folder-icon-cell';
2251 cell.dataset.path = filePath;
2252
2253 const imgEl = document.createElement('img');
2254 imgEl.alt = filePath.split('/').pop();
2255 imgEl.className = 'folder-icon-thumb';
2256 // Lazy-load via IntersectionObserver on the cell.
2257 imgEl.dataset.src = filePath;
2258
2259 const label = document.createElement('div');
2260 label.className = 'folder-icon-label';
2261 label.textContent = filePath.split('/').pop();
2262
2263 cell.appendChild(imgEl);
2264 cell.appendChild(label);
2265
2266 cell.addEventListener('click', () =>
2267 {
2268 grid.querySelectorAll('.folder-icon-cell.selected').forEach(el => el.classList.remove('selected'));
2269 cell.classList.add('selected');
2270 confirmBtn.disabled = false;
2271 });
2272
2273 grid.appendChild(cell);
2274 }
2275 }
2276
2277 const dialogActions = document.createElement('div');
2278 dialogActions.className = 'dialog-actions';
2279
2280 const clearBtn = document.createElement('button');
2281 clearBtn.textContent = 'Clear icon';
2282 clearBtn.addEventListener('click', async () =>
2283 {
2284 try
2285 {
2286 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath: null });
2287 } catch (err)
2288 {
2289 toast('Failed to clear icon: ' + err.message, 'err');
2290 return;
2291 }
2292 hide();
2293 refreshAfterIconChange(item);
2294 });
2295
2296 const cancelBtn = document.createElement('button');
2297 cancelBtn.textContent = 'Cancel';
2298 cancelBtn.addEventListener('click', () => hide());
2299
2300 const confirmBtn = document.createElement('button');
2301 confirmBtn.className = 'primary';
2302 confirmBtn.textContent = 'Set icon';
2303 confirmBtn.disabled = true;
2304 confirmBtn.addEventListener('click', async () =>
2305 {
2306 const selected = grid.querySelector('.folder-icon-cell.selected');
2307 if (!selected) return;
2308 const imagePath = selected.dataset.path;
2309 try
2310 {
2311 await api('POST', '/files/folder-icon', { folderPath: item.path, imagePath });
2312 } catch (err)
2313 {
2314 toast('Failed to set icon: ' + err.message, 'err');
2315 return;
2316 }
2317 hide();
2318 refreshAfterIconChange(item);
2319 });
2320
2321 dialogActions.appendChild(clearBtn);
2322 dialogActions.appendChild(cancelBtn);
2323 dialogActions.appendChild(confirmBtn);
2324
2325 modal.appendChild(closeBtn);
2326 modal.appendChild(title);
2327 modal.appendChild(subtitle);
2328 modal.appendChild(grid);
2329 modal.appendChild(dialogActions);
2330 overlay.appendChild(modal);
2331 document.body.appendChild(overlay);
2332
2333 function hide ()
2334 {
2335 overlay.remove();
2336 // Revoke any blob URLs we created for the picker thumbnails.
2337 grid.querySelectorAll('.folder-icon-thumb[src^="blob:"]').forEach(img =>
2338 {
2339 URL.revokeObjectURL(img.src);
2340 });
2341 }
2342
2343 closeBtn.addEventListener('click', hide);
2344 overlay.addEventListener('click', (e) => { if (e.target === overlay) hide(); });
2345
2346 // Eagerly load thumbnails for all cells (picker is small, fetch all).
2347 for (const cell of grid.querySelectorAll('.folder-icon-cell'))
2348 {
2349 const imgEl = cell.querySelector('.folder-icon-thumb');
2350 const filePath = imgEl.dataset.src;
2351 void fetch(`/api/files/thumbnail?file=${encodeURIComponent(filePath)}`, {
2352 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
2353 }).then(async (r) =>
2354 {
2355 if (!r.ok || !overlay.isConnected) return;
2356 const blob = await r.blob();
2357 const url = URL.createObjectURL(blob);
2358 imgEl.src = url;
2359 }).catch(() => {});
2360 }
2361}
2362
2363function refreshAfterIconChange (item)
2364{
2365 // Reset and reload icon in grid tiles.
2366 const gridTile = Array.from(document.querySelectorAll('.icon[data-folder-path]'))
2367 .find(el => el.dataset.folderPath === item.path);
2368 if (gridTile)
2369 {
2370 const svg = gridTile.querySelector('svg');
2371 if (svg)
2372 {
2373 // Rebuild to plain folder SVG, then reload.
2374 gridTile.innerHTML = iconFolder();
2375 delete gridTile.dataset.thumbReady;
2376 gridTile.dataset.folderPath = item.path;
2377 void loadOneFolderIcon(gridTile);
2378 }
2379 }
2380
2381 // Also reset the sidebar icon if it's showing the same folder.
2382 const sidebarIcon = document.getElementById('sidebar-icon');
2383 if (sidebarIcon && sidebarIcon.dataset.folderPath === item.path)
2384 {
2385 sidebarIcon.innerHTML = iconFolder(64);
2386 delete sidebarIcon.dataset.thumbReady;
2387 void loadOneFolderIcon(sidebarIcon);
2388 }
2389}
2390
2391// ───────────────────────────────────────────────────────────────────────────
2392// DOWNLOAD / VIEW
2393// ───────────────────────────────────────────────────────────────────────────
2394
2395function isInlinePreviewableBlob (blob, name)
2396{
2397 const mime = String(blob.type || '').toLowerCase();
2398 if (/^(image|video|audio)\//.test(mime)) return true;
2399 if (/^text\//.test(mime)) return true;
2400 if (mime === 'application/pdf') return true;
2401 if (mime === 'application/json') return true;
2402 if (mime === 'application/xml') return true;
2403 if (mime === 'application/javascript') return true;
2404
2405 // Fallback by extension when MIME is missing or generic.
2406 const ext = extOf(name || '');
2407 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
2408 if (CODE_EXTS.has(ext)) return true;
2409 return false;
2410}
2411
2412function isTextLikeBlob (blob, name)
2413{
2414 const mime = String(blob.type || '').toLowerCase();
2415 if (/^text\//.test(mime)) return true;
2416 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
2417 const ext = extOf(name || '');
2418 return CODE_EXTS.has(ext);
2419}
2420
2421function detectCodeLanguage (name, mime)
2422{
2423 const ext = extOf(name || '');
2424 const m = String(mime || '').toLowerCase();
2425 if (m.includes('json') || ext === 'json') return 'json';
2426 if (m.includes('xml') || ext === 'xml') return 'xml';
2427 if (m.includes('html') || ext === 'html' || ext === 'htm') return 'html';
2428 if (m.includes('css') || ext === 'css') return 'css';
2429 if (m.includes('javascript') || ['js', 'jsx', 'mjs', 'cjs'].includes(ext)) return 'js';
2430 if (m.includes('typescript') || ['ts', 'tsx'].includes(ext)) return 'ts';
2431 if (['sh', 'bash', 'zsh'].includes(ext)) return 'sh';
2432 if (['md', 'txt', 'log', 'ini', 'toml', 'yaml', 'yml'].includes(ext)) return 'plain';
2433 return CODE_EXTS.has(ext) ? 'js' : 'plain';
2434}
2435
2436function prettyPrintMarkup (raw)
2437{
2438 const src = String(raw || '')
2439 .replace(/>\s+</g, '><')
2440 .replace(/\r\n/g, '\n');
2441
2442 const lines = src.replace(/></g, '>\n<').split('\n');
2443 let indent = 0;
2444 const out = [];
2445
2446 for (const ln of lines)
2447 {
2448 const line = ln.trim();
2449 if (!line) continue;
2450 const isClose = /^<\//.test(line);
2451 const isSelf = /\/>$/.test(line) || /^<[^!?][^>]*>[^<]*<\/[^>]+>$/.test(line);
2452 const isOpen = /^<[^!?/][^>]*>$/.test(line);
2453
2454 if (isClose) indent = Math.max(0, indent - 1);
2455 out.push(' '.repeat(indent) + line);
2456 if (isOpen && !isSelf) indent += 1;
2457 }
2458
2459 return out.join('\n');
2460}
2461
2462function prettyPrintBraces (raw)
2463{
2464 const lines = String(raw || '')
2465 .replace(/\r\n/g, '\n')
2466 .split('\n');
2467 let indent = 0;
2468 const out = [];
2469
2470 for (const ln of lines)
2471 {
2472 const line = ln.trim();
2473 if (!line)
2474 {
2475 out.push('');
2476 continue;
2477 }
2478 if (/^[}\])]/.test(line)) indent = Math.max(0, indent - 1);
2479 out.push(' '.repeat(indent) + line);
2480 if (/[{[(]$/.test(line) || /[{[(]\s*(\/\/.*)?$/.test(line)) indent += 1;
2481 }
2482 return out.join('\n');
2483}
2484
2485function prettyPrintCode (raw, lang)
2486{
2487 const text = String(raw || '').replace(/\r\n/g, '\n');
2488 if (lang === 'json')
2489 {
2490 try { return JSON.stringify(JSON.parse(text), null, 2); } catch { return text; }
2491 }
2492 if (lang === 'xml' || lang === 'html') return prettyPrintMarkup(text);
2493 if (lang === 'js' || lang === 'ts' || lang === 'css') return prettyPrintBraces(text);
2494 return text;
2495}
2496
2497function escapeHtml (s)
2498{
2499 return String(s)
2500 .replace(/&/g, '&amp;')
2501 .replace(/</g, '&lt;')
2502 .replace(/>/g, '&gt;');
2503}
2504
2505function highlightCode (raw, lang)
2506{
2507 if (lang === 'plain') return escapeHtml(raw);
2508
2509 let html = escapeHtml(raw);
2510 const stash = [];
2511 const keep = (regex, cls) =>
2512 {
2513 html = html.replace(regex, (m) =>
2514 {
2515 const idx = stash.push(`<span class="tok-${cls}">${m}</span>`) - 1;
2516 return `@@TOK${idx}@@`;
2517 });
2518 };
2519
2520 if (lang === 'json')
2521 {
2522 html = html
2523 .replace(/("(?:\\.|[^"\\])*")\s*:/g, '<span class="tok-key">$1</span>:')
2524 .replace(/: ("(?:\\.|[^"\\])*")/g, ': <span class="tok-string">$1</span>')
2525 .replace(/\b(true|false|null)\b/g, '<span class="tok-keyword">$1</span>')
2526 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
2527 return html;
2528 }
2529
2530 if (lang === 'xml' || lang === 'html')
2531 {
2532 html = html
2533 .replace(/(&lt;\/?)([a-zA-Z0-9:_-]+)/g, '$1<span class="tok-keyword">$2</span>')
2534 .replace(/([a-zA-Z0-9:_-]+)=(&quot;[^&]*&quot;|"[^"]*")/g, '<span class="tok-key">$1</span>=<span class="tok-string">$2</span>');
2535 return html;
2536 }
2537
2538 if (lang === 'sh') keep(/(^|\s)#.*$/gm, 'comment');
2539 else keep(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, 'comment');
2540 keep(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, 'string');
2541
2542 html = html
2543 .replace(/\b(function|return|if|else|for|while|switch|case|break|continue|const|let|var|class|new|import|from|export|default|try|catch|finally|throw|await|async|true|false|null|undefined)\b/g, '<span class="tok-keyword">$1</span>')
2544 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
2545
2546 html = html.replace(/@@TOK(\d+)@@/g, (_, idx) => stash[Number(idx)] || '');
2547 return html;
2548}
2549
2550function clearPreviewObjectUrl ()
2551{
2552 if (typeof STATE.previewCleanup === 'function')
2553 {
2554 try { STATE.previewCleanup(); } catch { /* ignore */ }
2555 }
2556 STATE.previewCleanup = null;
2557 STATE.previewDownloadAction = null;
2558 if (!STATE.previewObjectUrl) return;
2559 if (String(STATE.previewObjectUrl).startsWith('blob:'))
2560 {
2561 URL.revokeObjectURL(STATE.previewObjectUrl);
2562 }
2563 STATE.previewObjectUrl = null;
2564}
2565
2566function ensureStylesheet (id, href)
2567{
2568 let link = document.getElementById(id);
2569 if (link) return Promise.resolve(link);
2570
2571 link = document.createElement('link');
2572 link.id = id;
2573 link.rel = 'stylesheet';
2574 link.href = href;
2575
2576 return new Promise((resolve, reject) =>
2577 {
2578 link.addEventListener('load', () => resolve(link), { once: true });
2579 link.addEventListener('error', () => reject(new Error('Failed to load video player styles.')), { once: true });
2580 document.head.appendChild(link);
2581 });
2582}
2583
2584function ensureScript (id, src)
2585{
2586 let script = document.getElementById(id);
2587 if (script && window.videojs) return Promise.resolve(window.videojs);
2588
2589 if (!script)
2590 {
2591 script = document.createElement('script');
2592 script.id = id;
2593 script.src = src;
2594 }
2595
2596 return new Promise((resolve, reject) =>
2597 {
2598 script.addEventListener('load', () => resolve(window.videojs), { once: true });
2599 script.addEventListener('error', () => reject(new Error('Failed to load video player script.')), { once: true });
2600 if (!script.isConnected) document.head.appendChild(script);
2601 });
2602}
2603
2604async function ensureVideoJsLoaded ()
2605{
2606 if (window.videojs)
2607 {
2608 configureVideoJsBuffering(window.videojs);
2609 return window.videojs;
2610 }
2611 if (!videoJsLoaderPromise)
2612 {
2613 videoJsLoaderPromise = Promise.all([
2614 ensureStylesheet('videojs-styles', '/vendor/video.js/video-js.css'),
2615 ensureScript('videojs-script', '/vendor/video.js/video.min.js'),
2616 ]).then(() =>
2617 {
2618 configureVideoJsBuffering(window.videojs);
2619 return window.videojs;
2620 });
2621 }
2622 return videoJsLoaderPromise;
2623}
2624
2625function configureVideoJsBuffering (videojs)
2626{
2627 if (! VIDEO_FORWARD_BUFFER_OVERRIDE_ENABLED)
2628return;
2629
2630 if (!videojs || !videojs.Vhs || videojs.__filemanagerBufferingConfigured) return;
2631 videojs.__filemanagerBufferingConfigured = true;
2632
2633 try
2634 {
2635 videojs.Vhs.GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
2636 videojs.Vhs.MAX_GOAL_BUFFER_LENGTH = VIDEO_FORWARD_BUFFER_SECONDS;
2637 } catch
2638 {
2639 // Ignore builds that do not expose VHS buffer configuration.
2640 }
2641}
2642
2643async function createVideoStreamSessionForItem (item)
2644{
2645 return api('POST', '/files/video-stream', { filePath: item.path });
2646}
2647
2648async function releaseVideoStreamSession (sessionId, opts = {})
2649{
2650 const id = String(sessionId || '').trim();
2651 if (!id) return;
2652
2653 await api('DELETE', `/files/video-stream/${encodeURIComponent(id)}`, null, {
2654 keepalive: !!opts.keepalive,
2655 noAutoLogout: true,
2656 }).catch(() => null);
2657}
2658
2659function releaseActivePreviewVideoStreamSession (opts = {})
2660{
2661 const sessionId = String(STATE.previewVideoStreamSessionId || '').trim();
2662 if (!sessionId) return;
2663 STATE.previewVideoStreamSessionId = null;
2664 void releaseVideoStreamSession(sessionId, opts);
2665}
2666
2667async function preparePreviewDownload (item)
2668{
2669 const blob = await fetchFileBlob(item);
2670 if (!blob)
2671 {
2672 toast('Download failed.', 'err');
2673 return;
2674 }
2675
2676 const objectUrl = URL.createObjectURL(blob);
2677 triggerDownload(item.name, objectUrl);
2678 setTimeout(() => URL.revokeObjectURL(objectUrl), 60 * 1000);
2679}
2680
2681async function renderStreamedVideoPreview (item, targetEl)
2682{
2683 const videojs = await ensureVideoJsLoaded();
2684 const session = await createVideoStreamSessionForItem(item);
2685 STATE.previewVideoStreamSessionId = String(session.sessionId || '').trim() || null;
2686 const prefs = loadUserVideoPrefs();
2687 applyUserVideoTextTrackPrefs();
2688
2689 if ((session.subtitleSummary && session.subtitleSummary.total > 0) && !(session.subtitleTracks || []).length)
2690 {
2691 toast('This video has subtitle tracks, but none are compatible with web playback.', 'err');
2692 }
2693
2694 STATE.previewDownloadAction = () => preparePreviewDownload(item);
2695
2696 const video = document.createElement('video');
2697 video.className = 'video-js vjs-big-play-centered preview-media preview-video-js';
2698 video.controls = true;
2699 video.preload = 'auto';
2700 video.playsInline = true;
2701 targetEl.classList.add('preview-expand-content--video');
2702 targetEl.appendChild(video);
2703
2704 const player = videojs(video, {
2705 controls: true,
2706 fluid: false,
2707 fill: true,
2708 responsive: false,
2709 preload: 'auto',
2710 controlBar: {
2711 currentTimeDisplay: true,
2712 timeDivider: true,
2713 durationDisplay: true,
2714 remainingTimeDisplay: false,
2715 },
2716 sources: [{ src: session.playlistUrl, type: 'application/x-mpegURL' }],
2717 tracks: (session.subtitleTracks || []).map((track) => ({
2718 kind: 'subtitles',
2719 src: track.src,
2720 srclang: track.language || 'und',
2721 label: track.label,
2722 default: !!track.default,
2723 })),
2724 });
2725
2726 const trackPrefs = bindUserVideoTrackPrefs(player, prefs);
2727
2728 ensureVideoPlaybackUi(player, session.durationSeconds);
2729
2730 let sentPartway = false;
2731 let sentFully = false;
2732 const markWatch = async () =>
2733 {
2734 let ratio = 0;
2735 try
2736 {
2737 const duration = Number(player.duration());
2738 const current = Number(player.currentTime());
2739 if (Number.isFinite(duration) && duration > 0 && Number.isFinite(current))
2740 {
2741 ratio = current / duration;
2742 }
2743 } catch
2744 {
2745 return;
2746 }
2747
2748 if (ratio >= 0.7)
2749 {
2750 if (sentFully) return;
2751 sentPartway = true;
2752 sentFully = true;
2753 void reportWatchProgress(item.path, ratio);
2754 return;
2755 }
2756
2757 if (ratio >= 0.05)
2758 {
2759 if (sentPartway) return;
2760 sentPartway = true;
2761 void reportWatchProgress(item.path, ratio);
2762 }
2763 };
2764
2765 player.ready(() =>
2766 {
2767 const volume = Number(prefs.volume);
2768 if (Number.isFinite(volume))
2769 {
2770 player.volume(Math.max(0, Math.min(1, volume)));
2771 }
2772 trackPrefs.applySavedTracks();
2773 });
2774
2775 player.on('loadedmetadata', trackPrefs.applySavedTracks);
2776 player.on('loadedplaylist', trackPrefs.applySavedTracks);
2777
2778 player.on('timeupdate', markWatch);
2779 player.on('ended', () =>
2780 {
2781 sentPartway = true;
2782 sentFully = true;
2783 void reportWatchProgress(item.path, 1);
2784 });
2785 player.on('volumechange', () =>
2786 {
2787 const v = Number(player.volume());
2788 if (Number.isFinite(v)) saveUserVideoPrefs({ volume: v });
2789 });
2790
2791 STATE.previewCleanup = () =>
2792 {
2793 releaseActivePreviewVideoStreamSession();
2794 try { markWatch(); } catch { /* ignore */ }
2795 try { trackPrefs.captureSelectedTracks(); } catch { /* ignore */ }
2796 try { trackPrefs.detach(); } catch { /* ignore */ }
2797 try { player.dispose(); } catch { /* ignore */ }
2798 };
2799}
2800
2801function fileAccentColor (name)
2802{
2803 const ext = extOf(name || '');
2804 if (IMAGE_EXTS.has(ext)) return '#3fcf8e';
2805 if (VIDEO_EXTS.has(ext)) return '#e05c6e';
2806 if (AUDIO_EXTS.has(ext)) return '#c084fc';
2807 if (DOC_EXTS.has(ext)) return '#f97316';
2808 if (CODE_EXTS.has(ext)) return '#38bdf8';
2809 if (ARCHIVE_EXTS.has(ext)) return '#facc15';
2810 return '#7880a0';
2811}
2812
2813function animateRect (el, fromRect, toRect, opts = {})
2814{
2815 const duration = opts.duration == null ? 260 : opts.duration;
2816 const easeOut = (t) => 1 - Math.pow(1 - t, 3);
2817
2818 el.style.left = `${fromRect.left}px`;
2819 el.style.top = `${fromRect.top}px`;
2820 el.style.width = `${fromRect.width}px`;
2821 el.style.height = `${fromRect.height}px`;
2822
2823 return new Promise((resolve) =>
2824 {
2825 const t0 = performance.now();
2826
2827 function frame (now)
2828 {
2829 const raw = Math.min((now - t0) / duration, 1);
2830 const t = easeOut(raw);
2831
2832 const left = fromRect.left + (toRect.left - fromRect.left) * t;
2833 const top = fromRect.top + (toRect.top - fromRect.top) * t;
2834 const width = fromRect.width + (toRect.width - fromRect.width) * t;
2835 const height = fromRect.height + (toRect.height - fromRect.height) * t;
2836
2837 el.style.left = `${left}px`;
2838 el.style.top = `${top}px`;
2839 el.style.width = `${width}px`;
2840 el.style.height = `${height}px`;
2841
2842 if (raw < 1)
2843 {
2844 requestAnimationFrame(frame);
2845 } else
2846 {
2847 resolve();
2848 }
2849 }
2850
2851 requestAnimationFrame(frame);
2852 });
2853}
2854
2855async function openExpandedTilePreview (item, tileEl, sourceSvgEl, loadPreviewContent)
2856{
2857 if (!tileEl || !sourceSvgEl) return false;
2858
2859 if (STATE.previewExpandState)
2860 {
2861 await closeExpandedTilePreview();
2862 }
2863
2864 const iconEl = tileEl.querySelector('.icon');
2865 const nameEl = tileEl.querySelector('.name');
2866 if (!iconEl) return false;
2867
2868 const startRect = tileEl.getBoundingClientRect();
2869 const targetW = Math.min(window.innerWidth * 0.94, 1100);
2870 const targetH = Math.min(window.innerHeight * 0.9, 860);
2871 const targetRect = {
2872 left: (window.innerWidth - targetW) / 2,
2873 top: (window.innerHeight - targetH) / 2,
2874 width: targetW,
2875 height: targetH,
2876 };
2877
2878 const backdrop = document.createElement('div');
2879 backdrop.className = 'preview-backdrop';
2880 document.body.appendChild(backdrop);
2881
2882 const parent = tileEl.parentNode;
2883 const nextSibling = tileEl.nextSibling;
2884 const iconHtml = iconEl.innerHTML;
2885 const originalIconSvg = iconEl.querySelector('svg');
2886
2887 tileEl.remove();
2888 document.body.appendChild(tileEl);
2889 tileEl.classList.add('file-item--preview');
2890 tileEl.style.setProperty('--preview-accent', fileAccentColor(item.name));
2891 tileEl.style.position = 'fixed';
2892 tileEl.style.left = `${startRect.left}px`;
2893 tileEl.style.top = `${startRect.top}px`;
2894 tileEl.style.width = `${startRect.width}px`;
2895 tileEl.style.height = `${startRect.height}px`;
2896 tileEl.style.margin = '0';
2897 tileEl.style.zIndex = '10000';
2898
2899 if (nameEl) nameEl.style.display = 'none';
2900
2901 const titleEl = document.createElement('div');
2902 titleEl.className = 'preview-expand-title';
2903 titleEl.textContent = item.name;
2904
2905 const closeBtn = document.createElement('button');
2906 closeBtn.className = 'preview-expand-close';
2907 closeBtn.type = 'button';
2908 closeBtn.textContent = '×';
2909 closeBtn.setAttribute('aria-label', 'Close preview');
2910
2911 const dlBtn = document.createElement('button');
2912 dlBtn.className = 'preview-expand-download';
2913 dlBtn.type = 'button';
2914 dlBtn.textContent = 'Download';
2915 dlBtn.addEventListener('click', async (e) =>
2916 {
2917 e.stopPropagation();
2918 if (STATE.previewDownloadAction)
2919 {
2920 await STATE.previewDownloadAction();
2921 return;
2922 }
2923 if (!STATE.previewObjectUrl)
2924 {
2925 toast('Preview still loading.', 'err');
2926 return;
2927 }
2928 triggerDownload(item.name, STATE.previewObjectUrl);
2929 });
2930
2931 const shareBtn = document.createElement('button');
2932 shareBtn.className = 'preview-expand-share';
2933 shareBtn.type = 'button';
2934 shareBtn.textContent = 'Share';
2935 shareBtn.addEventListener('click', (e) =>
2936 {
2937 e.stopPropagation();
2938 openShareModal(item);
2939 });
2940
2941 const actionsEl = document.createElement('div');
2942 actionsEl.className = 'preview-expand-actions';
2943 actionsEl.appendChild(shareBtn);
2944 actionsEl.appendChild(dlBtn);
2945
2946 iconEl.innerHTML = '';
2947
2948 if (originalIconSvg)
2949 {
2950 const outline = originalIconSvg.cloneNode(true);
2951 outline.classList.add('preview-expand-outline');
2952 iconEl.appendChild(outline);
2953 }
2954
2955 const previewMount = document.createElement('div');
2956 previewMount.className = 'preview-expand-content';
2957 iconEl.appendChild(previewMount);
2958
2959 // Show spinner during expansion animation; content loads after it finishes
2960 const spinner = document.createElement('div');
2961 spinner.className = 'preview-loading-spinner';
2962 previewMount.appendChild(spinner);
2963
2964 tileEl.insertBefore(titleEl, tileEl.firstChild);
2965 tileEl.appendChild(closeBtn);
2966 tileEl.appendChild(actionsEl);
2967
2968 STATE.previewExpandState = {
2969 item,
2970 requireExplicitClose: VIDEO_EXTS.has(extOf(item.name)),
2971 tileEl,
2972 sourceSvgEl,
2973 parent,
2974 nextSibling,
2975 iconEl,
2976 iconHtml,
2977 nameEl,
2978 backdrop,
2979 closeBtn,
2980 dlBtn,
2981 shareBtn,
2982 actionsEl,
2983 titleEl,
2984 previewMount,
2985 startRect,
2986 };
2987
2988 const onBackdrop = (e) =>
2989 {
2990 if (e.target === backdrop) closePreview();
2991 };
2992 const onClose = () => closePreview({ force: true });
2993 backdrop.addEventListener('click', onBackdrop);
2994 closeBtn.addEventListener('click', onClose);
2995 STATE.previewExpandState.onBackdrop = onBackdrop;
2996 STATE.previewExpandState.onClose = onClose;
2997
2998 requestAnimationFrame(() => backdrop.classList.add('visible'));
2999 await animateRect(tileEl, startRect, targetRect);
3000
3001 tileEl.style.left = `${targetRect.left}px`;
3002 tileEl.style.top = `${targetRect.top}px`;
3003 tileEl.style.width = `${targetRect.width}px`;
3004 tileEl.style.height = `${targetRect.height}px`;
3005
3006 try
3007 {
3008 await loadPreviewContent(previewMount);
3009 } catch
3010 {
3011 if (previewMount.isConnected)
3012 {
3013 previewMount.innerHTML = '';
3014 const msg = document.createElement('p');
3015 msg.className = 'preview-unsupported';
3016 msg.textContent = 'Preview failed to load. You can try again.';
3017 previewMount.appendChild(msg);
3018 }
3019 }
3020
3021 return true;
3022}
3023
3024async function closeExpandedTilePreview ()
3025{
3026 const st = STATE.previewExpandState;
3027 if (!st) return;
3028
3029 st.backdrop.classList.remove('visible');
3030 if (st.backdrop && st.onBackdrop) st.backdrop.removeEventListener('click', st.onBackdrop);
3031 if (st.closeBtn && st.onClose) st.closeBtn.removeEventListener('click', st.onClose);
3032
3033 const fromRect = st.tileEl.getBoundingClientRect();
3034 await animateRect(st.tileEl, fromRect, st.startRect, { duration: 220 });
3035
3036 st.tileEl.classList.remove('file-item--preview');
3037 st.tileEl.style.position = '';
3038 st.tileEl.style.left = '';
3039 st.tileEl.style.top = '';
3040 st.tileEl.style.width = '';
3041 st.tileEl.style.height = '';
3042 st.tileEl.style.margin = '';
3043 st.tileEl.style.zIndex = '';
3044
3045 if (st.titleEl) st.titleEl.remove();
3046 if (st.closeBtn) st.closeBtn.remove();
3047 if (st.actionsEl) st.actionsEl.remove();
3048 if (st.iconEl) st.iconEl.innerHTML = st.iconHtml;
3049 if (st.nameEl) st.nameEl.style.display = '';
3050
3051 if (st.parent)
3052 {
3053 if (st.nextSibling && st.nextSibling.parentNode === st.parent)
3054 {
3055 st.parent.insertBefore(st.tileEl, st.nextSibling);
3056 } else
3057 {
3058 st.parent.appendChild(st.tileEl);
3059 }
3060 }
3061
3062 if (st.backdrop) st.backdrop.remove();
3063 STATE.previewExpandState = null;
3064}
3065
3066async function closePreview (opts = {})
3067{
3068 if (STATE.previewClosing) return;
3069 if (STATE.previewExpandState)
3070 {
3071 if (STATE.previewExpandState.requireExplicitClose && !opts.force)
3072 {
3073 return;
3074 }
3075
3076 STATE.previewClosing = true;
3077 clearPreviewObjectUrl();
3078 try
3079 {
3080 await closeExpandedTilePreview();
3081 STATE.previewSourceEl = null;
3082 } finally
3083 {
3084 STATE.previewClosing = false;
3085 }
3086 }
3087}
3088
3089async function fetchFileBlob (item)
3090{
3091 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
3092 try
3093 {
3094 const res = await fetch(url, {
3095 headers: {
3096 Authorization: 'Bearer ' + STATE.token,
3097 'X-Fp': getFingerprint(),
3098 },
3099 });
3100 if (!res.ok) throw new Error('Download failed.');
3101 return await res.blob();
3102 } catch
3103 {
3104 return null;
3105 }
3106}
3107
3108function triggerDownload (filename, objectUrl)
3109{
3110 const a = document.createElement('a');
3111 a.href = objectUrl;
3112 a.download = filename;
3113 a.click();
3114}
3115
3116async function renderPreviewBody (item, blob, objectUrl, targetEl = null)
3117{
3118 const body = targetEl || document.getElementById('preview-body');
3119 body.innerHTML = '';
3120
3121 const mime = String(blob.type || '').toLowerCase();
3122 const previewable = isInlinePreviewableBlob(blob, item.name);
3123
3124 if (!previewable)
3125 {
3126 const msg = document.createElement('p');
3127 msg.className = 'preview-unsupported';
3128 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
3129 body.appendChild(msg);
3130 return;
3131 }
3132
3133 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
3134 {
3135 const img = document.createElement('img');
3136 img.className = 'preview-media';
3137 img.src = objectUrl;
3138 img.alt = item.name;
3139 body.appendChild(img);
3140 return;
3141 }
3142
3143 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
3144 {
3145 const video = document.createElement('video');
3146 video.className = 'preview-media';
3147 video.src = objectUrl;
3148 video.controls = true;
3149 video.preload = 'metadata';
3150 body.appendChild(video);
3151 return;
3152 }
3153
3154 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
3155 {
3156 const audio = document.createElement('audio');
3157 audio.className = 'preview-audio';
3158 audio.src = objectUrl;
3159 audio.controls = true;
3160 body.appendChild(audio);
3161 return;
3162 }
3163
3164 if (mime === 'application/pdf')
3165 {
3166 const frame = document.createElement('iframe');
3167 frame.className = 'preview-frame';
3168 frame.src = objectUrl;
3169 frame.title = item.name;
3170 body.appendChild(frame);
3171 return;
3172 }
3173
3174 if (isTextLikeBlob(blob, item.name))
3175 {
3176 const text = await blob.text();
3177 const lang = detectCodeLanguage(item.name, mime);
3178 const formatted = prettyPrintCode(text, lang);
3179 const pre = document.createElement('pre');
3180 pre.className = 'preview-text preview-code';
3181 pre.innerHTML = highlightCode(formatted, lang);
3182 body.appendChild(pre);
3183 return;
3184 }
3185
3186 const msg = document.createElement('p');
3187 msg.className = 'preview-unsupported';
3188 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
3189 body.appendChild(msg);
3190}
3191
3192async function downloadOrView (item, sourceSvgEl = null)
3193{
3194 if (STATE.previewExpandState)
3195 {
3196 await closePreview({ force: true });
3197 }
3198
3199 const sourceTileEl = sourceSvgEl ? sourceSvgEl.closest('.file-item') : null;
3200 if (sourceTileEl)
3201 {
3202 STATE.previewSourceEl = sourceSvgEl;
3203 const expanded = await openExpandedTilePreview(item, sourceTileEl, sourceSvgEl, async (previewMount) =>
3204 {
3205 if (VIDEO_EXTS.has(extOf(item.name)))
3206 {
3207 clearPreviewObjectUrl();
3208 previewMount.innerHTML = '';
3209 await renderStreamedVideoPreview(item, previewMount);
3210 return;
3211 }
3212
3213 const blob = await fetchFileBlob(item);
3214 if (!blob) throw new Error('Download failed');
3215
3216 clearPreviewObjectUrl();
3217 const objectUrl = URL.createObjectURL(blob);
3218 STATE.previewObjectUrl = objectUrl;
3219
3220 if (!previewMount.isConnected) return;
3221
3222 previewMount.innerHTML = '';
3223 await renderPreviewBody(item, blob, objectUrl, previewMount);
3224 });
3225 if (expanded) return;
3226 }
3227
3228 toast('Preview unavailable — no source tile found.', 'err');
3229}
3230
3231// ───────────────────────────────────────────────────────────────────────────
3232// UPLOAD
3233// ───────────────────────────────────────────────────────────────────────────
3234
3235function canWrite (item = null)
3236{
3237 if (STATE.isAdmin) return true;
3238 const root = item && item._root
3239 ? item._root
3240 : (STATE.currentRoot || (item ? resolveRootForPath(item.path) : null));
3241 if (!root) return false;
3242 const p = STATE.permissions[rootPermissionLabel(root)];
3243 return p && p.write;
3244}
3245
3246async function uploadFiles (fileList)
3247{
3248 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
3249 if (!canWrite()) { toast('No write access.', 'err'); return; }
3250
3251 const files = Array.from(fileList || []);
3252 if (!files.length) return;
3253
3254 // Show upload bar
3255 const wrap = document.createElement('div');
3256 wrap.className = 'upload-bar-wrap';
3257 wrap.innerHTML = `<span>Preparing upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
3258 document.body.appendChild(wrap);
3259 STATE.uploadInProgress = true;
3260
3261 try
3262 {
3263 const existingNames = await listDirNameSet(STATE.currentDir);
3264 let done = 0;
3265 let uploaded = 0;
3266
3267 for (const original of files)
3268 {
3269 let fileToUpload = original;
3270
3271 if (existingNames.has(original.name))
3272 {
3273 const suggested = nextAvailableName(original.name, existingNames);
3274 const decision = await showFileConflictChoice(original.name, suggested, 'upload');
3275 if (decision === 'cancel')
3276 {
3277 done++;
3278 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
3279 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
3280 continue;
3281 }
3282
3283 if (decision === 'rename')
3284 {
3285 fileToUpload = cloneFileWithName(original, suggested);
3286 }
3287 }
3288
3289 await uploadSingleFile(fileToUpload, STATE.currentDir);
3290 existingNames.add(fileToUpload.name);
3291 done++;
3292 uploaded++;
3293 wrap.querySelector('span').textContent = `Uploading ${done} / ${files.length} file(s)…`;
3294 wrap.querySelector('.upload-bar-fill').style.width = (done / files.length * 100) + '%';
3295 }
3296
3297 toast(`Uploaded ${uploaded} file(s).`, 'ok');
3298 await navigateTo(STATE.currentDir, STATE.currentRoot);
3299 } catch (err)
3300 {
3301 toast(err.message, 'err');
3302 } finally
3303 {
3304 STATE.uploadInProgress = false;
3305 wrap.remove();
3306 }
3307}
3308
3309async function uploadSingleFile (file, targetDir)
3310{
3311 const formData = new FormData();
3312 formData.append('files', file);
3313
3314 await new Promise((resolve, reject) =>
3315 {
3316 const xhr = new XMLHttpRequest();
3317 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
3318 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
3319 xhr.setRequestHeader('X-Fp', getFingerprint());
3320 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
3321 xhr.onload = () => xhr.status === 200
3322 ? resolve()
3323 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
3324 xhr.onerror = () => reject(new Error('Network error'));
3325 xhr.send(formData);
3326 });
3327}
3328
3329async function ensureServerDir (baseDir, relativeDir)
3330{
3331 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
3332 let current = baseDir;
3333 for (const part of parts)
3334 {
3335 try
3336 {
3337 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
3338 current = resp && resp.path ? resp.path : joinServerPath(current, part);
3339 } catch (err)
3340 {
3341 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
3342 current = joinServerPath(current, part);
3343 }
3344 }
3345 return current;
3346}
3347
3348async function uploadFolderInputFiles (fileList)
3349{
3350 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
3351 if (!canWrite()) { toast('No write access.', 'err'); return; }
3352 if (!fileList || !fileList.length) return;
3353
3354 const files = Array.from(fileList);
3355 const total = files.length;
3356 let done = 0;
3357
3358 const wrap = document.createElement('div');
3359 wrap.className = 'upload-bar-wrap';
3360 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
3361 document.body.appendChild(wrap);
3362 STATE.uploadInProgress = true;
3363
3364 try
3365 {
3366 const dirCache = new Map();
3367 dirCache.set('', STATE.currentDir);
3368
3369 for (const file of files)
3370 {
3371 const rel = file.webkitRelativePath || file.name;
3372 const relParts = rel.split(/[\\/]/).filter(Boolean);
3373 const relDir = relParts.slice(0, -1).join('/');
3374
3375 if (!dirCache.has(relDir))
3376 {
3377 const parentRel = relParts.slice(0, -2).join('/');
3378 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
3379 const thisName = relParts[relParts.length - 2];
3380
3381 try
3382 {
3383 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
3384 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
3385 } catch (err)
3386 {
3387 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
3388 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
3389 }
3390 }
3391
3392 const targetDir = dirCache.get(relDir) || STATE.currentDir;
3393 await uploadSingleFile(file, targetDir);
3394 done++;
3395 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
3396 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
3397 }
3398
3399 toast(`Uploaded ${total} file(s).`, 'ok');
3400 await navigateTo(STATE.currentDir, STATE.currentRoot);
3401 } catch (err)
3402 {
3403 toast(err.message, 'err');
3404 } finally
3405 {
3406 STATE.uploadInProgress = false;
3407 wrap.remove();
3408 }
3409}
3410
3411// ───────────────────────────────────────────────────────────────────────────
3412// FOLDER DRAG-AND-DROP (recursive)
3413// ───────────────────────────────────────────────────────────────────────────
3414
3415/**
3416 * Reads all readEntries batches from a DirectoryReader (browsers may return
3417 * results in chunks; we must keep calling until we get an empty array).
3418 */
3419function readAllEntries (reader)
3420{
3421 return new Promise((resolve, reject) =>
3422 {
3423 const all = [];
3424 function next ()
3425 {
3426 reader.readEntries(batch =>
3427 {
3428 if (!batch.length) { resolve(all); return; }
3429 all.push(...batch);
3430 next();
3431 }, reject);
3432 }
3433 next();
3434 });
3435}
3436
3437/**
3438 * Recursively walk a FileSystemEntry tree, creating server-side directories
3439 * on the fly and collecting { file, targetDir } pairs for upload.
3440 */
3441async function collectEntries (entry, serverDir, toUpload)
3442{
3443 if (entry.isFile)
3444 {
3445 const file = await new Promise((res, rej) => entry.file(res, rej));
3446 toUpload.push({ file, targetDir: serverDir });
3447 } else if (entry.isDirectory)
3448 {
3449 // Ask the server to create the directory; it returns the canonical path.
3450 let newServerDir;
3451 try
3452 {
3453 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
3454 newServerDir = resp.path;
3455 } catch
3456 {
3457 // Directory may already exist — reconstruct path from what we know.
3458 // The server always returns JSON with {error} on failure, so we can
3459 // still continue by falling back to a best-effort path join.
3460 // We rely on the fact that the server separator is consistent within
3461 // a session (the list/browse API already returned paths in that format).
3462 const sep = serverDir.includes('\\') ? '\\' : '/';
3463 newServerDir = serverDir + sep + entry.name;
3464 }
3465 const reader = entry.createReader();
3466 const subEntries = await readAllEntries(reader);
3467 for (const sub of subEntries)
3468 {
3469 await collectEntries(sub, newServerDir, toUpload);
3470 }
3471 }
3472}
3473
3474async function uploadEntries (entries)
3475{
3476 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
3477 if (!canWrite()) { toast('No write access.', 'err'); return; }
3478
3479 const wrap = document.createElement('div');
3480 wrap.className = 'upload-bar-wrap';
3481 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
3482 document.body.appendChild(wrap);
3483 STATE.uploadInProgress = true;
3484
3485 try
3486 {
3487 const toUpload = [];
3488 for (const entry of entries)
3489 {
3490 await collectEntries(entry, STATE.currentDir, toUpload);
3491 }
3492
3493 if (!toUpload.length) { toast('No files found.', 'err'); return; }
3494
3495 let done = 0;
3496 const total = toUpload.length;
3497 const updateBar = () =>
3498 {
3499 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
3500 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
3501 };
3502 updateBar();
3503
3504 for (const { file, targetDir } of toUpload)
3505 {
3506 await uploadSingleFile(file, targetDir);
3507 done++;
3508 updateBar();
3509 }
3510
3511 toast(`Uploaded ${total} file(s).`, 'ok');
3512 await navigateTo(STATE.currentDir, STATE.currentRoot);
3513 } catch (err)
3514 {
3515 toast(err.message, 'err');
3516 } finally
3517 {
3518 STATE.uploadInProgress = false;
3519 wrap.remove();
3520 }
3521}
3522
3523// DRAG-AND-DROP
3524// ───────────────────────────────────────────────────────────────────────────
3525
3526function initDragDrop ()
3527{
3528 const main = document.getElementById('main-content');
3529 const dropOvl = document.getElementById('drop-overlay');
3530 let dragDepth = 0;
3531
3532 main.addEventListener('dragenter', e =>
3533 {
3534 e.preventDefault();
3535 dragDepth++;
3536 dropOvl.classList.remove('hidden');
3537 });
3538 main.addEventListener('dragleave', () =>
3539 {
3540 dragDepth--;
3541 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
3542 });
3543 main.addEventListener('dragover', e => e.preventDefault());
3544 main.addEventListener('drop', async e =>
3545 {
3546 e.preventDefault();
3547 dragDepth = 0;
3548 dropOvl.classList.add('hidden');
3549 if (!canWrite()) { toast('No write access.', 'err'); return; }
3550
3551 const items = Array.from(e.dataTransfer.items || []);
3552 // Use the FileSystem Entry API when available so we can handle folders.
3553 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
3554 {
3555 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
3556 if (entries.some(en => en.isDirectory))
3557 {
3558 await uploadEntries(entries);
3559 return;
3560 }
3561 }
3562 // Plain files only — use the fast batch path.
3563 const files = e.dataTransfer.files;
3564 if (files.length) await uploadFiles(files);
3565 });
3566}
3567
3568// ───────────────────────────────────────────────────────────────────────────
3569// RENAME
3570// ───────────────────────────────────────────────────────────────────────────
3571
3572function openRenameModal (item)
3573{
3574 const modal = document.getElementById('rename-modal');
3575 modal.classList.remove('hidden');
3576 const input = document.getElementById('rename-input');
3577 input.value = item.name;
3578 input.focus();
3579 input.select();
3580 document.getElementById('rename-error').classList.add('hidden');
3581 document.getElementById('rename-form').onsubmit = async (e) =>
3582 {
3583 e.preventDefault();
3584 const newName = input.value.trim();
3585 if (!newName) return;
3586 try
3587 {
3588 if (item._root)
3589 {
3590 await api('POST', '/files/root-alias', { rootPath: item.path, alias: newName });
3591 } else
3592 {
3593 await api('POST', '/files/rename', { from: item.path, to: newName });
3594 }
3595 modal.classList.add('hidden');
3596 toast(item._root ? 'Alias updated.' : 'Renamed.', 'ok');
3597 if (item._root)
3598 {
3599 await loadRoots({
3600 preferredDir: STATE.currentDir,
3601 preferredRootPath: (STATE.currentRoot && STATE.currentRoot.path) || item.path,
3602 });
3603 } else
3604 {
3605 await navigateTo(STATE.currentDir, STATE.currentRoot);
3606 }
3607 } catch (err)
3608 {
3609 document.getElementById('rename-error').textContent = err.message;
3610 document.getElementById('rename-error').classList.remove('hidden');
3611 }
3612 };
3613}
3614
3615// ───────────────────────────────────────────────────────────────────────────
3616// DELETE
3617// ───────────────────────────────────────────────────────────────────────────
3618
3619async function deleteItem (item)
3620{
3621 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
3622 try
3623 {
3624 await api('POST', '/files/delete', { path: item.path });
3625 toast('Deleted.', 'ok');
3626 closeSidebar();
3627 await navigateTo(STATE.currentDir, STATE.currentRoot);
3628 } catch (err)
3629 {
3630 toast(err.message, 'err');
3631 }
3632}
3633
3634// ───────────────────────────────────────────────────────────────────────────
3635// ADMIN PANEL
3636// ───────────────────────────────────────────────────────────────────────────
3637
3638let _adminUpdateStatus = null;
3639
3640async function openAdminModal ()
3641{
3642 document.getElementById('admin-modal').classList.remove('hidden');
3643 await refreshAdminConfig();
3644 await refreshAdminUsers();
3645 void refreshAdminUpdateStatus();
3646}
3647
3648async function refreshAdminConfig ()
3649{
3650 const data = await api('GET', '/admin/config');
3651 if (!data) return;
3652 const container = document.getElementById('admin-paths');
3653 container.innerHTML = '';
3654 for (const p of data.paths)
3655 {
3656 const row = document.createElement('div');
3657 row.className = 'path-row';
3658 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
3659 row.querySelector('button').addEventListener('click', () =>
3660 {
3661 row.remove();
3662 });
3663 container.appendChild(row);
3664 }
3665}
3666
3667async function refreshAdminUsers ()
3668{
3669 const data = await api('GET', '/admin/users');
3670 if (!data) return;
3671 const container = document.getElementById('admin-users-list');
3672 container.innerHTML = '';
3673
3674 // Need paths for permission rows
3675 const cfg = await api('GET', '/admin/config');
3676 const paths = cfg ? (cfg.effectivePaths || []) : [];
3677
3678 for (const u of data.users)
3679 {
3680 const row = document.createElement('div');
3681 row.className = 'user-row';
3682 row.innerHTML = `
3683 <span class="user-name">${u.username}</span>
3684 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
3685 <button data-id="${u.id}" data-action="edit">Edit</button>
3686 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
3687 `;
3688 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
3689 openUserModal(u, paths));
3690 const deleteBtn = row.querySelector('[data-action="delete"]');
3691 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
3692 {
3693 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
3694 try
3695 {
3696 await api('DELETE', `/admin/users/${u.id}`);
3697 toast('User deleted.', 'ok');
3698 await refreshAdminUsers();
3699 } catch (err) { toast(err.message, 'err'); }
3700 });
3701 container.appendChild(row);
3702 }
3703}
3704
3705async function refreshAdminUpdateStatus ()
3706{
3707 const btn = document.getElementById('admin-shutdown-btn');
3708 _adminUpdateStatus = null;
3709 btn.textContent = 'Shut down server';
3710
3711 try
3712 {
3713 const data = await api('GET', '/admin/update-status');
3714 if (!data) return;
3715 _adminUpdateStatus = data;
3716
3717 if (!data.underSystemd)
3718 {
3719 btn.textContent = 'Shut down server';
3720 }
3721 else if (data.commitsAhead.length === 0)
3722 {
3723 btn.textContent = 'Restart Server';
3724 }
3725 else
3726 {
3727 btn.textContent = 'Restart & Update';
3728 }
3729 }
3730 catch
3731 {
3732 // Not critical; button stays as "Shut down server".
3733 }
3734}
3735
3736function openUserModal (user, paths)
3737{
3738 const modal = document.getElementById('user-modal');
3739 modal.classList.remove('hidden');
3740 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
3741 document.getElementById('user-error').classList.add('hidden');
3742
3743 const usernameInput = document.getElementById('user-username');
3744 usernameInput.value = user ? user.username : '';
3745 usernameInput.readOnly = !!user;
3746
3747 document.getElementById('user-password').value = '';
3748 document.getElementById('user-is-admin').checked = user ? user.isAdmin : false;
3749
3750 // Password placeholder
3751 document.getElementById('user-password').placeholder =
3752 user ? 'Leave blank to keep current' : 'Min 8 characters';
3753
3754 // Build permissions grid
3755 const permDiv = document.getElementById('user-permissions');
3756 permDiv.innerHTML = '';
3757 if (paths.length)
3758 {
3759 const heading = document.createElement('h4');
3760 heading.textContent = 'Path Permissions';
3761 permDiv.appendChild(heading);
3762
3763 const isAdminUser = !!(user && user.isAdmin);
3764 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
3765 const adminChk = document.getElementById('user-is-admin');
3766 const rebuildPermRows = (admin) =>
3767 {
3768 permDiv.querySelectorAll('.perm-row').forEach(r =>
3769 {
3770 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
3771 {
3772 cb.disabled = admin;
3773 if (admin) cb.checked = true;
3774 });
3775 r.title = admin ? 'Admins always have full access' : '';
3776 });
3777 };
3778 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
3779
3780 const syncReadWriteConstraints = (row, admin = false) =>
3781 {
3782 const readCb = row.querySelector('input[data-type="read"]');
3783 const writeCb = row.querySelector('input[data-type="write"]');
3784 if (!readCb || !writeCb) return;
3785
3786 if (admin)
3787 {
3788 readCb.checked = true;
3789 writeCb.checked = true;
3790 readCb.disabled = true;
3791 writeCb.disabled = true;
3792 return;
3793 }
3794
3795 readCb.disabled = false;
3796 if (!readCb.checked)
3797 {
3798 writeCb.checked = false;
3799 writeCb.disabled = true;
3800 }
3801 else
3802 {
3803 writeCb.disabled = false;
3804 }
3805 };
3806
3807 const syncAllReadWriteConstraints = () =>
3808 {
3809 const admin = adminChk.checked;
3810 permDiv.querySelectorAll('.perm-row').forEach((row) =>
3811 {
3812 syncReadWriteConstraints(row, admin);
3813 });
3814 };
3815
3816 for (const p of paths)
3817 {
3818 const label = p.split(/[\\/]/).pop();
3819 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
3820 const row = document.createElement('div');
3821 row.className = 'perm-row';
3822 const readChecked = isAdminUser || perms.read;
3823 const writeChecked = isAdminUser || perms.write;
3824 row.innerHTML = `
3825 <span class="perm-label">${label}</span>
3826 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
3827 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
3828 `;
3829 if (isAdminUser) row.title = 'Admins always have full access';
3830 const readCb = row.querySelector('input[data-type="read"]');
3831 if (readCb)
3832 {
3833 readCb.addEventListener('change', () =>
3834 {
3835 syncReadWriteConstraints(row, adminChk.checked);
3836 });
3837 }
3838 permDiv.appendChild(row);
3839 }
3840
3841 syncAllReadWriteConstraints();
3842 adminChk.addEventListener('change', syncAllReadWriteConstraints);
3843 }
3844
3845 document.getElementById('user-form').onsubmit = async (e) =>
3846 {
3847 e.preventDefault();
3848 const password = document.getElementById('user-password').value;
3849 const isAdmin = document.getElementById('user-is-admin').checked;
3850 const permissions = {};
3851 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
3852 {
3853 const lbl = cb.dataset.label;
3854 if (!permissions[lbl]) permissions[lbl] = {};
3855 permissions[lbl][cb.dataset.type] = cb.checked;
3856 });
3857
3858 try
3859 {
3860 if (user)
3861 {
3862 const body = { isAdmin, permissions };
3863 if (password) body.password = password;
3864 await api('PATCH', `/admin/users/${user.id}`, body);
3865 } else
3866 {
3867 const uname = document.getElementById('user-username').value.trim();
3868 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
3869 }
3870 modal.classList.add('hidden');
3871 toast('User saved.', 'ok');
3872 await refreshAdminUsers();
3873 } catch (err)
3874 {
3875 document.getElementById('user-error').textContent = err.message;
3876 document.getElementById('user-error').classList.remove('hidden');
3877 }
3878 };
3879}
3880
3881// ───────────────────────────────────────────────────────────────────────────
3882// SVG ICONS
3883// ───────────────────────────────────────────────────────────────────────────
3884
3885const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
3886const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
3887const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
3888const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
3889const CODE_EXTS = new Set(['js', 'ts', 'py', 'rb', 'go', 'rs', 'c', 'cpp', 'h', 'cs', 'java', 'php', 'html', 'css', 'json', 'xml', 'yaml', 'yml', 'sh', 'bash', 'md', 'txt']);
3890const ARCHIVE_EXTS = new Set(['zip', 'tar', 'gz', 'bz2', 'xz', 'rar', '7z']);
3891const MAX_DIRECT_SVG_THUMB_BYTES = 1024 * 1024;
3892
3893function iconFolder (size = 52)
3894{
3895 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
3896 stroke="#5b7fff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
3897 <path d="M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z"/>
3898 </svg>`;
3899}
3900
3901function iconFile (name, size = 52)
3902{
3903 const color = fileAccentColor(name);
3904 let symbol = '';
3905
3906 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
3907 stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
3908 <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
3909 <polyline points="14 2 14 8 20 8"/>
3910 </svg>`;
3911}
3912
3913// ───────────────────────────────────────────────────────────────────────────
3914// EVENT WIRING
3915// ───────────────────────────────────────────────────────────────────────────
3916
3917// ───────────────────────────────────────────────────────────────────────────
3918// THUMBNAIL PREVIEWS
3919// ───────────────────────────────────────────────────────────────────────────
3920
3921function revokeThumbnails ()
3922{
3923 STATE.thumbnailUrls.forEach(u => URL.revokeObjectURL(u));
3924 STATE.thumbnailUrls = [];
3925}
3926
3927function disconnectThumbnailObserver ()
3928{
3929 if (!STATE.thumbnailObserver) return;
3930 STATE.thumbnailObserver.disconnect();
3931 STATE.thumbnailObserver = null;
3932}
3933
3934function disconnectFolderIconObserver ()
3935{
3936 if (!STATE.folderIconObserver) return;
3937 STATE.folderIconObserver.disconnect();
3938 STATE.folderIconObserver = null;
3939}
3940
3941function setThumbnailPending (iconEl, pending)
3942{
3943 if (!iconEl) return;
3944 if (pending)
3945 {
3946 iconEl.classList.add('thumb-pending');
3947 iconEl.dataset.thumbPending = '1';
3948 return;
3949 }
3950
3951 iconEl.classList.remove('thumb-pending');
3952 delete iconEl.dataset.thumbPending;
3953}
3954
3955function getThumbnailKind (name)
3956{
3957 const ext = extOf(name || '');
3958 if (IMAGE_EXTS.has(ext)) return 'image';
3959 if (CODE_EXTS.has(ext)) return 'text';
3960 return 'badge';
3961}
3962
3963function maxThumbBytesForKind (kind)
3964{
3965 if (kind === 'image') return 15 * 1024 * 1024;
3966 if (kind === 'text') return 1024 * 1024;
3967 return 0;
3968}
3969
3970function drawTokenizedLine (ctx, line, x, y)
3971{
3972 const tokenRe = /(\/\/.*$|\/\*[\s\S]*?\*\/|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\b(?:function|return|if|else|for|while|switch|case|break|continue|const|let|var|class|new|import|from|export|default|try|catch|finally|throw|await|async|true|false|null|undefined)\b|\b\d+(?:\.\d+)?\b)/g;
3973 let last = 0;
3974 let cursor = x;
3975 for (const m of line.matchAll(tokenRe))
3976 {
3977 const i = m.index == null ? 0 : m.index;
3978 if (i > last)
3979 {
3980 const plain = line.slice(last, i);
3981 ctx.fillStyle = '#dce4ff';
3982 ctx.fillText(plain, cursor, y);
3983 cursor += ctx.measureText(plain).width;
3984 }
3985
3986 const tok = m[0];
3987 if (/^\/\//.test(tok) || /^\/\*/.test(tok)) ctx.fillStyle = '#6f7f9a';
3988 else if (/^['"`]/.test(tok)) ctx.fillStyle = '#9ee37d';
3989 else if (/^\d/.test(tok)) ctx.fillStyle = '#f8c46a';
3990 else ctx.fillStyle = '#8bb4ff';
3991
3992 ctx.fillText(tok, cursor, y);
3993 cursor += ctx.measureText(tok).width;
3994 last = i + tok.length;
3995 }
3996
3997 if (last < line.length)
3998 {
3999 const tail = line.slice(last);
4000 ctx.fillStyle = '#dce4ff';
4001 ctx.fillText(tail, cursor, y);
4002 }
4003}
4004
4005function textThumbnailDataUrl (text)
4006{
4007 const canvas = document.createElement('canvas');
4008 canvas.width = 160;
4009 canvas.height = 200;
4010 const ctx = canvas.getContext('2d');
4011 if (!ctx) return null;
4012
4013 ctx.fillStyle = '#0d111a';
4014 ctx.fillRect(0, 0, canvas.width, canvas.height);
4015 ctx.font = '8px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace';
4016 ctx.textBaseline = 'top';
4017
4018 const lines = String(text || '')
4019 .replace(/\r\n/g, '\n')
4020 .split('\n')
4021 .slice(0, 17);
4022
4023 let y = 8;
4024 for (const line of lines)
4025 {
4026 drawTokenizedLine(ctx, line.slice(0, 42), 6, y);
4027 y += 11;
4028 if (y > 190) break;
4029 }
4030 return canvas.toDataURL('image/png');
4031}
4032
4033function badgeThumbnailDataUrl (name, kind)
4034{
4035 const canvas = document.createElement('canvas');
4036 canvas.width = 160;
4037 canvas.height = 200;
4038 const ctx = canvas.getContext('2d');
4039 if (!ctx) return null;
4040
4041 const ext = (extOf(name || '') || 'file').toUpperCase().slice(0, 5);
4042 const color = '#5b7fff';
4043
4044 ctx.fillStyle = '#111826';
4045 ctx.fillRect(0, 0, 160, 200);
4046 ctx.fillStyle = color;
4047 ctx.fillRect(0, 0, 160, 28);
4048 ctx.fillStyle = '#ffffff';
4049 ctx.font = 'bold 12px sans-serif';
4050 ctx.textAlign = 'center';
4051 ctx.fillText(ext, 80, 8);
4052 ctx.textAlign = 'left';
4053 ctx.fillStyle = '#9fb1d8';
4054 ctx.font = '10px sans-serif';
4055 ctx.fillText('Preview', 8, 48);
4056 ctx.fillStyle = '#dce4ff';
4057 ctx.font = 'bold 11px sans-serif';
4058 ctx.fillText(ext, 8, 66);
4059 return canvas.toDataURL('image/png');
4060}
4061
4062async function buildThumbnailSource (item, blob, kind)
4063{
4064 if (kind === 'text') return textThumbnailDataUrl(await blob.text());
4065 return badgeThumbnailDataUrl(item.name, kind);
4066}
4067
4068function observeThumbnailIcon (iconEl)
4069{
4070 if (!iconEl || !iconEl.isConnected) return;
4071 if (iconEl.dataset.thumbReady === '1') return;
4072
4073 if (!('IntersectionObserver' in window))
4074 {
4075 void loadOneThumbnail(iconEl);
4076 return;
4077 }
4078
4079 if (!STATE.thumbnailObserver)
4080 {
4081 STATE.thumbnailObserver = new IntersectionObserver((entries) =>
4082 {
4083 for (const entry of entries)
4084 {
4085 if (!entry.isIntersecting) continue;
4086 const icon = entry.target;
4087 STATE.thumbnailObserver.unobserve(icon);
4088 void loadOneThumbnail(icon);
4089 }
4090 }, { root: null, rootMargin: THUMB_OBSERVER_ROOT_MARGIN, threshold: 0.01 });
4091 }
4092
4093 STATE.thumbnailObserver.observe(iconEl);
4094}
4095
4096async function loadThumbnails ()
4097{
4098 const icons = Array.from(document.querySelectorAll('.icon[data-preview-path]'));
4099 for (const icon of icons)
4100 {
4101 observeThumbnailIcon(icon);
4102 }
4103
4104 const folderIcons = Array.from(document.querySelectorAll('.icon[data-folder-path]'));
4105 for (const icon of folderIcons)
4106 {
4107 observeFolderIcon(icon);
4108 }
4109}
4110
4111async function loadOneThumbnail (iconEl)
4112{
4113 if (!iconEl.isConnected || !STATE.token) return;
4114 if (iconEl.dataset.thumbReady === '1') return;
4115 const filePath = iconEl.dataset.previewPath;
4116 const item = STATE.items.find(i => i.path === filePath);
4117 if (!item) return;
4118
4119 const kind = getThumbnailKind(item.name);
4120 let srcUrl = null;
4121
4122 if (kind === 'badge')
4123 {
4124 setThumbnailPending(iconEl, false);
4125 srcUrl = badgeThumbnailDataUrl(item.name, kind);
4126 }
4127 else if (kind === 'image')
4128 {
4129 const ext = extOf(item.name || '');
4130 const useDirectSource =
4131 ext === 'ico' ||
4132 (
4133 ext === 'svg' &&
4134 typeof item.size === 'number' &&
4135 item.size > 0 &&
4136 item.size <= MAX_DIRECT_SVG_THUMB_BYTES
4137 );
4138
4139 const url = useDirectSource
4140 ? `/api/files/download?file=${encodeURIComponent(filePath)}`
4141 : `/api/files/thumbnail?file=${encodeURIComponent(filePath)}`;
4142
4143 let res;
4144 try
4145 {
4146 res = await fetch(url, {
4147 headers: {
4148 Authorization: `Bearer ${STATE.token}`,
4149 'X-Fp': getFingerprint(),
4150 },
4151 });
4152 } catch
4153 {
4154 return;
4155 }
4156
4157 if (!useDirectSource && res.status === 404)
4158 {
4159 setThumbnailPending(iconEl, true);
4160 return;
4161 }
4162
4163 if (!res.ok || !iconEl.isConnected) return;
4164 setThumbnailPending(iconEl, false);
4165
4166 const blob = await res.blob();
4167 srcUrl = URL.createObjectURL(blob);
4168 STATE.thumbnailUrls.push(srcUrl);
4169 }
4170 else
4171 {
4172 setThumbnailPending(iconEl, false);
4173 const maxBytes = maxThumbBytesForKind(kind);
4174 if (maxBytes > 0 && typeof item.size === 'number' && item.size > maxBytes)
4175 {
4176 srcUrl = badgeThumbnailDataUrl(item.name, kind);
4177 } else
4178 {
4179 const url = `/api/files/download?file=${encodeURIComponent(filePath)}`;
4180
4181 let res;
4182 try
4183 {
4184 res = await fetch(url, {
4185 headers: {
4186 Authorization: `Bearer ${STATE.token}`,
4187 'X-Fp': getFingerprint(),
4188 },
4189 });
4190 } catch { return; }
4191 if (!res.ok || !iconEl.isConnected) return;
4192
4193 const blob = await res.blob();
4194 srcUrl = await buildThumbnailSource(item, blob, kind);
4195 }
4196 }
4197 if (!srcUrl || !iconEl.isConnected) return;
4198
4199 const svg = iconEl.querySelector('svg');
4200 if (!svg)
4201 {
4202 if (srcUrl.startsWith('blob:')) URL.revokeObjectURL(srcUrl);
4203 return;
4204 }
4205
4206 const NS = 'http://www.w3.org/2000/svg';
4207 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
4208
4209 // clipPath matches the main file body outline exactly (viewBox 0 0 24 24)
4210 const defs = document.createElementNS(NS, 'defs');
4211 const clipPath = document.createElementNS(NS, 'clipPath');
4212 clipPath.setAttribute('id', id);
4213 clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
4214 const clipShape = document.createElementNS(NS, 'path');
4215 clipShape.setAttribute('d', 'M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z');
4216 clipPath.appendChild(clipShape);
4217 defs.appendChild(clipPath);
4218
4219 // Image fills the file bounding box; clip keeps it inside the outline
4220 const img = document.createElementNS(NS, 'image');
4221 img.setAttribute('href', srcUrl);
4222 img.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', srcUrl);
4223 img.setAttribute('x', '4');
4224 img.setAttribute('y', '2');
4225 img.setAttribute('width', '16');
4226 img.setAttribute('height', '20');
4227 img.setAttribute('clip-path', `url(#${id})`);
4228 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
4229
4230 // Prepend so existing path/polyline elements (the outline) render on top
4231 svg.prepend(img);
4232 svg.prepend(defs);
4233 iconEl.dataset.thumbReady = '1';
4234}
4235
4236// ───────────────────────────────────────────────────────────────────────────
4237// FOLDER ICON THUMBNAILS
4238// ───────────────────────────────────────────────────────────────────────────
4239
4240function observeFolderIcon (iconEl)
4241{
4242 if (!iconEl || !iconEl.isConnected) return;
4243 if (iconEl.dataset.thumbReady === '1') return;
4244
4245 if (!('IntersectionObserver' in window))
4246 {
4247 void loadOneFolderIcon(iconEl);
4248 return;
4249 }
4250
4251 if (!STATE.folderIconObserver)
4252 {
4253 STATE.folderIconObserver = new IntersectionObserver((entries) =>
4254 {
4255 for (const entry of entries)
4256 {
4257 if (!entry.isIntersecting) continue;
4258 const icon = entry.target;
4259 STATE.folderIconObserver.unobserve(icon);
4260 void loadOneFolderIcon(icon);
4261 }
4262 }, { root: null, rootMargin: THUMB_OBSERVER_ROOT_MARGIN, threshold: 0.01 });
4263 }
4264
4265 STATE.folderIconObserver.observe(iconEl);
4266}
4267
4268async function loadOneFolderIcon (iconEl)
4269{
4270 if (!iconEl.isConnected || !STATE.token) return;
4271 if (iconEl.dataset.thumbReady === '1') return;
4272
4273 const folderPath = iconEl.dataset.folderPath;
4274 if (!folderPath) return;
4275
4276 let res;
4277 try
4278 {
4279 res = await fetch(`/api/files/folder-icon?dir=${encodeURIComponent(folderPath)}`, {
4280 headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() },
4281 });
4282 } catch { return; }
4283
4284 if (!res.ok || !iconEl.isConnected) return;
4285
4286 const data = await res.json();
4287 if (!data.icon) return; // No icon available — keep plain folder SVG.
4288
4289 // Fetch the thumbnail through the auth-gated endpoint.
4290 let thumbRes;
4291 try
4292 {
4293 thumbRes = await fetch(
4294 `/api/files/thumbnail?file=${encodeURIComponent(data.icon.filePath)}`,
4295 { headers: { Authorization: `Bearer ${STATE.token}`, 'X-Fp': getFingerprint() } },
4296 );
4297 } catch { return; }
4298
4299 if (!thumbRes.ok || !iconEl.isConnected) return;
4300
4301 const blob = await thumbRes.blob();
4302 const srcUrl = URL.createObjectURL(blob);
4303 STATE.thumbnailUrls.push(srcUrl);
4304
4305 applyFolderThumbnail(iconEl, srcUrl);
4306}
4307
4308/**
4309 * Overlays a thumbnail image inside the folder SVG outline.
4310 * The folder viewBox is 0 0 24 24; the folder body covers roughly x=2,y=5 to x=22,y=21.
4311 */
4312function applyFolderThumbnail (iconEl, srcUrl)
4313{
4314 if (!iconEl.isConnected) return;
4315 const svg = iconEl.querySelector('svg');
4316 if (!svg)
4317 {
4318 if (srcUrl.startsWith('blob:')) URL.revokeObjectURL(srcUrl);
4319 return;
4320 }
4321
4322 const NS = 'http://www.w3.org/2000/svg';
4323 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
4324
4325 const defs = document.createElementNS(NS, 'defs');
4326 const clipPath = document.createElementNS(NS, 'clipPath');
4327 clipPath.setAttribute('id', id);
4328 clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
4329 const clipShape = document.createElementNS(NS, 'path');
4330 // Folder outline path (same as iconFolder SVG path)
4331 clipShape.setAttribute('d', 'M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z');
4332 clipPath.appendChild(clipShape);
4333 defs.appendChild(clipPath);
4334
4335 // Image covers the folder body area; clip keeps it inside the outline.
4336 const img = document.createElementNS(NS, 'image');
4337 img.setAttribute('href', srcUrl);
4338 img.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', srcUrl);
4339 img.setAttribute('x', '2');
4340 img.setAttribute('y', '3');
4341 img.setAttribute('width', '20');
4342 img.setAttribute('height', '18');
4343 img.setAttribute('clip-path', `url(#${id})`);
4344 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
4345
4346 // Prepend so the folder outline strokes render on top.
4347 svg.prepend(img);
4348 svg.prepend(defs);
4349 iconEl.dataset.thumbReady = '1';
4350}
4351
4352function wireEvents ()
4353{
4354 // Auth form
4355 document.getElementById('auth-form').addEventListener('submit', async (e) =>
4356 {
4357 e.preventDefault();
4358 const username = document.getElementById('auth-username').value.trim();
4359 const password = document.getElementById('auth-password').value;
4360 const isSetup = e.target.dataset.mode === 'setup';
4361 const errEl = document.getElementById('auth-error');
4362 const btn = document.getElementById('auth-submit');
4363 btn.disabled = true;
4364 btn.textContent = 'Please wait…';
4365 const err = await doLogin(username, password, isSetup);
4366 if (err)
4367 {
4368 errEl.textContent = err;
4369 errEl.classList.remove('hidden');
4370 btn.disabled = false;
4371 btn.textContent = isSetup ? 'Create Account' : 'Sign In';
4372 }
4373 });
4374
4375 // Logout
4376 document.getElementById('btn-logout').addEventListener('click', logout);
4377
4378 // Hard refresh while keeping auth/session state.
4379 document.getElementById('btn-refresh').addEventListener('click', () =>
4380 {
4381 saveSessionState();
4382 location.reload();
4383 });
4384
4385 // Upload button
4386 document.getElementById('btn-upload').addEventListener('click', () =>
4387 {
4388 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
4389 if (!canWrite()) { toast('No write access.', 'err'); return; }
4390 document.getElementById('file-input').click();
4391 });
4392
4393 document.getElementById('file-input').addEventListener('change', async (e) =>
4394 {
4395 if (e.target.files.length) await uploadFiles(e.target.files);
4396 e.target.value = '';
4397 });
4398
4399 document.getElementById('btn-upload-folder').addEventListener('click', () =>
4400 {
4401 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
4402 if (!canWrite()) { toast('No write access.', 'err'); return; }
4403 document.getElementById('folder-input').click();
4404 });
4405
4406 document.getElementById('folder-input').addEventListener('change', async (e) =>
4407 {
4408 if (e.target.files.length) await uploadFolderInputFiles(e.target.files);
4409 e.target.value = '';
4410 });
4411
4412 document.getElementById('btn-new-folder').addEventListener('click', async () =>
4413 {
4414 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
4415 if (!canWrite()) { toast('No write access.', 'err'); return; }
4416
4417 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
4418 if (name == null) return;
4419 const folderName = name.trim();
4420 if (!folderName)
4421 {
4422 toast('Folder name is required.', 'err');
4423 return;
4424 }
4425
4426 try
4427 {
4428 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
4429 toast('Folder created.', 'ok');
4430 await navigateTo(STATE.currentDir, STATE.currentRoot);
4431 } catch (err)
4432 {
4433 toast(err.message, 'err');
4434 }
4435 });
4436
4437 document.getElementById('sidebar-close').addEventListener('click', (e) =>
4438 {
4439 e.stopPropagation();
4440 hideSidebarPanel();
4441 });
4442
4443 const mobileQuery = window.matchMedia(MOBILE_BREAKPOINT_QUERY);
4444 const syncSidebarForViewport = () =>
4445 {
4446 if (isMobileViewport())
4447 {
4448 hideSidebarPanel();
4449 return;
4450 }
4451
4452 if (!STATE.selectedItem) openFolderSidebar();
4453 };
4454
4455 if (typeof mobileQuery.addEventListener === 'function')
4456 {
4457 mobileQuery.addEventListener('change', syncSidebarForViewport);
4458 } else if (typeof mobileQuery.addListener === 'function')
4459 {
4460 mobileQuery.addListener(syncSidebarForViewport);
4461 }
4462
4463 // Click outside grid clears selection and returns to folder sidebar info.
4464 document.getElementById('main-content').addEventListener('click', (e) =>
4465 {
4466 if (!e.target.closest('.file-item')) closeSidebar();
4467 });
4468
4469 // Admin panel
4470 document.getElementById('btn-admin').addEventListener('click', openAdminModal);
4471 document.getElementById('admin-modal-close').addEventListener('click', () =>
4472 document.getElementById('admin-modal').classList.add('hidden'));
4473
4474 // Add path
4475 document.getElementById('admin-add-path').addEventListener('click', () =>
4476 {
4477 const val = document.getElementById('admin-new-path').value.trim();
4478 if (!val) return;
4479 const row = document.createElement('div');
4480 row.className = 'path-row';
4481 row.innerHTML = `<span>${val}</span><button title="Remove">✕</button>`;
4482 row.querySelector('button').addEventListener('click', () => row.remove());
4483 document.getElementById('admin-paths').appendChild(row);
4484 document.getElementById('admin-new-path').value = '';
4485 });
4486
4487 // Save paths
4488 document.getElementById('admin-save-paths').addEventListener('click', async () =>
4489 {
4490 const rows = document.querySelectorAll('#admin-paths .path-row span');
4491 const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
4492 try
4493 {
4494 await api('PUT', '/admin/config', { paths });
4495 toast('Paths saved.', 'ok');
4496 await loadRoots();
4497 } catch (err) { toast(err.message, 'err'); }
4498 });
4499
4500 // Shutdown / restart server
4501 document.getElementById('admin-shutdown-btn').addEventListener('click', async () =>
4502 {
4503 const status = _adminUpdateStatus;
4504
4505 if (!status || !status.underSystemd)
4506 {
4507 // Not running under systemd — plain shutdown (manual restart required).
4508 if (!await showConfirm('Shut down server', 'Shut down the server? You will lose access until it is restarted manually.')) return;
4509 }
4510 else if (status.commitsAhead.length === 0)
4511 {
4512 // Under systemd, no updates — restart only.
4513 if (!await showConfirm('Restart server', 'No update available. Would you like to restart?', { okLabel: 'Restart' })) return;
4514 }
4515 else
4516 {
4517 // Under systemd, updates available.
4518 const commitList = status.commitsAhead.map(c => escHtml(c)).join('<br/>');
4519 const msg = `Updates available:<br/><br/>${commitList}<br/><br/>Update now?`;
4520 if (!await showConfirm('Restart &amp; Update', msg, { html: true, okLabel: 'Update now' })) return;
4521 }
4522
4523 try
4524 {
4525 await api('POST', '/admin/shutdown');
4526 const toastMsg = (!status || !status.underSystemd)
4527 ? 'Server is shutting down\u2026'
4528 : status.commitsAhead.length > 0
4529 ? 'Server is updating and restarting\u2026'
4530 : 'Server is restarting\u2026';
4531 toast(toastMsg, 'ok');
4532 document.getElementById('admin-modal').classList.add('hidden');
4533 } catch
4534 {
4535 // Fetch may throw because the connection closes before a response arrives.
4536 const toastMsg = (!status || !status.underSystemd)
4537 ? 'Server is shutting down\u2026'
4538 : status.commitsAhead.length > 0
4539 ? 'Server is updating and restarting\u2026'
4540 : 'Server is restarting\u2026';
4541 toast(toastMsg, 'ok');
4542 document.getElementById('admin-modal').classList.add('hidden');
4543 }
4544 setTimeout(() => location.reload(), 3000);
4545 });
4546
4547 // New user
4548 document.getElementById('admin-new-user-btn').addEventListener('click', async () =>
4549 {
4550 const cfg = await api('GET', '/admin/config');
4551 const paths = cfg ? (cfg.effectivePaths || []) : [];
4552 openUserModal(null, paths);
4553 });
4554
4555 // User modal close
4556 document.getElementById('user-modal-close').addEventListener('click', () =>
4557 document.getElementById('user-modal').classList.add('hidden'));
4558
4559 // Rename modal close
4560 document.getElementById('rename-modal-close').addEventListener('click', () =>
4561 document.getElementById('rename-modal').classList.add('hidden'));
4562
4563 // Close modals on backdrop click
4564 document.querySelectorAll('.modal-overlay').forEach(overlay =>
4565 {
4566 overlay.addEventListener('click', e =>
4567 {
4568 if (e.target === overlay) overlay.classList.add('hidden');
4569 });
4570 });
4571}
4572
4573// ───────────────────────────────────────────────────────────────────────────
4574// BOOT
4575// ───────────────────────────────────────────────────────────────────────────
4576
4577(async function boot ()
4578{
4579 wireEvents();
4580 initDragDrop();
4581 window.addEventListener('beforeunload', () =>
4582 {
4583 saveSessionState();
4584 releaseActivePreviewVideoStreamSession({ keepalive: true });
4585 });
4586 window.addEventListener('pagehide', () =>
4587 {
4588 releaseActivePreviewVideoStreamSession({ keepalive: true });
4589 });
4590 await initAuth();
4591})();