BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

app.js 67.1 KiB Download Raw
1/* =========================================================
2 FILE MANAGER — CLIENT SPA
3 =========================================================
4 Architecture:
5 - RSA-OAEP + AES-256-GCM hybrid encryption via Web Crypto API
6 - Token is stored in localStorage to survive full page refresh
7 - Token is sent as Bearer header on every API call
8 - Fingerprint (derived from navigator info) locks the token to this browser
9 ========================================================= */
10'use strict';
11
12// ───────────────────────────────────────────────────────────────────────────
13// STATE
14// ───────────────────────────────────────────────────────────────────────────
15const STATE = {
16 token: null, // decrypted JWT string
17 username: null,
18 isAdmin: false,
19 permissions: {},
20 roots: [], // [{ label, path }]
21 currentDir: null, // absolute path currently shown (null = roots view)
22 currentRoot: null, // { label, path } of the active root
23 items: [], // current directory listing
24 selectedItem: null, // item object selected in sidebar
25
26 // Ephemeral key pair per session (client-side)
27 clientPrivateKey: null,
28 clientPublicKeyJwk: null,
29
30 // Server public key for encrypting login
31 serverPublicKeyJwk: null,
32
33 // Stable per-browser binding id used in fingerprint derivation
34 clientBindingId: null,
35
36 // Persisted view state
37 restoreDir: null,
38 restoreRootPath: null,
39 lastOperationAt: null,
40
41 // Background refresh state
42 autoRefreshTimer: null,
43 uploadInProgress: false,
44 // Blob URLs for thumbnail previews — revoked on each grid rebuild
45 thumbnailUrls: [],
46
47 // Preview overlay state
48 previewObjectUrl: null,
49};
50
51const SESSION_KEY = 'filemanager.session.v1';
52const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
53const CLIENT_BINDING_KEY = 'filemanager.client-binding-id.v1';
54
55// ───────────────────────────────────────────────────────────────────────────
56// CRYPTO HELPERS (Web Crypto API)
57// ───────────────────────────────────────────────────────────────────────────
58
59async function generateClientKeyPair ()
60{
61 if (!hasWebCrypto()) return;
62 const kp = await crypto.subtle.generateKey(
63 { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
64 true,
65 ['encrypt', 'decrypt'],
66 );
67 STATE.clientPrivateKey = kp.privateKey;
68 STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
69}
70
71/**
72 * Hybrid-encrypt a JS object using the server's RSA public key.
73 * Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
74 */
75async function hybridEncryptForServer (obj)
76{
77 if (!hasWebCrypto() || !STATE.serverPublicKeyJwk)
78 {
79 return { plaintext: obj };
80 }
81
82 const serverPub = await crypto.subtle.importKey(
83 'jwk', STATE.serverPublicKeyJwk,
84 { name: 'RSA-OAEP', hash: 'SHA-256' },
85 false, ['encrypt'],
86 );
87
88 const plaintext = new TextEncoder().encode(JSON.stringify(obj));
89 const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
90 const iv = crypto.getRandomValues(new Uint8Array(12));
91 const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
92
93 // gcmResult = ciphertext || tag (last 16 bytes are auth tag)
94 const gcmBytes = new Uint8Array(gcmResult);
95 const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
96 const tag = gcmBytes.slice(gcmBytes.length - 16);
97
98 const rawAes = await crypto.subtle.exportKey('raw', aesKey);
99 const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
100
101 return {
102 encryptedKey: b64(encryptedKey),
103 iv: b64(iv),
104 ciphertext: b64(ciphertext),
105 tag: b64(tag),
106 };
107}
108
109/**
110 * Hybrid-decrypt a payload encrypted by the server for us (using our public key).
111 */
112async function hybridDecryptFromServer (payload)
113{
114 if (!payload) return null;
115 if (payload.token) return payload.token;
116 if (!hasWebCrypto()) return null;
117
118 const encryptedKey = unb64(payload.encryptedKey);
119 const iv = unb64(payload.iv);
120 const ciphertext = unb64(payload.ciphertext);
121 const tag = unb64(payload.tag);
122
123 const rawAes = await crypto.subtle.decrypt(
124 { name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
125 );
126
127 const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
128
129 // Recombine ciphertext + tag for AES-GCM
130 const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
131 combined.set(new Uint8Array(ciphertext));
132 combined.set(new Uint8Array(tag), ciphertext.byteLength);
133
134 const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
135 return new TextDecoder().decode(plain);
136}
137
138// ───────────────────────────────────────────────────────────────────────────
139// UTIL
140// ───────────────────────────────────────────────────────────────────────────
141
142function b64 (buf)
143{
144 return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
145}
146
147function hasWebCrypto ()
148{
149 return !!(window.crypto && window.crypto.subtle);
150}
151
152function unb64 (str)
153{
154 const binary = atob(str);
155 const buf = new Uint8Array(binary.length);
156 for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
157 return buf.buffer;
158}
159
160/** Stable browser fingerprint (not stored, derived fresh each load) */
161function getFingerprint ()
162{
163 const binding = getOrCreateClientBindingId();
164 const nav = navigator;
165
166 // Keep this stable: avoid viewport/screen metrics that can change when
167 // devtools opens, orientation changes, or window state changes.
168 return [
169 binding,
170 nav.userAgent || '',
171 nav.language,
172 nav.platform || nav.userAgentData?.platform || '',
173 Intl.DateTimeFormat().resolvedOptions().timeZone,
174 ].join('|');
175}
176
177function randomIdHex (bytes = 16)
178{
179 const arr = new Uint8Array(bytes);
180 if (window.crypto && typeof window.crypto.getRandomValues === 'function')
181 {
182 window.crypto.getRandomValues(arr);
183 } else
184 {
185 for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
186 }
187 return Array.from(arr).map(n => n.toString(16).padStart(2, '0')).join('');
188}
189
190function getOrCreateClientBindingId ()
191{
192 if (STATE.clientBindingId) return STATE.clientBindingId;
193
194 try
195 {
196 const existing = localStorage.getItem(CLIENT_BINDING_KEY);
197 if (existing && typeof existing === 'string')
198 {
199 STATE.clientBindingId = existing;
200 return existing;
201 }
202 } catch
203 {
204 // Ignore storage read errors.
205 }
206
207 const created = randomIdHex(16);
208 STATE.clientBindingId = created;
209
210 try
211 {
212 localStorage.setItem(CLIENT_BINDING_KEY, created);
213 } catch
214 {
215 // Ignore storage write errors; in-memory fallback still keeps this stable
216 // for the current page session.
217 }
218
219 return created;
220}
221
222function formatBytes (bytes)
223{
224 if (bytes == null) return '—';
225 if (bytes < 1024) return bytes + ' B';
226 if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
227 if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
228 return (bytes / 1073741824).toFixed(2) + ' GB';
229}
230
231function extOf (name)
232{
233 const i = name.lastIndexOf('.');
234 return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
235}
236
237function getPathSep (basePath)
238{
239 return basePath && basePath.includes('\\') ? '\\' : '/';
240}
241
242function joinServerPath (basePath, segment)
243{
244 const sep = getPathSep(basePath);
245 const base = String(basePath || '').replace(/[\\/]+$/, '');
246 return base + sep + segment;
247}
248
249function samePath (a, b)
250{
251 if (!a || !b) return false;
252 return String(a).toLowerCase() === String(b).toLowerCase();
253}
254
255function pathInside (child, root)
256{
257 if (!child || !root) return false;
258 if (samePath(child, root)) return true;
259 const sep = getPathSep(root);
260 return String(child).toLowerCase().startsWith((String(root) + sep).toLowerCase());
261}
262
263function saveSessionState ()
264{
265 if (!STATE.token) return;
266 const now = Date.now();
267 STATE.lastOperationAt = now;
268 const payload = {
269 token: STATE.token,
270 dir: STATE.currentDir || null,
271 rootPath: STATE.currentRoot ? STATE.currentRoot.path : null,
272 lastOperationAt: STATE.lastOperationAt,
273 };
274 try
275 {
276 localStorage.setItem(SESSION_KEY, JSON.stringify(payload));
277 } catch
278 {
279 // Ignore storage errors (private mode/full quota).
280 }
281}
282
283function loadSessionState ()
284{
285 try
286 {
287 const raw = localStorage.getItem(SESSION_KEY);
288 if (!raw) return null;
289 const parsed = JSON.parse(raw);
290 if (!parsed || typeof parsed.token !== 'string') return null;
291 if (!Number.isFinite(parsed.lastOperationAt)) return null;
292
293 if (Date.now() - parsed.lastOperationAt > SESSION_IDLE_TIMEOUT_MS)
294 {
295 clearSessionState();
296 return null;
297 }
298
299 return parsed;
300 } catch
301 {
302 return null;
303 }
304}
305
306function clearSessionState ()
307{
308 try { localStorage.removeItem(SESSION_KEY); } catch { /* ignore */ }
309}
310
311// ───────────────────────────────────────────────────────────────────────────
312// API
313// ───────────────────────────────────────────────────────────────────────────
314
315async function api (method, path, body, opts = {})
316{
317 const headers = { 'Content-Type': 'application/json' };
318 const noAutoLogout = !!opts.noAutoLogout;
319 if (STATE.token)
320 {
321 headers['Authorization'] = 'Bearer ' + STATE.token;
322 headers['X-Fp'] = getFingerprint();
323 }
324 const fetchOpts = { ...opts };
325 delete fetchOpts.noAutoLogout;
326 const res = await fetch('/api' + path, {
327 method,
328 headers,
329 body: body != null ? JSON.stringify(body) : undefined,
330 ...fetchOpts,
331 });
332 if (!res.ok)
333 {
334 const j = await res.json().catch(() => ({}));
335 // Session-expired → force re-login
336 if (res.status === 401)
337 {
338 if (!noAutoLogout) logout();
339 return null;
340 }
341 throw new Error(j.error || res.statusText);
342 }
343 if (STATE.token && !path.startsWith('/auth/server-key') && !path.startsWith('/auth/setup-needed'))
344 {
345 saveSessionState();
346 }
347 return res.json();
348}
349
350// ───────────────────────────────────────────────────────────────────────────
351// TOAST
352// ───────────────────────────────────────────────────────────────────────────
353
354function toast (msg, type = '')
355{
356 const el = document.createElement('div');
357 el.className = 'toast-msg' + (type ? ' ' + type : '');
358 el.textContent = msg;
359 document.getElementById('toast').appendChild(el);
360 setTimeout(() => el.remove(), 3500);
361}
362
363// ───────────────────────────────────────────────────────────────────────────
364// DIALOG MODALS — centralised replacements for alert / confirm / prompt
365// ───────────────────────────────────────────────────────────────────────────
366
367/**
368 * Show a confirmation dialog.
369 * @param {string} title
370 * @param {string} message
371 * @returns {Promise<boolean>} true = OK, false = Cancel
372 */
373function showConfirm (title, message)
374{
375 return new Promise((resolve) =>
376 {
377 const overlay = document.getElementById('confirm-modal');
378 document.getElementById('confirm-modal-title').textContent = title;
379 document.getElementById('confirm-modal-message').textContent = message;
380 overlay.classList.remove('hidden');
381
382 const ok = document.getElementById('confirm-modal-ok');
383 const cancel = document.getElementById('confirm-modal-cancel');
384
385 function finish (result)
386 {
387 overlay.classList.add('hidden');
388 ok.removeEventListener('click', onOk);
389 cancel.removeEventListener('click', onCancel);
390 resolve(result);
391 }
392 function onOk () { finish(true); }
393 function onCancel () { finish(false); }
394
395 ok.addEventListener('click', onOk);
396 cancel.addEventListener('click', onCancel);
397 ok.focus();
398 });
399}
400
401/**
402 * Show a text-input dialog.
403 * @param {string} title
404 * @param {string} [message] — optional helper text shown above the input
405 * @param {string} [defaultValue] — pre-filled value
406 * @returns {Promise<string|null>} string = submitted value, null = cancelled
407 */
408function showPrompt (title, message = '', defaultValue = '')
409{
410 return new Promise((resolve) =>
411 {
412 const overlay = document.getElementById('prompt-modal');
413 const msgEl = document.getElementById('prompt-modal-message');
414 const input = document.getElementById('prompt-modal-input');
415 const errorEl = document.getElementById('prompt-modal-error');
416 const form = document.getElementById('prompt-modal-form');
417 const cancel = document.getElementById('prompt-modal-cancel');
418
419 document.getElementById('prompt-modal-title').textContent = title;
420 msgEl.textContent = message;
421 msgEl.classList.toggle('hidden', !message);
422 input.value = defaultValue;
423 errorEl.classList.add('hidden');
424 overlay.classList.remove('hidden');
425 input.focus();
426 input.select();
427
428 function finish (result)
429 {
430 overlay.classList.add('hidden');
431 form.removeEventListener('submit', onSubmit);
432 cancel.removeEventListener('click', onCancel);
433 resolve(result);
434 }
435 function onSubmit (e)
436 {
437 e.preventDefault();
438 finish(input.value);
439 }
440 function onCancel () { finish(null); }
441
442 form.addEventListener('submit', onSubmit);
443 cancel.addEventListener('click', onCancel);
444 });
445}
446
447/**
448 * Show an overwrite-decision dialog for a single file conflict.
449 * @param {string} filename
450 * @returns {Promise<'yes'|'no'|'all'|'none'>}
451 */
452function showOverwrite (filename)
453{
454 return new Promise((resolve) =>
455 {
456 const overlay = document.getElementById('overwrite-modal');
457 document.getElementById('overwrite-modal-filename').textContent = filename;
458 overlay.classList.remove('hidden');
459
460 const btnYes = document.getElementById('overwrite-modal-yes');
461 const btnNo = document.getElementById('overwrite-modal-no');
462 const btnAll = document.getElementById('overwrite-modal-all');
463 const btnSkipAll = document.getElementById('overwrite-modal-skip-all');
464
465 function finish (result)
466 {
467 overlay.classList.add('hidden');
468 btnYes.removeEventListener('click', onYes);
469 btnNo.removeEventListener('click', onNo);
470 btnAll.removeEventListener('click', onAll);
471 btnSkipAll.removeEventListener('click', onSkipAll);
472 resolve(result);
473 }
474 function onYes () { finish('yes'); }
475 function onNo () { finish('no'); }
476 function onAll () { finish('all'); }
477 function onSkipAll () { finish('none'); }
478
479 btnYes.addEventListener('click', onYes);
480 btnNo.addEventListener('click', onNo);
481 btnAll.addEventListener('click', onAll);
482 btnSkipAll.addEventListener('click', onSkipAll);
483 btnNo.focus();
484 });
485}
486
487// ───────────────────────────────────────────────────────────────────────────
488// AUTH FLOW
489// ───────────────────────────────────────────────────────────────────────────
490
491function showAuthOverlay (setupMode = false)
492{
493 document.getElementById('app').classList.add('hidden');
494 const overlay = document.getElementById('auth-overlay');
495 overlay.classList.remove('hidden');
496 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
497 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
498 const submitBtn = document.getElementById('auth-submit');
499 submitBtn.disabled = false;
500 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
501 document.getElementById('auth-error').classList.add('hidden');
502 document.getElementById('auth-username').value = '';
503 document.getElementById('auth-password').value = '';
504 document.getElementById('auth-username').focus();
505 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
506}
507
508function showApp ()
509{
510 document.getElementById('auth-overlay').classList.add('hidden');
511 document.getElementById('app').classList.remove('hidden');
512 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
513 startAutoRefresh();
514}
515
516async function initAuth ()
517{
518 // Always generate a fresh key pair so each page-load session is independent
519 await generateClientKeyPair().catch(() =>
520 {
521 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
522 });
523
524 // Fetch server public key
525 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
526 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
527 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
528 STATE.serverPublicKeyJwk = publicKey;
529
530 // Check whether first-run setup is needed
531 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
532
533 if (!needed)
534 {
535 const saved = loadSessionState();
536 if (saved && saved.token)
537 {
538 STATE.token = saved.token;
539 STATE.restoreDir = saved.dir || null;
540 STATE.restoreRootPath = saved.rootPath || null;
541 STATE.lastOperationAt = saved.lastOperationAt;
542
543 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
544 if (me)
545 {
546 STATE.username = me.username;
547 STATE.isAdmin = me.isAdmin;
548 STATE.permissions = me.permissions;
549 showApp();
550 await loadRoots({
551 preferredDir: STATE.restoreDir,
552 preferredRootPath: STATE.restoreRootPath,
553 });
554 return;
555 }
556
557 STATE.token = null;
558 clearSessionState();
559 }
560 }
561
562 showAuthOverlay(needed);
563}
564
565async function doLogin (username, password, isSetup)
566{
567 const encrypted = await hybridEncryptForServer({ username, password });
568 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
569
570 let data;
571 try
572 {
573 data = await api('POST', endpoint, {
574 encrypted,
575 clientPublicKey: STATE.clientPublicKeyJwk,
576 fingerprint: getFingerprint(),
577 });
578 } catch (err)
579 {
580 return err.message;
581 }
582
583 if (!data) return 'Login failed.';
584
585 // Decrypt the token sent back by the server
586 const token = await hybridDecryptFromServer(data.encrypted || data);
587 if (!token) return 'Login failed.';
588 STATE.token = token;
589
590 // Load user info
591 const me = await api('GET', '/auth/me');
592 if (!me) return 'Session error.';
593
594 STATE.username = me.username;
595 STATE.isAdmin = me.isAdmin;
596 STATE.permissions = me.permissions;
597
598 saveSessionState();
599 showApp();
600 await loadRoots();
601 return null; // no error
602}
603
604function logout ()
605{
606 void performLogout();
607}
608
609async function performLogout ()
610{
611 const tokenAtStart = STATE.token;
612 stopAutoRefresh();
613
614 if (tokenAtStart)
615 {
616 try
617 {
618 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
619 } catch
620 {
621 // Ignore network errors while logging out locally.
622 }
623 }
624
625 STATE.token = null;
626 STATE.username = null;
627 STATE.isAdmin = false;
628 STATE.permissions = {};
629 STATE.currentDir = null;
630 STATE.currentRoot = null;
631 STATE.items = [];
632 STATE.restoreDir = null;
633 STATE.restoreRootPath = null;
634 STATE.lastOperationAt = null;
635 clearSessionState();
636 closePreview();
637 closeSidebar();
638 await initAuth();
639}
640
641// ───────────────────────────────────────────────────────────────────────────
642// NAVIGATION
643// ───────────────────────────────────────────────────────────────────────────
644
645async function loadRoots (opts = {})
646{
647 const data = await api('GET', '/files/roots');
648 if (!data) return;
649 STATE.roots = data.roots;
650
651 const preferredDir = opts.preferredDir || null;
652 const preferredRootPath = opts.preferredRootPath || null;
653
654 if (preferredDir && preferredRootPath)
655 {
656 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
657 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
658 {
659 try
660 {
661 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
662 return;
663 } catch
664 {
665 // Fall back to default root behavior.
666 }
667 }
668 }
669
670 if (STATE.roots.length === 1)
671 {
672 // Single root → open it directly
673 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
674 } else
675 {
676 renderRootsView();
677 }
678}
679
680function renderRootsView ()
681{
682 STATE.currentDir = null;
683 STATE.currentRoot = null;
684 saveSessionState();
685 renderBreadcrumb();
686 const grid = document.getElementById('file-grid');
687 grid.innerHTML = '';
688 document.getElementById('empty-notice').classList.add('hidden');
689 document.getElementById('folder-stats').classList.add('hidden');
690 closeSidebar();
691
692 for (const root of STATE.roots)
693 {
694 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
695 grid.appendChild(el);
696 }
697}
698
699async function navigateTo (absPath, root, opts = {})
700{
701 if (root) STATE.currentRoot = root;
702 STATE.currentDir = absPath;
703
704 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
705 if (!data) return;
706
707 STATE.items = data.items;
708 saveSessionState();
709 renderBreadcrumb();
710 renderFileGrid();
711 await refreshFolderStats();
712 if (!opts.keepSidebar) closeSidebar();
713}
714
715function renderBreadcrumb ()
716{
717 const nav = document.getElementById('breadcrumb');
718 nav.innerHTML = '';
719
720 // "Home" crumb
721 const home = document.createElement('span');
722 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
723 home.textContent = 'Home';
724 home.addEventListener('click', () =>
725 {
726 if (STATE.roots.length === 1)
727 {
728 navigateTo(STATE.roots[0].path, STATE.roots[0]);
729 } else
730 {
731 renderRootsView();
732 }
733 });
734 nav.appendChild(home);
735
736 if (!STATE.currentDir || !STATE.currentRoot) return;
737
738 // Build path segments relative to the root
739 const rootPath = STATE.currentRoot.path;
740 const relative = STATE.currentDir === rootPath
741 ? ''
742 : STATE.currentDir.replace(rootPath, '').replace(/^[\\/]/, '');
743
744 const parts = [STATE.currentRoot.label, ...relative.split(/[\\/]/).filter(Boolean)];
745 let accumulated = rootPath;
746
747 for (let i = 0; i < parts.length; i++)
748 {
749 const sep = document.createElement('span');
750 sep.className = 'sep';
751 sep.textContent = ' / ';
752 nav.appendChild(sep);
753
754 const crumb = document.createElement('span');
755 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
756 crumb.textContent = parts[i];
757
758 // Capture the path for this crumb
759 const capturedPath = i === 0 ? rootPath : accumulated;
760 if (i < parts.length - 1)
761 {
762 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
763 }
764
765 nav.appendChild(crumb);
766
767 // Advance accumulated path (skip for root label)
768 if (i > 0) accumulated = accumulated + '/' + parts[i];
769 else if (i === 0 && parts.length > 1)
770 {
771 // After root label, next crumb should append the next segment
772 accumulated = rootPath;
773 }
774 }
775}
776
777async function refreshFolderStats ()
778{
779 const el = document.getElementById('folder-stats');
780 if (!STATE.currentDir)
781 {
782 el.classList.add('hidden');
783 return;
784 }
785
786 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
787 if (!data)
788 {
789 el.classList.add('hidden');
790 return;
791 }
792
793 const used = formatBytes(data.usedBytes);
794 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
795 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
796 el.classList.remove('hidden');
797}
798
799function itemsSignature (items)
800{
801 return JSON.stringify(
802 (items || []).map(it => [it.path, it.mtime, it.size, it.isDir])
803 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
804 );
805}
806
807async function incrementalRefreshCurrentDir ()
808{
809 if (!STATE.currentDir || STATE.uploadInProgress) return;
810 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
811 if (!data) return;
812
813 const oldSig = itemsSignature(STATE.items);
814 const newSig = itemsSignature(data.items);
815 if (oldSig !== newSig)
816 {
817 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
818 STATE.items = data.items;
819 renderFileGrid();
820
821 if (selectedPath)
822 {
823 const match = STATE.items.find(i => i.path === selectedPath);
824 if (match)
825 {
826 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
827 .find(el => el.dataset.path === selectedPath);
828 if (selectedEl) selectItem(selectedEl, match);
829 } else
830 {
831 closeSidebar();
832 }
833 }
834 }
835
836 await refreshFolderStats();
837}
838
839function startAutoRefresh ()
840{
841 stopAutoRefresh();
842 STATE.autoRefreshTimer = setInterval(() =>
843 {
844 if (document.hidden) return;
845 incrementalRefreshCurrentDir();
846 }, 5000);
847}
848
849function stopAutoRefresh ()
850{
851 if (STATE.autoRefreshTimer)
852 {
853 clearInterval(STATE.autoRefreshTimer);
854 STATE.autoRefreshTimer = null;
855 }
856}
857
858// ───────────────────────────────────────────────────────────────────────────
859// FILE GRID RENDERING
860// ───────────────────────────────────────────────────────────────────────────
861
862function renderFileGrid ()
863{
864 revokeThumbnails();
865 const grid = document.getElementById('file-grid');
866 grid.innerHTML = '';
867 const empty = document.getElementById('empty-notice');
868
869 const sorted = [...STATE.items].sort((a, b) =>
870 {
871 if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
872 return a.name.localeCompare(b.name);
873 });
874
875 empty.classList.toggle('hidden', sorted.length > 0);
876
877 for (const item of sorted)
878 {
879 grid.appendChild(makeFileItem(item));
880 }
881
882 loadThumbnails();
883}
884
885function makeFileItem (item)
886{
887 const el = document.createElement('div');
888 el.className = 'file-item';
889 el.dataset.path = item.path;
890
891 const icon = document.createElement('div');
892 icon.className = 'icon';
893 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
894 if (!item.isDir && IMAGE_EXTS.has(extOf(item.name)))
895 {
896 icon.dataset.previewPath = item.path;
897 }
898 el.appendChild(icon);
899
900 const name = document.createElement('div');
901 name.className = 'name';
902 name.textContent = item.name;
903 el.appendChild(name);
904
905 // Single-click: open sidebar
906 el.addEventListener('click', (e) =>
907 {
908 e.stopPropagation();
909 if (item._root)
910 {
911 // Clicking a root tile goes straight in
912 navigateTo(item.path, item._root);
913 return;
914 }
915 selectItem(el, item);
916 });
917
918 // Double-click: enter folder or view/download file
919 el.addEventListener('dblclick', (e) =>
920 {
921 e.stopPropagation();
922 if (item.isDir)
923 {
924 navigateTo(item.path, STATE.currentRoot);
925 } else
926 {
927 downloadOrView(item);
928 }
929 });
930
931 return el;
932}
933
934function selectItem (el, item)
935{
936 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
937 el.classList.add('selected');
938 STATE.selectedItem = item;
939 openSidebar(item);
940}
941
942// ───────────────────────────────────────────────────────────────────────────
943// SIDEBAR
944// ───────────────────────────────────────────────────────────────────────────
945
946async function openSidebar (item)
947{
948 const sidebar = document.getElementById('sidebar');
949 sidebar.classList.remove('hidden');
950 document.getElementById('app').classList.add('sidebar-open');
951
952 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
953 document.getElementById('sidebar-name').textContent = item.name;
954
955 // Load metadata
956 const dl = document.getElementById('sidebar-meta');
957 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
958
959 const actions = document.getElementById('sidebar-actions');
960 actions.innerHTML = '';
961
962 if (!item.isDir)
963 {
964 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`);
965 if (meta)
966 {
967 dl.innerHTML = `
968 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
969 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
970 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
971 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
972 `;
973 }
974
975 // View / download button
976 const btnDl = document.createElement('button');
977 btnDl.textContent = 'View / Download';
978 btnDl.addEventListener('click', () => downloadOrView(item));
979 actions.appendChild(btnDl);
980 } else
981 {
982 dl.innerHTML = `<dt>Type</dt><dd>Folder</dd>`;
983 const btnOpen = document.createElement('button');
984 btnOpen.textContent = 'Open folder';
985 btnOpen.addEventListener('click', () => navigateTo(item.path, STATE.currentRoot));
986 actions.appendChild(btnOpen);
987 }
988
989 // Rename button (write access required)
990 if (canWrite())
991 {
992 const btnRen = document.createElement('button');
993 btnRen.textContent = 'Rename';
994 btnRen.addEventListener('click', () => openRenameModal(item));
995 actions.appendChild(btnRen);
996
997 const btnDel = document.createElement('button');
998 btnDel.textContent = 'Delete';
999 btnDel.className = 'danger';
1000 btnDel.addEventListener('click', () => deleteItem(item));
1001 actions.appendChild(btnDel);
1002 }
1003}
1004
1005function closeSidebar ()
1006{
1007 document.getElementById('sidebar').classList.add('hidden');
1008 document.getElementById('app').classList.remove('sidebar-open');
1009 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
1010 STATE.selectedItem = null;
1011}
1012
1013// ───────────────────────────────────────────────────────────────────────────
1014// DOWNLOAD / VIEW
1015// ───────────────────────────────────────────────────────────────────────────
1016
1017function isInlinePreviewableBlob (blob, name)
1018{
1019 const mime = String(blob.type || '').toLowerCase();
1020 if (/^(image|video|audio)\//.test(mime)) return true;
1021 if (/^text\//.test(mime)) return true;
1022 if (mime === 'application/pdf') return true;
1023 if (mime === 'application/json') return true;
1024 if (mime === 'application/xml') return true;
1025 if (mime === 'application/javascript') return true;
1026
1027 // Fallback by extension when MIME is missing or generic.
1028 const ext = extOf(name || '');
1029 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
1030 if (CODE_EXTS.has(ext)) return true;
1031 return false;
1032}
1033
1034function isTextLikeBlob (blob, name)
1035{
1036 const mime = String(blob.type || '').toLowerCase();
1037 if (/^text\//.test(mime)) return true;
1038 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
1039 const ext = extOf(name || '');
1040 return CODE_EXTS.has(ext);
1041}
1042
1043function clearPreviewObjectUrl ()
1044{
1045 if (!STATE.previewObjectUrl) return;
1046 URL.revokeObjectURL(STATE.previewObjectUrl);
1047 STATE.previewObjectUrl = null;
1048}
1049
1050function closePreview ()
1051{
1052 const overlay = document.getElementById('preview-overlay');
1053 const body = document.getElementById('preview-body');
1054 if (!overlay || !body) return;
1055 overlay.classList.add('hidden');
1056 body.innerHTML = '';
1057 clearPreviewObjectUrl();
1058}
1059
1060async function fetchFileBlob (item)
1061{
1062 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
1063 try
1064 {
1065 const res = await fetch(url, {
1066 headers: {
1067 Authorization: 'Bearer ' + STATE.token,
1068 'X-Fp': getFingerprint(),
1069 },
1070 });
1071 if (!res.ok) throw new Error('Download failed.');
1072 return await res.blob();
1073 } catch
1074 {
1075 return null;
1076 }
1077}
1078
1079function triggerDownload (filename, objectUrl)
1080{
1081 const a = document.createElement('a');
1082 a.href = objectUrl;
1083 a.download = filename;
1084 a.click();
1085}
1086
1087async function renderPreviewBody (item, blob, objectUrl)
1088{
1089 const body = document.getElementById('preview-body');
1090 body.innerHTML = '';
1091
1092 const mime = String(blob.type || '').toLowerCase();
1093 const previewable = isInlinePreviewableBlob(blob, item.name);
1094
1095 if (!previewable)
1096 {
1097 const msg = document.createElement('p');
1098 msg.className = 'preview-unsupported';
1099 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
1100 body.appendChild(msg);
1101 return;
1102 }
1103
1104 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
1105 {
1106 const img = document.createElement('img');
1107 img.className = 'preview-media';
1108 img.src = objectUrl;
1109 img.alt = item.name;
1110 body.appendChild(img);
1111 return;
1112 }
1113
1114 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
1115 {
1116 const video = document.createElement('video');
1117 video.className = 'preview-media';
1118 video.src = objectUrl;
1119 video.controls = true;
1120 video.preload = 'metadata';
1121 body.appendChild(video);
1122 return;
1123 }
1124
1125 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
1126 {
1127 const audio = document.createElement('audio');
1128 audio.className = 'preview-audio';
1129 audio.src = objectUrl;
1130 audio.controls = true;
1131 body.appendChild(audio);
1132 return;
1133 }
1134
1135 if (mime === 'application/pdf')
1136 {
1137 const frame = document.createElement('iframe');
1138 frame.className = 'preview-frame';
1139 frame.src = objectUrl;
1140 frame.title = item.name;
1141 body.appendChild(frame);
1142 return;
1143 }
1144
1145 if (isTextLikeBlob(blob, item.name))
1146 {
1147 const text = await blob.text();
1148 const pre = document.createElement('pre');
1149 pre.className = 'preview-text';
1150 pre.textContent = text;
1151 body.appendChild(pre);
1152 return;
1153 }
1154
1155 const msg = document.createElement('p');
1156 msg.className = 'preview-unsupported';
1157 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
1158 body.appendChild(msg);
1159}
1160
1161async function downloadOrView (item)
1162{
1163 const blob = await fetchFileBlob(item);
1164 if (!blob)
1165 {
1166 toast('Download failed.', 'err');
1167 return;
1168 }
1169
1170 clearPreviewObjectUrl();
1171 const objectUrl = URL.createObjectURL(blob);
1172 STATE.previewObjectUrl = objectUrl;
1173
1174 const overlay = document.getElementById('preview-overlay');
1175 const title = document.getElementById('preview-title');
1176 const dlBtn = document.getElementById('preview-download');
1177
1178 title.textContent = item.name;
1179 dlBtn.onclick = () => triggerDownload(item.name, objectUrl);
1180 await renderPreviewBody(item, blob, objectUrl);
1181 overlay.classList.remove('hidden');
1182}
1183
1184// ───────────────────────────────────────────────────────────────────────────
1185// UPLOAD
1186// ───────────────────────────────────────────────────────────────────────────
1187
1188function canWrite ()
1189{
1190 if (STATE.isAdmin) return true;
1191 if (!STATE.currentRoot) return false;
1192 const p = STATE.permissions[STATE.currentRoot.label];
1193 return p && p.write;
1194}
1195
1196async function uploadFiles (fileList)
1197{
1198 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1199 if (!canWrite()) { toast('No write access.', 'err'); return; }
1200
1201 const totalSize = Array.from(fileList).reduce((sum, f) => sum + (f.size || 0), 0);
1202 const formData = new FormData();
1203 for (const f of fileList) formData.append('files', f);
1204
1205 // Show upload bar
1206 const wrap = document.createElement('div');
1207 wrap.className = 'upload-bar-wrap';
1208 wrap.innerHTML = `<span>Uploading ${fileList.length} file(s)…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1209 document.body.appendChild(wrap);
1210 STATE.uploadInProgress = true;
1211
1212 try
1213 {
1214 const xhr = new XMLHttpRequest();
1215 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(STATE.currentDir)}`);
1216 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
1217 xhr.setRequestHeader('X-Fp', getFingerprint());
1218 xhr.setRequestHeader('X-Upload-Size', String(totalSize));
1219
1220 xhr.upload.addEventListener('progress', e =>
1221 {
1222 if (e.lengthComputable)
1223 {
1224 wrap.querySelector('.upload-bar-fill').style.width = (e.loaded / e.total * 100) + '%';
1225 }
1226 });
1227
1228 await new Promise((resolve, reject) =>
1229 {
1230 xhr.onload = () =>
1231 {
1232 if (xhr.status === 200) resolve();
1233 else reject(new Error(JSON.parse(xhr.responseText).error || 'Upload failed'));
1234 };
1235 xhr.onerror = () => reject(new Error('Network error'));
1236 xhr.send(formData);
1237 });
1238
1239 toast(`Uploaded ${fileList.length} file(s).`, 'ok');
1240 await navigateTo(STATE.currentDir, STATE.currentRoot);
1241 } catch (err)
1242 {
1243 toast(err.message, 'err');
1244 } finally
1245 {
1246 STATE.uploadInProgress = false;
1247 wrap.remove();
1248 }
1249}
1250
1251async function uploadSingleFile (file, targetDir)
1252{
1253 const formData = new FormData();
1254 formData.append('files', file);
1255
1256 await new Promise((resolve, reject) =>
1257 {
1258 const xhr = new XMLHttpRequest();
1259 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
1260 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
1261 xhr.setRequestHeader('X-Fp', getFingerprint());
1262 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
1263 xhr.onload = () => xhr.status === 200
1264 ? resolve()
1265 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
1266 xhr.onerror = () => reject(new Error('Network error'));
1267 xhr.send(formData);
1268 });
1269}
1270
1271async function ensureServerDir (baseDir, relativeDir)
1272{
1273 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
1274 let current = baseDir;
1275 for (const part of parts)
1276 {
1277 try
1278 {
1279 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
1280 current = resp && resp.path ? resp.path : joinServerPath(current, part);
1281 } catch (err)
1282 {
1283 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
1284 current = joinServerPath(current, part);
1285 }
1286 }
1287 return current;
1288}
1289
1290async function uploadFolderInputFiles (fileList)
1291{
1292 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1293 if (!canWrite()) { toast('No write access.', 'err'); return; }
1294 if (!fileList || !fileList.length) return;
1295
1296 const files = Array.from(fileList);
1297 const total = files.length;
1298 let done = 0;
1299
1300 const wrap = document.createElement('div');
1301 wrap.className = 'upload-bar-wrap';
1302 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1303 document.body.appendChild(wrap);
1304 STATE.uploadInProgress = true;
1305
1306 try
1307 {
1308 const dirCache = new Map();
1309 dirCache.set('', STATE.currentDir);
1310
1311 for (const file of files)
1312 {
1313 const rel = file.webkitRelativePath || file.name;
1314 const relParts = rel.split(/[\\/]/).filter(Boolean);
1315 const relDir = relParts.slice(0, -1).join('/');
1316
1317 if (!dirCache.has(relDir))
1318 {
1319 const parentRel = relParts.slice(0, -2).join('/');
1320 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
1321 const thisName = relParts[relParts.length - 2];
1322
1323 try
1324 {
1325 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
1326 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
1327 } catch (err)
1328 {
1329 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
1330 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
1331 }
1332 }
1333
1334 const targetDir = dirCache.get(relDir) || STATE.currentDir;
1335 await uploadSingleFile(file, targetDir);
1336 done++;
1337 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
1338 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
1339 }
1340
1341 toast(`Uploaded ${total} file(s).`, 'ok');
1342 await navigateTo(STATE.currentDir, STATE.currentRoot);
1343 } catch (err)
1344 {
1345 toast(err.message, 'err');
1346 } finally
1347 {
1348 STATE.uploadInProgress = false;
1349 wrap.remove();
1350 }
1351}
1352
1353// ───────────────────────────────────────────────────────────────────────────
1354// FOLDER DRAG-AND-DROP (recursive)
1355// ───────────────────────────────────────────────────────────────────────────
1356
1357/**
1358 * Reads all readEntries batches from a DirectoryReader (browsers may return
1359 * results in chunks; we must keep calling until we get an empty array).
1360 */
1361function readAllEntries (reader)
1362{
1363 return new Promise((resolve, reject) =>
1364 {
1365 const all = [];
1366 function next ()
1367 {
1368 reader.readEntries(batch =>
1369 {
1370 if (!batch.length) { resolve(all); return; }
1371 all.push(...batch);
1372 next();
1373 }, reject);
1374 }
1375 next();
1376 });
1377}
1378
1379/**
1380 * Recursively walk a FileSystemEntry tree, creating server-side directories
1381 * on the fly and collecting { file, targetDir } pairs for upload.
1382 */
1383async function collectEntries (entry, serverDir, toUpload)
1384{
1385 if (entry.isFile)
1386 {
1387 const file = await new Promise((res, rej) => entry.file(res, rej));
1388 toUpload.push({ file, targetDir: serverDir });
1389 } else if (entry.isDirectory)
1390 {
1391 // Ask the server to create the directory; it returns the canonical path.
1392 let newServerDir;
1393 try
1394 {
1395 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
1396 newServerDir = resp.path;
1397 } catch
1398 {
1399 // Directory may already exist — reconstruct path from what we know.
1400 // The server always returns JSON with {error} on failure, so we can
1401 // still continue by falling back to a best-effort path join.
1402 // We rely on the fact that the server separator is consistent within
1403 // a session (the list/browse API already returned paths in that format).
1404 const sep = serverDir.includes('\\') ? '\\' : '/';
1405 newServerDir = serverDir + sep + entry.name;
1406 }
1407 const reader = entry.createReader();
1408 const subEntries = await readAllEntries(reader);
1409 for (const sub of subEntries)
1410 {
1411 await collectEntries(sub, newServerDir, toUpload);
1412 }
1413 }
1414}
1415
1416async function uploadEntries (entries)
1417{
1418 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1419 if (!canWrite()) { toast('No write access.', 'err'); return; }
1420
1421 const wrap = document.createElement('div');
1422 wrap.className = 'upload-bar-wrap';
1423 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1424 document.body.appendChild(wrap);
1425 STATE.uploadInProgress = true;
1426
1427 try
1428 {
1429 const toUpload = [];
1430 for (const entry of entries)
1431 {
1432 await collectEntries(entry, STATE.currentDir, toUpload);
1433 }
1434
1435 if (!toUpload.length) { toast('No files found.', 'err'); return; }
1436
1437 let done = 0;
1438 const total = toUpload.length;
1439 const updateBar = () =>
1440 {
1441 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
1442 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
1443 };
1444 updateBar();
1445
1446 for (const { file, targetDir } of toUpload)
1447 {
1448 await uploadSingleFile(file, targetDir);
1449 done++;
1450 updateBar();
1451 }
1452
1453 toast(`Uploaded ${total} file(s).`, 'ok');
1454 await navigateTo(STATE.currentDir, STATE.currentRoot);
1455 } catch (err)
1456 {
1457 toast(err.message, 'err');
1458 } finally
1459 {
1460 STATE.uploadInProgress = false;
1461 wrap.remove();
1462 }
1463}
1464
1465// DRAG-AND-DROP
1466// ───────────────────────────────────────────────────────────────────────────
1467
1468function initDragDrop ()
1469{
1470 const main = document.getElementById('main-content');
1471 const dropOvl = document.getElementById('drop-overlay');
1472 let dragDepth = 0;
1473
1474 main.addEventListener('dragenter', e =>
1475 {
1476 e.preventDefault();
1477 dragDepth++;
1478 dropOvl.classList.remove('hidden');
1479 });
1480 main.addEventListener('dragleave', () =>
1481 {
1482 dragDepth--;
1483 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
1484 });
1485 main.addEventListener('dragover', e => e.preventDefault());
1486 main.addEventListener('drop', async e =>
1487 {
1488 e.preventDefault();
1489 dragDepth = 0;
1490 dropOvl.classList.add('hidden');
1491 if (!canWrite()) { toast('No write access.', 'err'); return; }
1492
1493 const items = Array.from(e.dataTransfer.items || []);
1494 // Use the FileSystem Entry API when available so we can handle folders.
1495 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
1496 {
1497 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
1498 if (entries.some(en => en.isDirectory))
1499 {
1500 await uploadEntries(entries);
1501 return;
1502 }
1503 }
1504 // Plain files only — use the fast batch path.
1505 const files = e.dataTransfer.files;
1506 if (files.length) await uploadFiles(files);
1507 });
1508}
1509
1510// ───────────────────────────────────────────────────────────────────────────
1511// RENAME
1512// ───────────────────────────────────────────────────────────────────────────
1513
1514function openRenameModal (item)
1515{
1516 const modal = document.getElementById('rename-modal');
1517 modal.classList.remove('hidden');
1518 const input = document.getElementById('rename-input');
1519 input.value = item.name;
1520 input.focus();
1521 input.select();
1522 document.getElementById('rename-error').classList.add('hidden');
1523 document.getElementById('rename-form').onsubmit = async (e) =>
1524 {
1525 e.preventDefault();
1526 const newName = input.value.trim();
1527 if (!newName) return;
1528 try
1529 {
1530 await api('POST', '/files/rename', { from: item.path, to: newName });
1531 modal.classList.add('hidden');
1532 toast('Renamed.', 'ok');
1533 await navigateTo(STATE.currentDir, STATE.currentRoot);
1534 } catch (err)
1535 {
1536 document.getElementById('rename-error').textContent = err.message;
1537 document.getElementById('rename-error').classList.remove('hidden');
1538 }
1539 };
1540}
1541
1542// ───────────────────────────────────────────────────────────────────────────
1543// DELETE
1544// ───────────────────────────────────────────────────────────────────────────
1545
1546async function deleteItem (item)
1547{
1548 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
1549 try
1550 {
1551 await api('POST', '/files/delete', { path: item.path });
1552 toast('Deleted.', 'ok');
1553 closeSidebar();
1554 await navigateTo(STATE.currentDir, STATE.currentRoot);
1555 } catch (err)
1556 {
1557 toast(err.message, 'err');
1558 }
1559}
1560
1561// ───────────────────────────────────────────────────────────────────────────
1562// ADMIN PANEL
1563// ───────────────────────────────────────────────────────────────────────────
1564
1565async function openAdminModal ()
1566{
1567 document.getElementById('admin-modal').classList.remove('hidden');
1568 await refreshAdminConfig();
1569 await refreshAdminUsers();
1570}
1571
1572async function refreshAdminConfig ()
1573{
1574 const data = await api('GET', '/admin/config');
1575 if (!data) return;
1576 const container = document.getElementById('admin-paths');
1577 container.innerHTML = '';
1578 for (const p of data.paths)
1579 {
1580 const row = document.createElement('div');
1581 row.className = 'path-row';
1582 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
1583 row.querySelector('button').addEventListener('click', () =>
1584 {
1585 row.remove();
1586 });
1587 container.appendChild(row);
1588 }
1589}
1590
1591async function refreshAdminUsers ()
1592{
1593 const data = await api('GET', '/admin/users');
1594 if (!data) return;
1595 const container = document.getElementById('admin-users-list');
1596 container.innerHTML = '';
1597
1598 // Need paths for permission rows
1599 const cfg = await api('GET', '/admin/config');
1600 const paths = cfg ? (cfg.effectivePaths || []) : [];
1601
1602 for (const u of data.users)
1603 {
1604 const row = document.createElement('div');
1605 row.className = 'user-row';
1606 row.innerHTML = `
1607 <span class="user-name">${u.username}</span>
1608 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
1609 <button data-id="${u.id}" data-action="edit">Edit</button>
1610 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
1611 `;
1612 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
1613 openUserModal(u, paths));
1614 const deleteBtn = row.querySelector('[data-action="delete"]');
1615 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
1616 {
1617 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
1618 try
1619 {
1620 await api('DELETE', `/admin/users/${u.id}`);
1621 toast('User deleted.', 'ok');
1622 await refreshAdminUsers();
1623 } catch (err) { toast(err.message, 'err'); }
1624 });
1625 container.appendChild(row);
1626 }
1627}
1628
1629function openUserModal (user, paths)
1630{
1631 const modal = document.getElementById('user-modal');
1632 modal.classList.remove('hidden');
1633 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
1634 document.getElementById('user-error').classList.add('hidden');
1635
1636 const usernameInput = document.getElementById('user-username');
1637 usernameInput.value = user ? user.username : '';
1638 usernameInput.readOnly = !!user;
1639
1640 document.getElementById('user-password').value = '';
1641 document.getElementById('user-is-admin').checked = user ? user.isAdmin : false;
1642
1643 // Password placeholder
1644 document.getElementById('user-password').placeholder =
1645 user ? 'Leave blank to keep current' : 'Min 8 characters';
1646
1647 // Build permissions grid
1648 const permDiv = document.getElementById('user-permissions');
1649 permDiv.innerHTML = '';
1650 if (paths.length)
1651 {
1652 const heading = document.createElement('h4');
1653 heading.textContent = 'Path Permissions';
1654 permDiv.appendChild(heading);
1655
1656 const isAdminUser = !!(user && user.isAdmin);
1657 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
1658 const adminChk = document.getElementById('user-is-admin');
1659 const rebuildPermRows = (admin) =>
1660 {
1661 permDiv.querySelectorAll('.perm-row').forEach(r =>
1662 {
1663 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
1664 {
1665 cb.disabled = admin;
1666 if (admin) cb.checked = true;
1667 });
1668 r.title = admin ? 'Admins always have full access' : '';
1669 });
1670 };
1671 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
1672
1673 for (const p of paths)
1674 {
1675 const label = p.split(/[\\/]/).pop();
1676 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
1677 const row = document.createElement('div');
1678 row.className = 'perm-row';
1679 const readChecked = isAdminUser || perms.read;
1680 const writeChecked = isAdminUser || perms.write;
1681 row.innerHTML = `
1682 <span class="perm-label">${label}</span>
1683 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
1684 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
1685 `;
1686 if (isAdminUser) row.title = 'Admins always have full access';
1687 permDiv.appendChild(row);
1688 }
1689 }
1690
1691 document.getElementById('user-form').onsubmit = async (e) =>
1692 {
1693 e.preventDefault();
1694 const password = document.getElementById('user-password').value;
1695 const isAdmin = document.getElementById('user-is-admin').checked;
1696 const permissions = {};
1697 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
1698 {
1699 const lbl = cb.dataset.label;
1700 if (!permissions[lbl]) permissions[lbl] = {};
1701 permissions[lbl][cb.dataset.type] = cb.checked;
1702 });
1703
1704 try
1705 {
1706 if (user)
1707 {
1708 const body = { isAdmin, permissions };
1709 if (password) body.password = password;
1710 await api('PATCH', `/admin/users/${user.id}`, body);
1711 } else
1712 {
1713 const uname = document.getElementById('user-username').value.trim();
1714 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
1715 }
1716 modal.classList.add('hidden');
1717 toast('User saved.', 'ok');
1718 await refreshAdminUsers();
1719 } catch (err)
1720 {
1721 document.getElementById('user-error').textContent = err.message;
1722 document.getElementById('user-error').classList.remove('hidden');
1723 }
1724 };
1725}
1726
1727// ───────────────────────────────────────────────────────────────────────────
1728// SVG ICONS
1729// ───────────────────────────────────────────────────────────────────────────
1730
1731const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
1732const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
1733const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
1734const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
1735const 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']);
1736const ARCHIVE_EXTS = new Set(['zip', 'tar', 'gz', 'bz2', 'xz', 'rar', '7z']);
1737
1738function iconFolder (size = 52)
1739{
1740 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
1741 stroke="#5b7fff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
1742 <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"/>
1743 </svg>`;
1744}
1745
1746function iconFile (name, size = 52)
1747{
1748 const ext = extOf(name);
1749 let color = '#7880a0';
1750 let symbol = '';
1751
1752 if (IMAGE_EXTS.has(ext)) color = '#3fcf8e';
1753 else if (VIDEO_EXTS.has(ext)) color = '#e05c6e';
1754 else if (AUDIO_EXTS.has(ext)) color = '#c084fc';
1755 else if (DOC_EXTS.has(ext)) color = '#f97316';
1756 else if (CODE_EXTS.has(ext)) color = '#38bdf8';
1757 else if (ARCHIVE_EXTS.has(ext)) color = '#facc15';
1758
1759 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
1760 stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
1761 <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
1762 <polyline points="14 2 14 8 20 8"/>
1763 </svg>`;
1764}
1765
1766// ───────────────────────────────────────────────────────────────────────────
1767// EVENT WIRING
1768// ───────────────────────────────────────────────────────────────────────────
1769
1770// ───────────────────────────────────────────────────────────────────────────
1771// THUMBNAIL PREVIEWS
1772// ───────────────────────────────────────────────────────────────────────────
1773
1774function revokeThumbnails ()
1775{
1776 STATE.thumbnailUrls.forEach(u => URL.revokeObjectURL(u));
1777 STATE.thumbnailUrls = [];
1778}
1779
1780async function loadThumbnails ()
1781{
1782 const icons = Array.from(document.querySelectorAll('.icon[data-preview-path]'));
1783 if (!icons.length) return;
1784
1785 const queue = [...icons];
1786 async function worker ()
1787 {
1788 while (queue.length)
1789 {
1790 await loadOneThumbnail(queue.shift());
1791 }
1792 }
1793 // Four concurrent fetches — keeps the Pi's network from flooding
1794 await Promise.all(Array.from({ length: Math.min(4, icons.length) }, worker));
1795}
1796
1797async function loadOneThumbnail (iconEl)
1798{
1799 if (!iconEl.isConnected || !STATE.token) return;
1800 const filePath = iconEl.dataset.previewPath;
1801 const url = `/api/files/download?file=${encodeURIComponent(filePath)}`;
1802
1803 let res;
1804 try
1805 {
1806 res = await fetch(url, { headers: { Authorization: `Bearer ${STATE.token}` } });
1807 } catch { return; }
1808 if (!res.ok || !iconEl.isConnected) return;
1809
1810 const blob = await res.blob();
1811 if (!blob.type.startsWith('image/') || !iconEl.isConnected) return;
1812
1813 const objectUrl = URL.createObjectURL(blob);
1814 STATE.thumbnailUrls.push(objectUrl);
1815
1816 const svg = iconEl.querySelector('svg');
1817 if (!svg) { URL.revokeObjectURL(objectUrl); return; }
1818
1819 const NS = 'http://www.w3.org/2000/svg';
1820 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
1821
1822 // clipPath matches the main file body outline exactly (viewBox 0 0 24 24)
1823 const defs = document.createElementNS(NS, 'defs');
1824 const clipPath = document.createElementNS(NS, 'clipPath');
1825 clipPath.setAttribute('id', id);
1826 const clipShape = document.createElementNS(NS, 'path');
1827 clipShape.setAttribute('d', 'M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z');
1828 clipPath.appendChild(clipShape);
1829 defs.appendChild(clipPath);
1830
1831 // Image fills the file bounding box; clip keeps it inside the outline
1832 const img = document.createElementNS(NS, 'image');
1833 img.setAttribute('href', objectUrl);
1834 img.setAttribute('x', '4');
1835 img.setAttribute('y', '2');
1836 img.setAttribute('width', '16');
1837 img.setAttribute('height', '20');
1838 img.setAttribute('clip-path', `url(#${id})`);
1839 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
1840
1841 // Prepend so existing path/polyline elements (the outline) render on top
1842 svg.prepend(img);
1843 svg.prepend(defs);
1844}
1845
1846function wireEvents ()
1847{
1848 // Auth form
1849 document.getElementById('auth-form').addEventListener('submit', async (e) =>
1850 {
1851 e.preventDefault();
1852 const username = document.getElementById('auth-username').value.trim();
1853 const password = document.getElementById('auth-password').value;
1854 const isSetup = e.target.dataset.mode === 'setup';
1855 const errEl = document.getElementById('auth-error');
1856 const btn = document.getElementById('auth-submit');
1857 btn.disabled = true;
1858 btn.textContent = 'Please wait…';
1859 const err = await doLogin(username, password, isSetup);
1860 if (err)
1861 {
1862 errEl.textContent = err;
1863 errEl.classList.remove('hidden');
1864 btn.disabled = false;
1865 btn.textContent = isSetup ? 'Create Account' : 'Sign In';
1866 }
1867 });
1868
1869 // Logout
1870 document.getElementById('btn-logout').addEventListener('click', logout);
1871
1872 // Hard refresh while keeping auth/session state.
1873 document.getElementById('btn-refresh').addEventListener('click', () =>
1874 {
1875 saveSessionState();
1876 location.reload();
1877 });
1878
1879 // Upload button
1880 document.getElementById('btn-upload').addEventListener('click', () =>
1881 {
1882 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1883 if (!canWrite()) { toast('No write access.', 'err'); return; }
1884 document.getElementById('file-input').click();
1885 });
1886
1887 document.getElementById('file-input').addEventListener('change', async (e) =>
1888 {
1889 if (e.target.files.length) await uploadFiles(e.target.files);
1890 e.target.value = '';
1891 });
1892
1893 document.getElementById('btn-upload-folder').addEventListener('click', () =>
1894 {
1895 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1896 if (!canWrite()) { toast('No write access.', 'err'); return; }
1897 document.getElementById('folder-input').click();
1898 });
1899
1900 document.getElementById('folder-input').addEventListener('change', async (e) =>
1901 {
1902 if (e.target.files.length) await uploadFolderInputFiles(e.target.files);
1903 e.target.value = '';
1904 });
1905
1906 document.getElementById('btn-new-folder').addEventListener('click', async () =>
1907 {
1908 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1909 if (!canWrite()) { toast('No write access.', 'err'); return; }
1910
1911 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
1912 if (name == null) return;
1913 const folderName = name.trim();
1914 if (!folderName)
1915 {
1916 toast('Folder name is required.', 'err');
1917 return;
1918 }
1919
1920 try
1921 {
1922 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
1923 toast('Folder created.', 'ok');
1924 await navigateTo(STATE.currentDir, STATE.currentRoot);
1925 } catch (err)
1926 {
1927 toast(err.message, 'err');
1928 }
1929 });
1930
1931 // Sidebar close
1932 document.getElementById('sidebar-close').addEventListener('click', closeSidebar);
1933
1934 // Click outside grid closes sidebar
1935 document.getElementById('main-content').addEventListener('click', (e) =>
1936 {
1937 if (!e.target.closest('.file-item')) closeSidebar();
1938 });
1939
1940 // Admin panel
1941 document.getElementById('btn-admin').addEventListener('click', openAdminModal);
1942 document.getElementById('admin-modal-close').addEventListener('click', () =>
1943 document.getElementById('admin-modal').classList.add('hidden'));
1944
1945 // Add path
1946 document.getElementById('admin-add-path').addEventListener('click', () =>
1947 {
1948 const val = document.getElementById('admin-new-path').value.trim();
1949 if (!val) return;
1950 const row = document.createElement('div');
1951 row.className = 'path-row';
1952 row.innerHTML = `<span>${val}</span><button title="Remove">✕</button>`;
1953 row.querySelector('button').addEventListener('click', () => row.remove());
1954 document.getElementById('admin-paths').appendChild(row);
1955 document.getElementById('admin-new-path').value = '';
1956 });
1957
1958 // Save paths
1959 document.getElementById('admin-save-paths').addEventListener('click', async () =>
1960 {
1961 const rows = document.querySelectorAll('#admin-paths .path-row span');
1962 const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
1963 try
1964 {
1965 await api('PUT', '/admin/config', { paths });
1966 toast('Paths saved.', 'ok');
1967 await loadRoots();
1968 } catch (err) { toast(err.message, 'err'); }
1969 });
1970
1971 // Shutdown server
1972 document.getElementById('admin-shutdown-btn').addEventListener('click', async () =>
1973 {
1974 if (!await showConfirm('Shut down server', 'Shut down the server? You will lose access until it is restarted manually.')) return;
1975 try
1976 {
1977 await api('POST', '/admin/shutdown');
1978 toast('Server is shutting down…', 'ok');
1979 document.getElementById('admin-modal').classList.add('hidden');
1980 } catch
1981 {
1982 // Fetch may throw because the connection closes before a response arrives.
1983 toast('Server is shutting down…', 'ok');
1984 document.getElementById('admin-modal').classList.add('hidden');
1985 }
1986 });
1987
1988 // New user
1989 document.getElementById('admin-new-user-btn').addEventListener('click', async () =>
1990 {
1991 const cfg = await api('GET', '/admin/config');
1992 const paths = cfg ? (cfg.effectivePaths || []) : [];
1993 openUserModal(null, paths);
1994 });
1995
1996 // User modal close
1997 document.getElementById('user-modal-close').addEventListener('click', () =>
1998 document.getElementById('user-modal').classList.add('hidden'));
1999
2000 // Rename modal close
2001 document.getElementById('rename-modal-close').addEventListener('click', () =>
2002 document.getElementById('rename-modal').classList.add('hidden'));
2003
2004 // Preview close
2005 document.getElementById('preview-close').addEventListener('click', closePreview);
2006 document.getElementById('preview-overlay').addEventListener('click', (e) =>
2007 {
2008 if (e.target.id === 'preview-overlay') closePreview();
2009 });
2010
2011 document.addEventListener('keydown', (e) =>
2012 {
2013 if (e.key === 'Escape' && !document.getElementById('preview-overlay').classList.contains('hidden'))
2014 {
2015 closePreview();
2016 }
2017 });
2018
2019 // Close modals on backdrop click
2020 document.querySelectorAll('.modal-overlay').forEach(overlay =>
2021 {
2022 overlay.addEventListener('click', e =>
2023 {
2024 if (e.target === overlay) overlay.classList.add('hidden');
2025 });
2026 });
2027}
2028
2029// ───────────────────────────────────────────────────────────────────────────
2030// BOOT
2031// ───────────────────────────────────────────────────────────────────────────
2032
2033(async function boot ()
2034{
2035 wireEvents();
2036 initDragDrop();
2037 window.addEventListener('beforeunload', saveSessionState);
2038 await initAuth();
2039})();