BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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