BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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