BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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