BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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