BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

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