BlueGit

timfa filemanager

Files

filemanager / public / app.js

app.js

app.js 85.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
47 // Preview overlay state
48 previewObjectUrl: null,
49 previewSourceEl: null, // SVG element that triggered the preview
50 previewClosing: false, // guard to prevent double-close during animation
51};
52
53const SESSION_KEY = 'filemanager.session.v1';
54const SESSION_IDLE_TIMEOUT_MS = 60 * 60 * 1000; // 1 hour
55const CLIENT_BINDING_KEY = 'filemanager.client-binding-id.v1';
56
57// ───────────────────────────────────────────────────────────────────────────
58// CRYPTO HELPERS (Web Crypto API)
59// ───────────────────────────────────────────────────────────────────────────
60
61async function generateClientKeyPair ()
62{
63 if (!hasWebCrypto()) return;
64 const kp = await crypto.subtle.generateKey(
65 { name: 'RSA-OAEP', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' },
66 true,
67 ['encrypt', 'decrypt'],
68 );
69 STATE.clientPrivateKey = kp.privateKey;
70 STATE.clientPublicKeyJwk = await crypto.subtle.exportKey('jwk', kp.publicKey);
71}
72
73/**
74 * Hybrid-encrypt a JS object using the server's RSA public key.
75 * Returns { encryptedKey, iv, ciphertext, tag } all as base64 strings.
76 */
77async function hybridEncryptForServer (obj)
78{
79 if (!hasWebCrypto() || !STATE.serverPublicKeyJwk)
80 {
81 return { plaintext: obj };
82 }
83
84 const serverPub = await crypto.subtle.importKey(
85 'jwk', STATE.serverPublicKeyJwk,
86 { name: 'RSA-OAEP', hash: 'SHA-256' },
87 false, ['encrypt'],
88 );
89
90 const plaintext = new TextEncoder().encode(JSON.stringify(obj));
91 const aesKey = await crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt']);
92 const iv = crypto.getRandomValues(new Uint8Array(12));
93 const gcmResult = await crypto.subtle.encrypt({ name: 'AES-GCM', iv }, aesKey, plaintext);
94
95 // gcmResult = ciphertext || tag (last 16 bytes are auth tag)
96 const gcmBytes = new Uint8Array(gcmResult);
97 const ciphertext = gcmBytes.slice(0, gcmBytes.length - 16);
98 const tag = gcmBytes.slice(gcmBytes.length - 16);
99
100 const rawAes = await crypto.subtle.exportKey('raw', aesKey);
101 const encryptedKey = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, serverPub, rawAes);
102
103 return {
104 encryptedKey: b64(encryptedKey),
105 iv: b64(iv),
106 ciphertext: b64(ciphertext),
107 tag: b64(tag),
108 };
109}
110
111/**
112 * Hybrid-decrypt a payload encrypted by the server for us (using our public key).
113 */
114async function hybridDecryptFromServer (payload)
115{
116 if (!payload) return null;
117 if (payload.token) return payload.token;
118 if (!hasWebCrypto()) return null;
119
120 const encryptedKey = unb64(payload.encryptedKey);
121 const iv = unb64(payload.iv);
122 const ciphertext = unb64(payload.ciphertext);
123 const tag = unb64(payload.tag);
124
125 const rawAes = await crypto.subtle.decrypt(
126 { name: 'RSA-OAEP' }, STATE.clientPrivateKey, encryptedKey,
127 );
128
129 const aesKey = await crypto.subtle.importKey('raw', rawAes, { name: 'AES-GCM' }, false, ['decrypt']);
130
131 // Recombine ciphertext + tag for AES-GCM
132 const combined = new Uint8Array(ciphertext.byteLength + tag.byteLength);
133 combined.set(new Uint8Array(ciphertext));
134 combined.set(new Uint8Array(tag), ciphertext.byteLength);
135
136 const plain = await crypto.subtle.decrypt({ name: 'AES-GCM', iv }, aesKey, combined);
137 return new TextDecoder().decode(plain);
138}
139
140// ───────────────────────────────────────────────────────────────────────────
141// UTIL
142// ───────────────────────────────────────────────────────────────────────────
143
144function b64 (buf)
145{
146 return btoa(String.fromCharCode(...new Uint8Array(buf instanceof ArrayBuffer ? buf : buf.buffer)));
147}
148
149function hasWebCrypto ()
150{
151 return !!(window.crypto && window.crypto.subtle);
152}
153
154function unb64 (str)
155{
156 const binary = atob(str);
157 const buf = new Uint8Array(binary.length);
158 for (let i = 0; i < binary.length; i++) buf[i] = binary.charCodeAt(i);
159 return buf.buffer;
160}
161
162/** Stable browser fingerprint (not stored, derived fresh each load) */
163function getFingerprint ()
164{
165 const binding = getOrCreateClientBindingId();
166 const nav = navigator;
167
168 // Keep this stable: avoid viewport/screen metrics that can change when
169 // devtools opens, orientation changes, or window state changes.
170 return [
171 binding,
172 nav.userAgent || '',
173 nav.language,
174 nav.platform || nav.userAgentData?.platform || '',
175 Intl.DateTimeFormat().resolvedOptions().timeZone,
176 ].join('|');
177}
178
179function randomIdHex (bytes = 16)
180{
181 const arr = new Uint8Array(bytes);
182 if (window.crypto && typeof window.crypto.getRandomValues === 'function')
183 {
184 window.crypto.getRandomValues(arr);
185 } else
186 {
187 for (let i = 0; i < arr.length; i++) arr[i] = Math.floor(Math.random() * 256);
188 }
189 return Array.from(arr).map(n => n.toString(16).padStart(2, '0')).join('');
190}
191
192function getOrCreateClientBindingId ()
193{
194 if (STATE.clientBindingId) return STATE.clientBindingId;
195
196 try
197 {
198 const existing = localStorage.getItem(CLIENT_BINDING_KEY);
199 if (existing && typeof existing === 'string')
200 {
201 STATE.clientBindingId = existing;
202 return existing;
203 }
204 } catch
205 {
206 // Ignore storage read errors.
207 }
208
209 const created = randomIdHex(16);
210 STATE.clientBindingId = created;
211
212 try
213 {
214 localStorage.setItem(CLIENT_BINDING_KEY, created);
215 } catch
216 {
217 // Ignore storage write errors; in-memory fallback still keeps this stable
218 // for the current page session.
219 }
220
221 return created;
222}
223
224function formatBytes (bytes)
225{
226 if (bytes == null) return '—';
227 if (bytes < 1024) return bytes + ' B';
228 if (bytes < 1048576) return (bytes / 1024).toFixed(1) + ' KB';
229 if (bytes < 1073741824) return (bytes / 1048576).toFixed(1) + ' MB';
230 return (bytes / 1073741824).toFixed(2) + ' GB';
231}
232
233function extOf (name)
234{
235 const i = name.lastIndexOf('.');
236 return i >= 0 ? name.slice(i + 1).toLowerCase() : '';
237}
238
239function getPathSep (basePath)
240{
241 return basePath && basePath.includes('\\') ? '\\' : '/';
242}
243
244function joinServerPath (basePath, segment)
245{
246 const sep = getPathSep(basePath);
247 const base = String(basePath || '').replace(/[\\/]+$/, '');
248 return base + sep + segment;
249}
250
251function samePath (a, b)
252{
253 if (!a || !b) return false;
254 return String(a).toLowerCase() === String(b).toLowerCase();
255}
256
257function pathInside (child, root)
258{
259 if (!child || !root) return false;
260 if (samePath(child, root)) return true;
261 const sep = getPathSep(root);
262 return String(child).toLowerCase().startsWith((String(root) + sep).toLowerCase());
263}
264
265function saveSessionState ()
266{
267 if (!STATE.token) return;
268 const now = Date.now();
269 STATE.lastOperationAt = now;
270 const payload = {
271 token: STATE.token,
272 dir: STATE.currentDir || null,
273 rootPath: STATE.currentRoot ? STATE.currentRoot.path : null,
274 lastOperationAt: STATE.lastOperationAt,
275 };
276 try
277 {
278 localStorage.setItem(SESSION_KEY, JSON.stringify(payload));
279 } catch
280 {
281 // Ignore storage errors (private mode/full quota).
282 }
283}
284
285function loadSessionState ()
286{
287 try
288 {
289 const raw = localStorage.getItem(SESSION_KEY);
290 if (!raw) return null;
291 const parsed = JSON.parse(raw);
292 if (!parsed || typeof parsed.token !== 'string') return null;
293 if (!Number.isFinite(parsed.lastOperationAt)) return null;
294
295 if (Date.now() - parsed.lastOperationAt > SESSION_IDLE_TIMEOUT_MS)
296 {
297 clearSessionState();
298 return null;
299 }
300
301 return parsed;
302 } catch
303 {
304 return null;
305 }
306}
307
308function clearSessionState ()
309{
310 try { localStorage.removeItem(SESSION_KEY); } catch { /* ignore */ }
311}
312
313// ───────────────────────────────────────────────────────────────────────────
314// API
315// ───────────────────────────────────────────────────────────────────────────
316
317async function api (method, path, body, opts = {})
318{
319 const headers = { 'Content-Type': 'application/json' };
320 const noAutoLogout = !!opts.noAutoLogout;
321 if (STATE.token)
322 {
323 headers['Authorization'] = 'Bearer ' + STATE.token;
324 headers['X-Fp'] = getFingerprint();
325 }
326 const fetchOpts = { ...opts };
327 delete fetchOpts.noAutoLogout;
328 const res = await fetch('/api' + path, {
329 method,
330 headers,
331 body: body != null ? JSON.stringify(body) : undefined,
332 ...fetchOpts,
333 });
334 if (!res.ok)
335 {
336 const j = await res.json().catch(() => ({}));
337 // Session-expired → force re-login
338 if (res.status === 401)
339 {
340 if (!noAutoLogout) logout();
341 return null;
342 }
343 throw new Error(j.error || res.statusText);
344 }
345 if (STATE.token && !path.startsWith('/auth/server-key') && !path.startsWith('/auth/setup-needed'))
346 {
347 saveSessionState();
348 }
349 return res.json();
350}
351
352// ───────────────────────────────────────────────────────────────────────────
353// TOAST
354// ───────────────────────────────────────────────────────────────────────────
355
356function toast (msg, type = '')
357{
358 const el = document.createElement('div');
359 el.className = 'toast-msg' + (type ? ' ' + type : '');
360 el.textContent = msg;
361 document.getElementById('toast').appendChild(el);
362 setTimeout(() => el.remove(), 3500);
363}
364
365// ───────────────────────────────────────────────────────────────────────────
366// DIALOG MODALS — centralised replacements for alert / confirm / prompt
367// ───────────────────────────────────────────────────────────────────────────
368
369/**
370 * Show a confirmation dialog.
371 * @param {string} title
372 * @param {string} message
373 * @returns {Promise<boolean>} true = OK, false = Cancel
374 */
375function showConfirm (title, message)
376{
377 return new Promise((resolve) =>
378 {
379 const overlay = document.getElementById('confirm-modal');
380 document.getElementById('confirm-modal-title').textContent = title;
381 document.getElementById('confirm-modal-message').textContent = message;
382 overlay.classList.remove('hidden');
383
384 const ok = document.getElementById('confirm-modal-ok');
385 const cancel = document.getElementById('confirm-modal-cancel');
386
387 function finish (result)
388 {
389 overlay.classList.add('hidden');
390 ok.removeEventListener('click', onOk);
391 cancel.removeEventListener('click', onCancel);
392 resolve(result);
393 }
394 function onOk () { finish(true); }
395 function onCancel () { finish(false); }
396
397 ok.addEventListener('click', onOk);
398 cancel.addEventListener('click', onCancel);
399 ok.focus();
400 });
401}
402
403/**
404 * Show a text-input dialog.
405 * @param {string} title
406 * @param {string} [message] — optional helper text shown above the input
407 * @param {string} [defaultValue] — pre-filled value
408 * @returns {Promise<string|null>} string = submitted value, null = cancelled
409 */
410function showPrompt (title, message = '', defaultValue = '')
411{
412 return new Promise((resolve) =>
413 {
414 const overlay = document.getElementById('prompt-modal');
415 const msgEl = document.getElementById('prompt-modal-message');
416 const input = document.getElementById('prompt-modal-input');
417 const errorEl = document.getElementById('prompt-modal-error');
418 const form = document.getElementById('prompt-modal-form');
419 const cancel = document.getElementById('prompt-modal-cancel');
420
421 document.getElementById('prompt-modal-title').textContent = title;
422 msgEl.textContent = message;
423 msgEl.classList.toggle('hidden', !message);
424 input.value = defaultValue;
425 errorEl.classList.add('hidden');
426 overlay.classList.remove('hidden');
427 input.focus();
428 input.select();
429
430 function finish (result)
431 {
432 overlay.classList.add('hidden');
433 form.removeEventListener('submit', onSubmit);
434 cancel.removeEventListener('click', onCancel);
435 resolve(result);
436 }
437 function onSubmit (e)
438 {
439 e.preventDefault();
440 finish(input.value);
441 }
442 function onCancel () { finish(null); }
443
444 form.addEventListener('submit', onSubmit);
445 cancel.addEventListener('click', onCancel);
446 });
447}
448
449/**
450 * Show an overwrite-decision dialog for a single file conflict.
451 * @param {string} filename
452 * @returns {Promise<'yes'|'no'|'all'|'none'>}
453 */
454function showOverwrite (filename)
455{
456 return new Promise((resolve) =>
457 {
458 const overlay = document.getElementById('overwrite-modal');
459 document.getElementById('overwrite-modal-filename').textContent = filename;
460 overlay.classList.remove('hidden');
461
462 const btnYes = document.getElementById('overwrite-modal-yes');
463 const btnNo = document.getElementById('overwrite-modal-no');
464 const btnAll = document.getElementById('overwrite-modal-all');
465 const btnSkipAll = document.getElementById('overwrite-modal-skip-all');
466
467 function finish (result)
468 {
469 overlay.classList.add('hidden');
470 btnYes.removeEventListener('click', onYes);
471 btnNo.removeEventListener('click', onNo);
472 btnAll.removeEventListener('click', onAll);
473 btnSkipAll.removeEventListener('click', onSkipAll);
474 resolve(result);
475 }
476 function onYes () { finish('yes'); }
477 function onNo () { finish('no'); }
478 function onAll () { finish('all'); }
479 function onSkipAll () { finish('none'); }
480
481 btnYes.addEventListener('click', onYes);
482 btnNo.addEventListener('click', onNo);
483 btnAll.addEventListener('click', onAll);
484 btnSkipAll.addEventListener('click', onSkipAll);
485 btnNo.focus();
486 });
487}
488
489// ───────────────────────────────────────────────────────────────────────────
490// AUTH FLOW
491// ───────────────────────────────────────────────────────────────────────────
492
493function showAuthOverlay (setupMode = false)
494{
495 document.getElementById('app').classList.add('hidden');
496 const overlay = document.getElementById('auth-overlay');
497 overlay.classList.remove('hidden');
498 document.getElementById('auth-title').textContent = setupMode ? 'Create Admin Account' : 'Sign In';
499 document.getElementById('auth-subtitle').classList.toggle('hidden', !setupMode);
500 const submitBtn = document.getElementById('auth-submit');
501 submitBtn.disabled = false;
502 submitBtn.textContent = setupMode ? 'Create Account' : 'Sign In';
503 document.getElementById('auth-error').classList.add('hidden');
504 document.getElementById('auth-username').value = '';
505 document.getElementById('auth-password').value = '';
506 document.getElementById('auth-username').focus();
507 document.getElementById('auth-form').dataset.mode = setupMode ? 'setup' : 'login';
508}
509
510function showApp ()
511{
512 document.getElementById('auth-overlay').classList.add('hidden');
513 document.getElementById('app').classList.remove('hidden');
514 document.getElementById('app').classList.add('sidebar-open');
515 document.getElementById('sidebar').classList.remove('hidden');
516 document.getElementById('btn-admin').classList.toggle('hidden', !STATE.isAdmin);
517 startAutoRefresh();
518}
519
520async function initAuth ()
521{
522 // Always generate a fresh key pair so each page-load session is independent
523 await generateClientKeyPair().catch(() =>
524 {
525 toast('Secure crypto unavailable in this browser context; using compatibility login mode.', 'err');
526 });
527
528 // Fetch server public key
529 const { publicKey } = await api('GET', '/auth/server-key').catch(() => ({ publicKey: null }));
530 if (publicKey) STATE.serverPublicKeyJwk = publicKey;
531 if (!publicKey && hasWebCrypto()) { toast('Could not reach server.', 'err'); return; }
532 STATE.serverPublicKeyJwk = publicKey;
533
534 // Check whether first-run setup is needed
535 const { needed } = await api('GET', '/auth/setup-needed').catch(() => ({ needed: false }));
536
537 if (!needed)
538 {
539 const saved = loadSessionState();
540 if (saved && saved.token)
541 {
542 STATE.token = saved.token;
543 STATE.restoreDir = saved.dir || null;
544 STATE.restoreRootPath = saved.rootPath || null;
545 STATE.lastOperationAt = saved.lastOperationAt;
546
547 const me = await api('GET', '/auth/me', null, { noAutoLogout: true }).catch(() => null);
548 if (me)
549 {
550 STATE.username = me.username;
551 STATE.isAdmin = me.isAdmin;
552 STATE.permissions = me.permissions;
553 showApp();
554 await loadRoots({
555 preferredDir: STATE.restoreDir,
556 preferredRootPath: STATE.restoreRootPath,
557 });
558 return;
559 }
560
561 STATE.token = null;
562 clearSessionState();
563 }
564 }
565
566 showAuthOverlay(needed);
567}
568
569async function doLogin (username, password, isSetup)
570{
571 const encrypted = await hybridEncryptForServer({ username, password });
572 const endpoint = isSetup ? '/auth/setup' : '/auth/login';
573
574 let data;
575 try
576 {
577 data = await api('POST', endpoint, {
578 encrypted,
579 clientPublicKey: STATE.clientPublicKeyJwk,
580 fingerprint: getFingerprint(),
581 });
582 } catch (err)
583 {
584 return err.message;
585 }
586
587 if (!data) return 'Login failed.';
588
589 // Decrypt the token sent back by the server
590 const token = await hybridDecryptFromServer(data.encrypted || data);
591 if (!token) return 'Login failed.';
592 STATE.token = token;
593
594 // Load user info
595 const me = await api('GET', '/auth/me');
596 if (!me) return 'Session error.';
597
598 STATE.username = me.username;
599 STATE.isAdmin = me.isAdmin;
600 STATE.permissions = me.permissions;
601
602 saveSessionState();
603 showApp();
604 await loadRoots();
605 return null; // no error
606}
607
608function logout ()
609{
610 void performLogout();
611}
612
613async function performLogout ()
614{
615 const tokenAtStart = STATE.token;
616 stopAutoRefresh();
617
618 if (tokenAtStart)
619 {
620 try
621 {
622 await api('POST', '/auth/logout', {}, { noAutoLogout: true });
623 } catch
624 {
625 // Ignore network errors while logging out locally.
626 }
627 }
628
629 STATE.token = null;
630 STATE.username = null;
631 STATE.isAdmin = false;
632 STATE.permissions = {};
633 STATE.currentDir = null;
634 STATE.currentRoot = null;
635 STATE.items = [];
636 STATE.restoreDir = null;
637 STATE.restoreRootPath = null;
638 STATE.lastOperationAt = null;
639 clearSessionState();
640 closePreview();
641 closeSidebar();
642 await initAuth();
643}
644
645// ───────────────────────────────────────────────────────────────────────────
646// NAVIGATION
647// ───────────────────────────────────────────────────────────────────────────
648
649async function loadRoots (opts = {})
650{
651 const data = await api('GET', '/files/roots');
652 if (!data) return;
653 STATE.roots = data.roots;
654
655 const preferredDir = opts.preferredDir || null;
656 const preferredRootPath = opts.preferredRootPath || null;
657
658 if (preferredDir && preferredRootPath)
659 {
660 const preferredRoot = STATE.roots.find(r => samePath(r.path, preferredRootPath));
661 if (preferredRoot && pathInside(preferredDir, preferredRoot.path))
662 {
663 try
664 {
665 await navigateTo(preferredDir, preferredRoot, { keepSidebar: true });
666 return;
667 } catch
668 {
669 // Fall back to default root behavior.
670 }
671 }
672 }
673
674 if (STATE.roots.length === 1)
675 {
676 // Single root → open it directly
677 await navigateTo(STATE.roots[0].path, STATE.roots[0]);
678 } else
679 {
680 renderRootsView();
681 }
682}
683
684function renderRootsView ()
685{
686 STATE.currentDir = null;
687 STATE.currentRoot = null;
688 saveSessionState();
689 renderBreadcrumb();
690 const grid = document.getElementById('file-grid');
691 grid.innerHTML = '';
692 document.getElementById('empty-notice').classList.add('hidden');
693 document.getElementById('folder-stats').classList.add('hidden');
694 closeSidebar();
695
696 for (const root of STATE.roots)
697 {
698 const el = makeFileItem({ name: root.label, isDir: true, path: root.path, _root: root });
699 grid.appendChild(el);
700 }
701}
702
703async function navigateTo (absPath, root, opts = {})
704{
705 if (root) STATE.currentRoot = root;
706 STATE.currentDir = absPath;
707
708 const data = await api('GET', `/files/list?dir=${encodeURIComponent(absPath)}`);
709 if (!data) return;
710
711 STATE.items = data.items;
712 saveSessionState();
713 renderBreadcrumb();
714 renderFileGrid();
715 await refreshFolderStats();
716 closeSidebar();
717}
718
719function renderBreadcrumb ()
720{
721 const nav = document.getElementById('breadcrumb');
722 nav.innerHTML = '';
723
724 // "Home" crumb
725 const home = document.createElement('span');
726 home.className = 'crumb' + (STATE.currentDir == null ? ' active' : '');
727 home.textContent = 'Home';
728 home.addEventListener('click', () =>
729 {
730 if (STATE.roots.length === 1)
731 {
732 navigateTo(STATE.roots[0].path, STATE.roots[0]);
733 } else
734 {
735 renderRootsView();
736 }
737 });
738 nav.appendChild(home);
739
740 if (!STATE.currentDir || !STATE.currentRoot) return;
741
742 // Build path segments relative to the root
743 const rootPath = STATE.currentRoot.path;
744 const relative = STATE.currentDir === rootPath
745 ? ''
746 : STATE.currentDir.replace(rootPath, '').replace(/^[\\/]/, '');
747
748 const parts = [STATE.currentRoot.label, ...relative.split(/[\\/]/).filter(Boolean)];
749 let accumulated = rootPath;
750
751 for (let i = 0; i < parts.length; i++)
752 {
753 const sep = document.createElement('span');
754 sep.className = 'sep';
755 sep.textContent = ' / ';
756 nav.appendChild(sep);
757
758 const crumb = document.createElement('span');
759 crumb.className = 'crumb' + (i === parts.length - 1 ? ' active' : '');
760 crumb.textContent = parts[i];
761
762 // Capture the path for this crumb
763 const capturedPath = i === 0 ? rootPath : accumulated;
764 if (i < parts.length - 1)
765 {
766 crumb.addEventListener('click', () => navigateTo(capturedPath, STATE.currentRoot));
767 }
768
769 nav.appendChild(crumb);
770
771 // Advance accumulated path (skip for root label)
772 if (i > 0) accumulated = accumulated + '/' + parts[i];
773 else if (i === 0 && parts.length > 1)
774 {
775 // After root label, next crumb should append the next segment
776 accumulated = rootPath;
777 }
778 }
779}
780
781async function refreshFolderStats ()
782{
783 const el = document.getElementById('folder-stats');
784 if (!STATE.currentDir)
785 {
786 el.classList.add('hidden');
787 return;
788 }
789
790 const data = await api('GET', `/files/space?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
791 if (!data)
792 {
793 el.classList.add('hidden');
794 return;
795 }
796
797 const used = formatBytes(data.usedBytes);
798 const free = data.freeBytes == null ? 'unknown' : formatBytes(data.freeBytes);
799 el.textContent = `Folder usage: ${used} | Free on disk: ${free}`;
800 el.classList.remove('hidden');
801}
802
803function itemsSignature (items)
804{
805 return JSON.stringify(
806 (items || []).map(it => [it.path, it.mtime, it.size, it.isDir])
807 .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
808 );
809}
810
811async function incrementalRefreshCurrentDir ()
812{
813 if (!STATE.currentDir || STATE.uploadInProgress) return;
814
815 const data = await api('GET', `/files/list?dir=${encodeURIComponent(STATE.currentDir)}`).catch(() => null);
816 if (!data) return;
817
818 const oldSig = itemsSignature(STATE.items);
819 const newSig = itemsSignature(data.items);
820 if (oldSig !== newSig)
821 {
822 const selectedPath = STATE.selectedItem ? STATE.selectedItem.path : null;
823 STATE.items = data.items;
824 renderFileGrid();
825
826 if (selectedPath)
827 {
828 const match = STATE.items.find(i => i.path === selectedPath);
829 if (match)
830 {
831 const selectedEl = Array.from(document.querySelectorAll('.file-item'))
832 .find(el => el.dataset.path === selectedPath);
833 if (selectedEl) selectItem(selectedEl, match);
834 } else
835 {
836 closeSidebar();
837 }
838 }
839 }
840
841 await refreshFolderStats();
842}
843
844function startAutoRefresh ()
845{
846 stopAutoRefresh();
847 STATE.autoRefreshTimer = setInterval(() =>
848 {
849 if (document.hidden) return;
850 incrementalRefreshCurrentDir();
851 }, 5000);
852}
853
854function stopAutoRefresh ()
855{
856 if (STATE.autoRefreshTimer)
857 {
858 clearInterval(STATE.autoRefreshTimer);
859 STATE.autoRefreshTimer = null;
860 }
861}
862
863// ───────────────────────────────────────────────────────────────────────────
864// FILE GRID RENDERING
865// ───────────────────────────────────────────────────────────────────────────
866
867function renderFileGrid ()
868{
869 revokeThumbnails();
870 const grid = document.getElementById('file-grid');
871 grid.innerHTML = '';
872 const empty = document.getElementById('empty-notice');
873
874 const sorted = [...STATE.items].sort((a, b) =>
875 {
876 if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
877 return a.name.localeCompare(b.name);
878 });
879
880 empty.classList.toggle('hidden', sorted.length > 0);
881
882 for (const item of sorted)
883 {
884 grid.appendChild(makeFileItem(item));
885 }
886
887 loadThumbnails();
888}
889
890function makeFileItem (item)
891{
892 const el = document.createElement('div');
893 el.className = 'file-item';
894 el.dataset.path = item.path;
895 if (item.isDir) el.dataset.isdir = '1';
896
897 const icon = document.createElement('div');
898 icon.className = 'icon';
899 icon.innerHTML = item.isDir ? iconFolder() : iconFile(item.name);
900 if (!item.isDir)
901 {
902 icon.dataset.previewPath = item.path;
903 }
904 el.appendChild(icon);
905
906 const name = document.createElement('div');
907 name.className = 'name';
908 name.textContent = item.name;
909 el.appendChild(name);
910
911 makeDraggable(el, item);
912
913 // Single-click: open sidebar
914 el.addEventListener('click', (e) =>
915 {
916 e.stopPropagation();
917 if (item._root)
918 {
919 // Clicking a root tile goes straight in
920 navigateTo(item.path, item._root);
921 return;
922 }
923 selectItem(el, item);
924 });
925
926 // Double-click: enter folder or view/download file
927 el.addEventListener('dblclick', (e) =>
928 {
929 e.stopPropagation();
930 if (item.isDir)
931 {
932 navigateTo(item.path, STATE.currentRoot);
933 } else
934 {
935 downloadOrView(item, icon.querySelector('svg'));
936 }
937 });
938
939 return el;
940}
941
942function selectItem (el, item)
943{
944 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
945 el.classList.add('selected');
946 STATE.selectedItem = item;
947 openSidebar(item);
948}
949
950// ───────────────────────────────────────────────────────────────────────────
951// SIDEBAR
952// ───────────────────────────────────────────────────────────────────────────
953
954async function openSidebar (item)
955{
956 const sidebar = document.getElementById('sidebar');
957 sidebar.classList.remove('hidden');
958 document.getElementById('app').classList.add('sidebar-open');
959
960 document.getElementById('sidebar-icon').innerHTML = item.isDir ? iconFolder(64) : iconFile(item.name, 64);
961 document.getElementById('sidebar-name').textContent = item.name;
962
963 // Load metadata
964 const dl = document.getElementById('sidebar-meta');
965 dl.innerHTML = '<dt>Loading…</dt><dd></dd>';
966
967 const actions = document.getElementById('sidebar-actions');
968 actions.innerHTML = '';
969
970 if (!item.isDir)
971 {
972 const meta = await api('GET', `/files/meta?file=${encodeURIComponent(item.path)}`);
973 if (meta)
974 {
975 dl.innerHTML = `
976 <dt>Size</dt> <dd>${formatBytes(meta.size)}</dd>
977 <dt>Modified</dt> <dd>${new Date(meta.mtime).toLocaleString()}</dd>
978 <dt>Uploaded by</dt><dd>${meta.uploader || '—'}</dd>
979 <dt>Downloaded by</dt><dd>${meta.downloaders.join(', ') || '—'}</dd>
980 `;
981 }
982
983 // View / download button
984 const btnDl = document.createElement('button');
985 btnDl.textContent = 'View / Download';
986 btnDl.addEventListener('click', () =>
987 {
988 const tile = Array.from(document.querySelectorAll('.file-item')).find(node => node.dataset.path === item.path);
989 const source = (tile ? tile.querySelector('.icon svg') : null) || document.querySelector('#sidebar-icon svg');
990 downloadOrView(item, source);
991 });
992 actions.appendChild(btnDl);
993 } else
994 {
995 dl.innerHTML = `<dt>Type</dt><dd>Folder</dd>`;
996 const btnOpen = document.createElement('button');
997 btnOpen.textContent = 'Open folder';
998 btnOpen.addEventListener('click', () => navigateTo(item.path, STATE.currentRoot));
999 actions.appendChild(btnOpen);
1000 }
1001
1002 // Rename button (write access required)
1003 if (canWrite())
1004 {
1005 const btnRen = document.createElement('button');
1006 btnRen.textContent = 'Rename';
1007 btnRen.addEventListener('click', () => openRenameModal(item));
1008 actions.appendChild(btnRen);
1009
1010 const btnDel = document.createElement('button');
1011 btnDel.textContent = 'Delete';
1012 btnDel.className = 'danger';
1013 btnDel.addEventListener('click', () => deleteItem(item));
1014 actions.appendChild(btnDel);
1015 }
1016}
1017
1018function openFolderSidebar ()
1019{
1020 const sidebar = document.getElementById('sidebar');
1021 sidebar.classList.remove('hidden');
1022 document.getElementById('app').classList.add('sidebar-open');
1023
1024 document.getElementById('sidebar-icon').innerHTML = iconFolder(64);
1025
1026 const nameEl = document.getElementById('sidebar-name');
1027 const dl = document.getElementById('sidebar-meta');
1028 const actions = document.getElementById('sidebar-actions');
1029 actions.innerHTML = '';
1030
1031 if (!STATE.currentDir || !STATE.currentRoot)
1032 {
1033 nameEl.textContent = 'Storage Roots';
1034 dl.innerHTML = `
1035 <dt>Type</dt><dd>Root overview</dd>
1036 <dt>Roots</dt><dd>${STATE.roots.length}</dd>
1037 `;
1038 return;
1039 }
1040
1041 const parts = String(STATE.currentDir).split(/[\\/]/).filter(Boolean);
1042 const fallback = STATE.currentRoot.label || 'Folder';
1043 nameEl.textContent = parts.length ? parts[parts.length - 1] : fallback;
1044
1045 const dirs = STATE.items.filter(i => i.isDir).length;
1046 const files = STATE.items.length - dirs;
1047 dl.innerHTML = `
1048 <dt>Path</dt><dd>${STATE.currentDir}</dd>
1049 <dt>Folders</dt><dd>${dirs}</dd>
1050 <dt>Files</dt><dd>${files}</dd>
1051 `;
1052}
1053
1054function closeSidebar ()
1055{
1056 document.querySelectorAll('.file-item.selected').forEach(e => e.classList.remove('selected'));
1057 STATE.selectedItem = null;
1058 openFolderSidebar();
1059}
1060
1061// ───────────────────────────────────────────────────────────────────────────
1062// DOWNLOAD / VIEW
1063// ───────────────────────────────────────────────────────────────────────────
1064
1065function isInlinePreviewableBlob (blob, name)
1066{
1067 const mime = String(blob.type || '').toLowerCase();
1068 if (/^(image|video|audio)\//.test(mime)) return true;
1069 if (/^text\//.test(mime)) return true;
1070 if (mime === 'application/pdf') return true;
1071 if (mime === 'application/json') return true;
1072 if (mime === 'application/xml') return true;
1073 if (mime === 'application/javascript') return true;
1074
1075 // Fallback by extension when MIME is missing or generic.
1076 const ext = extOf(name || '');
1077 if (IMAGE_EXTS.has(ext) || VIDEO_EXTS.has(ext) || AUDIO_EXTS.has(ext)) return true;
1078 if (CODE_EXTS.has(ext)) return true;
1079 return false;
1080}
1081
1082function isTextLikeBlob (blob, name)
1083{
1084 const mime = String(blob.type || '').toLowerCase();
1085 if (/^text\//.test(mime)) return true;
1086 if (mime === 'application/json' || mime === 'application/xml' || mime === 'application/javascript') return true;
1087 const ext = extOf(name || '');
1088 return CODE_EXTS.has(ext);
1089}
1090
1091function detectCodeLanguage (name, mime)
1092{
1093 const ext = extOf(name || '');
1094 const m = String(mime || '').toLowerCase();
1095 if (m.includes('json') || ext === 'json') return 'json';
1096 if (m.includes('xml') || ext === 'xml') return 'xml';
1097 if (m.includes('html') || ext === 'html' || ext === 'htm') return 'html';
1098 if (m.includes('css') || ext === 'css') return 'css';
1099 if (m.includes('javascript') || ['js', 'jsx', 'mjs', 'cjs'].includes(ext)) return 'js';
1100 if (m.includes('typescript') || ['ts', 'tsx'].includes(ext)) return 'ts';
1101 if (['sh', 'bash', 'zsh'].includes(ext)) return 'sh';
1102 if (['md', 'txt', 'log', 'ini', 'toml', 'yaml', 'yml'].includes(ext)) return 'plain';
1103 return CODE_EXTS.has(ext) ? 'js' : 'plain';
1104}
1105
1106function prettyPrintMarkup (raw)
1107{
1108 const src = String(raw || '')
1109 .replace(/>\s+</g, '><')
1110 .replace(/\r\n/g, '\n');
1111
1112 const lines = src.replace(/></g, '>\n<').split('\n');
1113 let indent = 0;
1114 const out = [];
1115
1116 for (const ln of lines)
1117 {
1118 const line = ln.trim();
1119 if (!line) continue;
1120 const isClose = /^<\//.test(line);
1121 const isSelf = /\/>$/.test(line) || /^<[^!?][^>]*>[^<]*<\/[^>]+>$/.test(line);
1122 const isOpen = /^<[^!?/][^>]*>$/.test(line);
1123
1124 if (isClose) indent = Math.max(0, indent - 1);
1125 out.push(' '.repeat(indent) + line);
1126 if (isOpen && !isSelf) indent += 1;
1127 }
1128
1129 return out.join('\n');
1130}
1131
1132function prettyPrintBraces (raw)
1133{
1134 const lines = String(raw || '')
1135 .replace(/\r\n/g, '\n')
1136 .split('\n');
1137 let indent = 0;
1138 const out = [];
1139
1140 for (const ln of lines)
1141 {
1142 const line = ln.trim();
1143 if (!line)
1144 {
1145 out.push('');
1146 continue;
1147 }
1148 if (/^[}\])]/.test(line)) indent = Math.max(0, indent - 1);
1149 out.push(' '.repeat(indent) + line);
1150 if (/[{[(]$/.test(line) || /[{[(]\s*(\/\/.*)?$/.test(line)) indent += 1;
1151 }
1152 return out.join('\n');
1153}
1154
1155function prettyPrintCode (raw, lang)
1156{
1157 const text = String(raw || '').replace(/\r\n/g, '\n');
1158 if (lang === 'json')
1159 {
1160 try { return JSON.stringify(JSON.parse(text), null, 2); } catch { return text; }
1161 }
1162 if (lang === 'xml' || lang === 'html') return prettyPrintMarkup(text);
1163 if (lang === 'js' || lang === 'ts' || lang === 'css') return prettyPrintBraces(text);
1164 return text;
1165}
1166
1167function escapeHtml (s)
1168{
1169 return String(s)
1170 .replace(/&/g, '&amp;')
1171 .replace(/</g, '&lt;')
1172 .replace(/>/g, '&gt;');
1173}
1174
1175function highlightCode (raw, lang)
1176{
1177 if (lang === 'plain') return escapeHtml(raw);
1178
1179 let html = escapeHtml(raw);
1180 const stash = [];
1181 const keep = (regex, cls) =>
1182 {
1183 html = html.replace(regex, (m) =>
1184 {
1185 const idx = stash.push(`<span class="tok-${cls}">${m}</span>`) - 1;
1186 return `@@TOK${idx}@@`;
1187 });
1188 };
1189
1190 if (lang === 'json')
1191 {
1192 html = html
1193 .replace(/("(?:\\.|[^"\\])*")\s*:/g, '<span class="tok-key">$1</span>:')
1194 .replace(/: ("(?:\\.|[^"\\])*")/g, ': <span class="tok-string">$1</span>')
1195 .replace(/\b(true|false|null)\b/g, '<span class="tok-keyword">$1</span>')
1196 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
1197 return html;
1198 }
1199
1200 if (lang === 'xml' || lang === 'html')
1201 {
1202 html = html
1203 .replace(/(&lt;\/?)([a-zA-Z0-9:_-]+)/g, '$1<span class="tok-keyword">$2</span>')
1204 .replace(/([a-zA-Z0-9:_-]+)=(&quot;[^&]*&quot;|"[^"]*")/g, '<span class="tok-key">$1</span>=<span class="tok-string">$2</span>');
1205 return html;
1206 }
1207
1208 if (lang === 'sh') keep(/(^|\s)#.*$/gm, 'comment');
1209 else keep(/\/\*[\s\S]*?\*\/|\/\/[^\n]*/g, 'comment');
1210 keep(/"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`/g, 'string');
1211
1212 html = html
1213 .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>')
1214 .replace(/\b(-?\d+(?:\.\d+)?(?:e[+\-]?\d+)?)\b/gi, '<span class="tok-number">$1</span>');
1215
1216 html = html.replace(/@@TOK(\d+)@@/g, (_, idx) => stash[Number(idx)] || '');
1217 return html;
1218}
1219
1220function clearPreviewObjectUrl ()
1221{
1222 if (!STATE.previewObjectUrl) return;
1223 URL.revokeObjectURL(STATE.previewObjectUrl);
1224 STATE.previewObjectUrl = null;
1225}
1226
1227function fileAccentColor (name)
1228{
1229 const ext = extOf(name || '');
1230 if (IMAGE_EXTS.has(ext)) return '#3fcf8e';
1231 if (VIDEO_EXTS.has(ext)) return '#e05c6e';
1232 if (AUDIO_EXTS.has(ext)) return '#c084fc';
1233 if (DOC_EXTS.has(ext)) return '#f97316';
1234 if (CODE_EXTS.has(ext)) return '#38bdf8';
1235 if (ARCHIVE_EXTS.has(ext)) return '#facc15';
1236 return '#7880a0';
1237}
1238
1239function animatePreviewOpen (sourceSvgEl, sheetEl)
1240{
1241 if (!sourceSvgEl || !sheetEl || !sourceSvgEl.isConnected) return Promise.resolve({ startScale: 0.12 });
1242
1243 const start = sourceSvgEl.getBoundingClientRect();
1244 const end = sheetEl.getBoundingClientRect();
1245 if (!start.width || !start.height || !end.width || !end.height) return Promise.resolve({ startScale: 0.12 });
1246
1247 const ghost = document.createElement('div');
1248 ghost.className = 'preview-ghost';
1249 ghost.style.left = `${start.left}px`;
1250 ghost.style.top = `${start.top}px`;
1251 ghost.style.width = `${start.width}px`;
1252 ghost.style.height = `${start.height}px`;
1253
1254 // Clone before hiding so the ghost is a visible copy
1255 const clone = sourceSvgEl.cloneNode(true);
1256 // Hide source icon for the duration of the preview
1257 sourceSvgEl.style.visibility = 'hidden';
1258 clone.style.width = '100%';
1259 clone.style.height = '100%';
1260 clone.style.display = 'block';
1261 ghost.appendChild(clone);
1262 document.body.appendChild(ghost);
1263
1264 // Bézier path: random control points in viewport space
1265 const vw = window.innerWidth;
1266 const vh = window.innerHeight;
1267 const startCx = start.left + start.width / 2;
1268 const startCy = start.top + start.height / 2;
1269 const endCx = end.left + end.width / 2;
1270 const endCy = end.top + end.height / 2;
1271 const cp1x = startCx + (Math.random() - 0.5) * vw * 0.8;
1272 const cp1y = startCy + (Math.random() - 0.5) * vh * 0.8;
1273 const cp2x = endCx + (Math.random() - 0.5) * vw * 0.6;
1274 const cp2y = endCy + (Math.random() - 0.5) * vh * 0.6;
1275
1276 // Random full rotations: -3 to +3
1277 const totalDeg = (Math.random() * 6 - 3) * 360;
1278 const duration = 640;
1279 const startTime = performance.now();
1280 const startScale = start.width / end.width;
1281
1282 function easeInOut (t) { return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2; }
1283 function bezier1D (p0, p1, p2, p3, t)
1284 {
1285 const u = 1 - t;
1286 return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
1287 }
1288
1289 return new Promise((resolve) =>
1290 {
1291 function frame (now)
1292 {
1293 const raw = Math.min((now - startTime) / duration, 1);
1294 const t = easeInOut(raw);
1295
1296 const cx = bezier1D(startCx, cp1x, cp2x, endCx, t);
1297 const cy = bezier1D(startCy, cp1y, cp2y, endCy, t);
1298 const w = start.width + (end.width - start.width) * t;
1299 const h = start.height + (end.height - start.height) * t;
1300 const angle = t * totalDeg;
1301 const opacity = raw > 0.82 ? 1 - (raw - 0.82) / 0.18 : 1;
1302
1303 ghost.style.left = `${cx - w / 2}px`;
1304 ghost.style.top = `${cy - h / 2}px`;
1305 ghost.style.width = `${w}px`;
1306 ghost.style.height = `${h}px`;
1307 ghost.style.transform = `rotate(${angle}deg)`;
1308 ghost.style.opacity = opacity;
1309
1310 if (raw < 1)
1311 {
1312 requestAnimationFrame(frame);
1313 } else
1314 {
1315 ghost.remove();
1316 resolve({ startScale });
1317 }
1318 }
1319 requestAnimationFrame(frame);
1320 });
1321}
1322
1323function animatePreviewClose (sourceSvgEl, sheetEl)
1324{
1325 if (!sourceSvgEl || !sheetEl || !sourceSvgEl.isConnected) return Promise.resolve();
1326
1327 const sheetRect = sheetEl.getBoundingClientRect();
1328 const iconRect = sourceSvgEl.getBoundingClientRect();
1329 if (!sheetRect.width || !iconRect.width) return Promise.resolve();
1330
1331 // Ghost starts at sheet center, icon-sized, then flies back to icon
1332 const ghost = document.createElement('div');
1333 ghost.className = 'preview-ghost';
1334
1335 const clone = sourceSvgEl.cloneNode(true);
1336 clone.style.width = '100%';
1337 clone.style.height = '100%';
1338 clone.style.display = 'block';
1339 ghost.appendChild(clone);
1340 document.body.appendChild(ghost);
1341
1342 const vw = window.innerWidth;
1343 const vh = window.innerHeight;
1344 const startCx = sheetRect.left + sheetRect.width / 2;
1345 const startCy = sheetRect.top + sheetRect.height / 2;
1346 const endCx = iconRect.left + iconRect.width / 2;
1347 const endCy = iconRect.top + iconRect.height / 2;
1348
1349 const cp1x = startCx + (Math.random() - 0.5) * vw * 0.6;
1350 const cp1y = startCy + (Math.random() - 0.5) * vh * 0.6;
1351 const cp2x = endCx + (Math.random() - 0.5) * vw * 0.5;
1352 const cp2y = endCy + (Math.random() - 0.5) * vh * 0.5;
1353
1354 const totalDeg = (Math.random() * 6 - 3) * 360;
1355 const duration = 580;
1356 const startTime = performance.now();
1357
1358 function easeInOut (t) { return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2; }
1359 function bezier1D (p0, p1, p2, p3, t)
1360 {
1361 const u = 1 - t;
1362 return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
1363 }
1364
1365 return new Promise((resolve) =>
1366 {
1367 function frame (now)
1368 {
1369 const raw = Math.min((now - startTime) / duration, 1);
1370 const t = easeInOut(raw);
1371
1372 const cx = bezier1D(startCx, cp1x, cp2x, endCx, t);
1373 const cy = bezier1D(startCy, cp1y, cp2y, endCy, t);
1374 const angle = t * totalDeg;
1375 const opacity = raw < 0.85 ? 1 : 1 - (raw - 0.85) / 0.15;
1376
1377 ghost.style.left = `${cx - iconRect.width / 2}px`;
1378 ghost.style.top = `${cy - iconRect.height / 2}px`;
1379 ghost.style.width = `${iconRect.width}px`;
1380 ghost.style.height = `${iconRect.height}px`;
1381 ghost.style.transform = `rotate(${angle}deg)`;
1382 ghost.style.opacity = opacity;
1383
1384 if (raw < 1)
1385 {
1386 requestAnimationFrame(frame);
1387 } else
1388 {
1389 ghost.remove();
1390 sourceSvgEl.style.visibility = '';
1391 resolve();
1392 }
1393 }
1394 requestAnimationFrame(frame);
1395 });
1396}
1397
1398async function closePreview ()
1399{
1400 const overlay = document.getElementById('preview-overlay');
1401 const body = document.getElementById('preview-body');
1402 if (!overlay || !body) return;
1403 if (overlay.classList.contains('hidden')) return;
1404 if (STATE.previewClosing) return;
1405 STATE.previewClosing = true;
1406
1407 const sourceSvgEl = STATE.previewSourceEl;
1408 if (sourceSvgEl && sourceSvgEl.isConnected)
1409 {
1410 const sheet = document.getElementById('preview-sheet');
1411 // Shrink the sheet first, then fly ghost back
1412 await new Promise((res) =>
1413 {
1414 const a = sheet.animate(
1415 [{ transform: 'scale(1)', opacity: 1 }, { transform: 'scale(0.06)', opacity: 0 }],
1416 { duration: 180, easing: 'cubic-bezier(0.4, 0, 1, 1)', fill: 'forwards' }
1417 );
1418 a.onfinish = res;
1419 a.oncancel = res;
1420 });
1421 overlay.classList.add('preview-prep');
1422 sheet.style.transform = '';
1423 sheet.style.opacity = '';
1424 await animatePreviewClose(sourceSvgEl, sheet);
1425 } else if (sourceSvgEl)
1426 {
1427 sourceSvgEl.style.visibility = '';
1428 }
1429
1430 overlay.classList.add('hidden');
1431 overlay.classList.remove('preview-prep');
1432 body.innerHTML = '';
1433 clearPreviewObjectUrl();
1434 STATE.previewSourceEl = null;
1435 STATE.previewClosing = false;
1436}
1437
1438async function fetchFileBlob (item)
1439{
1440 const url = `/api/files/download?file=${encodeURIComponent(item.path)}`;
1441 try
1442 {
1443 const res = await fetch(url, {
1444 headers: {
1445 Authorization: 'Bearer ' + STATE.token,
1446 'X-Fp': getFingerprint(),
1447 },
1448 });
1449 if (!res.ok) throw new Error('Download failed.');
1450 return await res.blob();
1451 } catch
1452 {
1453 return null;
1454 }
1455}
1456
1457function triggerDownload (filename, objectUrl)
1458{
1459 const a = document.createElement('a');
1460 a.href = objectUrl;
1461 a.download = filename;
1462 a.click();
1463}
1464
1465async function renderPreviewBody (item, blob, objectUrl)
1466{
1467 const body = document.getElementById('preview-body');
1468 body.innerHTML = '';
1469
1470 const mime = String(blob.type || '').toLowerCase();
1471 const previewable = isInlinePreviewableBlob(blob, item.name);
1472
1473 if (!previewable)
1474 {
1475 const msg = document.createElement('p');
1476 msg.className = 'preview-unsupported';
1477 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
1478 body.appendChild(msg);
1479 return;
1480 }
1481
1482 if (/^image\//.test(mime) || IMAGE_EXTS.has(extOf(item.name)))
1483 {
1484 const img = document.createElement('img');
1485 img.className = 'preview-media';
1486 img.src = objectUrl;
1487 img.alt = item.name;
1488 body.appendChild(img);
1489 return;
1490 }
1491
1492 if (/^video\//.test(mime) || VIDEO_EXTS.has(extOf(item.name)))
1493 {
1494 const video = document.createElement('video');
1495 video.className = 'preview-media';
1496 video.src = objectUrl;
1497 video.controls = true;
1498 video.preload = 'metadata';
1499 body.appendChild(video);
1500 return;
1501 }
1502
1503 if (/^audio\//.test(mime) || AUDIO_EXTS.has(extOf(item.name)))
1504 {
1505 const audio = document.createElement('audio');
1506 audio.className = 'preview-audio';
1507 audio.src = objectUrl;
1508 audio.controls = true;
1509 body.appendChild(audio);
1510 return;
1511 }
1512
1513 if (mime === 'application/pdf')
1514 {
1515 const frame = document.createElement('iframe');
1516 frame.className = 'preview-frame';
1517 frame.src = objectUrl;
1518 frame.title = item.name;
1519 body.appendChild(frame);
1520 return;
1521 }
1522
1523 if (isTextLikeBlob(blob, item.name))
1524 {
1525 const text = await blob.text();
1526 const lang = detectCodeLanguage(item.name, mime);
1527 const formatted = prettyPrintCode(text, lang);
1528 const pre = document.createElement('pre');
1529 pre.className = 'preview-text preview-code';
1530 pre.innerHTML = highlightCode(formatted, lang);
1531 body.appendChild(pre);
1532 return;
1533 }
1534
1535 const msg = document.createElement('p');
1536 msg.className = 'preview-unsupported';
1537 msg.textContent = 'This file cannot be previewed, but you can download it with the button below.';
1538 body.appendChild(msg);
1539}
1540
1541async function downloadOrView (item, sourceSvgEl = null)
1542{
1543 const blob = await fetchFileBlob(item);
1544 if (!blob)
1545 {
1546 toast('Download failed.', 'err');
1547 return;
1548 }
1549
1550 clearPreviewObjectUrl();
1551 const objectUrl = URL.createObjectURL(blob);
1552 STATE.previewObjectUrl = objectUrl;
1553
1554 const overlay = document.getElementById('preview-overlay');
1555 const sheet = document.getElementById('preview-sheet');
1556 const title = document.getElementById('preview-title');
1557 const dlBtn = document.getElementById('preview-download');
1558
1559 sheet.style.setProperty('--preview-accent', fileAccentColor(item.name));
1560 title.textContent = item.name;
1561 dlBtn.onclick = () => triggerDownload(item.name, objectUrl);
1562 await renderPreviewBody(item, blob, objectUrl);
1563
1564 STATE.previewSourceEl = sourceSvgEl || null;
1565 overlay.classList.add('preview-prep');
1566 overlay.classList.remove('hidden');
1567 const { startScale } = await animatePreviewOpen(sourceSvgEl, sheet);
1568 overlay.classList.remove('preview-prep');
1569
1570 // Scale sheet up from the icon's apparent size, driven by JS so the start
1571 // scale matches the actual icon-to-sheet ratio for this specific invocation
1572 const s = (startScale > 0 && startScale < 1) ? startScale : 0.12;
1573 const scaleAnim = sheet.animate(
1574 [{ transform: `scale(${s})`, opacity: 0 }, { transform: 'scale(1)', opacity: 1 }],
1575 { duration: 220, easing: 'cubic-bezier(0.2, 0.9, 0.2, 1.05)', fill: 'forwards' }
1576 );
1577 scaleAnim.onfinish = () => { sheet.style.transform = ''; sheet.style.opacity = ''; };
1578}
1579
1580// ───────────────────────────────────────────────────────────────────────────
1581// UPLOAD
1582// ───────────────────────────────────────────────────────────────────────────
1583
1584function canWrite ()
1585{
1586 if (STATE.isAdmin) return true;
1587 if (!STATE.currentRoot) return false;
1588 const p = STATE.permissions[STATE.currentRoot.label];
1589 return p && p.write;
1590}
1591
1592async function uploadFiles (fileList)
1593{
1594 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1595 if (!canWrite()) { toast('No write access.', 'err'); return; }
1596
1597 const totalSize = Array.from(fileList).reduce((sum, f) => sum + (f.size || 0), 0);
1598 const formData = new FormData();
1599 for (const f of fileList) formData.append('files', f);
1600
1601 // Show upload bar
1602 const wrap = document.createElement('div');
1603 wrap.className = 'upload-bar-wrap';
1604 wrap.innerHTML = `<span>Uploading ${fileList.length} file(s)…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1605 document.body.appendChild(wrap);
1606 STATE.uploadInProgress = true;
1607
1608 try
1609 {
1610 const xhr = new XMLHttpRequest();
1611 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(STATE.currentDir)}`);
1612 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
1613 xhr.setRequestHeader('X-Fp', getFingerprint());
1614 xhr.setRequestHeader('X-Upload-Size', String(totalSize));
1615 xhr.upload.addEventListener('progress', e =>
1616 {
1617 if (e.lengthComputable)
1618 {
1619 wrap.querySelector('.upload-bar-fill').style.width = (e.loaded / e.total * 100) + '%';
1620 }
1621 });
1622
1623 await new Promise((resolve, reject) =>
1624 {
1625 xhr.onload = () =>
1626 {
1627 if (xhr.status === 200) resolve();
1628 else reject(new Error(JSON.parse(xhr.responseText).error || 'Upload failed'));
1629 };
1630 xhr.onerror = () => reject(new Error('Network error'));
1631 xhr.send(formData);
1632 });
1633
1634 toast(`Uploaded ${fileList.length} file(s).`, 'ok');
1635 await navigateTo(STATE.currentDir, STATE.currentRoot);
1636 } catch (err)
1637 {
1638 toast(err.message, 'err');
1639 } finally
1640 {
1641 STATE.uploadInProgress = false;
1642 wrap.remove();
1643 }
1644}
1645
1646async function uploadSingleFile (file, targetDir)
1647{
1648 const formData = new FormData();
1649 formData.append('files', file);
1650
1651 await new Promise((resolve, reject) =>
1652 {
1653 const xhr = new XMLHttpRequest();
1654 xhr.open('POST', `/api/files/upload?dir=${encodeURIComponent(targetDir)}`);
1655 xhr.setRequestHeader('Authorization', 'Bearer ' + STATE.token);
1656 xhr.setRequestHeader('X-Fp', getFingerprint());
1657 xhr.setRequestHeader('X-Upload-Size', String(file.size || 0));
1658 xhr.onload = () => xhr.status === 200
1659 ? resolve()
1660 : reject(new Error((JSON.parse(xhr.responseText) || {}).error || 'Upload failed'));
1661 xhr.onerror = () => reject(new Error('Network error'));
1662 xhr.send(formData);
1663 });
1664}
1665
1666async function ensureServerDir (baseDir, relativeDir)
1667{
1668 const parts = String(relativeDir || '').split(/[\\/]/).filter(Boolean);
1669 let current = baseDir;
1670 for (const part of parts)
1671 {
1672 try
1673 {
1674 const resp = await api('POST', '/files/mkdir', { dir: current, name: part });
1675 current = resp && resp.path ? resp.path : joinServerPath(current, part);
1676 } catch (err)
1677 {
1678 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
1679 current = joinServerPath(current, part);
1680 }
1681 }
1682 return current;
1683}
1684
1685async function uploadFolderInputFiles (fileList)
1686{
1687 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1688 if (!canWrite()) { toast('No write access.', 'err'); return; }
1689 if (!fileList || !fileList.length) return;
1690
1691 const files = Array.from(fileList);
1692 const total = files.length;
1693 let done = 0;
1694
1695 const wrap = document.createElement('div');
1696 wrap.className = 'upload-bar-wrap';
1697 wrap.innerHTML = `<span>Preparing folder upload…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1698 document.body.appendChild(wrap);
1699 STATE.uploadInProgress = true;
1700
1701 try
1702 {
1703 const dirCache = new Map();
1704 dirCache.set('', STATE.currentDir);
1705
1706 for (const file of files)
1707 {
1708 const rel = file.webkitRelativePath || file.name;
1709 const relParts = rel.split(/[\\/]/).filter(Boolean);
1710 const relDir = relParts.slice(0, -1).join('/');
1711
1712 if (!dirCache.has(relDir))
1713 {
1714 const parentRel = relParts.slice(0, -2).join('/');
1715 const parentAbs = dirCache.get(parentRel) || await ensureServerDir(STATE.currentDir, parentRel);
1716 const thisName = relParts[relParts.length - 2];
1717
1718 try
1719 {
1720 const created = await api('POST', '/files/mkdir', { dir: parentAbs, name: thisName });
1721 dirCache.set(relDir, created.path || joinServerPath(parentAbs, thisName));
1722 } catch (err)
1723 {
1724 if (!/exist|EEXIST/i.test(err.message || '')) throw err;
1725 dirCache.set(relDir, joinServerPath(parentAbs, thisName));
1726 }
1727 }
1728
1729 const targetDir = dirCache.get(relDir) || STATE.currentDir;
1730 await uploadSingleFile(file, targetDir);
1731 done++;
1732 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
1733 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
1734 }
1735
1736 toast(`Uploaded ${total} file(s).`, 'ok');
1737 await navigateTo(STATE.currentDir, STATE.currentRoot);
1738 } catch (err)
1739 {
1740 toast(err.message, 'err');
1741 } finally
1742 {
1743 STATE.uploadInProgress = false;
1744 wrap.remove();
1745 }
1746}
1747
1748// ───────────────────────────────────────────────────────────────────────────
1749// FOLDER DRAG-AND-DROP (recursive)
1750// ───────────────────────────────────────────────────────────────────────────
1751
1752/**
1753 * Reads all readEntries batches from a DirectoryReader (browsers may return
1754 * results in chunks; we must keep calling until we get an empty array).
1755 */
1756function readAllEntries (reader)
1757{
1758 return new Promise((resolve, reject) =>
1759 {
1760 const all = [];
1761 function next ()
1762 {
1763 reader.readEntries(batch =>
1764 {
1765 if (!batch.length) { resolve(all); return; }
1766 all.push(...batch);
1767 next();
1768 }, reject);
1769 }
1770 next();
1771 });
1772}
1773
1774/**
1775 * Recursively walk a FileSystemEntry tree, creating server-side directories
1776 * on the fly and collecting { file, targetDir } pairs for upload.
1777 */
1778async function collectEntries (entry, serverDir, toUpload)
1779{
1780 if (entry.isFile)
1781 {
1782 const file = await new Promise((res, rej) => entry.file(res, rej));
1783 toUpload.push({ file, targetDir: serverDir });
1784 } else if (entry.isDirectory)
1785 {
1786 // Ask the server to create the directory; it returns the canonical path.
1787 let newServerDir;
1788 try
1789 {
1790 const resp = await api('POST', '/files/mkdir', { dir: serverDir, name: entry.name });
1791 newServerDir = resp.path;
1792 } catch
1793 {
1794 // Directory may already exist — reconstruct path from what we know.
1795 // The server always returns JSON with {error} on failure, so we can
1796 // still continue by falling back to a best-effort path join.
1797 // We rely on the fact that the server separator is consistent within
1798 // a session (the list/browse API already returned paths in that format).
1799 const sep = serverDir.includes('\\') ? '\\' : '/';
1800 newServerDir = serverDir + sep + entry.name;
1801 }
1802 const reader = entry.createReader();
1803 const subEntries = await readAllEntries(reader);
1804 for (const sub of subEntries)
1805 {
1806 await collectEntries(sub, newServerDir, toUpload);
1807 }
1808 }
1809}
1810
1811async function uploadEntries (entries)
1812{
1813 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
1814 if (!canWrite()) { toast('No write access.', 'err'); return; }
1815
1816 const wrap = document.createElement('div');
1817 wrap.className = 'upload-bar-wrap';
1818 wrap.innerHTML = `<span>Scanning…</span><div class="upload-bar-track"><div class="upload-bar-fill" style="width:0%"></div></div>`;
1819 document.body.appendChild(wrap);
1820 STATE.uploadInProgress = true;
1821
1822 try
1823 {
1824 const toUpload = [];
1825 for (const entry of entries)
1826 {
1827 await collectEntries(entry, STATE.currentDir, toUpload);
1828 }
1829
1830 if (!toUpload.length) { toast('No files found.', 'err'); return; }
1831
1832 let done = 0;
1833 const total = toUpload.length;
1834 const updateBar = () =>
1835 {
1836 wrap.querySelector('span').textContent = `Uploading ${done} / ${total} file(s)…`;
1837 wrap.querySelector('.upload-bar-fill').style.width = (done / total * 100) + '%';
1838 };
1839 updateBar();
1840
1841 for (const { file, targetDir } of toUpload)
1842 {
1843 await uploadSingleFile(file, targetDir);
1844 done++;
1845 updateBar();
1846 }
1847
1848 toast(`Uploaded ${total} file(s).`, 'ok');
1849 await navigateTo(STATE.currentDir, STATE.currentRoot);
1850 } catch (err)
1851 {
1852 toast(err.message, 'err');
1853 } finally
1854 {
1855 STATE.uploadInProgress = false;
1856 wrap.remove();
1857 }
1858}
1859
1860// DRAG-AND-DROP
1861// ───────────────────────────────────────────────────────────────────────────
1862
1863function initDragDrop ()
1864{
1865 const main = document.getElementById('main-content');
1866 const dropOvl = document.getElementById('drop-overlay');
1867 let dragDepth = 0;
1868
1869 main.addEventListener('dragenter', e =>
1870 {
1871 e.preventDefault();
1872 dragDepth++;
1873 dropOvl.classList.remove('hidden');
1874 });
1875 main.addEventListener('dragleave', () =>
1876 {
1877 dragDepth--;
1878 if (dragDepth <= 0) { dragDepth = 0; dropOvl.classList.add('hidden'); }
1879 });
1880 main.addEventListener('dragover', e => e.preventDefault());
1881 main.addEventListener('drop', async e =>
1882 {
1883 e.preventDefault();
1884 dragDepth = 0;
1885 dropOvl.classList.add('hidden');
1886 if (!canWrite()) { toast('No write access.', 'err'); return; }
1887
1888 const items = Array.from(e.dataTransfer.items || []);
1889 // Use the FileSystem Entry API when available so we can handle folders.
1890 if (items.length && typeof items[0].webkitGetAsEntry === 'function')
1891 {
1892 const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
1893 if (entries.some(en => en.isDirectory))
1894 {
1895 await uploadEntries(entries);
1896 return;
1897 }
1898 }
1899 // Plain files only — use the fast batch path.
1900 const files = e.dataTransfer.files;
1901 if (files.length) await uploadFiles(files);
1902 });
1903}
1904
1905// ───────────────────────────────────────────────────────────────────────────
1906// RENAME
1907// ───────────────────────────────────────────────────────────────────────────
1908
1909function openRenameModal (item)
1910{
1911 const modal = document.getElementById('rename-modal');
1912 modal.classList.remove('hidden');
1913 const input = document.getElementById('rename-input');
1914 input.value = item.name;
1915 input.focus();
1916 input.select();
1917 document.getElementById('rename-error').classList.add('hidden');
1918 document.getElementById('rename-form').onsubmit = async (e) =>
1919 {
1920 e.preventDefault();
1921 const newName = input.value.trim();
1922 if (!newName) return;
1923 try
1924 {
1925 await api('POST', '/files/rename', { from: item.path, to: newName });
1926 modal.classList.add('hidden');
1927 toast('Renamed.', 'ok');
1928 await navigateTo(STATE.currentDir, STATE.currentRoot);
1929 } catch (err)
1930 {
1931 document.getElementById('rename-error').textContent = err.message;
1932 document.getElementById('rename-error').classList.remove('hidden');
1933 }
1934 };
1935}
1936
1937// ───────────────────────────────────────────────────────────────────────────
1938// DELETE
1939// ───────────────────────────────────────────────────────────────────────────
1940
1941async function deleteItem (item)
1942{
1943 if (!await showConfirm('Delete item', `Delete "${item.name}"? This cannot be undone.`)) return;
1944 try
1945 {
1946 await api('POST', '/files/delete', { path: item.path });
1947 toast('Deleted.', 'ok');
1948 closeSidebar();
1949 await navigateTo(STATE.currentDir, STATE.currentRoot);
1950 } catch (err)
1951 {
1952 toast(err.message, 'err');
1953 }
1954}
1955
1956// ───────────────────────────────────────────────────────────────────────────
1957// ADMIN PANEL
1958// ───────────────────────────────────────────────────────────────────────────
1959
1960async function openAdminModal ()
1961{
1962 document.getElementById('admin-modal').classList.remove('hidden');
1963 await refreshAdminConfig();
1964 await refreshAdminUsers();
1965}
1966
1967async function refreshAdminConfig ()
1968{
1969 const data = await api('GET', '/admin/config');
1970 if (!data) return;
1971 const container = document.getElementById('admin-paths');
1972 container.innerHTML = '';
1973 for (const p of data.paths)
1974 {
1975 const row = document.createElement('div');
1976 row.className = 'path-row';
1977 row.innerHTML = `<span>${p}</span><button data-path="${p}" title="Remove">✕</button>`;
1978 row.querySelector('button').addEventListener('click', () =>
1979 {
1980 row.remove();
1981 });
1982 container.appendChild(row);
1983 }
1984}
1985
1986async function refreshAdminUsers ()
1987{
1988 const data = await api('GET', '/admin/users');
1989 if (!data) return;
1990 const container = document.getElementById('admin-users-list');
1991 container.innerHTML = '';
1992
1993 // Need paths for permission rows
1994 const cfg = await api('GET', '/admin/config');
1995 const paths = cfg ? (cfg.effectivePaths || []) : [];
1996
1997 for (const u of data.users)
1998 {
1999 const row = document.createElement('div');
2000 row.className = 'user-row';
2001 row.innerHTML = `
2002 <span class="user-name">${u.username}</span>
2003 ${u.isAdmin ? '<span class="user-admin-badge">Admin</span>' : ''}
2004 <button data-id="${u.id}" data-action="edit">Edit</button>
2005 ${u.username === STATE.username ? '' : `<button data-id="${u.id}" data-action="delete" class="danger">Delete</button>`}
2006 `;
2007 row.querySelector('[data-action="edit"]').addEventListener('click', () =>
2008 openUserModal(u, paths));
2009 const deleteBtn = row.querySelector('[data-action="delete"]');
2010 if (deleteBtn) deleteBtn.addEventListener('click', async () =>
2011 {
2012 if (!await showConfirm('Delete user', `Delete user "${u.username}"? This cannot be undone.`)) return;
2013 try
2014 {
2015 await api('DELETE', `/admin/users/${u.id}`);
2016 toast('User deleted.', 'ok');
2017 await refreshAdminUsers();
2018 } catch (err) { toast(err.message, 'err'); }
2019 });
2020 container.appendChild(row);
2021 }
2022}
2023
2024function openUserModal (user, paths)
2025{
2026 const modal = document.getElementById('user-modal');
2027 modal.classList.remove('hidden');
2028 document.getElementById('user-modal-title').textContent = user ? `Edit: ${user.username}` : 'New User';
2029 document.getElementById('user-error').classList.add('hidden');
2030
2031 const usernameInput = document.getElementById('user-username');
2032 usernameInput.value = user ? user.username : '';
2033 usernameInput.readOnly = !!user;
2034
2035 document.getElementById('user-password').value = '';
2036 document.getElementById('user-is-admin').checked = user ? user.isAdmin : false;
2037
2038 // Password placeholder
2039 document.getElementById('user-password').placeholder =
2040 user ? 'Leave blank to keep current' : 'Min 8 characters';
2041
2042 // Build permissions grid
2043 const permDiv = document.getElementById('user-permissions');
2044 permDiv.innerHTML = '';
2045 if (paths.length)
2046 {
2047 const heading = document.createElement('h4');
2048 heading.textContent = 'Path Permissions';
2049 permDiv.appendChild(heading);
2050
2051 const isAdminUser = !!(user && user.isAdmin);
2052 // Mirror the is-admin checkbox so toggling it live-updates the perm rows.
2053 const adminChk = document.getElementById('user-is-admin');
2054 const rebuildPermRows = (admin) =>
2055 {
2056 permDiv.querySelectorAll('.perm-row').forEach(r =>
2057 {
2058 r.querySelectorAll('input[type=checkbox]').forEach(cb =>
2059 {
2060 cb.disabled = admin;
2061 if (admin) cb.checked = true;
2062 });
2063 r.title = admin ? 'Admins always have full access' : '';
2064 });
2065 };
2066 adminChk.addEventListener('change', () => rebuildPermRows(adminChk.checked));
2067
2068 for (const p of paths)
2069 {
2070 const label = p.split(/[\\/]/).pop();
2071 const perms = user && user.permissions ? (user.permissions[label] || {}) : {};
2072 const row = document.createElement('div');
2073 row.className = 'perm-row';
2074 const readChecked = isAdminUser || perms.read;
2075 const writeChecked = isAdminUser || perms.write;
2076 row.innerHTML = `
2077 <span class="perm-label">${label}</span>
2078 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="read" ${readChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Read</label>
2079 <label class="checkbox-label"><input type="checkbox" data-label="${label}" data-type="write" ${writeChecked ? 'checked' : ''} ${isAdminUser ? 'disabled' : ''} /> Write</label>
2080 `;
2081 if (isAdminUser) row.title = 'Admins always have full access';
2082 permDiv.appendChild(row);
2083 }
2084 }
2085
2086 document.getElementById('user-form').onsubmit = async (e) =>
2087 {
2088 e.preventDefault();
2089 const password = document.getElementById('user-password').value;
2090 const isAdmin = document.getElementById('user-is-admin').checked;
2091 const permissions = {};
2092 permDiv.querySelectorAll('input[data-label]').forEach(cb =>
2093 {
2094 const lbl = cb.dataset.label;
2095 if (!permissions[lbl]) permissions[lbl] = {};
2096 permissions[lbl][cb.dataset.type] = cb.checked;
2097 });
2098
2099 try
2100 {
2101 if (user)
2102 {
2103 const body = { isAdmin, permissions };
2104 if (password) body.password = password;
2105 await api('PATCH', `/admin/users/${user.id}`, body);
2106 } else
2107 {
2108 const uname = document.getElementById('user-username').value.trim();
2109 await api('POST', '/admin/users', { username: uname, password, isAdmin, permissions });
2110 }
2111 modal.classList.add('hidden');
2112 toast('User saved.', 'ok');
2113 await refreshAdminUsers();
2114 } catch (err)
2115 {
2116 document.getElementById('user-error').textContent = err.message;
2117 document.getElementById('user-error').classList.remove('hidden');
2118 }
2119 };
2120}
2121
2122// ───────────────────────────────────────────────────────────────────────────
2123// SVG ICONS
2124// ───────────────────────────────────────────────────────────────────────────
2125
2126const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'svg', 'bmp', 'ico', 'avif']);
2127const VIDEO_EXTS = new Set(['mp4', 'webm', 'ogv', 'mov', 'avi', 'mkv']);
2128const AUDIO_EXTS = new Set(['mp3', 'ogg', 'wav', 'flac', 'aac', 'm4a']);
2129const DOC_EXTS = new Set(['pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx', 'odt', 'ods', 'odp']);
2130const 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']);
2131const ARCHIVE_EXTS = new Set(['zip', 'tar', 'gz', 'bz2', 'xz', 'rar', '7z']);
2132
2133function iconFolder (size = 52)
2134{
2135 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
2136 stroke="#5b7fff" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
2137 <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"/>
2138 </svg>`;
2139}
2140
2141function iconFile (name, size = 52)
2142{
2143 const color = fileAccentColor(name);
2144 let symbol = '';
2145
2146 return `<svg width="${size}" height="${size}" viewBox="0 0 24 24" fill="none"
2147 stroke="${color}" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
2148 <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/>
2149 <polyline points="14 2 14 8 20 8"/>
2150 </svg>`;
2151}
2152
2153// ───────────────────────────────────────────────────────────────────────────
2154// EVENT WIRING
2155// ───────────────────────────────────────────────────────────────────────────
2156
2157// ───────────────────────────────────────────────────────────────────────────
2158// THUMBNAIL PREVIEWS
2159// ───────────────────────────────────────────────────────────────────────────
2160
2161function revokeThumbnails ()
2162{
2163 STATE.thumbnailUrls.forEach(u => URL.revokeObjectURL(u));
2164 STATE.thumbnailUrls = [];
2165}
2166
2167function getThumbnailKind (name)
2168{
2169 const ext = extOf(name || '');
2170 if (IMAGE_EXTS.has(ext)) return 'image';
2171 if (VIDEO_EXTS.has(ext)) return 'video';
2172 if (CODE_EXTS.has(ext)) return 'text';
2173 if (AUDIO_EXTS.has(ext)) return 'audio';
2174 if (ext === 'pdf') return 'pdf';
2175 return 'badge';
2176}
2177
2178function maxThumbBytesForKind (kind)
2179{
2180 if (kind === 'image') return 15 * 1024 * 1024;
2181 if (kind === 'video') return 25 * 1024 * 1024;
2182 if (kind === 'text') return 1024 * 1024;
2183 return 0;
2184}
2185
2186function drawTokenizedLine (ctx, line, x, y)
2187{
2188 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;
2189 let last = 0;
2190 let cursor = x;
2191 for (const m of line.matchAll(tokenRe))
2192 {
2193 const i = m.index == null ? 0 : m.index;
2194 if (i > last)
2195 {
2196 const plain = line.slice(last, i);
2197 ctx.fillStyle = '#dce4ff';
2198 ctx.fillText(plain, cursor, y);
2199 cursor += ctx.measureText(plain).width;
2200 }
2201
2202 const tok = m[0];
2203 if (/^\/\//.test(tok) || /^\/\*/.test(tok)) ctx.fillStyle = '#6f7f9a';
2204 else if (/^['"`]/.test(tok)) ctx.fillStyle = '#9ee37d';
2205 else if (/^\d/.test(tok)) ctx.fillStyle = '#f8c46a';
2206 else ctx.fillStyle = '#8bb4ff';
2207
2208 ctx.fillText(tok, cursor, y);
2209 cursor += ctx.measureText(tok).width;
2210 last = i + tok.length;
2211 }
2212
2213 if (last < line.length)
2214 {
2215 const tail = line.slice(last);
2216 ctx.fillStyle = '#dce4ff';
2217 ctx.fillText(tail, cursor, y);
2218 }
2219}
2220
2221function textThumbnailDataUrl (text)
2222{
2223 const canvas = document.createElement('canvas');
2224 canvas.width = 160;
2225 canvas.height = 200;
2226 const ctx = canvas.getContext('2d');
2227 if (!ctx) return null;
2228
2229 ctx.fillStyle = '#0d111a';
2230 ctx.fillRect(0, 0, canvas.width, canvas.height);
2231 ctx.font = '8px ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace';
2232 ctx.textBaseline = 'top';
2233
2234 const lines = String(text || '')
2235 .replace(/\r\n/g, '\n')
2236 .split('\n')
2237 .slice(0, 17);
2238
2239 let y = 8;
2240 for (const line of lines)
2241 {
2242 drawTokenizedLine(ctx, line.slice(0, 42), 6, y);
2243 y += 11;
2244 if (y > 190) break;
2245 }
2246 return canvas.toDataURL('image/png');
2247}
2248
2249function badgeThumbnailDataUrl (name, kind)
2250{
2251 const canvas = document.createElement('canvas');
2252 canvas.width = 160;
2253 canvas.height = 200;
2254 const ctx = canvas.getContext('2d');
2255 if (!ctx) return null;
2256
2257 const ext = (extOf(name || '') || 'file').toUpperCase().slice(0, 5);
2258 const color = kind === 'audio' ? '#c084fc'
2259 : kind === 'pdf' ? '#f97316'
2260 : '#5b7fff';
2261
2262 ctx.fillStyle = '#111826';
2263 ctx.fillRect(0, 0, 160, 200);
2264 ctx.fillStyle = color;
2265 ctx.fillRect(0, 0, 160, 28);
2266 ctx.fillStyle = '#ffffff';
2267 ctx.font = 'bold 12px sans-serif';
2268 ctx.textAlign = 'center';
2269 ctx.fillText(ext, 80, 8);
2270 ctx.textAlign = 'left';
2271 ctx.fillStyle = '#9fb1d8';
2272 ctx.font = '10px sans-serif';
2273 ctx.fillText('Preview', 8, 48);
2274 ctx.fillStyle = '#dce4ff';
2275 ctx.font = 'bold 11px sans-serif';
2276 ctx.fillText(ext, 8, 66);
2277 return canvas.toDataURL('image/png');
2278}
2279
2280async function videoThumbnailDataUrl (blob)
2281{
2282 const src = URL.createObjectURL(blob);
2283 try
2284 {
2285 const video = document.createElement('video');
2286 video.src = src;
2287 video.muted = true;
2288 video.preload = 'metadata';
2289
2290 await new Promise((resolve, reject) =>
2291 {
2292 const fail = () => reject(new Error('video load failed'));
2293 video.addEventListener('error', fail, { once: true });
2294 video.addEventListener('loadeddata', resolve, { once: true });
2295 });
2296
2297 const targetTime = Number.isFinite(video.duration) && video.duration > 1 ? 1 : 0;
2298 await new Promise((resolve) =>
2299 {
2300 video.currentTime = targetTime;
2301 video.addEventListener('seeked', resolve, { once: true });
2302 });
2303
2304 const canvas = document.createElement('canvas');
2305 canvas.width = 160;
2306 canvas.height = 200;
2307 const ctx = canvas.getContext('2d');
2308 if (!ctx) return null;
2309
2310 ctx.fillStyle = '#0d111a';
2311 ctx.fillRect(0, 0, canvas.width, canvas.height);
2312 const rw = video.videoWidth || 1;
2313 const rh = video.videoHeight || 1;
2314 const scale = Math.max(canvas.width / rw, canvas.height / rh);
2315 const dw = rw * scale;
2316 const dh = rh * scale;
2317 ctx.drawImage(video, (canvas.width - dw) / 2, (canvas.height - dh) / 2, dw, dh);
2318
2319 // subtle play badge
2320 ctx.fillStyle = 'rgba(0,0,0,0.45)';
2321 ctx.beginPath();
2322 ctx.arc(80, 100, 18, 0, Math.PI * 2);
2323 ctx.fill();
2324 ctx.fillStyle = '#ffffff';
2325 ctx.beginPath();
2326 ctx.moveTo(75, 90);
2327 ctx.lineTo(75, 110);
2328 ctx.lineTo(90, 100);
2329 ctx.closePath();
2330 ctx.fill();
2331
2332 return canvas.toDataURL('image/png');
2333 } catch
2334 {
2335 return null;
2336 } finally
2337 {
2338 URL.revokeObjectURL(src);
2339 }
2340}
2341
2342async function buildThumbnailSource (item, blob, kind)
2343{
2344 if (kind === 'image') return URL.createObjectURL(blob);
2345 if (kind === 'video') return await videoThumbnailDataUrl(blob);
2346 if (kind === 'text') return textThumbnailDataUrl(await blob.text());
2347 return badgeThumbnailDataUrl(item.name, kind);
2348}
2349
2350async function loadThumbnails ()
2351{
2352 const icons = Array.from(document.querySelectorAll('.icon[data-preview-path]'));
2353 if (!icons.length) return;
2354
2355 const queue = [...icons];
2356 async function worker ()
2357 {
2358 while (queue.length)
2359 {
2360 await loadOneThumbnail(queue.shift());
2361 }
2362 }
2363 // Four concurrent fetches — keeps the Pi's network from flooding
2364 await Promise.all(Array.from({ length: Math.min(4, icons.length) }, worker));
2365}
2366
2367async function loadOneThumbnail (iconEl)
2368{
2369 if (!iconEl.isConnected || !STATE.token) return;
2370 if (iconEl.dataset.thumbReady === '1') return;
2371 const filePath = iconEl.dataset.previewPath;
2372 const item = STATE.items.find(i => i.path === filePath);
2373 if (!item) return;
2374
2375 const kind = getThumbnailKind(item.name);
2376 let srcUrl = null;
2377
2378 if (kind === 'badge' || kind === 'audio' || kind === 'pdf')
2379 {
2380 srcUrl = badgeThumbnailDataUrl(item.name, kind);
2381 } else
2382 {
2383 const maxBytes = maxThumbBytesForKind(kind);
2384 if (maxBytes > 0 && typeof item.size === 'number' && item.size > maxBytes)
2385 {
2386 srcUrl = badgeThumbnailDataUrl(item.name, kind);
2387 } else
2388 {
2389 const url = `/api/files/download?file=${encodeURIComponent(filePath)}`;
2390
2391 let res;
2392 try
2393 {
2394 res = await fetch(url, {
2395 headers: {
2396 Authorization: `Bearer ${STATE.token}`,
2397 'X-Fp': getFingerprint(),
2398 },
2399 });
2400 } catch { return; }
2401 if (!res.ok || !iconEl.isConnected) return;
2402
2403 const blob = await res.blob();
2404 srcUrl = await buildThumbnailSource(item, blob, kind);
2405 if (kind === 'image' && srcUrl) STATE.thumbnailUrls.push(srcUrl);
2406 }
2407 }
2408 if (!srcUrl || !iconEl.isConnected) return;
2409
2410 const svg = iconEl.querySelector('svg');
2411 if (!svg)
2412 {
2413 if (srcUrl.startsWith('blob:')) URL.revokeObjectURL(srcUrl);
2414 return;
2415 }
2416
2417 const NS = 'http://www.w3.org/2000/svg';
2418 const id = `fcp-${Math.random().toString(36).slice(2, 9)}`;
2419
2420 // clipPath matches the main file body outline exactly (viewBox 0 0 24 24)
2421 const defs = document.createElementNS(NS, 'defs');
2422 const clipPath = document.createElementNS(NS, 'clipPath');
2423 clipPath.setAttribute('id', id);
2424 clipPath.setAttribute('clipPathUnits', 'userSpaceOnUse');
2425 const clipShape = document.createElementNS(NS, 'path');
2426 clipShape.setAttribute('d', 'M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z');
2427 clipPath.appendChild(clipShape);
2428 defs.appendChild(clipPath);
2429
2430 // Image fills the file bounding box; clip keeps it inside the outline
2431 const img = document.createElementNS(NS, 'image');
2432 img.setAttribute('href', srcUrl);
2433 img.setAttributeNS('http://www.w3.org/1999/xlink', 'xlink:href', srcUrl);
2434 img.setAttribute('x', '4');
2435 img.setAttribute('y', '2');
2436 img.setAttribute('width', '16');
2437 img.setAttribute('height', '20');
2438 img.setAttribute('clip-path', `url(#${id})`);
2439 img.setAttribute('preserveAspectRatio', 'xMidYMid slice');
2440
2441 // Prepend so existing path/polyline elements (the outline) render on top
2442 svg.prepend(img);
2443 svg.prepend(defs);
2444 iconEl.dataset.thumbReady = '1';
2445}
2446
2447function wireEvents ()
2448{
2449 // Auth form
2450 document.getElementById('auth-form').addEventListener('submit', async (e) =>
2451 {
2452 e.preventDefault();
2453 const username = document.getElementById('auth-username').value.trim();
2454 const password = document.getElementById('auth-password').value;
2455 const isSetup = e.target.dataset.mode === 'setup';
2456 const errEl = document.getElementById('auth-error');
2457 const btn = document.getElementById('auth-submit');
2458 btn.disabled = true;
2459 btn.textContent = 'Please wait…';
2460 const err = await doLogin(username, password, isSetup);
2461 if (err)
2462 {
2463 errEl.textContent = err;
2464 errEl.classList.remove('hidden');
2465 btn.disabled = false;
2466 btn.textContent = isSetup ? 'Create Account' : 'Sign In';
2467 }
2468 });
2469
2470 // Logout
2471 document.getElementById('btn-logout').addEventListener('click', logout);
2472
2473 // Hard refresh while keeping auth/session state.
2474 document.getElementById('btn-refresh').addEventListener('click', () =>
2475 {
2476 saveSessionState();
2477 location.reload();
2478 });
2479
2480 // Upload button
2481 document.getElementById('btn-upload').addEventListener('click', () =>
2482 {
2483 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
2484 if (!canWrite()) { toast('No write access.', 'err'); return; }
2485 document.getElementById('file-input').click();
2486 });
2487
2488 document.getElementById('file-input').addEventListener('change', async (e) =>
2489 {
2490 if (e.target.files.length) await uploadFiles(e.target.files);
2491 e.target.value = '';
2492 });
2493
2494 document.getElementById('btn-upload-folder').addEventListener('click', () =>
2495 {
2496 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
2497 if (!canWrite()) { toast('No write access.', 'err'); return; }
2498 document.getElementById('folder-input').click();
2499 });
2500
2501 document.getElementById('folder-input').addEventListener('change', async (e) =>
2502 {
2503 if (e.target.files.length) await uploadFolderInputFiles(e.target.files);
2504 e.target.value = '';
2505 });
2506
2507 document.getElementById('btn-new-folder').addEventListener('click', async () =>
2508 {
2509 if (!STATE.currentDir) { toast('Open a folder first.', 'err'); return; }
2510 if (!canWrite()) { toast('No write access.', 'err'); return; }
2511
2512 const name = await showPrompt('New Folder', 'Enter a name for the new folder:');
2513 if (name == null) return;
2514 const folderName = name.trim();
2515 if (!folderName)
2516 {
2517 toast('Folder name is required.', 'err');
2518 return;
2519 }
2520
2521 try
2522 {
2523 await api('POST', '/files/mkdir', { dir: STATE.currentDir, name: folderName });
2524 toast('Folder created.', 'ok');
2525 await navigateTo(STATE.currentDir, STATE.currentRoot);
2526 } catch (err)
2527 {
2528 toast(err.message, 'err');
2529 }
2530 });
2531
2532 // Sidebar is persistent; close button is intentionally disabled.
2533
2534 // Click outside grid clears selection and returns to folder sidebar info.
2535 document.getElementById('main-content').addEventListener('click', (e) =>
2536 {
2537 if (!e.target.closest('.file-item')) closeSidebar();
2538 });
2539
2540 // Admin panel
2541 document.getElementById('btn-admin').addEventListener('click', openAdminModal);
2542 document.getElementById('admin-modal-close').addEventListener('click', () =>
2543 document.getElementById('admin-modal').classList.add('hidden'));
2544
2545 // Add path
2546 document.getElementById('admin-add-path').addEventListener('click', () =>
2547 {
2548 const val = document.getElementById('admin-new-path').value.trim();
2549 if (!val) return;
2550 const row = document.createElement('div');
2551 row.className = 'path-row';
2552 row.innerHTML = `<span>${val}</span><button title="Remove">✕</button>`;
2553 row.querySelector('button').addEventListener('click', () => row.remove());
2554 document.getElementById('admin-paths').appendChild(row);
2555 document.getElementById('admin-new-path').value = '';
2556 });
2557
2558 // Save paths
2559 document.getElementById('admin-save-paths').addEventListener('click', async () =>
2560 {
2561 const rows = document.querySelectorAll('#admin-paths .path-row span');
2562 const paths = [...rows].map(s => s.textContent.trim()).filter(Boolean);
2563 try
2564 {
2565 await api('PUT', '/admin/config', { paths });
2566 toast('Paths saved.', 'ok');
2567 await loadRoots();
2568 } catch (err) { toast(err.message, 'err'); }
2569 });
2570
2571 // Shutdown server
2572 document.getElementById('admin-shutdown-btn').addEventListener('click', async () =>
2573 {
2574 if (!await showConfirm('Shut down server', 'Shut down the server? You will lose access until it is restarted manually.')) return;
2575 try
2576 {
2577 await api('POST', '/admin/shutdown');
2578 toast('Server is shutting down…', 'ok');
2579 document.getElementById('admin-modal').classList.add('hidden');
2580 } catch
2581 {
2582 // Fetch may throw because the connection closes before a response arrives.
2583 toast('Server is shutting down…', 'ok');
2584 document.getElementById('admin-modal').classList.add('hidden');
2585 }
2586 });
2587
2588 // New user
2589 document.getElementById('admin-new-user-btn').addEventListener('click', async () =>
2590 {
2591 const cfg = await api('GET', '/admin/config');
2592 const paths = cfg ? (cfg.effectivePaths || []) : [];
2593 openUserModal(null, paths);
2594 });
2595
2596 // User modal close
2597 document.getElementById('user-modal-close').addEventListener('click', () =>
2598 document.getElementById('user-modal').classList.add('hidden'));
2599
2600 // Rename modal close
2601 document.getElementById('rename-modal-close').addEventListener('click', () =>
2602 document.getElementById('rename-modal').classList.add('hidden'));
2603
2604 // Preview close
2605 document.getElementById('preview-close').addEventListener('click', closePreview);
2606 document.getElementById('preview-overlay').addEventListener('click', (e) =>
2607 {
2608 if (e.target.id === 'preview-overlay') closePreview();
2609 });
2610
2611 document.addEventListener('keydown', (e) =>
2612 {
2613 if (e.key === 'Escape' && !document.getElementById('preview-overlay').classList.contains('hidden'))
2614 {
2615 closePreview();
2616 }
2617 });
2618
2619 // Close modals on backdrop click
2620 document.querySelectorAll('.modal-overlay').forEach(overlay =>
2621 {
2622 overlay.addEventListener('click', e =>
2623 {
2624 if (e.target === overlay) overlay.classList.add('hidden');
2625 });
2626 });
2627}
2628
2629// ───────────────────────────────────────────────────────────────────────────
2630// BOOT
2631// ───────────────────────────────────────────────────────────────────────────
2632
2633(async function boot ()
2634{
2635 wireEvents();
2636 initDragDrop();
2637 window.addEventListener('beforeunload', saveSessionState);
2638 await initAuth();
2639})();