BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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