BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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